RFC 2911 - Internet Printing Protocol/1.1: Model and Semantics
(Formats: TXT)
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.
Hastings, et al. Standards Track [Page 1]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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.
Hastings, et al. Standards Track [Page 2]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 3]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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 88
the document format
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
Hastings, et al. Standards Track [Page 4]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 5]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 6]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 7]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 8]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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].
Hastings, et al. Standards Track [Page 9]
RFC 2911 IPP/1.1: Model and Semantics September 2000
- 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).
Hastings, et al. Standards Track [Page 10]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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,
Hastings, et al. Standards Track [Page 11]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 12]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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.
Hastings, et al. Standards Track [Page 13]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 14]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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)
Hastings, et al. Standards Track [Page 15]
RFC 2911 IPP/1.1: Model and Semantics September 2000
- "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.
Hastings, et al. Standards Track [Page 16]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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.
Hastings, et al. Standards Track [Page 17]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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
Hastings, et al. Standards Track [Page 18]
RFC 2911 IPP/1.1: Model and Semantics September 2000
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.
Hastings, et al. Standards Track [Page 19]
RFC 2911 IPP/1.1: Model and Semantics September 2000
- 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.
3. IPP Operations
IPP objects support operations. An operation consists of a request
and a response. When a client communicates with an IPP object, the
client issues an operation request to the URI for that object.
Operation requests and responses have parameters that identify the
operation. Operations also have attributes that affect the run-time
characteristics of the operation (the intended target, localization
information, etc.). These operation-specific attributes are called
operation attributes (as compared to object attributes such as
Printer object attributes or Job object attributes). Each request
carries along with it any operation attributes, object attributes,
and/or document data required to perform the operation. Each request
requires a response from the object. Each response indicates success
or failure of the operation with a status code as a response
parameter. The response contains any operation attributes, object
attributes, and/or status messages generated during the execution of
the operation request.
This section describes the semantics of the IPP operations, both
requests and responses, in terms of the parameters, attributes, and
other data associated with each operation.
Hastings, et al. Standards Track [Page 20]
RFC 2911 IPP/1.1: Model and Semantics September 2000
The IPP/1.1 Printer operations are:
Print-Job (section 3.2.1)
Print-URI (section 3.2.2)
Validate-Job (section 3.2.3)
Create-Job (section 3.2.4)
Get-Printer-Attributes (section 3.2.5)
Get-Jobs (section 3.2.6)
Pause-Printer (section 3.3.5)
Resume-Printer (section 3.3.6)
Purge-Jobs (section 3.3.7)
The Job operations are:
Send-Document (section 3.3.1)
Send-URI (section 3.3.2)
Cancel-Job (section 3.3.3)
Get-Job-Attributes (section 3.3.4)
Hold-Job (section 3.3.5)
Release-Job (section 3.3.6)
Restart-Job (section 3.3.7)
The Send-Document and Send-URI Job operations are used to add a new
document to an existing multi-document Job object created using the
Create-Job operation.
3.1 Common Semantics
All IPP operations require some common parameters and operation
attributes. These common elements and their semantic characteristics
are defined and described in more detail in the following sections.
3.1.1 Required Parameters
Every operation request contains the following REQUIRED parameters:
- a "version-number",
- an "operation-id",
- a "request-id", and
- the attributes that are REQUIRED for that type of request.
Every operation response contains the following REQUIRED parameters:
- a "version-number",
- a "status-code",
- the "request-id" that was supplied in the corresponding request,
and
- the attributes that are REQUIRED for that type of response.
Hastings, et al. Standards Track [Page 21]
RFC 2911 IPP/1.1: Model and Semantics September 2000
The "Encoding and Transport" document [RFC2910] defines special rules
for the encoding of these parameters. All other operation elements
are represented using the more generic encoding rules for attributes
and groups of attributes.
3.1.2 Operation IDs and Request IDs
Each IPP operation request includes an identifying "operation-id"
value. Valid values are defined in the "operations-supported"
Printer attribute section (see section 4.4.15). The client specifies
which operation is being requested by supplying the correct
"operation-id" value.
In addition, every invocation of an operation is identified by a
"request-id" value. For each request, the client chooses the
"request-id" which MUST be an integer (possibly unique depending on
client requirements) in the range from 1 to 2**31 - 1 (inclusive).
This "request-id" allows clients to manage multiple outstanding
requests. The receiving IPP object copies all 32-bits of the client-
supplied "request-id" attribute into the response so that the client
can match the response with the correct outstanding request, even if
the "request-id" is out of range. If the request is terminated
before the complete "request-id" is received, the IPP object rejects
the request and returns a response with a "request-id" of 0.
Note: In some cases, the transport protocol underneath IPP might be a
connection oriented protocol that would make it impossible for a
client to receive responses in any order other than the order in
which the corresponding requests were sent. In such cases, the
"request-id" attribute would not be essential for correct protocol
operation. However, in other mappings, the operation responses can
come back in any order. In these cases, the "request-id" would be
essential.
3.1.3 Attributes
Operation requests and responses are both composed of groups of
attributes and/or document data. The attributes groups are:
- Operation Attributes: These attributes are passed in the
operation and affect the IPP object's behavior while processing
the operation request and may affect other attributes or groups
of attributes. Some operation attributes describe the document
data associated with the print job and are associated with new
Job objects, however most operation attributes do not persist
beyond the life of the operation. The description of each
operation attribute includes conformance statements indicating
which operation attributes are REQUIRED and which are OPTIONAL
Hastings, et al. Standards Track [Page 22]
RFC 2911 IPP/1.1: Model and Semantics September 2000
for an IPP object to support and which attributes a client MUST
supply in a request and an IPP object MUST supply in a response.
- Job Template Attributes: These attributes affect the processing
of a job. A client OPTIONALLY supplies Job Template Attributes
in a create request, and the receiving object MUST be prepared
to receive all supported attributes. The Job object can later
be queried to find out what Job Template attributes were
originally requested in the create request, and such attributes
are returned in the response as Job Object Attributes. The
Printer object can be queried about its Job Template attributes
to find out what type of job processing capabilities are
supported and/or what the default job processing behaviors are,
though such attributes are returned in the response as Printer
Object Attributes. The "ipp-attribute-fidelity" operation
attribute affects processing of all client-supplied Job Template
attributes (see sections 3.2.1.2 and 15 for a full description
of "ipp-attribute-fidelity" and its relationship to other
attributes).
- Job Object Attributes: These attributes are returned in response
to a query operation directed at a Job object.
- Printer Object Attributes: These attributes are returned in
response to a query operation directed at a Printer object.
- Unsupported Attributes: In a create request, the client supplies
a set of Operation and Job Template attributes. If any of these
attributes or their values is unsupported by the Printer object,
the Printer object returns the set of unsupported attributes in
the response. Sections 3.1.7, 3.2.1.2, and 15 give a full
description of how Job Template attributes supplied by the
client in a create request are processed by the Printer object
and how unsupported attributes are returned to the client.
Because of extensibility, any IPP object might receive a request
that contains new or unknown attributes or values for which it
has no support. In such cases, the IPP object processes what it
can and returns the unsupported attributes in the response. The
Unsupported Attribute group is defined for all operation
responses for returning unsupported attributes that the client
supplied in the request.
Later in this section, each operation is formally defined by
identifying the allowed and expected groups of attributes for each
request and response. The model identifies a specific order for each
group in each request or response, but the attributes within each
group may be in any order, unless specified otherwise.
The attributes within a group MUST be unique; if an attribute with
the same name occurs more than once, the group is mal-formed.
Clients MUST NOT submit such malformed requests and Printers MUST NOT
return such malformed responses. If such a malformed request is
Hastings, et al. Standards Track [Page 23]
RFC 2911 IPP/1.1: Model and Semantics September 2000
submitted to a Printer, the Printer MUST either (1) reject the
request with the 'client-error-bad-request' status code (see section
13.1.4.1) or (2) process the request normally after selecting only
one of the attribute instances, depending on implementation. Which
attribute is selected when there are duplicate attributes depends on
implementation. The IPP Printer MUST NOT use the values from more
than one such duplicate attribute instance.
Each attribute definition includes the attribute's name followed by
the name of its attribute syntax(es) in parenthesizes. In addition,
each 'integer' attribute is followed by the allowed range in
parentheses, (m:n), for values of that attribute. Each 'text' or
'name' attribute is followed by the maximum size in octets in
parentheses, (size), for values of that attribute. For more details
on attribute syntax notation, see the descriptions of these
attributes syntaxes in section 4.1.
Note: Document data included in the operation is not strictly an
attribute, but it is treated as a special attribute group for
ordering purposes. The only operations that support supplying the
document data within an operation request are Print-Job and Send-
Document. There are no operation responses that include document
data.
Some operations are REQUIRED for IPP objects to support; the others
are OPTIONAL (see section 5.2.2). Therefore, before using an
OPTIONAL operation, a client SHOULD first use the REQUIRED Get-
Printer-Attributes operation to query the Printer's "operations-
supported" attribute in order to determine which OPTIONAL Printer and
Job operations are actually supported. The client SHOULD NOT use an
OPTIONAL operation that is not supported. When an IPP object
receives a request to perform an operation it does not support, it
returns the 'server-error-operation-not-supported' status code (see
section 13.1.5.2). An IPP object is non-conformant if it does not
support a REQUIRED operation.
3.1.4 Character Set and Natural Language Operation Attributes
Some Job and Printer attributes have values that are text strings and
names intended for human understanding rather than machine
understanding (see the 'text' and 'name' attribute syntax
descriptions in section 4.1). The following sections describe two
special Operation Attributes called "attributes-charset" and
"attributes-natural-language". These attributes are always part of
the Operation Attributes group. For most attribute groups, the order
of the attributes within the group is not important. However, for
these two attributes within the Operation Attributes group, the order
is critical. The "attributes-charset" attribute MUST be the first
Hastings, et al. Standards Track [Page 24]
RFC 2911 IPP/1.1: Model and Semantics September 2000
attribute in the group and the "attributes-natural-language"
attribute MUST be the second attribute in the group. In other words,
these attributes MUST be supplied in every IPP request and response,
they MUST come first in the group, and MUST come in the specified
order. For job creation operations, the IPP Printer implementation
saves these two attributes with the new Job object as Job Description
attributes. For the sake of brevity in this document, these
operation attribute descriptions are not repeated with every
operation request and response, but have a reference back to this
section instead.
3.1.4.1 Request Operation Attributes
The client MUST supply and the Printer object MUST support the
following REQUIRED operation attributes in every IPP/1.1 operation
request:
"attributes-charset" (charset):
This operation attribute identifies the charset (coded
character set and encoding method) used by any 'text' and
'name' attributes that the client is supplying in this request.
It also identifies the charset that the Printer object MUST use
(if supported) for all 'text' and 'name' attributes and status
messages that the Printer object returns in the response to
this request. See Sections 4.1.1 and 4.1.2 for the definition
of the 'text' and 'name' attribute syntaxes.
All clients and IPP objects MUST support the 'utf-8' charset
[RFC2279] and MAY support additional charsets provided that
they are registered with IANA [IANA-CS]. If the Printer object
does not support the client supplied charset value, the Printer
object MUST reject the request, set the "attributes-charset" to
'utf-8' in the response, and return the 'client-error-charset-
not-supported' status code and any 'text' or 'name' attributes
using the 'utf-8' charset. The Printer NEED NOT return any
attributes in the Unsupported Attributes Group (See sections
3.1.7 and 3.2.1.2). The Printer object MUST indicate the
charset(s) supported as the values of the "charset-supported"
Printer attribute (see Section 4.4.18), so that the client can
query to determine which charset(s) are supported.
Note to client implementers: Since IPP objects are only
required to support the 'utf-8' charset, in order to maximize
interoperability with multiple IPP object implementations, a
client may want to supply 'utf-8' in the "attributes-charset"
operation attribute, even though the client is only passing and
able to present a simpler charset, such as US-ASCII [ASCII] or
ISO-8859-1 [ISO8859-1]. Then the client will have to filter
Hastings, et al. Standards Track [Page 25]
RFC 2911 IPP/1.1: Model and Semantics September 2000
out (or charset convert) those characters that are returned in
the response that it cannot present to its user. On the other
hand, if both the client and the IPP objects also support a
charset in common besides utf-8, the client may want to use
that charset in order to avoid charset conversion or data loss.
See the 'charset' attribute syntax description in Section 4.1.7
for the syntax and semantic interpretation of the values of
this attribute and for example values.
"attributes-natural-language" (naturalLanguage):
This operation attribute identifies the natural language used
by any 'text' and 'name' attributes that the client is
supplying in this request. This attribute also identifies the
natural language that the Printer object SHOULD use for all
'text' and 'name' attributes and status messages that the
Printer object returns in the response to this request. See
the 'naturalLanguage' attribute syntax description in section
4.1.8 for the syntax and semantic interpretation of the values
of this attribute and for example values.
There are no REQUIRED natural languages required for the
Printer object to support. However, the Printer object's
"generated-natural-language-supported" attribute identifies the
natural languages supported by the Printer object and any
contained Job objects for all text strings generated by the IPP
object. A client MAY query this attribute to determine which
natural language(s) are supported for generated messages.
For any of the attributes for which the Printer object
generates text, i.e., for the "job-state-message", "printer-
state-message", and status messages (see Section 3.1.6), the
Printer object MUST be able to generate these text strings in
any of its supported natural languages. If the client requests
a natural language that is not supported, the Printer object
MUST return these generated messages in the Printer's
configured natural language as specified by the Printer's
"natural-language-configured" attribute" (see Section 4.4.19).
For other 'text' and 'name' attributes supplied by the client,
authentication system, operator, system administrator, or
manufacturer (i.e., for "job-originating-user-name", "printer-
name" (name), "printer-location" (text), "printer-info" (text),
and "printer-make-and-model" (text)), the Printer object is
only required to support the configured natural language of the
Hastings, et al. Standards Track [Page 26]
RFC 2911 IPP/1.1: Model and Semantics September 2000
Printer identified by the Printer object's "natural-language-
configured" attribute, though support of additional natural
languages for these attributes is permitted.
For any 'text' or 'name' attribute in the request that is in a
different natural language than the value supplied in the
"attributes-natural-language" operation attribute, the client
MUST use the Natural Language Override mechanism (see sections
4.1.1.2 and 4.1.2.2) for each such attribute value supplied.
The client MAY use the Natural Language Override mechanism
redundantly, i.e., use it even when the value is in the same
natural language as the value supplied in the "attributes-
natural-language" operation attribute of the request.
The IPP object MUST accept any natural language and any Natural
Language Override, whether the IPP object supports that natural
language or not (and independent of the value of the "ipp-
attribute-fidelity" Operation attribute). That is the IPP
object accepts all client supplied values no matter what the
values are in the Printer object's "generated-natural-
language-supported" attribute. That attribute, "generated-
natural-language-supported", only applies to generated
messages, not client supplied messages. The IPP object MUST
remember that natural language for all client-supplied
attributes, and when returning those attributes in response to
a query, the IPP object MUST indicate that natural language.
Each value whose attribute syntax type is 'text' or 'name' (see
sections 4.1.1 and 4.1.2) has an Associated Natural-Language.
This document does not specify how this association is stored
in a Printer or Job object. When such a value is encoded in a
request or response, the natural language is either implicit or
explicit:
- In the implicit case, the value contains only the text/name
value, and the language is specified by the "attributes-
natural-language" operation attribute in the request or
response (see sections 4.1.1.1 textWithoutLanguage and
4.1.2.1 nameWithoutLanguage).
- In the explicit case (also known as the Natural-Language
Override case), the value contains both the language and the
text/name value (see sections 4.1.1.2 textWithLanguage and
4.1.2.2 nameWithLanguage).
For example, the "job-name" attribute MAY be supplied by the
client in a create request. The text value for this attribute
will be in the natural language identified by the "attribute-
Hastings, et al. Standards Track [Page 27]
RFC 2911 IPP/1.1: Model and Semantics September 2000
natural-language" attribute, or if different, as identified by
the Natural Language Override mechanism. If supplied, the IPP
object will use the value of the "job-name" attribute to
populate the Job object's "job-name" attribute. Whenever any
client queries the Job object's "job-name" attribute, the IPP
object returns the attribute as stored and uses the Natural
Language Override mechanism to specify the natural language, if
it is different from that reported in the "attributes-natural-
language" operation attribute of the response. The IPP object
MAY use the Natural Language Override mechanism redundantly,
i.e., use it even when the value is in the same natural
language as the value supplied in the "attributes-natural-
language" operation attribute of the response.
An IPP object MUST NOT reject a request based on a supplied
natural language in an "attributes-natural-language" Operation
attribute or in any attribute that uses the Natural Language
Override.
Clients SHOULD NOT supply 'text' or 'name' attributes that use an
illegal combination of natural language and charset. For example,
suppose a Printer object supports charsets 'utf-8', 'iso-8859-1', and
'iso-8859-7'. Suppose also, that it supports natural languages 'en'
(English), 'fr' (French), and 'el' (Greek). Although the Printer
object supports the charset 'iso-8859-1' and natural language 'el',
it probably does not support the combination of Greek text strings
using the 'iso-8859-1' charset. The Printer object handles this
apparent incompatibility differently depending on the context in
which it occurs:
- In a create request: If the client supplies a text or name
attribute (for example, the "job-name" operation attribute) that
uses an apparently incompatible combination, it is a client
choice that does not affect the Printer object or its correct
operation. Therefore, the Printer object simply accepts the
client supplied value, stores it with the Job object, and
responds back with the same combination whenever the client (or
any client) queries for that attribute.
- In a query-type operation, like Get-Printer-Attributes: If the
client requests an apparently incompatible combination, the
Printer object responds (as described in section 3.1.4.2) using
the Printer's configured natural language rather than the
natural language requested by the client.
In either case, the Printer object does not reject the request
because of the apparent incompatibility. The potential incompatible
combination of charset and natural language can occur either at the
global operation level or at the Natural Language Override
Hastings, et al. Standards Track [Page 28]
RFC 2911 IPP/1.1: Model and Semantics September 2000
attribute-by-attribute level. In addition, since the response always
includes explicit charset and natural language information, there is
never any question or ambiguity in how the client interprets the
response.
3.1.4.2 Response Operation Attributes
The Printer object MUST supply and the client MUST support the
following REQUIRED operation attributes in every IPP/1.1 operation
response:
"attributes-charset" (charset):
This operation attribute identifies the charset used by any
'text' and 'name' attributes that the Printer object is
returning in this response. The value in this response MUST be
the same value as the "attributes-charset" operation attribute
supplied by the client in the request. If this is not possible
(i.e., the charset requested is not supported), the request
would have been rejected. See "attributes-charset" described
in Section 3.1.4.1 above.
If the Printer object supports more than just the 'utf-8'
charset, the Printer object MUST be able to code convert
between each of the charsets supported on a highest fidelity
possible basis in order to return the 'text' and 'name'
attributes in the charset requested by the client. However,
some information loss MAY occur during the charset conversion
depending on the charsets involved. For example, the Printer
object may convert from a UTF-8 'a' to a US-ASCII 'a' (with no
loss of information), from an ISO Latin 1 CAPITAL LETTER A WITH
ACUTE ACCENT to US-ASCII 'A' (losing the accent), or from a
UTF-8 Japanese Kanji character to some ISO Latin 1 error
character indication such as '?', decimal code equivalent, or
to the absence of a character, depending on implementation.
Whether an implementation that supports more than one charset
stores the data in the charset supplied by the client or code
converts to one of the other supported charsets, depends on
implementation. The strategy should try to minimize loss of
information during code conversion. On each response, such an
implementation converts from its internal charset to that
requested.
"attributes-natural-language" (naturalLanguage):
This operation attribute identifies the natural language used
by any 'text' and 'name' attributes that the IPP object is
returning in this response. Unlike the "attributes-charset"
operation attribute, the IPP object NEED NOT return the same
Hastings, et al. Standards Track [Page 29]
RFC 2911 IPP/1.1: Model and Semantics September 2000
value as that supplied by the client in the request. The IPP
object MAY return the natural language of the Job object or the
Printer's configured natural language as identified by the
Printer object's "natural-language-configured" attribute,
rather than the natural language supplied by the client. For
any 'text' or 'name' attribute or status message in the
response that is in a different natural language than the value
returned in the "attributes-natural-language" operation
attribute, the IPP object MUST use the Natural Language
Override mechanism (see sections 4.1.1.2 and 4.1.2.2) on each
attribute value returned. The IPP object MAY use the Natural
Language Override mechanism redundantly, i.e., use it even when
the value is in the same natural language as the value supplied
in the "attributes-natural-language" operation attribute of the
response.
3.1.5 Operation Targets
All IPP operations are directed at IPP objects. For Printer
operations, the operation is always directed at a Printer object
using one of its URIs (i.e., one of the values in the Printer
object's "printer-uri-supported" attribute). Even if the Printer
object supports more than one URI, the client supplies only one URI
as the target of the operation. The client identifies the target
object by supplying the correct URI in the "printer-uri (uri)"
operation attribute.
For Job operations, the operation is directed at either:
- The Job object itself using the Job object's URI. In this case,
the client identifies the target object by supplying the correct
URI in the "job-uri (uri)" operation attribute.
- The Printer object that created the Job object using both the
Printer objects URI and the Job object's Job ID. Since the
Printer object that created the Job object generated the Job ID,
it MUST be able to correctly associate the client supplied Job
ID with the correct Job object. The client supplies the Printer
object's URI in the "printer-uri (uri)" operation attribute and
the Job object's Job ID in the "job-id (integer(1:MAX))"
operation attribute.
If the operation is directed at the Job object directly using the Job
object's URI, the client MUST NOT include the redundant "job-id"
operation attribute.
Hastings, et al. Standards Track [Page 30]
RFC 2911 IPP/1.1: Model and Semantics September 2000
The operation target attributes are REQUIRED operation attributes
that MUST be included in every operation request. Like the charset
and natural language attributes (see section 3.1.4), the operation
target attributes are specially ordered operation attributes. In all
cases, the operation target attributes immediately follow the
"attributes-charset" and "attributes-natural-language" attributes
within the operation attribute group, however the specific ordering
rules are:
- In the case where there is only one operation target attribute
(i.e., either only the "printer-uri" attribute or only the
"job-uri" attribute), that attribute MUST be the third attribute
in the operation attributes group.
- In the case where Job operations use two operation target
attributes (i.e., the "printer-uri" and "job-id" attributes),
the "printer-uri" attribute MUST be the third attribute and the
"job-id" attribute MUST be the fourth attribute.
In all cases, the target URIs contained within the body of IPP
operation requests and responses must be in absolute format rather
than relative format (a relative URL identifies a resource with the
scope of the HTTP server, but does not include scheme, host or port).
The following rules apply to the use of port numbers in URIs that
identify IPP objects:
1. If the URI scheme allows the port number to be explicitly
included in the URI string, and a port number is specified
within the URI, then that port number MUST be used by the
client to contact the IPP object.
2. If the URI scheme allows the port number to be explicitly
included in the URI string, and a port number is not specified
within the URI, then default port number implied by that URI
scheme MUST be used by the client to contact the IPP object.
3. If the URI scheme does not allow an explicit port number to be
specified within the URI, then the default port number implied
by that URI MUST be used by the client to contact the IPP
object.
Note: The IPP "Encoding and Transport document [RFC2910] shows a
mapping of IPP onto HTTP/1.1 [RFC2616] and defines a new default port
number for using IPP over HTTP/1.1.
Hastings, et al. Standards Track [Page 31]
RFC 2911 IPP/1.1: Model and Semantics September 2000
3.1.6 Operation Response Status Codes and Status Messages
Every operation response includes a REQUIRED "status-code" parameter
and an OPTIONAL "status-message" operation attribute, and an OPTIONAL
"detailed-status-message" operation attribute. The Print-URI and
Send-URI response MAY include an OPTIONAL "document-access-error"
operation attribute.
3.1.6.1 "status-code" (type2 enum)
The REQUIRED "status-code" parameter provides information on the
processing of a request.
The status code is intended for use by automata. A client
implementation of IPP SHOULD convert status code values into any
localized message that has semantic meaning to the end user.
The "status-code" value is a numeric value that has semantic meaning.
The "status-code" syntax is similar to a "type2 enum" (see section
4.1 on "Attribute Syntaxes") except that values can range only from
0x0000 to 0x7FFF. Section 13 describes the status codes, assigns the
numeric values, and suggests a corresponding status message for each
status code for use by the client when the user's natural language is
English.
If the Printer performs an operation with no errors and it encounters
no problems, it MUST return the status code 'successful-ok' in the
response. See section 13.
If the client supplies unsupported values for the following
parameters or Operation attributes, the Printer object MUST reject
the operation, NEED NOT return the unsupported attribute value in the
Unsupported Attributes group, and MUST return the indicated status
code:
Parameter/Attribute Status code
version-number server-error-version-not-supported
operation-id server-error-operation-not-supported
attributes-charset client-error-charset-not-supported
compression client-error-compression-not-supported
document-format client-error-document-format-not-supported
document-uri client-error-uri-scheme-not-supported,
client-error-document-access-error
If the client supplies unsupported values for other attributes, or
unsupported attributes, the Printer returns the status code defined
in section 3.1.7 on Unsupported Attributes.
Hastings, et al. Standards Track [Page 32]
RFC 2911 IPP/1.1: Model and Semantics September 2000
3.1.6.2 "status-message" (text(255))
The OPTIONAL "status-message" operation attribute provides a short
textual description of the status of the operation. The "status-
message" attribute's syntax is "text(255)", so the maximum length is
255 octets (see section 4.1.1). The status message is intended for
the human end user. If a response does include a "status-message"
attribute, an IPP client NEED NOT examine or display the messages,
however it SHOULD do so in some implementation specific manner. The
"status-message" is especially useful for a later version of a
Printer object to return as supplemental information for the human
user to accompany a status code that an earlier version of a client
might not understand.
If the Printer object supports the "status-message" operation
attribute, the Printer object MUST be able to generate this message
in any of the natural languages identified by the Printer object's
"generated-natural-language-supported" attribute (see the
"attributes-natural-language" operation attribute specified in
section 3.1.4.1. Section 13 suggests the text for the status message
returned by the Printer for use with the English natural language.
As described in section 3.1.4.1 for any returned 'text' attribute, if
there is a choice for generating this message, the Printer object
uses the natural language indicated by the value of the "attributes-
natural-language" in the client request if supported, otherwise the
Printer object uses the value in the Printer object's own "natural-
language-configured" attribute.
If the Printer object supports the "status-message" operation
attribute, it SHOULD use the REQUIRED 'utf-8' charset to return a
status message for the following error status codes (see section 13):
'client-error-bad-request', 'client-error-charset-not-supported',
'server-error-internal-error', 'server-error-operation-not-
supported', and 'server-error-version-not-supported'. In this case,
it MUST set the value of the "attributes-charset" operation attribute
to 'utf-8' in the error response.
3.1.6.3 "detailed-status-message" (text(MAX))
The OPTIONAL "detailed-status-message" operation attribute provides
additional more detailed technical and implementation-specific
information about the operation. The "detailed-status-message"
attribute's syntax is "text(MAX)", so the maximum length is 1023
octets (see section 4.1.1). If the Printer objects supports the
"detailed-status-message" operation attribute, the Printer NEED NOT
localize the message, since it is intended for use by the system
administrator or other experienced technical persons. Localization
Hastings, et al. Standards Track [Page 33]
RFC 2911 IPP/1.1: Model and Semantics September 2000
might obscure the technical meaning of such messages. Clients MUST
NOT attempt to parse the value of this attribute. See the
"document-access-error" operation attribute (section 3.1.6.4) for
additional errors that a program can process.
3.1.6.4 "document-access-error" (text(MAX))
This OPTIONAL operation attribute provides additional information
about any document access errors encountered by the Printer before it
returned a response to the Print-URI (section 3.2.2) or Send-URI
(section 3.3.1) operation. For errors in the protocol identified by
the URI scheme in the "document-uri" operation attribute, such as
'http:' or 'ftp:', the error code is returned in parentheses,
followed by the URI. For example:
(404) http://ftp.pwg.org/pub/pwg/ipp/new_MOD/ipp-model-v11.pdf
Most Internet protocols use decimal error codes (unlike IPP), so the
ASCII error code representation is in decimal.
3.1.7 Unsupported Attributes
The Unsupported Attributes group contains attributes that are not
supported by the operation. This group is primarily for the job
creation operations, but all operations can return this group.
A Printer object MUST include an Unsupported Attributes group in a
response if the status code is one of the following: 'successful-
ok-ignored-or-substituted-attributes', 'successful-ok-conflicting-
attributes', 'client-error-attributes-or-values-not-supported' or
'client-error-conflicting-attributes'.
If the status code is one of the four specified in the preceding
paragraph, the Unsupported Attributes group MUST contain all of those
attributes and only those attributes that are:
a. an Operation or Job Template attribute supplied in the request,
and
b. unsupported by the printer. See below for details on the three
categories "unsupported" attributes.
If the status code is one of those in the table in section 3.1.6.1,
the Unsupported Attributes group NEED NOT contain the unsupported
parameter or attribute indicated in that table.
Hastings, et al. Standards Track [Page 34]
RFC 2911 IPP/1.1: Model and Semantics September 2000
If the Printer object is not returning any Unsupported Attributes in
the response, the Printer object SHOULD omit Group 2 rather than
sending an empty group. However, a client MUST be able to accept an
empty group.
Unsupported attributes fall into three categories:
1. The Printer object does not support the supplied attribute (no
matter what the attribute syntax or value).
2. The Printer object does support the attribute, but does not
support some or all of the particular attribute syntaxes or
values supplied by the client (i.e., the Printer object does
not have those attribute syntaxes or values in its
corresponding "xxx-supported" attribute).
3. The Printer object does support the attributes and values
supplied, but the particular values are in conflict with one
another, because they violate a constraint, such as not being
able to staple transparencies.
In the case of an unsupported attribute name, the Printer object
returns the client-supplied attribute with a substituted value of
'unsupported'. This value's syntax type is "out-of-band" and its
encoding is defined by special rules for "out-of-band" values in the
"Encoding and Transport" document [RFC2910]. Its value indicates no
support for the attribute itself (see the beginning of section 4.1).
In the case of a supported attribute with one or more unsupported
attribute syntaxes or values, the Printer object simply returns the
client-supplied attribute with the unsupported attribute syntaxes or
values as supplied by the client. This indicates support for the
attribute, but no support for that particular attribute syntax or
value. If the client supplies a multi-valued attribute with more
than one value and the Printer object supports the attribute but only
supports a subset of the client-supplied attribute syntaxes or
values, the Printer object
MUST return only those attribute syntaxes or values that are
unsupported.
In the case of two (or more) supported attribute values that are in
conflict with one another (although each is supported independently,
the values conflict when requested together within the same job), the
Printer object MUST return all the values that it ignores or
substitutes to resolve the conflict, but not any of the values that
Hastings, et al. Standards Track [Page 35]
RFC 2911 IPP/1.1: Model and Semantics September 2000
it is still using. The choice for exactly how to resolve the
conflict is implementation dependent. See sections 3.2.1.2 and 15.
See The Implementer's Guide [IPP-IIG] for an example.
3.1.8 Versions
Each operation request and response carries with it a "version-
number" parameter. Each value of the "version-number" is in the form
"X.Y" where X is the major version number and Y is the minor version
number. By including a version number in the client request, it
allows the client to identify which version of IPP it is interested
in using, i.e., the version whose conformance requirements the client
may be depending upon the Printer to meet.
If the IPP object does not support that major version number supplied
by the client, i.e., the major version field of the "version-number"
parameter does not match any of the values of the Printer's "ipp-
versions-supported" (see section 4.4.14), the object MUST respond
with a status code of 'server-error-version-not-supported' along with
the closest version number that is supported (see section 13.1.5.4).
If the major version number is supported, but the minor version
number is not, the IPP object SHOULD accept and attempt to perform
the request (or reject the request if the operation is not
supported), else it rejects the request and returns the 'server-
error-version-not-supported' status code. In all cases, the IPP
object MUST return the "version-number" that it supports that is
closest to the version number supplied by the client in the request.
There is no version negotiation per se. However, if after receiving
a 'server-error-version-not-supported' status code from an IPP
object, a client SHOULD try again with a different version number. A
client MAY also determine the versions supported either from a
directory that conforms to Appendix E (see section 16) or by querying
the Printer object's "ipp-versions-supported" attribute (see section
4.4.14) to determine which versions are supported.
An IPP object implementation MUST support version '1.1', i.e., meet
the conformance requirements for IPP/1.1 as specified in this
document and [RFC2910]. It is recommended that IPP object
implementations accept any request with the major version '1' (or
reject the request if the operation is not supported).
There is only one notion of "version number" that covers both IPP
Model and IPP Protocol changes. Thus the version number MUST change
when introducing a new version of the Model and Semantics document
(this document) or a new version of the "Encoding and Transport"
document [RFC2910].
Hastings, et al. Standards Track [Page 36]
RFC 2911 IPP/1.1: Model and Semantics September 2000
Changes to the major version number of the Model and Semantics
document indicate structural or syntactic changes that make it
impossible for older version of IPP clients and Printer objects to
correctly parse and correctly process the new or changed attributes,
operations and responses. If the major version number changes, the
minor version numbers is set to zero. As an example, adding the
REQUIRED "ipp-attribute-fidelity" attribute to version '1.1' (if it
had not been part of version '1.0'), would have required a change to
the major version number, since an IPP/1.0 Printer would not have
processed a request with the correct semantics that contained the
"ipp-attribute-fidelity" attribute that it did not know about. Items
that might affect the changing of the major version number include
any changes to the Model and Semantics document (this document) or
the "Encoding and Transport" document [RFC2910] itself, such as:
- reordering of ordered attributes or attribute sets
- changes to the syntax of existing attributes
- adding REQUIRED (for an IPP object to support) operation
attribute groups
- adding values to existing REQUIRED operation attributes
- adding REQUIRED operations
Changes to the minor version number indicate the addition of new
features, attributes and attribute values that may not be understood
by all IPP objects, but which can be ignored if not understood.
Items that might affect the changing of the minor version number
include any changes to the model objects and attributes but not the
encoding and transport rules [RFC2910] (except adding attribute
syntaxes). Examples of such changes are:
- grouping all extensions not included in a previous version into
a new version
- adding new attribute values
- adding new object attributes
- adding OPTIONAL (for an IPP object to support) operation
attributes (i.e., those attributes that an IPP object can ignore
without confusing clients)
- adding OPTIONAL (for an IPP object to support) operation
attribute groups (i.e., those attributes that an IPP object can
ignore without confusing clients)
- adding new attribute syntaxes
- adding OPTIONAL operations
- changing Job Description attributes or Printer Description
attributes from OPTIONAL to REQUIRED or vice versa.
- adding OPTIONAL attribute syntaxes to an existing attribute.
The encoding of the "version-number" MUST NOT change over any version
number (either major or minor). This rule guarantees that all future
Hastings, et al. Standards Track [Page 37]
RFC 2911 IPP/1.1: Model and Semantics September 2000
versions will be backwards compatible with all previous versions (at
least for checking the "version-number"). In addition, any protocol
elements (attributes, error codes, tags, etc.) that are not carried
forward from one version to the next are deprecated so that they can
never be reused with new semantics.
Implementations that support a certain version NEED NOT support ALL
previous versions. As each new version is defined (through the
release of a new IPP specification document), that version will
specify which previous versions MUST and which versions SHOULD be
supported in compliant implementations.
3.1.9 Job Creation Operations
In order to "submit a print job" and create a new Job object, a
client issues a create request. A create request is any one of
following three operation requests:
- The Print-Job Request: A client that wants to submit a print job
with only a single document uses the Print-Job operation. The
operation allows for the client to "push" the document data to
the Printer object by including the document data in the request
itself.
- The Print-URI Request: A client that wants to submit a print job
with only a single document (where the Printer object "pulls"
the document data instead of the client "pushing" the data to
the Printer object) uses the Print-URI operation. In this
case, the client includes in the request only a URI reference to
the document data (not the document data itself).
- The Create-Job Request: A client that wants to submit a print
job with multiple documents uses the Create-Job operation. This
operation is followed by an arbitrary number (one or more) of
Send-Document and/or Send-URI operations (each creating another
document for the newly create Job object). The Send-Document
operation includes the document data in the request (the client
"pushes" the document data to the printer), and the Send-URI
operation includes only a URI reference to the document data in
the request (the Printer "pulls" the document data from the
referenced location). The last Send-Document or Send-URI
request for a given Job object includes a "last-document"
operation attribute set to 'true' indicating that this is the
last request.
Throughout this model document, the term "create request" is used to
refer to any of these three operation requests.
Hastings, et al. Standards Track [Page 38]
RFC 2911 IPP/1.1: Model and Semantics September 2000
A Create-Job operation followed by only one Send-Document operation
is semantically equivalent to a Print-Job operation, however, for
performance reasons, the client SHOULD use the Print-Job operation
for all single document jobs. Also, Print-Job is a REQUIRED
operation (all implementations MUST support it) whereas Create-Job is
an OPTIONAL operation, hence some implementations might not support
it.
Job submission time is the point in time when a client issues a
create request. The initial state of every Job object is the
'pending', 'pending-held', or 'processing' state (see section 4.3.7).
When the Printer object begins processing the print job, the Job
object's state moves to 'processing'. This is known as job
processing time. There are validation checks that must be done at
job submission time and others that must be performed at job
processing time.
At job submission time and at the time a Validate-Job operation is
received, the Printer MUST do the following:
1. Process the client supplied attributes and either accept or
reject the request
2. Validate the syntax of and support for the scheme of any client
supplied URI
At job submission time the Printer object MUST validate whether or
not the supplied attributes, attribute syntaxes, and values are
supported by matching them with the Printer object's corresponding
"xxx-supported" attributes. See section 3.1.7 for details. [IPP-
IIG] presents suggested steps for an IPP object to either accept or
reject any request and additional steps for processing create
requests.
At job submission time the Printer object NEED NOT perform the
validation checks reserved for job processing time such as:
1. Validating the document data
2. Validating the actual contents of any client supplied URI
(resolve the reference and follow the link to the document
data)
At job submission time, these additional job processing time
validation checks are essentially useless, since they require
actually parsing and interpreting the document data, are not
guaranteed to be 100% accurate, and MUST be done, yet again, at job
processing time. Also, in the case of a URI, checking for
availability at job submission time does not guarantee availability
Hastings, et al. Standards Track [Page 39]
RFC 2911 IPP/1.1: Model and Semantics September 2000
at job processing time. In addition, at job processing time, the
Printer object might discover any of the following conditions that
were not detectable at job submission time:
- runtime errors in the document data,
- nested document data that is in an unsupported format,
- the URI reference is no longer valid (i.e., the server hosting
the document might be down), or
- any other job processing error
At job submission time, a Printer object, especially a non-spooling
Printer, MAY accept jobs that it does not have enough space for. In
such a situation, a Printer object MAY stop reading data from a
client for an indefinite period of time. A client MUST be prepared
for a write operation to block for an indefinite period of time (see
section 5.1 on client conformance).
When a Printer object has too little space for starting a new job, it
MAY reject a new create request. In this case, a Printer object MUST
return a response (in reply to the rejected request) with a status-
code of 'server-error-busy' (see section 14.1.5.8) and it MAY close
the connection before receiving all bytes of the operation. A
Printer SHOULD indicate that it is temporarily unable to accept jobs
by setting the 'spool-space-full' value in its "printer-state-
reasons" attribute and removing the value when it can accept another
job (see section 4.4.12).
When receiving a 'server-error-busy' status-code in an operation
response, a client MUST be prepared for the Printer object to close
the connection before the client has sent all of the data (especially
for the Print-Job operation). A client MUST be prepared to keep
submitting a create request until the IPP Printer object accepts the
create request.
At job processing time, since the Printer object has already
responded with a successful status code in the response to the create
request, if the Printer object detects an error, the Printer object
is unable to inform the end user of the error with an operation
status code. In this case, the Printer, depending on the error, can
set the job object's "job-state", "job-state-reasons", or "job-
state-message" attributes to the appropriate value(s) so that later
queries can report the correct job status.
Note: Asynchronous notification of events is outside the scope of
this IPP/1.1 document.
Hastings, et al. Standards Track [Page 40]
RFC 2911 IPP/1.1: Model and Semantics September 2000
3.2 Printer Operations
All Printer operations are directed at Printer objects. A client
MUST always supply the "printer-uri" operation attribute in order to
identify the correct target of the operation.
3.2.1 Print-Job Operation
This REQUIRED operation allows a client to submit a print job with
only one document and supply the document data (rather than just a
reference to the data). See Section 15 for the suggested steps for
processing create operations and their Operation and Job Template
attributes.
3.2.1.1 Print-Job Request
The following groups of attributes are supplied as part of the
Print-Job Request:
Group 1: Operation Attributes
Natural Language and Character Set:
The "attributes-charset" and "attributes-natural-language"
attributes as described in section 3.1.4.1. The Printer object
MUST copy these values to the corresponding Job Description
attributes described in sections 4.3.19 and 4.3.20.
Target:
The "printer-uri" (uri) operation attribute which is the target
for this operation as described in section 3.1.5.
Requesting User Name:
The "requesting-user-name" (name(MAX)) attribute SHOULD be
supplied by the client as described in section 8.3.
"job-name" (name(MAX)):
The client OPTIONALLY supplies this attribute. The Printer
object MUST support this attribute. It contains the client
supplied Job name. If this attribute is supplied by the
client, its value is used for the "job-name" attribute of the
newly created Job object. The client MAY automatically include
any information that will help the end-user distinguish amongst
his/her jobs, such as the name of the application program along
with information from the document, such as the document name,
document subject, or source file name. If this attribute is
not supplied by the client, the Printer generates a name to use
in the "job-name" attribute of the newly created Job object
(see Section 4.3.5).
Hastings, et al. Standards Track [Page 41]
RFC 2911 IPP/1.1: Model and Semantics September 2000
"ipp-attribute-fidelity" (boolean):
The client OPTIONALLY supplies this attribute. The Printer
object MUST support this attribute. The value 'true' indicates
that total fidelity to client supplied Job Template attributes
and values is required, else the Printer object MUST reject the
Print-Job request. The value 'false' indicates that a
reasonable attempt to print the Job object is acceptable and
the Printer object MUST accept the Print-Job request. If not
supplied, the Printer object assumes the value is 'false'. All
Printer objects MUST support both types of job processing. See
section 15 for a full description of "ipp-attribute-fidelity"
and its relationship to other attributes, especially the
Printer object's "pdl-override-supported" attribute.
"document-name" (name(MAX)):
The client OPTIONALLY supplies this attribute. The Printer
object MUST support this attribute. It contains the client
supplied document name. The document name MAY be different
than the Job name. Typically, the client software
automatically supplies the document name on behalf of the end
user by using a file name or an application generated name. If
this attribute is supplied, its value can be used in a manner
defined by each implementation. Examples include: printed
along with the Job (job start sheet, page adornments, etc.),
used by accounting or resource tracking management tools, or
even stored along with the document as a document level
attribute. IPP/1.1 does not support the concept of document
level attributes.
"compression" (type3 keyword):
The client OPTIONALLY supplies this attribute. The Printer
object MUST support this attribute and the "compression-
supported" attribute (see section 4.4.32). The client supplied
"compression" operation attribute identifies the compression
algorithm used on the document data. The following cases exist:
a) If the client omits this attribute, the Printer object MUST
assume that the data is not compressed (i.e. the Printer
follows the rules below as if the client supplied the
"compression" attribute with a value of 'none').
b) If the client supplies this attribute, but the value is not
supported by the Printer object, i.e., the value is not one
of the values of the Printer object's "compression-
supported" attribute, the Printer object MUST reject the
request, and return the 'client-error-compression-not-
supported' status code. See section 3.1.7 for returning
unsupported attributes and values.
Hastings, et al. Standards Track [Page 42]
RFC 2911 IPP/1.1: Model and Semantics September 2000
c) If the client supplies the attribute and the Printer object
supports the attribute value, the Printer object uses the
corresponding decompression algorithm on the document data.
d) If the decompression algorithm fails before the Printer
returns an operation response, the Printer object MUST
reject the request and return the 'client-error-
compression-error' status code.
e) If the decompression algorithm fails after the Printer
returns an operation response, the Printer object MUST abort
the job and add the 'compression-error' value to the job's
"job-state-reasons" attribute.
f) If the decompression algorithm succeeds, the document data
MUST then have the format specified by the job's "document-
format" attribute, if supplied (see "document-format"
operation attribute definition below).
"document-format" (mimeMediaType):
The client OPTIONALLY supplies this attribute. The Printer
object MUST support this attribute. The value of this
attribute identifies the format of the supplied document data.
The following cases exist:
a) If the client does not supply this attribute, the Printer
object assumes that the document data is in the format
defined by the Printer object's "document-format-default"
attribute. (i.e. the Printer follows the rules below as if
|
