Tech-invite3GPPspaceIETFspace
959493929190898887868584838281807978777675747372717069686766656463626160595857565554535251504948474645444342414039383736353433323130292827262524232221201918171615141312111009080706050403020100
in Index   Prev   Next

RFC 2911

Internet Printing Protocol/1.1: Model and Semantics

Pages: 224
Obsoletes:  2566
Obsoleted by:  8011
Updated by:  33803382399639957472
Part 2 of 9 – Pages 20 to 40
First   Prev   Next

ToP   noToC   RFC2911 - Page 20   prevText

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.
ToP   noToC   RFC2911 - Page 21
   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.
ToP   noToC   RFC2911 - Page 22
   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
ToP   noToC   RFC2911 - Page 23
        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
ToP   noToC   RFC2911 - Page 24
   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
ToP   noToC   RFC2911 - Page 25
   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
ToP   noToC   RFC2911 - Page 26
         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
ToP   noToC   RFC2911 - Page 27
         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-
ToP   noToC   RFC2911 - Page 28
         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
ToP   noToC   RFC2911 - Page 29
   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
ToP   noToC   RFC2911 - Page 30
         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.
ToP   noToC   RFC2911 - Page 31
   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.
ToP   noToC   RFC2911 - Page 32

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.
ToP   noToC   RFC2911 - Page 33
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
ToP   noToC   RFC2911 - Page 34
   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.
ToP   noToC   RFC2911 - Page 35
   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
ToP   noToC   RFC2911 - Page 36
   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].
ToP   noToC   RFC2911 - Page 37
   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
ToP   noToC   RFC2911 - Page 38
   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.
ToP   noToC   RFC2911 - Page 39
   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
ToP   noToC   RFC2911 - Page 40
   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.


(next page on part 3)

Next Section