Debian Codegraph @

rfc713.html

raw
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 &lt;--&gt; b-LINTEGER, b-SINTEGER
1077 p-STRING &lt;--&gt; b-STRING, b-STRUC, b-USTRUC
1078 p-STRUC &lt;--&gt; b-STRING, b-STRUC, b-USTRUC
1079 p-BITS &lt;--&gt; b=SBITSTR, b-LBITSTR
1080 p-CHAR &lt;--&gt; b-CHAR7
1081 p-BOOL &lt;--&gt; b-BOOL
1082 p-EMPTY &lt;--&gt; b=EMPTY
1083 p-XTRA &lt;--&gt; b-XTRA
1084 p-EDT &lt;--&gt; b-EDT (all semantic items)
1085 -none- &lt;--&gt; b-PADDING
1086 -none- &lt;--&gt; 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>