Network Working Group T. Hastings, Editor Request for Comments: 2911 R. Herriot Obsoletes: 2566 Xerox Corporation Category: Standards Track R. deBry Utah Valley State College S. Isaacson Novell, Inc. P. Powell Astart Technologies September 2000 Internet Printing Protocol/1.1: Model and Semantics Status of this Memo This document specifies an Internet standards track protocol for the Internet community, and requests discussion and suggestions for improvements. Please refer to the current edition of the "Internet Official Protocol Standards" (STD 1) for the standardization state and status of this protocol. Distribution of this memo is unlimited. Copyright Notice Copyright (C) The Internet Society (2000). All Rights Reserved.
AbstractThis document is one of a set of documents, which together describe all aspects of a new Internet Printing Protocol (IPP). IPP is an application level protocol that can be used for distributed printing using Internet tools and technologies. This document describes a simplified model consisting of abstract objects, their attributes, and their operations that is independent of encoding and transport. The model consists of a Printer and a Job object. A Job optionally supports multiple documents. IPP 1.1 semantics allow end-users and operators to query printer capabilities, submit print jobs, inquire about the status of print jobs and printers, cancel, hold, release, and restart print jobs. IPP 1.1 semantics allow operators to pause, resume, and purge (jobs from) Printer objects. This document also addresses security, internationalization, and directory issues.
The full set of IPP documents includes: Design Goals for an Internet Printing Protocol [RFC2567] Rationale for the Structure and Model and Protocol for the Internet Printing Protocol [RFC2568] Internet Printing Protocol/1.1: Model and Semantics (this document) Internet Printing Protocol/1.1: Encoding and Transport [RFC2910] Internet Printing Protocol/1.1: Implementer's Guide [IPP-IIG] Mapping between LPD and IPP Protocols [RFC2569] The "Design Goals for an Internet Printing Protocol" document takes a broad look at distributed printing functionality, and it enumerates real-life scenarios that help to clarify the features that need to be included in a printing protocol for the Internet. It identifies requirements for three types of users: end users, operators, and administrators. It calls out a subset of end user requirements that are satisfied in IPP/1.0. A few OPTIONAL operator operations have been added to IPP/1.1. The "Rationale for the Structure and Model and Protocol for the Internet Printing Protocol" document describes IPP from a high level view, defines a roadmap for the various documents that form the suite of IPP specification documents, and gives background and rationale for the IETF working group's major decisions. The "Internet Printing Protocol/1.1: Encoding and Transport" document is a formal mapping of the abstract operations and attributes defined in the model document onto HTTP/1.1 [RFC2616]. It defines the encoding rules for a new Internet MIME media type called "application/ipp". This document also defines the rules for transporting over HTTP a message body whose Content-Type is "application/ipp". This document defines a new scheme named 'ipp' for identifying IPP printers and jobs. The "Internet Printing Protocol/1.1: Implementer's Guide" document gives insight and advice to implementers of IPP clients and IPP objects. It is intended to help them understand IPP/1.1 and some of the considerations that may assist them in the design of their client and/or IPP object implementations. For example, a typical order of processing requests is given, including error checking. Motivation for some of the specification decisions is also included. The "Mapping between LPD and IPP Protocols" document gives some advice to implementers of gateways between IPP and LPD (Line Printer Daemon) implementations.
1. Introduction 9 1.1 Simplified Printing Model 10 2. IPP Objects 12 2.1 Printer Object 13 2.2 Job Object 15 2.3 Object Relationships 16 2.4 Object Identity 17 3. IPP Operations 20 3.1 Common Semantics 21 3.1.1 Required Parameters 21 3.1.2 Operation IDs and Request IDs 22 3.1.3 Attributes 22 3.1.4 Character Set and Natural Language Operation Attribute 24 126.96.36.199 Request Operation Attributes 25 188.8.131.52 Response Operation Attributes 29 3.1.5 Operation Targets 30 3.1.6 Operation Response Status Codes and Status Messages 32 184.108.40.206 "status-code" (type2 enum) 32 220.127.116.11 "status-message" (text(255)) 33 18.104.22.168 "detailed-status-message" (text(MAX)) 33 22.214.171.124 "document-access-error" (text(MAX)) 34 3.1.7 Unsupported Attributes 34 3.1.8 Versions 36 3.1.9 Job Creation Operations 38 3.2 Printer Operations 41 3.2.1 Print-Job Operation 41 126.96.36.199 Print-Job Request 41 188.8.131.52 Print-Job Response 46 3.2.2 Print-URI Operation 48 3.2.3 Validate-Job Operation 49 3.2.4 Create-Job Operation 49 3.2.5 Get-Printer-Attributes Operation 50 184.108.40.206 Get-Printer-Attributes Request 51 220.127.116.11 Get-Printer-Attributes Response 53 3.2.6 Get-Jobs Operation 54 18.104.22.168 Get-Jobs Request 54 22.214.171.124 Get-Jobs Response 56 3.2.7 Pause-Printer Operation 57 126.96.36.199 Pause-Printer Request 59 188.8.131.52 Pause-Printer Response 60 3.2.8 Resume-Printer Operation 60 3.2.9 Purge-Jobs Operation 61 3.3 Job Operations 62 3.3.1 Send-Document Operation 62 184.108.40.206 Send-Document Request 64 220.127.116.11 Send-Document Response 65
3.3.2 Send-URI Operation 66 3.3.3 Cancel-Job Operation 66 18.104.22.168 Cancel-Job Request 67 22.214.171.124 Cancel-Job Response 68 3.3.4 Get-Job-Attributes Operation 69 126.96.36.199 Get-Job-Attributes Request 69 188.8.131.52 Get-Job-Attributes Response 70 3.3.5 Hold-Job Operation 71 184.108.40.206 Hold-Job Request 72 220.127.116.11 Hold-Job Response 73 3.3.6 Release-Job Operation 74 3.3.7 Restart-Job Operation 75 18.104.22.168 Restart-Job Request 76 22.214.171.124 Restart-Job Response 78 4. Object Attributes 78 4.1 Attribute Syntaxes 78 4.1.1 'text' 79 126.96.36.199 'textWithoutLanguage' 80 188.8.131.52 'textWithLanguage' 80 4.1.2 'name' 81 184.108.40.206 'nameWithoutLanguage' 82 220.127.116.11 'nameWithLanguage' 82 18.104.22.168 Matching 'name' attribute values 83 4.1.3 'keyword' 84 4.1.4 'enum' 85 4.1.5 'uri' 85 4.1.6 'uriScheme' 86 4.1.7 'charset' 86 4.1.8 'naturalLanguage' 87 4.1.9 'mimeMediaType' 87 22.214.171.124 Application/octet-stream -- Auto-Sensing the document format 88 4.1.10 'octetString' 89 4.1.11 'boolean' 89 4.1.12 'integer' 89 4.1.13 'rangeOfInteger' 90 4.1.14 'dateTime' 90 4.1.15 'resolution' 90 4.1.16 '1setOf X' 90 4.2 Job Template Attributes 91 4.2.1 job-priority (integer(1:100)) 94 4.2.2 job-hold-until (type3 keyword | name (MAX)) 95 4.2.3 job-sheets (type3 keyword | name(MAX)) 96 4.2.4 multiple-document-handling (type2 keyword) 96 4.2.5 copies (integer(1:MAX)) 98 4.2.6 finishings (1setOf type2 enum) 98 4.2.7 page-ranges (1setOf rangeOfInteger (1:MAX)) 101 4.2.8 sides (type2 keyword) 102
4.2.9 number-up (integer(1:MAX)) 102 4.2.10 orientation-requested (type2 enum) 103 4.2.11 media (type3 keyword | name(MAX)) 104 4.2.12 printer-resolution (resolution) 105 4.2.13 print-quality (type2 enum) 105 4.3 Job Description Attributes 106 4.3.1 job-uri (uri) 107 4.3.2 job-id (integer(1:MAX)) 108 4.3.3 job-printer-uri (uri) 108 4.3.4 job-more-info (uri) 108 4.3.5 job-name (name(MAX)) 108 4.3.6 job-originating-user-name (name(MAX)) 109 4.3.7 job-state (type1 enum) 109 126.96.36.199 Forwarding Servers 112 188.8.131.52 Partitioning of Job States 112 4.3.8 job-state-reasons (1setOf type2 keyword) 113 4.3.9 job-state-message (text(MAX)) 118 4.3.10 job-detailed-status-messages (1setOf text(MAX)) 118 4.3.11 job-document-access-errors (1setOf text(MAX)) 118 4.3.12 number-of-documents (integer(0:MAX)) 119 4.3.13 output-device-assigned (name(127)) 119 4.3.14 Event Time Job Description Attributes 119 184.108.40.206 time-at-creation (integer(MIN:MAX)) 120 220.127.116.11 time-at-processing (integer(MIN:MAX)) 120 18.104.22.168 time-at-completed (integer(MIN:MAX)) 120 22.214.171.124 job-printer-up-time (integer(1:MAX)) 120 126.96.36.199 date-time-at-creation (dateTime) 121 188.8.131.52 date-time-at-processing (dateTime) 121 184.108.40.206 date-time-at-completed (dateTime) 121 4.3.15 number-of-intervening-jobs (integer(0:MAX)) 121 4.3.16 job-message-from-operator (text(127)) 121 4.3.17 Job Size Attributes 121 220.127.116.11 job-k-octets (integer(0:MAX)) 122 18.104.22.168 job-impressions (integer(0:MAX)) 122 22.214.171.124 job-media-sheets (integer(0:MAX)) 123 4.3.18 Job Progress Attributes 123 126.96.36.199 job-k-octets-processed (integer(0:MAX)) 123 188.8.131.52 job-impressions-completed (integer(0:MAX)) 123 184.108.40.206 job-media-sheets-completed (integer(0:MAX)) 124 4.3.19 attributes-charset (charset) 124 4.3.20 attributes-natural-language (naturalLanguage) 124 4.4 Printer Description Attributes 124 4.4.1 printer-uri-supported (1setOf uri) 126 4.4.2 uri-authentication-supported (1setOf type2 keyword) 127 4.4.3 uri-security-supported (1setOf type2 keyword) 128 4.4.4 printer-name (name(127)) 129 4.4.5 printer-location (text(127)) 129 4.4.6 printer-info (text(127)) 130
4.4.7 printer-more-info (uri) 130 4.4.8 printer-driver-installer (uri) 130 4.4.9 printer-make-and-model (text(127)) 130 4.4.10 printer-more-info-manufacturer (uri) 130 4.4.11 printer-state (type1 enum) 131 4.4.12 printer-state-reasons (1setOf type2 keyword) 131 4.4.13 printer-state-message (text(MAX)) 134 4.4.14 ipp-versions-supported (1setOf type2 keyword) 134 4.4.15 operations-supported (1setOf type2 enum) 135 4.4.16 multiple-document-jobs-supported (boolean) 136 4.4.17 charset-configured (charset) 136 4.4.18 charset-supported (1setOf charset) 137 4.4.19 natural-language-configured (naturalLanguage) 137 4.4.20 generated-natural-language-supported (1setOf naturalLanguage) 137 4.4.21 document-format-default (mimeMediaType) 138 4.4.22 document-format-supported (1setOf mimeMediaType) 138 4.4.23 printer-is-accepting-jobs (boolean) 138 4.4.24 queued-job-count (integer(0:MAX)) 138 4.4.25 printer-message-from-operator (text(127)) 139 4.4.26 color-supported (boolean) 139 4.4.27 reference-uri-schemes-supported (1setOf uriScheme) 139 4.4.28 pdl-override-supported (type2 keyword) 139 4.4.29 printer-up-time (integer(1:MAX)) 140 4.4.30 printer-current-time (dateTime) 140 4.4.31 multiple-operation-time-out (integer(1:MAX)) 141 4.4.32 compression-supported (1setOf type3 keyword) 141 4.4.33 job-k-octets-supported (rangeOfInteger(0:MAX)) 142 4.4.34 job-impressions-supported (rangeOfInteger(0:MAX)) 142 4.4.35 job-media-sheets-supported (rangeOfInteger(0:MAX)) 142 4.4.36 pages-per-minute (integer(0:MAX)) 142 4.4.37 pages-per-minute-color (integer(0:MAX)) 142 5. Conformance 143 5.1 Client Conformance Requirements 143 5.2 IPP Object Conformance Requirements 145 5.2.1 Objects 145 5.2.2 Operations 145 5.2.3 IPP Object Attributes 146 5.2.4 Versions 146 5.2.5 Extensions 147 5.2.6 Attribute Syntaxes 147 5.2.7 Security 148 5.3 Charset and Natural Language Requirements 148 6. IANA Considerations 148 6.1 Typed 'keyword' and 'enum' Extensions 149 6.2 Attribute Extensibility 151 6.3 Attribute Syntax Extensibility 152 6.4 Operation Extensibility 152
6.5 Attribute Group Extensibility 153 6.6 Status Code Extensibility 153 6.7 Out-of-band Attribute Value Extensibility 154 6.8 Registration of MIME types/sub-types for document-formats 154 6.9 Registration of charsets for use in 'charset' attribute values 154 7. Internationalization Considerations 154 8. Security Considerations 158 8.1 Security Scenarios 159 8.1.1 Client and Server in the Same Security Domain 159 8.1.2 Client and Server in Different Security Domains 159 8.1.3 Print by Reference 160 8.2 URIs in Operation, Job, and Printer attributes 160 8.3 URIs for each authentication mechanisms 160 8.4 Restricted Queries 161 8.5 Operations performed by operators and system administrators 161 8.6 Queries on jobs submitted using non-IPP protocols 162 9. References 162 10. Authors' Addresses 166 11. Formats for IPP Registration Proposals 168 11.1 Type2 keyword attribute values registration 169 11.2 Type3 keyword attribute values registration 169 11.3 Type2 enum attribute values registration 169 11.4 Type3 enum attribute values registration 170 11.5 Attribute registration 170 11.6 Attribute Syntax registration 171 11.7 Operation registration 171 11.8 Attribute Group registration 171 11.9 Status code registration 172 11.10 Out-of-band Attribute Value registration 172 12. APPENDIX A: Terminology 173 12.1 Conformance Terminology 173 12.1.1 NEED NOT 173 12.2 Model Terminology 173 12.2.1 Keyword 173 12.2.2 Attributes 173 220.127.116.11 Attribute Name 173 18.104.22.168 Attribute Group Name 174 22.214.171.124 Attribute Value 174 126.96.36.199 Attribute Syntax 174 12.2.3 Supports 174 12.2.4 print-stream page 176 12.2.5 impression 177 13. APPENDIX B: Status Codes and Suggested Status Code Messages 177 13.1 Status Codes 178 13.1.1 Informational 178 13.1.2 Successful Status Codes 178
188.8.131.52 successful-ok (0x0000) 178 184.108.40.206 successful-ok-ignored-or-substituted-attributes (0x0001) 179 220.127.116.11 successful-ok-conflicting-attributes (0x0002) 179 13.1.3 Redirection Status Codes 179 13.1.4 Client Error Status Codes 179 18.104.22.168 client-error-bad-request (0x0400) 180 22.214.171.124 client-error-forbidden (0x0401) 180 126.96.36.199 client-error-not-authenticated (0x0402) 180 188.8.131.52 client-error-not-authorized (0x0403) 180 184.108.40.206 client-error-not-possible (0x0404) 180 220.127.116.11 client-error-timeout (0x0405) 181 18.104.22.168 client-error-not-found (0x0406) 181 22.214.171.124 client-error-gone (0x0407) 181 126.96.36.199 client-error-request-entity-too-large (0x0408) 182 188.8.131.52 client-error-request-value-too-long (0x0409) 182 184.108.40.206 client-error-document-format-not-supported (0x040A) 182 220.127.116.11 client-error-attributes-or-values-not-supported (0x040B) 183 18.104.22.168 client-error-uri-scheme-not-supported (0x040C) 183 22.214.171.124 client-error-charset-not-supported (0x040D) 183 126.96.36.199 client-error-conflicting-attributes (0x040E) 183 188.8.131.52 client-error-compression-not-supported (0x040F) 184 184.108.40.206 client-error-compression-error (0x0410) 184 220.127.116.11 client-error-document-format-error (0x0411) 184 18.104.22.168 client-error-document-access-error (0x0412) 184 13.1.5 Server Error Status Codes 185 22.214.171.124 server-error-internal-error (0x0500) 185 126.96.36.199 server-error-operation-not-supported (0x0501) 185 188.8.131.52 server-error-service-unavailable (0x0502) 185 184.108.40.206 server-error-version-not-supported (0x0503) 185 220.127.116.11 server-error-device-error (0x0504) 186 18.104.22.168 server-error-temporary-error (0x0505) 186 22.214.171.124 server-error-not-accepting-jobs (0x0506) 187 126.96.36.199 server-error-busy (0x0507) 187 188.8.131.52 server-error-job-canceled (0x0508) 187 184.108.40.206 server-error-multiple-document-jobs-not-supported (0x0509) 187 13.2 Status Codes for IPP Operations 187 14. APPENDIX C: "media" keyword values 190 15. APPENDIX D: Processing IPP Attributes 208 15.1 Fidelity 209 15.2 Page Description Language (PDL) Override 210 15.3 Using Job Template Attributes During Document Processing 212 16. APPENDIX E: Generic Directory Schema 214 17. APPENDIX F: Differences between the IPP/1.0 and IPP/1.1 "Model and Semantics" Documents 215 18. Full Copyright Statement 224
RFC2567] Rationale for the Structure and Model and Protocol for the Internet Printing Protocol [RFC2568] Internet Printing Protocol/1.1: Model and Semantics (this document) Internet Printing Protocol/1.1: Encoding and Transport [RFC2910] Internet Printing Protocol/1.1: Implementer's Guide [IPP-IIG] Mapping between LPD and IPP Protocols [RFC2569] Anyone reading these documents for the first time is strongly encouraged to read the IPP documents in the above order. This document is laid out as follows: - The rest of Section 1 is an introduction to the IPP simplified model for distributed printing. - Section 2 introduces the object types covered in the model with their basic behaviors, attributes, and interactions. - Section 3 defines the operations included in IPP/1.1. IPP operations are synchronous, therefore, for each operation, there is a both request and a response. - Section 4 defines the attributes (and their syntaxes) that are used in the model. - Sections 5 - 6 summarizes the implementation conformance requirements for objects that support the protocol and IANA considerations, respectively. - Sections 7 - 11 cover the Internationalization and Security considerations as well as References, Author contact information, and Formats for Registration Proposals. - Sections 12 - 14 are appendices that cover Terminology, Status Codes and Messages, and "media" keyword values. Note: This document uses terms such as "attributes", "keywords", and "support". These terms have special meaning and are defined in the model terminology section 12.2. Capitalized terms, such as MUST, MUST NOT, REQUIRED, SHOULD, SHOULD NOT, MAY, NEED NOT, and OPTIONAL, have special meaning relating to conformance. These terms are defined in section 12.1 on conformance terminology, most of which is taken from RFC 2119 [RFC2119].
- Section 15 is an appendix that helps to clarify the effects of interactions between related attributes and their values. - Section 16 is an appendix that enumerates the subset of Printer attributes that form a generic directory schema. These attributes are useful when registering a Printer so that a client can find the Printer not just by name, but by filtered searches as well. - Section 17 is an appendix summarizing the additions and changes from the IPP/1.0 "Model and Semantics" document [RFC2566] to make this IPP/1.1 document. - Section 18 is the full copyright notice. HTPP] [ISO10175] [LDPA] [P1387.4] [PSIS] [RFC1179] [SWP]. IPP is heavily influenced by the printing model introduced in the Document Printing Application (DPA) [ISO10175] standard. Although DPA specifies both end user and administrative features, IPP version 1.1 (IPP/1.1) focuses primarily on end user functionality with a few additional OPTIONAL operator operations. The IPP/1.1 model encapsulates the important components of distributed printing into two object types: - Printer (Section 2.1) - Job (Section 2.2) Each object type has an associated set of operations (see section 3) and attributes (see section 4).
It is important, however, to understand that in real system implementations (which lie underneath the abstracted IPP/1.1 model), there are other components of a print service which are not explicitly defined in the IPP/1.1 model. The following figure illustrates where IPP/1.1 fits with respect to these other components. +--------------+ | Application | o +. . . . . . . | \|/ | Spooler | / \ +. . . . . . . | +---------+ End-User | Print Driver |---| File | +-----------+ +-----+ +------+-------+ +----+----+ | Browser | | GUI | | | +-----+-----+ +--+--+ | | | | | | | +---+------------+---+ | N D S | | IPP Client |------------+ O I E | +---------+----------+ T R C | | I E U | F C R -------------- Transport ------------------ I T I C O T | --+ A R Y +--------+--------+ | T Y | IPP Server | | I +--------+--------+ | O | | N +-----------------+ | IPP Printer | Print Service | | +-----------------+ | | --+ +-----------------+ | Output Device(s)| +-----------------+ An IPP Printer object encapsulates the functions normally associated with physical output devices along with the spooling, scheduling and multiple device management functions often associated with a print server. Printer objects are optionally registered as entries in a directory where end users find and select them based on some sort of filtered and context based searching mechanism (see section 16). The directory is used to store relatively static information about the Printer, allowing end users to search for and find Printers that match their search criteria, for example: name, context, printer capabilities, etc. The more dynamic information, such as state, currently loaded and ready media, number of jobs at the Printer,
errors, warnings, and so forth, is directly associated with the Printer object itself rather than with the entry in the directory which only represents the Printer object. IPP clients implement the IPP protocol on the client side and give end users (or programs running on behalf of end users) the ability to query Printer objects and submit and manage print jobs. An IPP server is just that part of the Printer object that implements the server-side protocol. The rest of the Printer object implements (or gateways into) the application semantics of the print service itself. The Printer objects may be embedded in an output device or may be implemented on a host on the network that communicates with an output device. When a job is submitted to the Printer object and the Printer object validates the attributes in the submission request, the Printer object creates a new Job object. The end user then interacts with this new Job object to query its status and monitor the progress of the job. An end user can also cancel their print jobs by using the Job object's Cancel-Job operation. An end-user can also hold, release, and restart their print jobs using the Job object's OPTIONAL Hold-Job, Release-Job, and Restart-Job operations, if implemented. A privileged operator or administrator of a Printer object can cancel, hold, release, and restart any user's job using the REQUIRED Cancel-Job and the OPTIONAL Hold-Job, Release-Job, and Restart-Job operations. In additional privileged operator or administrator of a Printer object can pause, resume, or purge (jobs from) a Printer object using the OPTIONAL Pause-Printer, Resume-Printer, and Purge- Jobs operations, if implemented. The notification service is out of scope for this IPP/1.1 document, but using such a notification service, the end user is able to register for and receive Printer specific and Job specific events. An end user can query the status of Printer objects and can follow the progress of Job objects by polling using the Get-Printer- Attributes, Get-Jobs, and Get-Job-Attributes operations.
and characteristics. For example, the Printer object type is defined as a set of attributes that each Printer object potentially supports. In the same manner, the Job object type is defined as a set of attributes that are potentially supported by each Job object. Each attribute included in the set of attributes defining an object type is labeled as: - "REQUIRED": each object MUST support the attribute. - "RECOMMENDED": each object SHOULD support the attribute. - "OPTIONAL": each object MAY support the attribute. Some definitions of attribute values indicate that an object MUST or SHOULD support the value; otherwise, support of the value is OPTIONAL. However, if an implementation supports an attribute, it MUST support at least one of the possible values for that attribute. Section 3 describes each of the Printer operations in detail. The capabilities and state of a Printer object are described by its attributes. Printer attributes are divided into two groups: - "job-template" attributes: These attributes describe supported job processing capabilities and defaults for the Printer object. (See section 4.2) - "printer-description" attributes: These attributes describe the Printer object's identification, state, location, references to other sources of information about the Printer object, etc. (see section 4.4) Since a Printer object is an abstraction of a generic document output device and print service provider, a Printer object could be used to represent any real or virtual device with semantics consistent with the Printer object, such as a fax device, an imager, or even a CD writer.
Some examples of configurations supporting a Printer object include: 1) An output device with no spooling capabilities 2) An output device with a built-in spooler 3) A print server supporting IPP with one or more associated output devices 3a) The associated output devices may or may not be capable of spooling jobs 3b) The associated output devices may or may not support IPP The following figures show some examples of how Printer objects can be realized on top of various distributed printing configurations. The embedded case below represents configurations 1 and 2. The hosted and fan-out figures below represent configurations 3a and 3b. In this document the term "client" refers to a software entity that sends IPP operation requests to an IPP Printer object and accepts IPP operation responses. A client MAY be: 1. contained within software controlled by an end user, e.g. activated by the "Print" menu item in an application or 2. the print server component that sends IPP requests to either an output device or another "downstream" print server. The term "IPP Printer" is a network entity that accepts IPP operation requests and returns IPP operation responses. As such, an IPP object MAY be: 1. an (embedded) device component that accepts IPP requests and controls the device or 2. a component of a print server that accepts IPP requests (where the print server controls one or more networked devices using IPP or other protocols). Legend: ##### indicates a Printer object which is either embedded in an output device or is hosted in a server. The Printer object might or might not be capable of queuing/spooling. any indicates any network protocol or direct connect, including IPP
embedded printer: output device +---------------+ O +--------+ | ########### | /|\ | client |------------IPP------------># Printer # | / \ +--------+ | # Object # | | ########### | +---------------+ hosted printer: +---------------+ O +--------+ ########### | | /|\ | client |--IPP--># Printer #-any->| output device | / \ +--------+ # Object # | | ########### +---------------+ +---------------+ fan out: | | +-->| output device | any/ | | O +--------+ ########### / +---------------+ /|\ | client |-IPP-># Printer #--* / \ +--------+ # Object # \ +---------------+ ########### any\ | | +-->| output device | | | +---------------+ Section 3 describes each of the Job operations in detail. The characteristics and state of a Job object are described by its attributes. Job attributes are grouped into two groups as follows: - "job-template" attributes: These attributes can be supplied by the client or end user and include job processing instructions which are intended to override any Printer object defaults and/or instructions embedded within the document data. (See section 4.2)
- "job-description" attributes: These attributes describe the Job object's identification, state, size, etc. The client supplies some of these attributes, and the Printer object generates others. (See section 4.3) An implementation MUST support at least one document per Job object. An implementation MAY support multiple documents per Job object. A document is either: - a stream of document data in a format supported by the Printer object (typically a Page Description Language - PDL), or - a reference to such a stream of document data In IPP/1.1, a document is not modeled as an IPP object, therefore it has no object identifier or associated attributes. All job processing instructions are modeled as Job object attributes. These attributes are called Job Template attributes and they apply equally to all documents within a Job object. section 2.4). A Job object is either empty (before any documents have been added) or contains one or more documents. If the contained document is a stream of document data, that stream can be contained in only one document. However, there can be identical copies of the stream in other documents in the same or different Job objects. If the contained document is just a reference to a stream of document data, other documents (in the same or different Job object(s)) may contain the same reference.
RFC2396] so that they can be persistently and unambiguously referenced. Since every URL is a specialized form of a URI, even though the more generic term URI is used throughout the rest of this document, its usage is intended to cover the more specific notion of URL as well. An administrator configures Printer objects to either support or not support authentication and/or message privacy using Transport Layer Security (TLS) [RFC2246] (the mechanism for security configuration is outside the scope of this IPP/1.1 document). In some situations, both types of connections (both authenticated and unauthenticated) can be established using a single communication channel that has some sort of negotiation mechanism. In other situations, multiple communication channels are used, one for each type of security configuration. Section 8 provides a full description of all security considerations and configurations. If a Printer object supports more than one communication channel, some or all of those channels might support and/or require different security mechanisms. In such cases, an administrator could expose the simultaneous support for these multiple communication channels as multiple URIs for a single Printer object where each URI represents one of the communication channels to the Printer object. To support this flexibility, the IPP Printer object type defines a multi-valued identification attribute called the "printer-uri-supported" attribute. It MUST contain at least one URI. It MAY contain more than one URI. That is, every Printer object will have at least one URI that identifies at least one communication channel to the Printer object, but it may have more than one URI where each URI identifies a different communication channel to the Printer object. The "printer-uri-supported" attribute has two companion attributes, the "uri-security-supported" attribute and the "uri-authentication- supported". Both have the same cardinality as "printer-uri- supported". The purpose of the "uri-security-supported" attribute is to indicate the security mechanisms (if any) used for each URI listed in "printer-uri-supported". The purpose of the "uri-authentication- supported" attribute is to indicate the authentication mechanisms (if any) used for each URI listed in "printer-uri-supported". These three attributes are fully described in sections 4.4.1, 4.4.2, and 4.4.3. When a job is submitted to the Printer object via a create request, the client supplies only a single Printer object URI. The client supplied Printer object URI MUST be one of the values in the "printer-uri-supported" Printer attribute.
IPP/1.1 does not specify how the client obtains the client supplied URI, but it is RECOMMENDED that a Printer object be registered as an entry in a directory service. End-users and programs can then interrogate the directory searching for Printers. Section 16 defines a generic schema for Printer object entries in the directory service and describes how the entry acts as a bridge to the actual IPP Printer object. The entry in the directory that represents the IPP Printer object includes the possibly many URIs for that Printer object as values in one its attributes. When a client submits a create request to the Printer object, the Printer object validates the request and creates a new Job object. The Printer object assigns the new Job object a URI which is stored in the "job-uri" Job attribute. This URI is then used by clients as the target for subsequent Job operations. The Printer object generates a Job URI based on its configured security policy and the URI used by the client in the create request. For example, consider a Printer object that supports both a communication channel secured by the use of SSL3 (using HTTP over SSL3 with an "https" schemed URI) and another open communication channel that is not secured with SSL3 (using a simple "http" schemed URI). If a client were to submit a job using the secure URI, the Printer object would assign the new Job object a secure URI as well. If a client were to submit a job using the open-channel URI, the Printer would assign the new Job object an open-channel URI. In addition, the Printer object also populates the Job object's "job-printer-uri" attribute. This is a reference back to the Printer object that created the Job object. If a client only has access to a Job object's "job-uri" identifier, the client can query the Job's "job-printer-uri" attribute in order to determine which Printer object created the Job object. If the Printer object supports more than one URI, the Printer object picks the one URI supplied by the client when creating the job to build the value for and to populate the Job's "job-printer-uri" attribute. Allowing Job objects to have URIs allows for flexibility and scalability. For example, in some implementations, the Printer object might create Jobs that are processed in the same local environment as the Printer object itself. In this case, the Job URI might just be a composition of the Printer's URI and some unique component for the Job object, such as the unique 32-bit positive integer mentioned later in this paragraph. In other implementations, the Printer object might be a central clearing-house for validating all Job object creation requests, but the Job object itself might be created in some environment that is remote from the Printer object. In this case, the Job object's URI may have no physical-location
relationship at all to the Printer object's URI. Again, the fact that Job objects have URIs allows for flexibility and scalability, however, many existing printing systems have local models or interface constraints that force print jobs to be identified using only a 32-bit positive integer rather than an independent URI. This numeric Job ID is only unique within the context of the Printer object to which the create request was originally submitted. Therefore, in order to allow both types of client access to IPP Job objects (either by Job URI or by numeric Job ID), when the Printer object successfully processes a create request and creates a new Job object, the Printer object MUST generate both a Job URI and a Job ID. The Job ID (stored in the "job-id" attribute) only has meaning in the context of the Printer object to which the create request was originally submitted. This requirement to support both Job URIs and Job IDs allows all types of clients to access Printer objects and Job objects no matter the local constraints imposed on the client implementation. In addition to identifiers, Printer objects and Job objects have names ("printer-name" and "job-name"). An object name NEED NOT be unique across all instances of all objects. A Printer object's name is chosen and set by an administrator through some mechanism outside the scope of this IPP/1.1 document. A Job object's name is optionally chosen and supplied by the IPP client submitting the job. If the client does not supply a Job object name, the Printer object generates a name for the new Job object. In all cases, the name only has local meaning. To summarize: - Each Printer object is identified with one or more URIs. The Printer's "printer-uri-supported" attribute contains the URI(s). - The Printer object's "uri-security-supported" attribute identifies the communication channel security protocols that may or may not have been configured for the various Printer object URIs (e.g., 'tls' or 'none'). - The Printer object's "uri-authentication-supported" attribute identifies the authentication mechanisms that may or may not have been configured for the various Printer object URIs (e.g., 'digest' or 'none'). - Each Job object is identified with a Job URI. The Job's "job- uri" attribute contains the URI. - Each Job object is also identified with Job ID which is a 32- bit, positive integer. The Job's "job-id" attribute contains the Job ID. The Job ID is only unique within the context of the Printer object which created the Job object.
- Each Job object has a "job-printer-uri" attribute which contains the URI of the Printer object that was used to create the Job object. This attribute is used to determine the Printer object that created a Job object when given only the URI for the Job object. This linkage is necessary to determine the languages, charsets, and operations which are supported on that Job (the basis for such support comes from the creating Printer object). - Each Printer object has a name (which is not necessarily unique). The administrator chooses and sets this name through some mechanism outside the scope of this IPP/1.1 document. The Printer object's "printer-name" attribute contains the name. - Each Job object has a name (which is not necessarily unique). The client optionally supplies this name in the create request. If the client does not supply this name, the Printer object generates a name for the Job object. The Job object's "job-name" attribute contains the name.