Tech-invite3GPPspaceIETFspace
96959493929190898887868584838281807978777675747372717069686766656463626160595857565554535251504948474645444342414039383736353433323130292827262524232221201918171615141312111009080706050403020100
in Index   Prev   Next

RFC 2911

Internet Printing Protocol/1.1: Model and Semantics

Pages: 224
Obsoletes:  2566
Obsoleted by:  8011
Updated by:  33803382399639957472
Part 1 of 9 – Pages 1 to 20
None   None   Next

ToP   noToC   RFC2911 - Page 1
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.

Abstract

This 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.
ToP   noToC   RFC2911 - Page 2
   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.
ToP   noToC   RFC2911 - Page 3

Table of Contents

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 3.1.4.1 Request Operation Attributes 25 3.1.4.2 Response Operation Attributes 29 3.1.5 Operation Targets 30 3.1.6 Operation Response Status Codes and Status Messages 32 3.1.6.1 "status-code" (type2 enum) 32 3.1.6.2 "status-message" (text(255)) 33 3.1.6.3 "detailed-status-message" (text(MAX)) 33 3.1.6.4 "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 3.2.1.1 Print-Job Request 41 3.2.1.2 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 3.2.5.1 Get-Printer-Attributes Request 51 3.2.5.2 Get-Printer-Attributes Response 53 3.2.6 Get-Jobs Operation 54 3.2.6.1 Get-Jobs Request 54 3.2.6.2 Get-Jobs Response 56 3.2.7 Pause-Printer Operation 57 3.2.7.1 Pause-Printer Request 59 3.2.7.2 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 3.3.1.1 Send-Document Request 64 3.3.1.2 Send-Document Response 65
ToP   noToC   RFC2911 - Page 4
   3.3.2  Send-URI Operation                                        66
   3.3.3  Cancel-Job Operation                                      66
   3.3.3.1   Cancel-Job Request                                     67
   3.3.3.2   Cancel-Job Response                                    68
   3.3.4  Get-Job-Attributes Operation                              69
   3.3.4.1   Get-Job-Attributes Request                             69
   3.3.4.2   Get-Job-Attributes Response                            70
   3.3.5  Hold-Job Operation                                        71
   3.3.5.1   Hold-Job Request                                       72
   3.3.5.2   Hold-Job Response                                      73
   3.3.6  Release-Job Operation                                     74
   3.3.7  Restart-Job Operation                                     75
   3.3.7.1   Restart-Job Request                                    76
   3.3.7.2   Restart-Job Response                                   78
   4.   Object Attributes                                           78
   4.1   Attribute Syntaxes                                         78
   4.1.1  'text'                                                    79
   4.1.1.1   'textWithoutLanguage'                                  80
   4.1.1.2   'textWithLanguage'                                     80
   4.1.2  'name'                                                    81
   4.1.2.1   'nameWithoutLanguage'                                  82
   4.1.2.2   'nameWithLanguage'                                     82
   4.1.2.3   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
   4.1.9.1 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
ToP   noToC   RFC2911 - Page 5
   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
   4.3.7.1   Forwarding Servers                                    112
   4.3.7.2   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
   4.3.14.1  time-at-creation (integer(MIN:MAX))                   120
   4.3.14.2  time-at-processing (integer(MIN:MAX))                 120
   4.3.14.3  time-at-completed (integer(MIN:MAX))                  120
   4.3.14.4  job-printer-up-time (integer(1:MAX))                  120
   4.3.14.5  date-time-at-creation (dateTime)                      121
   4.3.14.6  date-time-at-processing (dateTime)                    121
   4.3.14.7  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
   4.3.17.1  job-k-octets (integer(0:MAX))                         122
   4.3.17.2  job-impressions (integer(0:MAX))                      122
   4.3.17.3  job-media-sheets (integer(0:MAX))                     123
   4.3.18 Job Progress Attributes                                  123
   4.3.18.1  job-k-octets-processed (integer(0:MAX))               123
   4.3.18.2  job-impressions-completed (integer(0:MAX))            123
   4.3.18.3  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
ToP   noToC   RFC2911 - Page 6
   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
ToP   noToC   RFC2911 - Page 7
   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
   12.2.2.1  Attribute Name                                        173
   12.2.2.2  Attribute Group Name                                  174
   12.2.2.3  Attribute Value                                       174
   12.2.2.4  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
ToP   noToC   RFC2911 - Page 8
   13.1.2.1  successful-ok (0x0000)                                178
   13.1.2.2  successful-ok-ignored-or-substituted-attributes
             (0x0001)                                              179
   13.1.2.3  successful-ok-conflicting-attributes (0x0002)         179
   13.1.3 Redirection Status Codes                                 179
   13.1.4 Client Error Status Codes                                179
   13.1.4.1  client-error-bad-request (0x0400)                     180
   13.1.4.2  client-error-forbidden (0x0401)                       180
   13.1.4.3  client-error-not-authenticated (0x0402)               180
   13.1.4.4  client-error-not-authorized (0x0403)                  180
   13.1.4.5  client-error-not-possible (0x0404)                    180
   13.1.4.6  client-error-timeout (0x0405)                         181
   13.1.4.7  client-error-not-found (0x0406)                       181
   13.1.4.8  client-error-gone (0x0407)                            181
   13.1.4.9  client-error-request-entity-too-large (0x0408)        182
   13.1.4.10 client-error-request-value-too-long (0x0409)          182
   13.1.4.11 client-error-document-format-not-supported (0x040A)   182
   13.1.4.12 client-error-attributes-or-values-not-supported
             (0x040B)                                              183
   13.1.4.13 client-error-uri-scheme-not-supported (0x040C)        183
   13.1.4.14 client-error-charset-not-supported (0x040D)           183
   13.1.4.15 client-error-conflicting-attributes (0x040E)          183
   13.1.4.16 client-error-compression-not-supported (0x040F)       184
   13.1.4.17 client-error-compression-error (0x0410)               184
   13.1.4.18 client-error-document-format-error (0x0411)           184
   13.1.4.19 client-error-document-access-error (0x0412)           184
   13.1.5    Server Error Status Codes                             185
   13.1.5.1  server-error-internal-error (0x0500)                  185
   13.1.5.2  server-error-operation-not-supported (0x0501)         185
   13.1.5.3  server-error-service-unavailable (0x0502)             185
   13.1.5.4  server-error-version-not-supported (0x0503)           185
   13.1.5.5  server-error-device-error (0x0504)                    186
   13.1.5.6  server-error-temporary-error (0x0505)                 186
   13.1.5.7  server-error-not-accepting-jobs (0x0506)              187
   13.1.5.8  server-error-busy (0x0507)                            187
   13.1.5.9  server-error-job-canceled (0x0508)                    187
   13.1.5.10 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
ToP   noToC   RFC2911 - Page 9

1. Introduction

The Internet Printing Protocol (IPP) is an application level protocol that can be used for distributed printing using Internet tools and technologies. IPP version 1.1 (IPP/1.1) focuses primarily on end user functionality with a few administrative operations included. This document is just one of a suite of documents that fully define IPP. 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] 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].
ToP   noToC   RFC2911 - Page 10
   - 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.

1.1 Simplified Printing Model

In order to achieve its goal of realizing a workable printing protocol for the Internet, the Internet Printing Protocol (IPP) is based on a simplified printing model that abstracts the many components of real world printing solutions. The Internet is a distributed computing environment where requesters of print services (clients, applications, printer drivers, etc.) cooperate and interact with print service providers. This model and semantics document describes a simple, abstract model for IPP even though the underlying configurations may be complex "n-tier" client/server systems. An important simplifying step in the IPP model is to expose only the key objects and interfaces required for printing. The model described in this model document does not include features, interfaces, and relationships that are beyond the scope of the first version of IPP (IPP/1.1). IPP/1.1 incorporates many of the relevant ideas and lessons learned from other specification and development efforts [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).
ToP   noToC   RFC2911 - Page 11
   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,
ToP   noToC   RFC2911 - Page 12
   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.

2. IPP Objects

The IPP/1.1 model introduces objects of type Printer and Job. Each type of object models relevant aspects of a real-world entity such as a real printer or real print job. Each object type is defined as a set of possible attributes that may be supported by instances of that object type. For each object (instance), the actual set of supported attributes and values describe a specific implementation. The object's attributes and values describe its state, capabilities, realizable features, job processing functions, and default behaviors
ToP   noToC   RFC2911 - Page 13
   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.

2.1 Printer Object

The major component of the IPP/1.1 model is the Printer object. A Printer object implements the server-side of the IPP/1.1 protocol. Using the protocol, end users may query the attributes of the Printer object and submit print jobs to the Printer object. The actual implementation components behind the Printer abstraction may take on different forms and different configurations. However, the model abstraction allows the details of the configuration of real components to remain opaque to the end user. 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.
ToP   noToC   RFC2911 - Page 14
   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
ToP   noToC   RFC2911 - Page 15
   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 |
                                            |               |
                                            +---------------+

2.2 Job Object

A Job object is used to model a print job. A Job object contains documents. The information required to create a Job object is sent in a create request from the end user via an IPP Client to the Printer object. The Printer object validates the create request, and if the Printer object accepts the request, the Printer object creates the new Job object. 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)
ToP   noToC   RFC2911 - Page 16
      - "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.

2.3 Object Relationships

IPP objects have relationships that are maintained persistently along with the persistent storage of the object attributes. A Printer object can represent either one or more physical output devices or a logical device which "processes" jobs but never actually uses a physical output device to put marks on paper. Examples of logical devices include a Web page publisher or a gateway into an online document archive or repository. A Printer object contains zero or more Job objects. A Job object is contained by exactly one Printer object, however the identical document data associated with a Job object could be sent to either the same or a different Printer object. In this case, a second Job object would be created which would be almost identical to the first Job object, however it would have new (different) Job object identifiers (see 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.
ToP   noToC   RFC2911 - Page 17

2.4 Object Identity

All Printer and Job objects are identified by a Uniform Resource Identifier (URI) [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.
ToP   noToC   RFC2911 - Page 18
   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
ToP   noToC   RFC2911 - Page 19
   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.
ToP   noToC   RFC2911 - Page 20
      - 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.



(page 20 continued on part 2)

Next Section