xdr.rfc.ms

RTEMS (Real-Time Executive for Multiprocessor Systems) is a free open source real-time operating sys

.\"
.\"  Must use -- tbl -- with this one
.\"
.\" @(#)xdr.rfc.ms	2.2 88/08/05 4.0 RPCSRC
.de BT
.if \\n%=1 .tl ''- % -''
..
.ND
.\" prevent excess underlining in nroff
.if n .fp 2 R
.OH 'External Data Representation Standard''Page %'
.EH 'Page %''External Data Representation Standard'
.IX "External Data Representation"
.if \\n%=1 .bp
.SH
\&External Data Representation Standard: Protocol Specification
.IX XDR RFC
.IX XDR "protocol specification"
.LP
.NH 0
\&Status of this Standard
.nr OF 1
.IX XDR "RFC status"
.LP
Note: This chapter specifies a protocol that Sun Microsystems, Inc., and 
others are using.  It has been designated RFC1014 by the ARPA Network
Information Center.
.NH 1
Introduction
\&
.LP
XDR is a standard for the description and encoding of data.  It is
useful for transferring data between different computer
architectures, and has been used to communicate data between such
diverse machines as the Sun Workstation, VAX, IBM-PC, and Cray.
XDR fits into the ISO presentation layer, and is roughly analogous in
purpose to X.409, ISO Abstract Syntax Notation.  The major difference
between these two is that XDR uses implicit typing, while X.409 uses
explicit typing.
.LP
XDR uses a language to describe data formats.  The language can only
be used only to describe data; it is not a programming language.
This language allows one to describe intricate data formats in a
concise manner. The alternative of using graphical representations
(itself an informal language) quickly becomes incomprehensible when
faced with complexity.  The XDR language itself is similar to the C
language [1], just as Courier [4] is similar to Mesa. Protocols such
as Sun RPC (Remote Procedure Call) and the NFS (Network File System)
use XDR to describe the format of their data.
.LP
The XDR standard makes the following assumption: that bytes (or
octets) are portable, where a byte is defined to be 8 bits of data.
A given hardware device should encode the bytes onto the various
media in such a way that other hardware devices may decode the bytes
without loss of meaning.  For example, the Ethernet standard
suggests that bytes be encoded in "little-endian" style [2], or least
significant bit first.
.NH 2
\&Basic Block Size
.IX XDR "basic block size"
.IX XDR "block size"
.LP
The representation of all items requires a multiple of four bytes (or
32 bits) of data.  The bytes are numbered 0 through n-1.  The bytes
are read or written to some byte stream such that byte m always
precedes byte m+1.  If the n bytes needed to contain the data are not
a multiple of four, then the n bytes are followed by enough (0 to 3)
residual zero bytes, r, to make the total byte count a multiple of 4.
.LP
We include the familiar graphic box notation for illustration and
comparison.  In most illustrations, each box (delimited by a plus
sign at the 4 corners and vertical bars and dashes) depicts a byte.
Ellipses (...) between boxes show zero or more additional bytes where
required.
.ie t .DS
.el .DS L
\fIA Block\fP

\f(CW+--------+--------+...+--------+--------+...+--------+
| byte 0 | byte 1 |...|byte n-1|    0   |...|    0   |
+--------+--------+...+--------+--------+...+--------+
|<-----------n bytes---------->|<------r bytes------>|
|<-----------n+r (where (n+r) mod 4 = 0)>----------->|\fP

.DE
.NH 1
\&XDR Data Types
.IX XDR "data types"
.IX "XDR data types"
.LP
Each of the sections that follow describes a data type defined in the
XDR standard, shows how it is declared in the language, and includes
a graphic illustration of its encoding.
.LP
For each data type in the language we show a general paradigm
declaration.  Note that angle brackets (< and >) denote
variable length sequences of data and square brackets ([ and ]) denote
fixed-length sequences of data.  "n", "m" and "r" denote integers.
For the full language specification and more formal definitions of
terms such as "identifier" and "declaration", refer to
.I "The XDR Language Specification" ,
below.
.LP
For some data types, more specific examples are included.  
A more extensive example of a data description is in
.I "An Example of an XDR Data Description"
below.
.NH 2
\&Integer
.IX XDR integer
.LP
An XDR signed integer is a 32-bit datum that encodes an integer in
the range [-2147483648,2147483647].  The integer is represented in
two's complement notation.  The most and least significant bytes are
0 and 3, respectively.  Integers are declared as follows:
.ie t .DS
.el .DS L
\fIInteger\fP

\f(CW(MSB)                   (LSB)
+-------+-------+-------+-------+
|byte 0 |byte 1 |byte 2 |byte 3 |
+-------+-------+-------+-------+
<------------32 bits------------>\fP
.DE
.NH 2
\&Unsigned Integer
.IX XDR "unsigned integer"
.IX XDR "integer, unsigned"
.LP
An XDR unsigned integer is a 32-bit datum that encodes a nonnegative
integer in the range [0,4294967295].  It is represented by an
unsigned binary number whose most and least significant bytes are 0
and 3, respectively.  An unsigned integer is declared as follows:
.ie t .DS
.el .DS L
\fIUnsigned Integer\fP

\f(CW(MSB)                   (LSB)
+-------+-------+-------+-------+
|byte 0 |byte 1 |byte 2 |byte 3 |
+-------+-------+-------+-------+
<------------32 bits------------>\fP
.DE
.NH 2
\&Enumeration
.IX XDR enumeration
.LP
Enumerations have the same representation as signed integers.
Enumerations are handy for describing subsets of the integers.
Enumerated data is declared as follows:
.ft CW
.DS
enum { name-identifier = constant, ... } identifier;
.DE
For example, the three colors red, yellow, and blue could be
described by an enumerated type:
.DS
.ft CW
enum { RED = 2, YELLOW = 3, BLUE = 5 } colors;
.DE
It is an error to encode as an enum any other integer than those that
have been given assignments in the enum declaration.
.NH 2
\&Boolean
.IX XDR boolean
.LP
Booleans are important enough and occur frequently enough to warrant
their own explicit type in the standard.  Booleans are declared as
follows:
.DS
.ft CW
bool identifier;
.DE
This is equivalent to:
.DS
.ft CW
enum { FALSE = 0, TRUE = 1 } identifier;
.DE
.NH 2
\&Hyper Integer and Unsigned Hyper Integer
.IX XDR "hyper integer"
.IX XDR "integer, hyper"
.LP
The standard also defines 64-bit (8-byte) numbers called hyper
integer and unsigned hyper integer.  Their representations are the
obvious extensions of integer and unsigned integer defined above.
They are represented in two's complement notation.  The most and
least significant bytes are 0 and 7, respectively.  Their
declarations:
.ie t .DS
.el .DS L
\fIHyper Integer\fP
\fIUnsigned Hyper Integer\fP

\f(CW(MSB)                                                   (LSB)
+-------+-------+-------+-------+-------+-------+-------+-------+
|byte 0 |byte 1 |byte 2 |byte 3 |byte 4 |byte 5 |byte 6 |byte 7 |
+-------+-------+-------+-------+-------+-------+-------+-------+
<----------------------------64 bits---------------------------->\fP
.DE
.NH 2
\&Floating-point
.IX XDR "integer, floating point"
.IX XDR "floating-point integer"
.LP
The standard defines the floating-point data type "float" (32 bits or
4 bytes).  The encoding used is the IEEE standard for normalized
single-precision floating-point numbers [3].  The following three
fields describe the single-precision floating-point number:
.RS
.IP \fBS\fP:
The sign of the number.  Values 0 and  1 represent  positive and
negative, respectively.  One bit.
.IP \fBE\fP:
The exponent of the number, base 2.  8  bits are devoted to this
field.  The exponent is biased by 127.
.IP \fBF\fP:
The fractional part of the number's mantissa,  base 2.   23 bits
are devoted to this field.
.RE
.LP
Therefore, the floating-point number is described by:
.DS
(-1)**S * 2**(E-Bias) * 1.F
.DE
It is declared as follows:
.ie t .DS
.el .DS L
\fISingle-Precision Floating-Point\fP

\f(CW+-------+-------+-------+-------+
|byte 0 |byte 1 |byte 2 |byte 3 |
S|   E   |           F          |
+-------+-------+-------+-------+
1|<- 8 ->|<-------23 bits------>|
<------------32 bits------------>\fP
.DE
Just as the most and least significant bytes of a number are 0 and 3,
the most and least significant bits of a single-precision floating-
point number are 0 and 31.  The beginning bit (and most significant
bit) offsets of S, E, and F are 0, 1, and 9, respectively.  Note that
these numbers refer to the mathematical positions of the bits, and
NOT to their actual physical locations (which vary from medium to
medium).
.LP
The IEEE specifications should be consulted concerning the encoding
for signed zero, signed infinity (overflow), and denormalized numbers
(underflow) [3].  According to IEEE specifications, the "NaN" (not a
number) is system dependent and should not be used externally.
.NH 2
\&Double-precision Floating-point
.IX XDR "integer, double-precision floating point"
.IX XDR "double-precision floating-point integer"
.LP
The standard defines the encoding for the double-precision floating-
point data type "double" (64 bits or 8 bytes).  The encoding used is
the IEEE standard for normalized double-precision floating-point
numbers [3].  The standard encodes the following three fields, which
describe the double-precision floating-point number:
.RS
.IP \fBS\fP:
The sign of the number.  Values  0 and 1  represent positive and
negative, respectively.  One bit.
.IP \fBE\fP:
The exponent of the number, base 2.  11 bits are devoted to this
field.  The exponent is biased by 1023.
.IP \fBF\fP:
The fractional part of the number's  mantissa, base 2.   52 bits
are devoted to this field.
.RE
.LP
Therefore, the floating-point number is described by:
.DS
(-1)**S * 2**(E-Bias) * 1.F
.DE
It is declared as follows:
.ie t .DS
.el .DS L
\fIDouble-Precision Floating-Point\fP

\f(CW+------+------+------+------+------+------+------+------+
|byte 0|byte 1|byte 2|byte 3|byte 4|byte 5|byte 6|byte 7|
S|    E   |                    F                        |
+------+------+------+------+------+------+------+------+
1|<--11-->|<-----------------52 bits------------------->|
<-----------------------64 bits------------------------->\fP
.DE
Just as the most and least significant bytes of a number are 0 and 3,
the most and least significant bits of a double-precision floating-
point number are 0 and 63.  The beginning bit (and most significant
bit) offsets of S, E , and F are 0, 1, and 12, respectively.  Note
that these numbers refer to the mathematical positions of the bits,
and NOT to their actual physical locations (which vary from medium to
medium).
.LP
The IEEE specifications should be consulted concerning the encoding
for signed zero, signed infinity (overflow), and denormalized numbers
(underflow) [3].  According to IEEE specifications, the "NaN" (not a
number) is system dependent and should not be used externally.
.NH 2
\&Fixed-length Opaque Data
.IX XDR "fixed-length opaque data"
.IX XDR "opaque data, fixed length"
.LP
At times, fixed-length uninterpreted data needs to be passed among
machines.  This data is called "opaque" and is declared as follows:
.DS
.ft CW
opaque identifier[n];
.DE
where the constant n is the (static) number of bytes necessary to
contain the opaque data.  If n is not a multiple of four, then the n
bytes are followed by enough (0 to 3) residual zero bytes, r, to make
the total byte count of the opaque object a multiple of four.
.ie t .DS
.el .DS L
\fIFixed-Length Opaque\fP

\f(CW0        1     ...
+--------+--------+...+--------+--------+...+--------+
| byte 0 | byte 1 |...|byte n-1|    0   |...|    0   |
+--------+--------+...+--------+--------+...+--------+
|<-----------n bytes---------->|<------r bytes------>|
|<-----------n+r (where (n+r) mod 4 = 0)------------>|\fP
.DE
.NH 2
\&Variable-length Opaque Data
.IX XDR "variable-length opaque data"
.IX XDR "opaque data, variable length"
.LP
The standard also provides for variable-length (counted) opaque data,
defined as a sequence of n (numbered 0 through n-1) arbitrary bytes
to be the number n encoded as an unsigned integer (as described
below), and followed by the n bytes of the sequence.
.LP
Byte m of the sequence always precedes byte m+1 of the sequence, and
byte 0 of the sequence always follows the sequence's length (count).
enough (0 to 3) residual zero bytes, r, to make the total byte count
a multiple of four.  Variable-length opaque data is declared in the
following way:
.DS
.ft CW
opaque identifier<m>;
.DE
or
.DS
.ft CW
opaque identifier<>;
.DE
The constant m denotes an upper bound of the number of bytes that the
sequence may contain.  If m is not specified, as in the second
declaration, it is assumed to be (2**32) - 1, the maximum length.