12.  The RPC Language

   Just as there was a need to describe the XDR data-types in a formal
   language, there is also need to describe the procedures that operate
   on these XDR data-types in a formal language as well.  The RPC
   language is an extension to the XDR language, with the addition of
   "program", "procedure", and "version" declarations.  The keywords
   "program" and "version" are reserved in the RPC language, and
   implementations of XDR compilers MAY reserve these keywords even when
   provided with pure XDR, non-RPC, descriptions.  The following example
   is used to describe the essence of the language.

12.1.  An Example Service Described in the RPC Language

   Here is an example of the specification of a simple ping program.

      program PING_PROG {
            /*
             * Latest and greatest version
             */
            version PING_VERS_PINGBACK {
               void
               PINGPROC_NULL(void) = 0;
               /*
                * Ping the client, return the round-trip time
                * (in microseconds).  Returns -1 if the operation
                * timed out.
                */
               int
               PINGPROC_PINGBACK(void) = 1;
            } = 2;

            /*
             * Original version
             */
            version PING_VERS_ORIG {
               void
               PINGPROC_NULL(void) = 0;
            } = 1;
         } = 1;

         const PING_VERS = 2;      /* latest version */

   The first version described is PING_VERS_PINGBACK with two
   procedures: PINGPROC_NULL and PINGPROC_PINGBACK.  PINGPROC_NULL takes
   no arguments and returns no results, but it is useful for computing
   round-trip times from the client to the server and back again.  By
   convention, procedure 0 of any RPC protocol should have the same
   semantics and never require any kind of authentication.  The second
   procedure is used for the client to have the server do a reverse ping
   operation back to the client, and it returns the amount of time (in
   microseconds) that the operation used.  The next version,
   PING_VERS_ORIG, is the original version of the protocol, and it does
   not contain the PINGPROC_PINGBACK procedure.  It is useful for
   compatibility with old client programs, and as this program matures,
   it may be dropped from the protocol entirely.

12.2.  The RPC Language Specification

   The RPC language is identical to the XDR language defined in RFC
   4506, except for the added definition of a "program-def", described
   below.

      program-def:
         "program" identifier "{"
            version-def
            version-def *
         "}" "=" constant ";"

      version-def:
         "version" identifier "{"
             procedure-def
             procedure-def *
         "}" "=" constant ";"

      procedure-def:
         proc-return identifier "(" proc-firstarg
           ("," type-specifier )* ")" "=" constant ";"

      proc-return: "void" | type-specifier

      proc-firstarg: "void" | type-specifier

12.3.  Syntax Notes

   o  The following keywords are added and cannot be used as
      identifiers: "program" and "version".

   o  A version name cannot occur more than once within the scope of a
      program definition.  Neither can a version number occur more than
      once within the scope of a program definition.

   o  A procedure name cannot occur more than once within the scope of a
      version definition.  Neither can a procedure number occur more
      than once within the scope of version definition.

   o  Program identifiers are in the same name space as constant and
      type identifiers.

   o  Only unsigned constants can be assigned to programs, versions, and
      procedures.

   o  Current RPC language compilers do not generally support more than
      one type-specifier in procedure argument lists; the usual practice
      is to wrap arguments into a structure.

13.  IANA Considerations

   The assignment of RPC program numbers, authentication flavor numbers,
   and authentication status numbers has in the past been performed by
   Sun Microsystems, Inc (Sun).  This is inappropriate for an IETF
   Standards Track protocol, as such work is done well by the Internet
   Assigned Numbers Authority (IANA).  This document proposes the
   transfer of authority over RPC program numbers, authentication flavor
   numbers, and authentication status numbers described here from Sun
   Microsystems, Inc. to IANA and describes how IANA will maintain and
   assign these numbers.  Users of RPC protocols will benefit by having
   an independent body responsible for these number assignments.

13.1.  Numbering Requests to IANA

   Appendix B of this document describes the information to be sent to
   IANA to request one or more RPC numbers and the rules that apply.
   IANA will store the request for documentary purposes and put the
   following information into the public registry:

   o  The short description of purpose and use

   o  The program number(s) assigned

   o  The short identifier string(s)

13.2.  Protecting Past Assignments

   Sun has made assignments in both the RPC program number space and the
   RPC authentication flavor number space since the original deployment
   of RPC.  The assignments made by Sun Microsystems are still valid,
   and will be preserved.  Sun has communicated all current assignments
   in both number spaces to IANA and final handoff of number assignment
   is complete.  Current program and auth number assignments are
   provided in Appendix C.  Current authentication status numbers are
   listed in Section 9 of this document in the "enum auth_stat"
   definition.

13.3.  RPC Number Assignment

   Future IANA practice will deal with the following partitioning of the
   32-bit number space as listed in Section 8.3.  Detailed information
   for the administration of the partitioned blocks in Section 8.3 is
   given below.

13.3.1.  To Be Assigned By IANA

   The first block will be administered by IANA, with previous
   assignments by Sun protected.  Previous assignments were restricted
   to the range decimal 100000-399999 (0x000186a0 to 0x00061a7f);
   therefore, IANA will begin assignments at decimal 400000.  Individual
   numbers should be grated on a First Come First Served basis, and
   blocks should be granted under rules related to the size of the
   block.

13.3.2.  Defined by Local Administrator

   The "Defined by local administrator" block is available for any local
   administrative domain to use, in a similar manner to IP address
   ranges reserved for private use.  The expected use would be through
   the establishment of a local domain "authority" for assigning numbers
   from this range.  This authority would establish any policies or
   procedures to be used within that local domain for use or assignment
   of RPC numbers from the range.  The local domain should be
   sufficiently isolated that it would be unlikely that RPC applications
   developed by other local domains could communicate with the domain.
   This could result in RPC number contention, which would cause one of
   the applications to fail.  In the absence of a local administrator,
   this block can be utilized in a "Private Use" manner per [RFC5226].

13.3.3.  Transient Block

   The "Transient" block can be used by any RPC application on an "as
   available" basis.  This range is intended for services that can
   communicate a dynamically selected RPC program number to clients of
   the service.  Any mechanism can be used to communicate the number.
   For example, either shared memory when the client and server are
   located on the same system or a network message (either RPC or
   otherwise) that disseminates the selected number can be used.

   The transient block is not administered.  An RPC service uses this
   range by selecting a number in the transient range and attempting to
   register that number with the local system's RPC bindery (see the
   RPCBPROC_SET or PMAPPROC_SET procedures in "Binding Protocols for ONC
   RPC Version 2", [RFC1833]).  If successful, no other RPC service was
   using that number and the RPC Bindery has assigned that number to the
   requesting RPC application.  The registration is valid until the RPC
   Bindery terminates, which normally would only happen if the system
   reboots, causing all applications, including the RPC service using
   the transient number, to terminate.  If the transient number
   registration fails, another RPC application is using the number and

   the requestor must select another number and try again.  To avoid
   conflicts, the recommended method is to select a number randomly from
   the transient range.

13.3.4.  Reserved Block

   The "Reserved" blocks are available for future use.  RPC applications
   must not use numbers in these ranges unless their use is allowed by
   future action by the IESG.

13.3.5.  RPC Number Sub-Blocks

   RPC numbers are usually assigned for specific RPC services.  Some
   applications, however, require multiple RPC numbers for a service.
   The most common example is an RPC service that needs to have multiple
   instances of the service active simultaneously at a specific site.
   RPC does not have an "instance identifier" in the protocol, so either
   a mechanism must be implemented to multiplex RPC requests amongst
   various instances of the service or unique RPC numbers must be used
   by each instance.

   In these cases, the RPC protocol used with the various numbers may be
   different or the same.  The numbers may either be assigned
   dynamically by the application, or as part of a site-specific
   administrative decision.  If possible, RPC services that dynamically
   assign RPC numbers should use the "Transient" RPC number block
   defined in Section 13.3.3.  If not possible, RPC number sub-blocks
   may be requested.

   Assignment of RPC Number Sub-Blocks is controlled by the size of the
   sub-block being requested.  "Specification Required" and "IESG
   Approval" are used as defined by Section 4.1 of [RFC5226].

   Size of sub-block        Assignment Method         Authority
   -----------------        -----------------         ---------
   Up to 100 numbers        First Come First Served   IANA
   Up to 1000 numbers       Specification Required    IANA
   More than 1000 numbers   IESG Approval required    IESG

   Note: sub-blocks can be any size.  The limits given above are
   maximums, and smaller size sub-blocks are allowed.

   Sub-blocks sized up to 100 numbers may be assigned by IANA on a First
   Come First Served basis.  The RPC Service Description included in the
   range must include an indication of how the sub-block is managed.  At
   a minimum, the statement should indicate whether the sub-block is

   used with a single RPC protocol or multiple RPC protocols, and
   whether the numbers are dynamically assigned or statically (through
   administrative action) assigned.

   Sub-blocks of up to 1000 numbers must be documented in detail.  The
   documentation must describe the RPC protocol or protocols that are to
   be used in the range.  It must also describe how the numbers within
   the sub-block are to be assigned or used.

   Sub-blocks sized over 1000 numbers must be documented as described
   above, and the assignment must be approved by the IESG.  It is
   expected that this will be rare.

   In order to avoid multiple requests of large blocks of numbers, the
   following rule is proposed.

   Requests up to and including 100 RPC numbers are handled via the
   First Come First Served assignment method.  This 100 number threshold
   applies to the total number of RPC numbers assigned to an individual
   or entity.  For example, if an individual or entity first requests,
   say, 70 numbers, and then later requests 40 numbers, then the request
   for the 40 numbers will be assigned via the Specification Required
   method.  As long as the total number of numbers assigned does not
   exceed 1000, IANA is free to waive the Specification Required
   assignment for incremental requests of less than 100 numbers.

   If an individual or entity has under 1000 numbers and later requests
   an additional set of numbers such that the individual or entity would
   be granted over 1000 numbers, then the additional request will
   require IESG Approval.

13.4.  RPC Authentication Flavor Number Assignment

   The second number space is the authentication mechanism identifier,
   or "flavor", number.  This number is used to distinguish between
   various authentication mechanisms that can be optionally used with an
   RPC message.  An authentication identifier is used in the "flavor"
   field of the "opaque_auth" structure.

13.4.1.  Assignment Policy

   Appendix B of this document describes the information to be sent to
   IANA to request one or more RPC auth numbers and the rules that
   apply.  IANA will store the request for documentary purposes and put
   the following information into the public registry:

   o  The short identifier string(s)

   o  The auth number(s) assigned

   o  The short description of purpose and use

13.4.2.  Auth Flavors vs. Pseudo-Flavors

   Recent progress in RPC security has moved away from new auth flavors
   as used by AUTH_DH [DH], and has focused on using the existing
   RPCSEC_GSS [RFC2203] flavor and inventing novel GSS-API (Generic
   Security Services Application Programming Interface) mechanisms that
   can be used with it.  Even though RPCSEC_GSS is an assigned
   authentication flavor, use of a new RPCSEC_GSS mechanism with the
   Network File System (NFS) ([RFC1094] [RFC1813], and [RFC3530]) will
   require the registration of 'pseudo-flavors' that are used to
   negotiate security mechanisms in an unambiguous way, as defined by
   [RFC2623].  Existing pseudo-flavors have been granted in the decimal
   range 390000-390255.  New pseudo-flavor requests will be granted by
   IANA within this block on a First Come First Served basis.

   For non-pseudo-flavor requests, IANA will begin granting RPC
   authentication flavor numbers at 400000 on a First Come First Served
   basis to avoid conflicts with currently granted numbers.

   For authentication flavors or RPCSEC_GSS mechanisms to be used on the
   Internet, it is strongly advised that an Informational or Standards
   Track RFC be published describing the authentication mechanism
   behaviour and parameters.

13.5.  Authentication Status Number Assignment

   The final number space is the authentication status or "auth_stat"
   values that describe the nature of a problem found during an attempt
   to authenticate or validate authentication.  The complete initial
   list of these values is found in Section 9 of this document, in the
   "auth_stat" enum listing.  It is expected that it will be rare to add
   values, but that a small number of new values may be added from time
   to time as new authentication flavors introduce new possibilities.
   Numbers should be granted on a First Come First Served basis to avoid
   conflicts with currently granted numbers.

13.5.1.  Assignment Policy

   Appendix B of this document describes the information to be sent to
   IANA to request one or more auth_stat values and the rules that
   apply.  IANA will store the request for documentary purposes, and put
   the following information into the public registry:

   o  The short identifier string(s)

   o  The auth_stat number(s) assigned

   o  The short description of purpose and use

14.  Security Considerations

   AUTH_SYS as described in Appendix A is known to be insecure due to
   the lack of a verifier to permit the credential to be validated.
   AUTH_SYS SHOULD NOT be used for services that permit clients to
   modify data.  AUTH_SYS MUST NOT be specified as RECOMMENDED or
   REQUIRED for any Standards Track RPC service.

   AUTH_DH as mentioned in Sections 8.2 and 13.4.2 is considered
   obsolete and insecure; see [RFC2695].  AUTH_DH SHOULD NOT be used for
   services that permit clients to modify data.  AUTH_DH MUST NOT be
   specified as RECOMMENDED or REQUIRED for any Standards Track RPC
   service.

   [RFC2203] defines a new security flavor, RPCSEC_GSS, which permits
   GSS-API [RFC2743] mechanisms to be used for securing RPC.  All non-
   trivial RPC programs developed in the future should implement
   RPCSEC_GSS-based security appropriately.  [RFC2623] describes how
   this was done for a widely deployed RPC program.

   Standards Track RPC services MUST mandate support for RPCSEC_GSS, and
   MUST mandate support for an authentication pseudo-flavor with
   appropriate levels of security, depending on the need for simple
   authentication, integrity (a.k.a. non-repudiation), or data privacy.

Appendix A: System Authentication

   The client may wish to identify itself, for example, as it is
   identified on a UNIX(tm) system.  The flavor of the client credential
   is "AUTH_SYS".  The opaque data constituting the credential encodes
   the following structure:

         struct authsys_parms {
            unsigned int stamp;
            string machinename<255>;
            unsigned int uid;
            unsigned int gid;
            unsigned int gids<16>;
         };

   The "stamp" is an arbitrary ID that the caller machine may generate.
   The "machinename" is the name of the caller's machine (like
   "krypton").  The "uid" is the caller's effective user ID.  The "gid"
   is the caller's effective group ID.  "gids" are a counted array of
   groups that contain the caller as a member.  The verifier
   accompanying the credential should have "AUTH_NONE" flavor value
   (defined above).  Note that this credential is only unique within a
   particular domain of machine names, uids, and gids.

   The flavor value of the verifier received in the reply message from
   the server may be "AUTH_NONE" or "AUTH_SHORT".  In the case of
   "AUTH_SHORT", the bytes of the reply verifier's string encode an
   opaque structure.  This new opaque structure may now be passed to the
   server instead of the original "AUTH_SYS" flavor credential.  The
   server may keep a cache that maps shorthand opaque structures (passed
   back by way of an "AUTH_SHORT" style reply verifier) to the original
   credentials of the caller.  The caller can save network bandwidth and
   server cpu cycles by using the shorthand credential.

   The server may flush the shorthand opaque structure at any time.  If
   this happens, the remote procedure call message will be rejected due
   to an authentication error.  The reason for the failure will be
   "AUTH_REJECTEDCRED".  At this point, the client may wish to try the
   original "AUTH_SYS" style of credential.

   It should be noted that use of this flavor of authentication does not
   guarantee any security for the users or providers of a service, in
   itself.  The authentication provided by this scheme can be considered
   legitimate only when applications using this scheme and the network
   can be secured externally, and privileged transport addresses are
   used for the communicating end-points (an example of this is the use
   of privileged TCP/UDP ports in UNIX systems -- note that not all
   systems enforce privileged transport address mechanisms).

Appendix B: Requesting RPC-Related Numbers from IANA

   RPC program numbers, authentication flavor numbers, and
   authentication status numbers that must be unique across all networks
   are assigned by the Internet Assigned Number Authority.  To apply for
   a single number or a block of numbers, electronic mail must be sent
   to IANA <iana@iana.org> with the following information:

   o  The type of number(s) (program number or authentication flavor
      number or authentication status number) sought

   o  How many numbers are sought

   o  The name of the person or company that will use the number

   o  An "identifier string" that associates the number with a service

   o  Email address of the contact person for the service that will be
      using the number

   o  A short description of the purpose and use of the number

   o  If an authentication flavor number is sought, and the number will
      be a 'pseudo-flavor' intended for use with RPCSEC_GSS and NFS,
      mappings analogous to those in Section 4.2 of [RFC2623]

   Specific numbers cannot be requested.  Numbers are assigned on a
   First Come First Served basis.

   For all RPC authentication flavor and authentication status numbers
   to be used on the Internet, it is strongly advised that an
   Informational or Standards Track RFC be published describing the
   authentication mechanism behaviour and parameters.