| 1 |
<pre>Request for Comments: 713 Jack Haverty (JFH@MIT-DMS) |
| 2 |
NIC #34739 Apr 1976 |
| 3 |
|
| 4 |
|
| 5 |
|
| 6 |
|
| 7 |
|
| 8 |
|
| 9 |
|
| 10 |
<span class="h2"><a class="selflink" id="appendix-I" href="#appendix-I">I</a>. ABSTRACT</span> |
| 11 |
|
| 12 |
|
| 13 |
A mechanism is defined for use by message servers in |
| 14 |
transferring data between hosts. The mechanism, called the |
| 15 |
MSDTP, is defined in terms of a model of the process as a |
| 16 |
translation between two sets of items, the abstract entities |
| 17 |
such as 'strings' and 'integers', and the formats used to |
| 18 |
represent such data as a byte stream. |
| 19 |
|
| 20 |
A proposed organization of a general data transfer |
| 21 |
mechanism is described, and the manner in which the MSDTP |
| 22 |
would be used in that environment is presented. |
| 23 |
|
| 24 |
|
| 25 |
|
| 26 |
|
| 27 |
|
| 28 |
|
| 29 |
|
| 30 |
|
| 31 |
|
| 32 |
|
| 33 |
|
| 34 |
|
| 35 |
|
| 36 |
|
| 37 |
|
| 38 |
|
| 39 |
|
| 40 |
|
| 41 |
|
| 42 |
|
| 43 |
|
| 44 |
|
| 45 |
|
| 46 |
|
| 47 |
|
| 48 |
|
| 49 |
|
| 50 |
|
| 51 |
|
| 52 |
|
| 53 |
|
| 54 |
|
| 55 |
|
| 56 |
|
| 57 |
|
| 58 |
|
| 59 |
|
| 60 |
-1-</pre> |
| 61 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>II. REFERENCES |
| 62 |
|
| 63 |
|
| 64 |
Black, Edward H., "The DMS Message Composer", MIT Project |
| 65 |
MAC, Programming Technology Division Document |
| 66 |
SYS.16.02. |
| 67 |
|
| 68 |
Burchfiel, Jerry D., Leavitt, Elsie M., Shapiro, Sonya and |
| 69 |
Strollo, Theodore R., compilers, "Tenex Users' Guide", |
| 70 |
Bolt Beranek and Newman, Cambridge, Mass., May 1971, |
| 71 |
revised January 1975, Descriptive sections on the TENEX |
| 72 |
subsystems: MAlLER, p. 116-11; MAlLSTAT, p. 118-119; |
| 73 |
READMAIL, p. 137; and SNDMSG, p. 165-170. |
| 74 |
|
| 75 |
Haverty, Jack, "Communications System Overview", MIT Project |
| 76 |
MAC, Programming Technology Division Document |
| 77 |
SYS.16.00. |
| 78 |
|
| 79 |
Haverty, Jack, "Communications System Daemon Manual", MIT |
| 80 |
Project MAC, Programming Technology Division Document |
| 81 |
SYS.16.01. |
| 82 |
|
| 83 |
ISI Information Automation Project, "Military Message |
| 84 |
Processing System Design," Internal Project |
| 85 |
Documentation (Out of Print), Jan. 1975 |
| 86 |
|
| 87 |
Message Services Committee, "Interim Report", Jan. 28, 1975 |
| 88 |
|
| 89 |
Mooers, Charlotte D., "Mailsys Message System: Manual For |
| 90 |
Users", Bolt Beranek and Newman, Cambridge, Mass., June |
| 91 |
<span class="h2"><a class="selflink" id="section-1975" href="#section-1975">1975</a> (draft).</span> |
| 92 |
|
| 93 |
Myer, Theodore H., "Notes On The BBN Mail System", Bolt |
| 94 |
Beranek and Newman, November 8, 1974. |
| 95 |
|
| 96 |
Myer, Theodore H., and Henderson, D. Austin, "Message |
| 97 |
Transmission Protocol", Network Working Group <a href="./rfc680">RFC 680</a>, |
| 98 |
NIC 32116, April 30, 1975. |
| 99 |
|
| 100 |
Postel, Jon, "The PCPB8 Format", NSW Proposal, June 5, 1975 |
| 101 |
|
| 102 |
Tugender, R., and D. R. Oestreicher, "Basic Functional |
| 103 |
Capabilities for a Military Message Processing |
| 104 |
Service," ISI?RR-74-23., May 1975 |
| 105 |
|
| 106 |
Vezza, Al, "Message Services Committee Minority Report", |
| 107 |
Jan. 1975 |
| 108 |
|
| 109 |
|
| 110 |
|
| 111 |
|
| 112 |
|
| 113 |
|
| 114 |
|
| 115 |
|
| 116 |
|
| 117 |
|
| 118 |
-2-</pre> |
| 119 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>III. OVERVIEW |
| 120 |
|
| 121 |
|
| 122 |
This document describes a mechanism developed for use |
| 123 |
by message servers communicating over an eight-bit |
| 124 |
byte-oriented network connection to move data structures and |
| 125 |
associated data-typing information. It is presented here in |
| 126 |
the hope that it may be of use to other projects which need |
| 127 |
to transfer data structures between dissimilar hosts. |
| 128 |
|
| 129 |
A set of abstract entities called PRIMITIVE ITEMS is |
| 130 |
enumerated. These are intended to include traditional data |
| 131 |
types of general utility, such as integers, strings, and |
| 132 |
arrays. |
| 133 |
|
| 134 |
A mechanism is defined for augmenting the set of |
| 135 |
abstract data entities handled, to allow the introduction of |
| 136 |
application-specific data, whose format and semantics are |
| 137 |
understood by the application programs involved, but which |
| 138 |
can be transmitted using common coding facilities. An |
| 139 |
example might be a data structure called a 'file |
| 140 |
specification', or a 'date'. Abstract data entities defined |
| 141 |
using this mechanism will be termed SEMANTIC ITEMS, since |
| 142 |
they are typically used to carry data having semantic |
| 143 |
content in the application involved. |
| 144 |
|
| 145 |
Semantic and primitive items are collectively referred |
| 146 |
to simply as ITEMS. |
| 147 |
|
| 148 |
The protocol next involves the definition of the format |
| 149 |
of the byte stream used to convey items from machine to |
| 150 |
machine. These encodings are described in terms of OBJECTS, |
| 151 |
which are the physical byte streams transmitted. |
| 152 |
|
| 153 |
To complete the protocol, the rules for translating |
| 154 |
between objects and items are presented as each object is |
| 155 |
defined. |
| 156 |
|
| 157 |
An item is transmitted by being translated into an |
| 158 |
object which is transmitted over the connection as a stream |
| 159 |
of bytes to the receiver, and reconstructed there as an |
| 160 |
item. The protocol mechanism may thus be viewed as a simple |
| 161 |
translator. It enumerates a set of abstract entities, the |
| 162 |
items, which are known to programmers, a set of entities in |
| 163 |
byte-stream format, the objects, and the translation rules |
| 164 |
for conversion between the sets. A site implementing the |
| 165 |
MSDTP would typically provide a facility to convert between |
| 166 |
objects and the local representation of the various items |
| 167 |
handled. Applications using the MSDTP define their |
| 168 |
interactions using items, without regard to the actual |
| 169 |
formats in which such items are represented at various |
| 170 |
machines. This permits programs to handle higher-level |
| 171 |
concepts such as a character string, without concern for its |
| 172 |
numerous representational formats. Such detail is handled |
| 173 |
by the MSDTP. |
| 174 |
|
| 175 |
-3-</pre> |
| 176 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>Finally, a discussion of a general data transfer |
| 177 |
mechanism for communication between programs is presented, |
| 178 |
and the manner in which the particular byte-oriented |
| 179 |
protocol defined herein would be used in that environment is |
| 180 |
discussed. |
| 181 |
|
| 182 |
Terminology, as introduced, is defined and highlighted |
| 183 |
by capitalizing. |
| 184 |
|
| 185 |
|
| 186 |
IV. PRIMITIVE DATA ITEMS |
| 187 |
|
| 188 |
The primitive data items include a variety of |
| 189 |
traditional, well-understood types, such as integers and |
| 190 |
strings. Primitive data items will be presented using |
| 191 |
mnemonic names preceded by the character pair "p-", to serve |
| 192 |
as a reminder that the named object is primitive. |
| 193 |
|
| 194 |
These items may be represented in various computer |
| 195 |
systems in whatever fashion their programmers desire. |
| 196 |
|
| 197 |
|
| 198 |
IV.1 -- Set Of Primitive Items |
| 199 |
|
| 200 |
|
| 201 |
The set of primitive items defined includes p-INT, |
| 202 |
p-STRING, p-STRUC, p-BITS, p-CHAR, p-BOOL, p-EMPTY, and |
| 203 |
p-XTRA. |
| 204 |
|
| 205 |
Since the protocol was developed primarily for use in |
| 206 |
message services, items such as p-FLOAT are not included |
| 207 |
since they were unnecessary. Additional items may be easily |
| 208 |
added as necessary. |
| 209 |
|
| 210 |
A p-INT performs the traditional role of representing |
| 211 |
integer numbers. A p-BITS (BIT Stream) item represents a |
| 212 |
bit stream. The two possible p-BOOL (BOOLean) items are |
| 213 |
used to represent the logical values of *TRUE* and *FALSE*. |
| 214 |
The single p-EMPTY item is used to, for example, indicate |
| 215 |
that a given field of a message is empty. It is provided to |
| 216 |
act as a place-holder, representing 'no data', and appears |
| 217 |
as *EMPTY*. |
| 218 |
|
| 219 |
The p-STRUC (STRUCture) item is used to group together |
| 220 |
a collection of items as a single value, maintaining the |
| 221 |
ordering of the elements, such as a p-STRUC of p-INTs. |
| 222 |
|
| 223 |
A p-CHAR is a single character. The most common |
| 224 |
occurrence of character data, however, will be as p-STRINGs. |
| 225 |
A p-STRING should be considered to be a synonym for a |
| 226 |
p-STRUC containing only p-CHARs. This concept is important |
| 227 |
for generality and consistency, especially when considering |
| 228 |
definitions of permissible operations on structures, such as |
| 229 |
extracting subsequences of elements, etc. |
| 230 |
|
| 231 |
-4-</pre> |
| 232 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>Four p-XTRA items, which can be transmitted in a single |
| 233 |
byte, are made available for higher level protocols to use |
| 234 |
when a frequently used datum is handled which can be |
| 235 |
represented just by its name. An example would be an |
| 236 |
acknowledgment between two servers. Using p-XTRAs to |
| 237 |
represent such data permits them to be handled in a single |
| 238 |
byte. There are four possible p-XTRA items, termed *XTRA0*, |
| 239 |
*XTRA1*, *XTRA2*, and *XTRA3*. These may be assigned |
| 240 |
meanings by user protocols as desired. |
| 241 |
|
| 242 |
|
| 243 |
IV.2 -- Printing Conventions |
| 244 |
|
| 245 |
|
| 246 |
The following printing conventions are introduced to |
| 247 |
facilitate discussion of the primitive items. |
| 248 |
|
| 249 |
When a specific instance of a primitive data item is |
| 250 |
presented, it will be shown in a traditional representation |
| 251 |
for that kind of data. For example, p-INTs are shown as |
| 252 |
sequences of digits, e.g. 100, p-STRINGs, as sequences of |
| 253 |
characters enclosed in double-quote characters, for example |
| 254 |
"ABCDEF". |
| 255 |
|
| 256 |
As shown above, the two possible p-BOOL items are shown |
| 257 |
as *TRUE* or *FALSE*. The object p-EMPTY appears as |
| 258 |
*EMPTY*. A bit stream, i.e. p-BITS, appears as a stream of |
| 259 |
1s and 0s enclosed in asterisks, for example *100101001*. A |
| 260 |
p-CHAR will be presented as the character enclosed in single |
| 261 |
quote characters, e.g., 'A'. |
| 262 |
|
| 263 |
P-STRUCs are printed as the representations of their |
| 264 |
elements, enclosed in parentheses, for example (1 2 3 4) or |
| 265 |
("XYZ" "ABC" 1 2) or ((1 2 3) "A" "B"). Note that because |
| 266 |
p-STRINGs are simply a class of p-STRUCs assigned a special |
| 267 |
name and printing format for brevity and convenience, the |
| 268 |
items "ABC" and ('A' 'B' 'C') are identical, and the latter |
| 269 |
format should not be used. |
| 270 |
|
| 271 |
To present a generic p-STRUC, as in specifying formats |
| 272 |
of the contents of something, the items are presented as a |
| 273 |
mnemonic name, optionally followed by a colon and the |
| 274 |
permissible types of values for that datum. When one of |
| 275 |
several items may appear as the value for some component, |
| 276 |
the permissible ones appear separated by vertical-bar |
| 277 |
characters. For example, p-INT|p-STRING represents a single |
| 278 |
item, which may be either a p-INT or a p-STRING. |
| 279 |
|
| 280 |
To represent a succession of items, the Kleene star |
| 281 |
convention is used. The specification p-INT[*] represents |
| 282 |
any number of p-INTs. Similarly, p-INT[3,5] represents from |
| 283 |
<span class="h2"><a class="selflink" id="section-3" href="#section-3">3</a> to 5 p-INTs, while p-INT[*,5] specifies up to 5 and</span> |
| 284 |
p-iNT[5,*] specifies at least 5 p-INTs. |
| 285 |
|
| 286 |
|
| 287 |
|
| 288 |
-5-</pre> |
| 289 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>For example, a p-STRUC which is used to carry names and |
| 290 |
numbers might be specified as follows. |
| 291 |
|
| 292 |
(name:p-STRING number:p-INT) |
| 293 |
|
| 294 |
In discussing items in general, when a specific data |
| 295 |
value is not intended, the name and types representation may |
| 296 |
be used, e.g., offset:p-INT to discuss an 'offset' which has |
| 297 |
a numeric value. |
| 298 |
|
| 299 |
|
| 300 |
<span class="h2"><a class="selflink" id="appendix-V" href="#appendix-V">V</a>. SEMANTIC ITEM MECHANISM</span> |
| 301 |
|
| 302 |
|
| 303 |
The semantic item mechanism provides a means for |
| 304 |
program designers to use a variety of application-specific |
| 305 |
data items. |
| 306 |
|
| 307 |
This mechanism is implemented using a special tagged |
| 308 |
structure to carry the data type information as well as the |
| 309 |
actual components of the particular semantic item. For |
| 310 |
discussion purposes. Such a special p-STRUC will be termed a |
| 311 |
p-EDT (Extended Data Type). |
| 312 |
|
| 313 |
When p-EDTs are transferred, their identity as a p-EDT |
| 314 |
is maintained. So that an applications program receives the |
| 315 |
corresponding semantic item instead of a simple p-STRUC. A |
| 316 |
p-EDT is identical to a p-STRUC in all other respects. |
| 317 |
|
| 318 |
|
| 319 |
<span class="h3"><a class="selflink" id="appendix-V.1" href="#appendix-V.1">V.1</a> -- Format of p-EDTs</span> |
| 320 |
|
| 321 |
|
| 322 |
A prototypical p-EDT follows. It is printed as if it |
| 323 |
were a normal p-STRUC. Since p-EDTs are converted to |
| 324 |
semantic items for presentation to the user, a p-EDT will |
| 325 |
never be used except in this protocol definition. |
| 326 |
|
| 327 |
(type:p-INT|p-STRING version:p-INT com1:any |
| 328 |
com2:any ...) |
| 329 |
|
| 330 |
The first element, the 'type' is generally a p-INT, and |
| 331 |
is used to identify the particular type of semantic item. |
| 332 |
Types are assigned numeric codes in a controlled fashion. |
| 333 |
The type may alternatively be specified by a p-STRING, to |
| 334 |
permit development of new data types for possible later |
| 335 |
assignment of codes. Each type has an equivalent p-STRING |
| 336 |
name. These may be used interchangeably as 'type' elements, |
| 337 |
primarily to maintain upward compatibility. |
| 338 |
|
| 339 |
The second element of a p-EDT is always an p-INT, the |
| 340 |
'version', and specifies the exact format of the particular |
| 341 |
datum. A semantic item may undergo several revisions of its |
| 342 |
internal structure. Which would be evident through assigning |
| 343 |
different versions to each revision. |
| 344 |
|
| 345 |
-6-</pre> |
| 346 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>Successive components. The 'com' elements, if any. |
| 347 |
carry the actual data of the semantic item. As each |
| 348 |
semantic item is defined, conventions on permissible values |
| 349 |
and interpretation of these components are presented. Such |
| 350 |
definitions may use any types of items to specify the format |
| 351 |
of the semantic item. Use of lower level concepts, such as |
| 352 |
objects, in these definitions is prohibited. |
| 353 |
|
| 354 |
Semantic items will be printed as the mnemonic for the |
| 355 |
type involved, preceded by the character pair "s-", to |
| 356 |
signify that the data item is handled by this mechanism. |
| 357 |
|
| 358 |
|
| 359 |
<span class="h3"><a class="selflink" id="appendix-V.2" href="#appendix-V.2">V.2</a> -- Printing Conventions</span> |
| 360 |
|
| 361 |
|
| 362 |
A semantic item is represented as if it were a p-STRUC |
| 363 |
containing only the components, if any, but preceded by the |
| 364 |
semantic type name and a # character. The version number is |
| 365 |
assumed to be 1 if unspecified. For later versions, the |
| 366 |
version number is attached to the type name, as in, for |
| 367 |
example, FILE-2 to represent version 2 of the FILE data |
| 368 |
type. |
| 369 |
|
| 370 |
For example, a semantic item called a 'file |
| 371 |
specification' might be defined, containing two components, |
| 372 |
a host number and pathname. A specific instance of such an |
| 373 |
item might appear as #FILE(69 "DIRECTORY.NAME-OF-FILE"), |
| 374 |
while a generic s-FILE might be presented as the following. |
| 375 |
|
| 376 |
#FILE(host:p-INT|p-STRING pathname:p-STRING) |
| 377 |
|
| 378 |
|
| 379 |
the item, which may be either a p-INT or p-STRING, and |
| 380 |
'pathname' is the second component, which must be a |
| 381 |
p-STRING. The full definition would present interpretation |
| 382 |
rules for these components. |
| 383 |
|
| 384 |
|
| 385 |
VI. ENCODING OBJECTS |
| 386 |
|
| 387 |
|
| 388 |
This section presents the set of objects which are used |
| 389 |
to represent items as byte streams for inter-server |
| 390 |
transmission. Objects will be presented using mnemonic |
| 391 |
type-names preceded by the character pair "b-", indicating |
| 392 |
their existence only as byte streams. |
| 393 |
|
| 394 |
All servers are required to be capable of decoding the |
| 395 |
entire set of objects. Servers are not required to transmit |
| 396 |
certain objects which are available to improve channel |
| 397 |
efficiency. |
| 398 |
|
| 399 |
|
| 400 |
|
| 401 |
|
| 402 |
-7-</pre> |
| 403 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>The encodings are designed to facilitate programming |
| 404 |
and efficiency of the receiving decoder. In all cases, the |
| 405 |
type and length in bytes of objects is supplied as the first |
| 406 |
information sent. This characteristic is important for ease |
| 407 |
of implementation. The type information permits a decoder to |
| 408 |
be constructed in a modular fashion. The most important |
| 409 |
advantage of including size information is that the receiver |
| 410 |
always knows how many bytes it must read to discover what to |
| 411 |
do next, and knows when each object terminates. This |
| 412 |
requirement avoids many potential problems with timing and |
| 413 |
synchronization of processes. |
| 414 |
|
| 415 |
Two varieties of objects are defined. The first will |
| 416 |
be called ATOMIC, and includes objects used to efficiently |
| 417 |
encode the most common data. The second variety is termed |
| 418 |
NON-ATOMIC, and is used to encode larger or less common |
| 419 |
items. |
| 420 |
|
| 421 |
In all cases, a data object begins with a single byte, |
| 422 |
which will be termed the TYPE-BYTE, a field of which |
| 423 |
contains the type code of the object. The following bytes, |
| 424 |
if any, are interpreted according to the type involved. |
| 425 |
|
| 426 |
|
| 427 |
VI.1 -- Presentation Conventations |
| 428 |
|
| 429 |
|
| 430 |
In discussing formats of bytes, the following |
| 431 |
conventions will be employed. The individual bits of a byte |
| 432 |
will be referenced by using capital letters from A to H, |
| 433 |
where A signifies the highest order bit, and H the lowest. |
| 434 |
The entire eight bit value, for example, could be referred |
| 435 |
to as ABCDEFGH. Similarly, subfields of the byte will be |
| 436 |
identified by such sequences. The CDEF field specifies the |
| 437 |
middle four bits of a byte. |
| 438 |
|
| 439 |
In referring to values of fields, binary format will be |
| 440 |
used, and small letters near the end of the alphabet will be |
| 441 |
used to identify particular bits for discussion. For |
| 442 |
example, we might say that the BCD field of a byte contains |
| 443 |
a specifier for some type, and define its value to be |
| 444 |
BCD=11z. In discussions of the specifier usage, we could |
| 445 |
refer to the cases where z=l and where z=0, as shorthand |
| 446 |
notation to identify BCD=111 and BCD=110, respectively. |
| 447 |
|
| 448 |
|
| 449 |
V1.2 -- Type-Byte Bit Assignment |
| 450 |
|
| 451 |
|
| 452 |
To assist in understanding the assignment of the |
| 453 |
various type-byte values, the table and graph below are |
| 454 |
included, showing representations of the eight bits. |
| 455 |
|
| 456 |
|
| 457 |
|
| 458 |
|
| 459 |
-8-</pre> |
| 460 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>OXXXXXXX -- CHAR7 (CHARacter, 7 bit) |
| 461 |
10XXXXXX -- SINTEGER (Small INTEGER) |
| 462 |
l10XXXXX -- NON-ATOM (NON-ATOMic objects) |
| 463 |
11100XXX -- LINTEGER (Large INTEGER) |
| 464 |
11101XXX -- reserved |
| 465 |
11110XXX -- SBITSTR (Short BIT STReam) |
| 466 |
111110XX -- XTRA (eXTRA single-byte objects) |
| 467 |
1111110X -- BOOL (BOOLean) |
| 468 |
<span class="h2"><a class="selflink" id="section-11111110" href="#section-11111110">11111110</a> -- EMPTY (EMPTY data item)</span> |
| 469 |
<span class="h2"><a class="selflink" id="section-11111111" href="#section-11111111">11111111</a> -- PADDING (unused byte)</span> |
| 470 |
|
| 471 |
|
| 472 |
In each case, the bits identified by X's are used to |
| 473 |
contain information specific to the type involved. These |
| 474 |
are explained when each type is defined. |
| 475 |
|
| 476 |
An equivalent tree representation follows, for those |
| 477 |
who prefer it. |
| 478 |
start with high order bit |
| 479 |
| |
| 480 |
| |
| 481 |
| |
| 482 |
0-----0-----0-----0-----0-----0-----0-----0-----X |
| 483 |
| | | | | | | | PADDING |
| 484 |
0| 0| 0| 0| 0| 0| 0| 0| |
| 485 |
| | | | | | | | |
| 486 |
X | X | X | X X |
| 487 |
CHAR7 | NON-ATOM | BITS | BOOL EMPTY |
| 488 |
(7) | (5) | (3) | (1) |
| 489 |
| 0| | | |
| 490 |
SINTEGER | XTRA |
| 491 |
(6) | (2) |
| 492 |
LINTEGER |
| 493 |
(3) |
| 494 |
|
| 495 |
Type-Byte Bit Assignment Scheme |
| 496 |
|
| 497 |
|
| 498 |
|
| 499 |
|
| 500 |
This picture is interpreted by entering at the top, and |
| 501 |
taking the appropriate branch at each node to correspond to |
| 502 |
the next bit of the type-byte, as it is scanned from left to |
| 503 |
right. When a type is assigned, the branch terminates with |
| 504 |
an "X' and the name of the type of the object, with the |
| 505 |
number of remaining bits in parentheses. The individual |
| 506 |
object definitions specify how these bits are used for that |
| 507 |
particular type. |
| 508 |
|
| 509 |
|
| 510 |
V1.3 -- Atomic Objects |
| 511 |
|
| 512 |
|
| 513 |
Atomic objects are identified by specific patterns in a |
| 514 |
type-byte. Receiving servers must be capable of recognizing |
| 515 |
|
| 516 |
|
| 517 |
-9-</pre> |
| 518 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>and handling all atomic types, since the size of the object |
| 519 |
is not explicitly present in a uniform fashion. |
| 520 |
|
| 521 |
|
| 522 |
================================ |
| 523 |
| Atomic Object: B-CHAR7 | |
| 524 |
================================ |
| 525 |
|
| 526 |
|
| 527 |
The b-CHAR7 (CHARacter 7 bit) object is introduced to |
| 528 |
handle transmission of characters, in 7-bit ASCII format. |
| 529 |
Since the vast majority of message-related data involves |
| 530 |
such objects, they are designed to be very efficient in |
| 531 |
transmission. Other formats, such as eight bit values, can |
| 532 |
be introduced as non-atomic objects. The format of a b-CHAR7 |
| 533 |
follows: |
| 534 |
|
| 535 |
A=0 identifying the b-CHAR7 data type |
| 536 |
BCDEFGH=tuvwxyz containing the character |
| 537 |
code |
| 538 |
|
| 539 |
The tuvwxyz objects contain the ASCII code of the |
| 540 |
character. For example, transmission of a "space' (ASCII |
| 541 |
code 32, 40 octal) would be accomplished by the following |
| 542 |
byte. |
| 543 |
|
| 544 |
00100000 |
| 545 |
ABCDEFGH |
| 546 |
|
| 547 |
A=0 to identify this byte as a b-CHAR7. The remaining |
| 548 |
bits contain the 7 bit code, octal 40, for space. |
| 549 |
|
| 550 |
A b-CHAR7 standing alone is presented as a p-CHAR. |
| 551 |
Such occurrences will probably be rare if they are used at |
| 552 |
all. The most common use of b-CHAR7's is as elements of |
| 553 |
b-USTRUCs used to transmit p-STRINGS, as explained later. |
| 554 |
|
| 555 |
|
| 556 |
============================= |
| 557 |
| Atomic Object: B-SINTEGER | |
| 558 |
============================= |
| 559 |
|
| 560 |
The b-SINTEGER (Small INTEGER) object is used to |
| 561 |
transmit very small positive integers, of values up to 64. |
| 562 |
It always translates to an p-INT, and any p-INT between 0 |
| 563 |
and 63 may be encoded as a b-SINTEGER for transmission. The |
| 564 |
format of an b-SINTEGER follows. |
| 565 |
|
| 566 |
AB=10 identifying the object as a b-SINTEGER |
| 567 |
CDEFGH=uvwxyz containing the actual number |
| 568 |
|
| 569 |
For example, to transmit the integer 10 (12 octal), the |
| 570 |
following byte would be transmitted: |
| 571 |
|
| 572 |
10001010 |
| 573 |
ABCDEFGH |
| 574 |
|
| 575 |
-10-</pre> |
| 576 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>AB=10 to specify a b-SINTEGER. The remaining six bits |
| 577 |
contain the number 10 expressed in binary. |
| 578 |
|
| 579 |
============================= |
| 580 |
| Atomic Object: B-SINTEGER | |
| 581 |
============================= |
| 582 |
|
| 583 |
The b-SINTEGER (Large INTEGER) object is used to |
| 584 |
transmit p-INTs to any precision up to 64 bits. It is |
| 585 |
always translated as a p-INT. Sending servers are permitted |
| 586 |
to choose either b-SINTEGER or b-SINTEGER format for |
| 587 |
transmission of numbers, as appropriate. When possible, |
| 588 |
b-SINTEGERs can be used for better channel efficiency. The |
| 589 |
format of a b-SINTEGER follows: |
| 590 |
|
| 591 |
ABCDE=11100 specifying that this is a b-SINTEGER. |
| 592 |
FGH=xyz containing a count of number of bytes to follow. |
| 593 |
|
| 594 |
The xyz bits are interpreted as a number of bytes to |
| 595 |
follow which contain the actual binary code of the the |
| 596 |
integer in 2's complement format. Since a zero-byte integer |
| 597 |
is disallowed, the pattern xyz=000 is interpreted as 1000, |
| 598 |
specifying that 8 bytes follow. The number is transmitted |
| 599 |
with high-order bits first. This format permits |
| 600 |
transmission of integers as large as 64 bits in magnitude. |
| 601 |
|
| 602 |
For example, if the number 4096 (10000 octal) is to be |
| 603 |
transmitted, the following sequence of bytes would be sent: |
| 604 |
|
| 605 |
<span class="h2"><a class="selflink" id="section-11100010" href="#section-11100010">11100010</a> 00010000 00000000</span> |
| 606 |
ABCDEFGH ---actual data--- |
| 607 |
|
| 608 |
ABCDE=11100, identifying this as a b-LINTEGER, E=0, |
| 609 |
specifying a positive number, and FGH=010, specifying that 2 |
| 610 |
bytes follow, containing the actual binary number. |
| 611 |
|
| 612 |
============================ |
| 613 |
| Atomic Object: B-SBITSTR | |
| 614 |
============================ |
| 615 |
|
| 616 |
The b-SBITSTR (Short BIT STReam) object is used to |
| 617 |
transmit a p-BITS of length 63 or less. For longer bit |
| 618 |
streams, the non-atomic object b-LBITSTR may be used. The |
| 619 |
format of a b-SBITSTR follows. |
| 620 |
|
| 621 |
ABCDE=11110 specifying the type as b-SBITSTR |
| 622 |
FGH=xyz specifying the number of bytes |
| 623 |
following. |
| 624 |
|
| 625 |
|
| 626 |
|
| 627 |
|
| 628 |
|
| 629 |
|
| 630 |
|
| 631 |
-11-</pre> |
| 632 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>The xyz value specifies the number of additional bytes |
| 633 |
to be read to obtain the bit stream values. As in the case |
| 634 |
of b-SINTEGER, the value xyz=000 is interpreted as 1000, |
| 635 |
specifying that 8 bytes follow. |
| 636 |
|
| 637 |
To avoid requiring specification of exactly the number |
| 638 |
of bits contained, the following convention is used. The |
| 639 |
first data byte is scanned from left to right until the |
| 640 |
first 1 bit is encountered. The bit stream is defined to |
| 641 |
begin with the immediately following bit, and run through |
| 642 |
the last bit of the last byte read. In other words, the bit |
| 643 |
stream is 'right-adjusted' in the collected bytes, with its |
| 644 |
left end delimited by the first "on' bit. |
| 645 |
|
| 646 |
For example, to send the bit stream *001010011* (9 |
| 647 |
bits), the following bytes are transmitted. |
| 648 |
|
| 649 |
<span class="h2"><a class="selflink" id="section-11110010" href="#section-11110010">11110010</a> 00000010 01010011</span> |
| 650 |
ABCDEhij klmnopqr stuvwxyz |
| 651 |
|
| 652 |
The hij=010 value specifies that two bytes follow. The |
| 653 |
q bit, which is the first 1 bit encountered, identifies the |
| 654 |
start of the bit stream as being the r bit. The rstuvwxyz |
| 655 |
bits are the bit stream being handled. |
| 656 |
|
| 657 |
========================= |
| 658 |
| Atomic Object: b-BOOL | |
| 659 |
========================= |
| 660 |
|
| 661 |
The b-BOOL (BOOLean) object is used to transmit |
| 662 |
p-BOOLs. The format of b-BOOL objects follows. |
| 663 |
|
| 664 |
ABCDEFG=1111110 specifying the type as |
| 665 |
b-BOOL |
| 666 |
H=z specifying the value |
| 667 |
|
| 668 |
The two possible translations of a b-BOOL are *FALSE* |
| 669 |
and *TRUE*. |
| 670 |
|
| 671 |
<span class="h2"><a class="selflink" id="section-11111100" href="#section-11111100">11111100</a> represents *FALSE*</span> |
| 672 |
<span class="h2"><a class="selflink" id="section-11111101" href="#section-11111101">11111101</a> represents *TRUE*</span> |
| 673 |
ABCDEFGz |
| 674 |
|
| 675 |
if z=0, the value is FALSE, otherwise TRUE. |
| 676 |
|
| 677 |
|
| 678 |
|
| 679 |
======================================== |
| 680 |
| Atomic Object: B-EMPTY | |
| 681 |
======================================== |
| 682 |
|
| 683 |
The b-EMPTY object type is used to transmit a 'null' |
| 684 |
object, i.e. an *EMPTY*. The format of an b-EMPTY follows. |
| 685 |
|
| 686 |
ABCDEFGH=11111110 specifying *EMPTY* |
| 687 |
|
| 688 |
-12-</pre> |
| 689 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>========================= |
| 690 |
| Atomic Object: B-XTRA | |
| 691 |
========================= |
| 692 |
|
| 693 |
The b-XTRA objects are used to carry the four possible |
| 694 |
p-XTRA items, i.e., *XTRA0*, *XTRA1*, *XTRA2*, and *XTRA3*. |
| 695 |
These four items correspond to the binary coding of the |
| 696 |
remaining two bits after the b-XTRA type code bits. The |
| 697 |
format of a b-XTRA follows. |
| 698 |
|
| 699 |
ABCDEF=111110 to specify the type b-XTRA |
| 700 |
GH=yz to identify the particular p-XTRA item |
| 701 |
carried |
| 702 |
|
| 703 |
The GH bits of the byte are decoded to produce a |
| 704 |
particular p-XTRA item, as follows. |
| 705 |
|
| 706 |
GH=00 -- *XTRA0* |
| 707 |
GH=01 -- *XTRA1* |
| 708 |
GH=10 -- *XTRA2* |
| 709 |
GH=11 -- *XTRA3* |
| 710 |
|
| 711 |
The b-XTRA object is included to provide the use of |
| 712 |
several single-byte data items to higher levels. These |
| 713 |
items may be assigned by individual applications to improve |
| 714 |
the efficiency of transmission of several very frequent data |
| 715 |
items. For example, the message services protocols will use |
| 716 |
these items to convey positive and negative acknowledgments, |
| 717 |
two very common items in every interaction. |
| 718 |
|
| 719 |
======================================== |
| 720 |
| Atomic Object: B-PADDING |
| 721 |
======================================== |
| 722 |
|
| 723 |
This object is anomalous, since it represents really no |
| 724 |
data at all. Whenever it is encountered in a byte stream in |
| 725 |
a position where a type-byte is expected, it is completely |
| 726 |
ignored, and the succeeding byte examined instead. Its |
| 727 |
purpose is to serve as a filler in byte streams, providing |
| 728 |
servers with an aid in handling internal problems related to |
| 729 |
their specific word lengths, etc. The encoders may freely |
| 730 |
use this object to serve as padding when necessary. |
| 731 |
|
| 732 |
All b-PADDING data objects exist only within an encoded |
| 733 |
byte stream. They never cause any data item whatsoever to |
| 734 |
be presented externally to the coder module. The format of a |
| 735 |
b-PADDING follows. |
| 736 |
|
| 737 |
ABCDEFGH=11111111 |
| 738 |
|
| 739 |
Note that this does not imply that all such 'null' |
| 740 |
bytes in a stream are to be ignored, since they could be |
| 741 |
encountered as a byte within some other type, such as |
| 742 |
b-LINTEGER. Only bytes of this format which, by their |
| 743 |
position in the stream, appear as a 'type' byte are to be |
| 744 |
ignored. |
| 745 |
|
| 746 |
-13-</pre> |
| 747 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>VI.4 -- Non-Atomic Objects |
| 748 |
|
| 749 |
|
| 750 |
Non-atomic objects are are always transmitted preceded |
| 751 |
by both a single type byte and some small number of size |
| 752 |
byte(s). The type byte identifies that the data object |
| 753 |
concerned is of a non-atomic type, as well as uniquely |
| 754 |
specifying the particular type involved. All non-atomic |
| 755 |
objects have type byte values of the following form. |
| 756 |
|
| 757 |
ABC=110 specifying that the object is |
| 758 |
non-atomic |
| 759 |
DEFGH=vwxyz specifying the particular type |
| 760 |
of object |
| 761 |
|
| 762 |
The vwxyz value is used to specify one of 31 possible |
| 763 |
non-atomic types. The value vwxyz=00000 is reserved for use |
| 764 |
in future expansion. |
| 765 |
|
| 766 |
In all non-atomic data objects, the byte(s) following |
| 767 |
the type-byte specify the number of bytes to follow which |
| 768 |
contain the data object. In all cases, if the number of |
| 769 |
bytes specified are processed, the next byte to be seen |
| 770 |
should be another type-byte, the beginning of the next |
| 771 |
object in the stream. |
| 772 |
|
| 773 |
The number of bytes containing the object size |
| 774 |
information is variable. These bytes will be termed the |
| 775 |
SIZE-BYTES. The first byte encountered has the following |
| 776 |
format. |
| 777 |
|
| 778 |
A=s specifying the manner in which the size |
| 779 |
information is encoded |
| 780 |
BCDEFGH=tuvwxyz specifying the size, or |
| 781 |
number of bytes containing the size |
| 782 |
|
| 783 |
The tuvwxyz values supply a positive binary number. If |
| 784 |
the s value is a one, the tuvwxyz value specifies the number |
| 785 |
of bytes to follow which should be read and concatenated as |
| 786 |
a binary number, which will then specify the size of the |
| 787 |
object. These bytes will appear with high order bits first. |
| 788 |
Thus, if s=1, up to 128 bytes may follow, containing the |
| 789 |
count of the succeeding data bytes, which should certainly |
| 790 |
be sufficient. |
| 791 |
|
| 792 |
Since many non-atomic objects will be fairly short, the |
| 793 |
s=0 condition is used to indicate that the 7 bits contained |
| 794 |
in tuvwxyz specify the actual data byte count. This permits |
| 795 |
|
| 796 |
objects of sizes up to 128 bytes to be specified using one |
| 797 |
size-information byte. The case tuvwxyz=0000000 is |
| 798 |
interpreted as specifying 128 bytes. |
| 799 |
|
| 800 |
For example, a data object of some non-atomic type |
| 801 |
which requires 100 (144 octal) bytes to be transmitted would |
| 802 |
be sent as follows. |
| 803 |
|
| 804 |
-14-</pre> |
| 805 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>110XXXXX -- identifying a specific |
| 806 |
non-atomic object |
| 807 |
<span class="h2"><a class="selflink" id="section-01100100" href="#section-01100100">01100100</a> -- specifying that 100 bytes follow</span> |
| 808 |
. |
| 809 |
. |
| 810 |
data -- the 100 data bytes |
| 811 |
. |
| 812 |
. |
| 813 |
|
| 814 |
Note that the size count does not include the |
| 815 |
size-specifier byte(s) themselves, but does include all |
| 816 |
succeeding bytes in the stream used to encode the object. |
| 817 |
|
| 818 |
A data object requiring 20000 (47040 octal) bytes would |
| 819 |
appear in the stream as follows. |
| 820 |
|
| 821 |
110XXXXX -- identifying a specific |
| 822 |
non-atomic object |
| 823 |
<span class="h2"><a class="selflink" id="section-10000010" href="#section-10000010">10000010</a> -- specifying that the next 2 bytes</span> |
| 824 |
contain the stream length |
| 825 |
<span class="h2"><a class="selflink" id="section-01001110" href="#section-01001110">01001110</a> -- first byte of number 20000</span> |
| 826 |
<span class="h2"><a class="selflink" id="section-00100000" href="#section-00100000">00100000</a> -- second byte</span> |
| 827 |
. |
| 828 |
. |
| 829 |
data -- 20,000 bytes |
| 830 |
. |
| 831 |
. |
| 832 |
|
| 833 |
Interpretation of the contents of the 20000 bytes in |
| 834 |
the stream can be performed by a module which knows the |
| 835 |
specific format of the non-atomic type specified by DEFGH in |
| 836 |
the type-byte. |
| 837 |
|
| 838 |
The remainder of this section defines an initial set of |
| 839 |
non-atomic types, the format of their encoding, and the |
| 840 |
semantics of their interpretation. |
| 841 |
|
| 842 |
|
| 843 |
================================ |
| 844 |
| Non-atomic Object: B-LBITSTR | |
| 845 |
================================ |
| 846 |
|
| 847 |
The b-LBITSTR (Long BIT Stream) data type is introduced |
| 848 |
to transmit p-BITS which cannot be handled by a b-SBITSTR. |
| 849 |
A b-LBITSTR may be used to transmit short p-BITS as well. |
| 850 |
Its format follows. |
| 851 |
|
| 852 |
|
| 853 |
|
| 854 |
|
| 855 |
|
| 856 |
|
| 857 |
|
| 858 |
|
| 859 |
|
| 860 |
|
| 861 |
-15-</pre> |
| 862 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span class="h2"><a class="selflink" id="section-11000001" href="#section-11000001">11000001</a> size-bytes data-bytes</span> |
| 863 |
ABCDEFGH |
| 864 |
|
| 865 |
ABC=110 identifies this as a non-atomic object. |
| 866 |
DEFGH=00001 specifies that it is a b-LBITSTR. The standard |
| 867 |
sizing information specifies the number of succeeding bytes. |
| 868 |
Within the data-bytes, the first object encountered must |
| 869 |
decode to a p-INT. This number conveys the length of the |
| 870 |
bit stream to follow. The actual bit stream begins with the |
| 871 |
next byte, and is left-adjusted in the byte stream. For |
| 872 |
example to encode *101010101010*, the following b-LBITSTR |
| 873 |
could be used, although a b-SBITSTR would be more compact. |
| 874 |
|
| 875 |
<span class="h2"><a class="selflink" id="section-11000001" href="#section-11000001">11000001</a> -- identifies a b-LBITSTR</span> |
| 876 |
<span class="h2"><a class="selflink" id="section-00000010" href="#section-00000010">00000010</a> -- b-SINTEGER, to specify length</span> |
| 877 |
<span class="h2"><a class="selflink" id="section-10001100" href="#section-10001100">10001100</a> -- size = 2</span> |
| 878 |
<span class="h2"><a class="selflink" id="section-10101010" href="#section-10101010">10101010</a> -- first 8 data bits</span> |
| 879 |
<span class="h2"><a class="selflink" id="section-10100000" href="#section-10100000">10100000</a> -- last 4 data bits</span> |
| 880 |
|
| 881 |
|
| 882 |
|
| 883 |
============================== |
| 884 |
| Non-atomic Object: B-STRUC | |
| 885 |
============================== |
| 886 |
|
| 887 |
The b-STRUC (STRUCture) data type is used to transmit |
| 888 |
any p-STRUC. The translation rules for converting a b-STRUC |
| 889 |
into a primitive item are presented following the discussion |
| 890 |
of b-REPEATs. The b-STRUC format appears as follows. |
| 891 |
|
| 892 |
<span class="h2"><a class="selflink" id="section-11000010" href="#section-11000010">11000010</a> size-bytes data-bytes</span> |
| 893 |
ABCDEFGH |
| 894 |
|
| 895 |
ABC=110 identifies this as a non-atomic type. |
| 896 |
DEFGH=00010 specifies that the object is a b-STRUC. Within |
| 897 |
the data-bytes stream, objects simply follow in order. This |
| 898 |
implies that the b-STRUC encoder and decoder modules can |
| 899 |
simply make use of recursive calls to a standard |
| 900 |
encoder/decoder for processing each element of the b-STRUC. |
| 901 |
|
| 902 |
Note that any type of object is permitted as an element of a |
| 903 |
b-STRUC, but the size information of the b-STRUC must |
| 904 |
include all bytes used to represent the elements. |
| 905 |
|
| 906 |
Containment of b-STRUCs within other b-STRUCs is |
| 907 |
permitted to any reasonable level. That is, a b-STRUC may |
| 908 |
contain as an element another b-STRUC, which contains |
| 909 |
another b-STRUC, and so on. All servers are requires to |
| 910 |
handle such containment to at least a minimum depth of |
| 911 |
three. |
| 912 |
|
| 913 |
Examples of encoded structures appear in a later |
| 914 |
section. |
| 915 |
|
| 916 |
|
| 917 |
-16-</pre> |
| 918 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>============================ |
| 919 |
| Non-atomic Object: B-EDT | |
| 920 |
============================ |
| 921 |
|
| 922 |
A b-EDT is the object used as the carrier for p-EDTs in |
| 923 |
transmission of semantic items. It is functionally |
| 924 |
identical to a b-STRUC, but has a different type code to |
| 925 |
permit it to be identified and converted to a semantic item |
| 926 |
instead of a p-STRUC. The format of a b-EDT follows. |
| 927 |
|
| 928 |
<span class="h2"><a class="selflink" id="section-11000011" href="#section-11000011">11000011</a> size-bytes data-bytes</span> |
| 929 |
ABCDEFGH |
| 930 |
|
| 931 |
As with all non-atomic types, ABC=110 to identify this |
| 932 |
as such, and DEFGH=00011 to specify a b-EDT. The objects in |
| 933 |
the data-bytes are decoded as for b-STRUCs. However, the |
| 934 |
first object must decode to a p-iNT or p-STRING and the |
| 935 |
second to a p-INT, to conform to the format of p-EDTs. |
| 936 |
|
| 937 |
|
| 938 |
|
| 939 |
=============================== |
| 940 |
| Non-atomic Object: b-REPEAT | |
| 941 |
=============================== |
| 942 |
|
| 943 |
|
| 944 |
The b-REPEAT object is never translated directly into |
| 945 |
an item. It is legal only as an component of an enclosing |
| 946 |
b-STRUC, b-USTRUC, b-EDT, or b-REPEAT. A b-REPEAT is used to |
| 947 |
concisely specify a set of elements to be treated as if they |
| 948 |
appeared in the enclosing structure in place of the |
| 949 |
b-REPEAT. This provides a mechanism for encoding a sequence |
| 950 |
of identical data items or patterns efficiently for |
| 951 |
transmission. |
| 952 |
|
| 953 |
A common example of this would be in transmission of |
| 954 |
text, where line images containing long sequences of spaces, |
| 955 |
or pages containing multiple carriage-return, line-feed |
| 956 |
pairs, are often encountered. Such sequences could be |
| 957 |
encoded as an appropriate b-REPEAT to compact the data for |
| 958 |
transmission. The format of a b-REPEAT is as follows. |
| 959 |
|
| 960 |
<span class="h2"><a class="selflink" id="section-11000100" href="#section-11000100">11000100</a> -- identifyIng the object as a</span> |
| 961 |
<span class="h2"> b-REPEAT</span> |
| 962 |
size-bytes -- the standard non-atomic object |
| 963 |
size information |
| 964 |
countspec -- an object which translates to a p-INT |
| 965 |
. |
| 966 |
. |
| 967 |
data -- the objects which define the pattern |
| 968 |
. |
| 969 |
. |
| 970 |
|
| 971 |
The 'countspec' object must translate to an p-INT to |
| 972 |
specify the number of times that the following data pattern |
| 973 |
should be repeated in the object enclosing the b-REPEAT. |
| 974 |
|
| 975 |
-17-</pre> |
| 976 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>The remaining objects in the b-REPEAT constitute the |
| 977 |
data pattern which is to be repeated. The decoding of the |
| 978 |
enclosing structure will be continued as if the data pattern |
| 979 |
objects appeared 'countspec' times in place of the b-REPEAT. |
| 980 |
Zero repeat counts are permitted, for generality. They |
| 981 |
cause no objects to be simulated in the enclosing structure. |
| 982 |
|
| 983 |
An encoder does not have to use b-REPEATs at all, if |
| 984 |
simplicity of coding outweighs the benefits of data |
| 985 |
compression. In message services, for example, an encoder |
| 986 |
might limIt itself to only compressing long text strings. It |
| 987 |
is important for compatibility, however, to have the ability |
| 988 |
in the decoders to handle b-REPEATs. |
| 989 |
|
| 990 |
=============================== |
| 991 |
| Non-atomic Object: B-USTRUC | |
| 992 |
=============================== |
| 993 |
|
| 994 |
The b-USTRUC (Uniform Structure) object type is |
| 995 |
provided to enable servers to convey the fact that a p-STRUC |
| 996 |
being transferred contains items of only a single type. The |
| 997 |
most common example would involve a b-USTRUC which |
| 998 |
translates to a p-STRUC of only p-CHARs, and hence may be |
| 999 |
considered to be a p-STRING. Servers may use this |
| 1000 |
information to assist them in decoding objects efficiently. |
| 1001 |
No server is required to generate b-USTRUCs. |
| 1002 |
|
| 1003 |
The internal construction of a b-USTRUC is identical to |
| 1004 |
that of a b-STRUC, except for the type-byte. The format of a |
| 1005 |
b-USTRUC follows. |
| 1006 |
|
| 1007 |
<span class="h2"><a class="selflink" id="section-11000101" href="#section-11000101">11000101</a> size-bytes data-bytes</span> |
| 1008 |
ABCDEFGH |
| 1009 |
|
| 1010 |
ABC=110 to identify a non-atomic object. DEFGH=00101 |
| 1011 |
specifies the object as a b-USTRUC. |
| 1012 |
|
| 1013 |
=============================== |
| 1014 |
| Non-atomic Object: B-STRING | |
| 1015 |
=============================== |
| 1016 |
|
| 1017 |
The b-STRING object is included to permit explicit |
| 1018 |
specification of a structure as a p-STRING. This |
| 1019 |
information will permit receiving servers to process the |
| 1020 |
incoming structure more efficiently. A b-STRING is |
| 1021 |
formatted similarity to a b-USTRUC, except that its type-byte |
| 1022 |
identifies the object as a b-STRI/NG. The normal sizing |
| 1023 |
information is followed by a stream of bytes which are |
| 1024 |
interpreted as b-CHAR7s, Ignoring the high-order bit. The |
| 1025 |
format of a b-STRING follows. |
| 1026 |
|
| 1027 |
<span class="h2"><a class="selflink" id="section-11000110" href="#section-11000110">11000110</a> size-bytes data-bytes</span> |
| 1028 |
ABCDEFGH |
| 1029 |
|
| 1030 |
ABC=110 to identify a non-atomic object. DEFGH=00110 |
| 1031 |
specifies the object as a b-STRING. |
| 1032 |
|
| 1033 |
-18-</pre> |
| 1034 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>VI.5 -- Structure Translation Rules |
| 1035 |
|
| 1036 |
|
| 1037 |
A b-STRUC is translated into a p-STRUC. This is |
| 1038 |
performed by translating each object of the b-STRUC Into its |
| 1039 |
corresponding item, and saving it for inclusion In the |
| 1040 |
p-STRUC being generated. A b-USTRUC is handled similarly, |
| 1041 |
but the coding programs may utilize the information that the |
| 1042 |
resultant p-STRUC will contain items of uniform type. The |
| 1043 |
preferred method of coding p-STRINGS is to use b-USTRUCs. |
| 1044 |
|
| 1045 |
If all of the elements of the resultant p-STRUC are |
| 1046 |
p-CHARs, it is presented to the user of the decoder as a |
| 1047 |
p-STRING. A p-STRING should be considered to be a synonym |
| 1048 |
for a p-STRUC containing only characters. It need not |
| 1049 |
necessarily exist at particular sites which would present |
| 1050 |
p-STRUCs of p-CHARs to their application programs |
| 1051 |
|
| 1052 |
The object b-REPEAT is handled in a special fashion |
| 1053 |
when encountered as an element. When this occurs, the data |
| 1054 |
pattern of the b-REPEAT is translated into a sequence of |
| 1055 |
items, and that sequence is repeated in the next higher |
| 1056 |
level as many times as specified in the b-REPEAT. |
| 1057 |
Therefore, b-REPEATS are legal only as elements of a |
| 1058 |
surrounding b-STRUC, b-USTRUC, b-EDT, or b-REPEAT. |
| 1059 |
|
| 1060 |
In encoding a p-STRUC or p-STRING for transmission, a |
| 1061 |
translator may use b-REPEATs as desired to effect data |
| 1062 |
compression, but their use is not mandatory. Similarly, |
| 1063 |
b-STRINGS may be used, but are not mandatory. |
| 1064 |
|
| 1065 |
A b-EDT is translated into a p-EDT to identify it as a |
| 1066 |
carrier for a semantic item. Otherwise, it is treated |
| 1067 |
identically to a b-STRUC. |
| 1068 |
|
| 1069 |
|
| 1070 |
VI.6 -- Translation Summary |
| 1071 |
|
| 1072 |
|
| 1073 |
The following table summarizes the possible |
| 1074 |
translations between primitive items and objects. |
| 1075 |
|
| 1076 |
p-INT <--> b-LINTEGER, b-SINTEGER |
| 1077 |
p-STRING <--> b-STRING, b-STRUC, b-USTRUC |
| 1078 |
p-STRUC <--> b-STRING, b-STRUC, b-USTRUC |
| 1079 |
p-BITS <--> b=SBITSTR, b-LBITSTR |
| 1080 |
p-CHAR <--> b-CHAR7 |
| 1081 |
p-BOOL <--> b-BOOL |
| 1082 |
p-EMPTY <--> b=EMPTY |
| 1083 |
p-XTRA <--> b-XTRA |
| 1084 |
p-EDT <--> b-EDT (all semantic items) |
| 1085 |
-none- <--> b-PADDING |
| 1086 |
-none- <--> b-REPEAT (only within structure) |
| 1087 |
|
| 1088 |
Note that all semantic items are represented as p-EDTs |
| 1089 |
which always exist as b-EDTs in byte-stream format. |
| 1090 |
|
| 1091 |
-19-</pre> |
| 1092 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>V1.7 -- Structure Coding Examples |
| 1093 |
|
| 1094 |
|
| 1095 |
The following stream transmits a b-STRUC containing 3 |
| 1096 |
b-SINTEGERs, with values 1, 2, and 3, representing a p-STRUC |
| 1097 |
containing three p-INTs, i.e. (1 2 3). |
| 1098 |
|
| 1099 |
<span class="h2"><a class="selflink" id="section-11000010" href="#section-11000010">11000010</a> -- b-STRUC</span> |
| 1100 |
<span class="h2"><a class="selflink" id="section-00000011" href="#section-00000011">00000011</a> -- size=3</span> |
| 1101 |
<span class="h2"><a class="selflink" id="section-10000001" href="#section-10000001">10000001</a> -- b-SINTEGER=1</span> |
| 1102 |
<span class="h2"><a class="selflink" id="section-10000010" href="#section-10000010">10000010</a> -- b-SINTEGER=2</span> |
| 1103 |
<span class="h2"><a class="selflink" id="section-10000011" href="#section-10000011">10000011</a> -- b-SINTEGER=3</span> |
| 1104 |
|
| 1105 |
The next example represents a b-STRUC containing the |
| 1106 |
characters X and Y, followed by the b-LINTEGER 10, |
| 1107 |
representing a p-STRUC of 2 p-CHARs and a p-INT, i.e., ('X' |
| 1108 |
'Y' 10). Note that the p-INT prevents considering this a |
| 1109 |
p-STRING. |
| 1110 |
|
| 1111 |
<span class="h2"><a class="selflink" id="section-11000010" href="#section-11000010">11000010</a> -- b-STRUC</span> |
| 1112 |
<span class="h2"><a class="selflink" id="section-00000100" href="#section-00000100">00000100</a> -- size=4</span> |
| 1113 |
<span class="h2"><a class="selflink" id="section-01011000" href="#section-01011000">01011000</a> -- b-CHAR7 'X'</span> |
| 1114 |
<span class="h2"><a class="selflink" id="section-01011001" href="#section-01011001">01011001</a> -- b-CHAR7 'Y'</span> |
| 1115 |
<span class="h2"><a class="selflink" id="section-11100001" href="#section-11100001">11100001</a> -- b-LINTEGER</span> |
| 1116 |
<span class="h2"><a class="selflink" id="section-00001010" href="#section-00001010">00001010</a> -- 10</span> |
| 1117 |
|
| 1118 |
Note that a better way to send this p-STRUC would be to |
| 1119 |
represent the integer as a b-SINTEGER, as shown below. |
| 1120 |
|
| 1121 |
<span class="h2"><a class="selflink" id="section-11000010" href="#section-11000010">11000010</a> -- b-STRUC</span> |
| 1122 |
<span class="h2"><a class="selflink" id="section-00000011" href="#section-00000011">00000011</a> -- size=3</span> |
| 1123 |
<span class="h2"><a class="selflink" id="section-01011000" href="#section-01011000">01011000</a> -- b-CHAR7 'X'</span> |
| 1124 |
<span class="h2"><a class="selflink" id="section-01011001" href="#section-01011001">01011001</a> -- b-CHAR7 'Y'</span> |
| 1125 |
<span class="h2"><a class="selflink" id="section-10001010" href="#section-10001010">10001010</a> -- b-SINTEGER=10</span> |
| 1126 |
|
| 1127 |
The next example shows a b-STRUC of b-CHAR7s. It is |
| 1128 |
the translation of the b-STRING "HELLO". |
| 1129 |
|
| 1130 |
<span class="h2"><a class="selflink" id="section-11000010" href="#section-11000010">11000010</a> -- b-STRUC</span> |
| 1131 |
<span class="h2"><a class="selflink" id="section-00000101" href="#section-00000101">00000101</a> -- size=5</span> |
| 1132 |
<span class="h2"><a class="selflink" id="section-01001000" href="#section-01001000">01001000</a> -- b-CHAR7 'H'</span> |
| 1133 |
<span class="h2"><a class="selflink" id="section-01000101" href="#section-01000101">01000101</a> -- b-CHAR7 'E'</span> |
| 1134 |
<span class="h2"><a class="selflink" id="section-01001100" href="#section-01001100">01001100</a> -- b-CHAR7 'L'</span> |
| 1135 |
<span class="h2"><a class="selflink" id="section-01001100" href="#section-01001100">01001100</a> -- b-CHAR7 'L'</span> |
| 1136 |
<span class="h2"><a class="selflink" id="section-01001111" href="#section-01001111">01001111</a> -- b-CHAR7 'O'</span> |
| 1137 |
|
| 1138 |
This datum could also be transmitted as a b-STRING. |
| 1139 |
Note that the character bytes are not necessarily b-CHAR7s, |
| 1140 |
since the high-order bit is ignored. |
| 1141 |
|
| 1142 |
<span class="h2"><a class="selflink" id="section-11000110" href="#section-11000110">11000110</a> -- b-STRING</span> |
| 1143 |
<span class="h2"><a class="selflink" id="section-00000101" href="#section-00000101">00000101</a> -- size=5</span> |
| 1144 |
<span class="h2"><a class="selflink" id="section-01001000" href="#section-01001000">01001000</a> -- 'H'</span> |
| 1145 |
<span class="h2"><a class="selflink" id="section-01000101" href="#section-01000101">01000101</a> -- 'E'</span> |
| 1146 |
<span class="h2"><a class="selflink" id="section-01001100" href="#section-01001100">01001100</a> -- 'L'</span> |
| 1147 |
<span class="h2"><a class="selflink" id="section-01001100" href="#section-01001100">01001100</a> -- 'L'</span> |
| 1148 |
<span class="h2"><a class="selflink" id="section-01001111" href="#section-01001111">01001111</a> -- 'O'</span> |
| 1149 |
|
| 1150 |
-20-</pre> |
| 1151 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>To encode a p-STRING containing 20 carriage-return |
| 1152 |
line-feed pairs, the following b-STRUC containing a b-REPEAT |
| 1153 |
could be used. |
| 1154 |
|
| 1155 |
<span class="h2"><a class="selflink" id="section-11000010" href="#section-11000010">11000010</a> -- b-STRUC</span> |
| 1156 |
<span class="h2"><a class="selflink" id="section-00000101" href="#section-00000101">00000101</a> -- size=5</span> |
| 1157 |
<span class="h2"><a class="selflink" id="section-11000100" href="#section-11000100">11000100</a> -- b-REPEAT</span> |
| 1158 |
<span class="h2"><a class="selflink" id="section-00000011" href="#section-00000011">00000011</a> -- size=3</span> |
| 1159 |
<span class="h2"><a class="selflink" id="section-10010100" href="#section-10010100">10010100</a> -- count, b-SINTEGER=20</span> |
| 1160 |
<span class="h2"><a class="selflink" id="section-00001101" href="#section-00001101">00001101</a> -- b-CHAR7, "CR'</span> |
| 1161 |
<span class="h2"><a class="selflink" id="section-00001010" href="#section-00001010">00001010</a> -- b-CHAR7, 'IF'</span> |
| 1162 |
|
| 1163 |
To encode a p-STRUC of p-INTs, where the sequence |
| 1164 |
contains a sequence of thirty 0's preceded by a single 1, |
| 1165 |
the following b-STRUC could be used. |
| 1166 |
|
| 1167 |
<span class="h2"><a class="selflink" id="section-11000010" href="#section-11000010">11000010</a> -- b-STRUC</span> |
| 1168 |
<span class="h2"><a class="selflink" id="section-00000110" href="#section-00000110">00000110</a> -- size=6</span> |
| 1169 |
<span class="h2"><a class="selflink" id="section-10000001" href="#section-10000001">10000001</a> -- b-SINTEGER=1</span> |
| 1170 |
<span class="h2"><a class="selflink" id="section-11000100" href="#section-11000100">11000100</a> -- b-REPEAT</span> |
| 1171 |
<span class="h2"><a class="selflink" id="section-00000010" href="#section-00000010">00000010</a> -- size=2</span> |
| 1172 |
<span class="h2"><a class="selflink" id="section-10011110" href="#section-10011110">10011110</a> -- count, b-SINTEGER=30</span> |
| 1173 |
<span class="h2"><a class="selflink" id="section-10000000" href="#section-10000000">10000000</a> -- b-SINTEGER=0</span> |
| 1174 |
|
| 1175 |
|
| 1176 |
VII. A GENERAL DATA TRANSFER SCHEME |
| 1177 |
|
| 1178 |
|
| 1179 |
This section considers a possible scheme for extending |
| 1180 |
the concept of a data translator into an multi-purpose data |
| 1181 |
transfer mechanism. |
| 1182 |
|
| 1183 |
The proposed environment would provide a set of |
| 1184 |
primitive items, including those enumerated herein but |
| 1185 |
extended as necessary to accommodate a variety of |
| 1186 |
applications. Communication between processes would be |
| 1187 |
defined solely in terms of these items, and would |
| 1188 |
specifically avoid any consideration of the actual formats |
| 1189 |
in which the data is transferred. |
| 1190 |
|
| 1191 |
A repertoire of translators would be provided, one of |
| 1192 |
which is the MSDTP machinery, for use in converting items to |
| 1193 |
any of a number of transmission formats. Borrowing a |
| 1194 |
concept from radio terminology, each translator would be |
| 1195 |
analogous to a different type of modulation scheme, to be |
| 1196 |
used to transfer data through some communications medium. |
| 1197 |
Such media could be an eight-bit byte-oriented connection, |
| 1198 |
36-bit connection, etc. and conceivably have other |
| 1199 |
distinguishing features, such as bandwidth, cost, and delay. |
| 1200 |
For each media which a site supports, it would provide its |
| 1201 |
programmers with a module for performing the translations |
| 1202 |
required. |
| 1203 |
|
| 1204 |
|
| 1205 |
|
| 1206 |
|
| 1207 |
-21-</pre> |
| 1208 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'>Certain media or translators might not handle various |
| 1209 |
items. For example, the MSDTP does not handle items which |
| 1210 |
might be termed p-FLOATs, p-COMPLEXs, p-ARRAY, and so on. In |
| 1211 |
addition, the efficiency of various media for transfer of |
| 1212 |
specific items may differ drastically. MSDTP, for example, |
| 1213 |
transfers data frequently used in message handling very |
| 1214 |
efficiently, but is relatively poor at transfer of very |
| 1215 |
large or deep tree structures. |
| 1216 |
|
| 1217 |
Available at each site as a process or subroutine |
| 1218 |
package wouLd be a module responsible for interfacing with |
| 1219 |
its counterpart at the other end of the media. These |
| 1220 |
modules would use a protocol, not yet defined, to match |
| 1221 |
their capabilities, and choose a particular media and |
| 1222 |
translator, when more than one exists, for transfer of data |
| 1223 |
items. |
| 1224 |
|
| 1225 |
Such a facility could totally insulate applications |
| 1226 |
from need to consider encoding formats, machine differences, |
| 1227 |
and so on, as well as eliminate duplication of effort in |
| 1228 |
producing such facilities for every new project which |
| 1229 |
requires them. In addition, as new translators or media are |
| 1230 |
introduced, they would become immediately available to |
| 1231 |
existing users without reprogramming. |
| 1232 |
|
| 1233 |
Implementation of such a protocol should not be very |
| 1234 |
difficult or time-consuming, since it need not be very |
| 1235 |
sophisticated in choosing the most appropriate transfer |
| 1236 |
mechanism in initial implementations. The system is |
| 1237 |
inherently upward-compatible and easily expandable. |
| 1238 |
|
| 1239 |
|
| 1240 |
|
| 1241 |
|
| 1242 |
|
| 1243 |
|
| 1244 |
|
| 1245 |
|
| 1246 |
|
| 1247 |
|
| 1248 |
|
| 1249 |
|
| 1250 |
|
| 1251 |
|
| 1252 |
|
| 1253 |
|
| 1254 |
|
| 1255 |
|
| 1256 |
|
| 1257 |
|
| 1258 |
|
| 1259 |
|
| 1260 |
|
| 1261 |
-22- |
| 1262 |
</pre> |