Debian Codegraph @

rfc1791.html

raw
1 <pre>Network Working Group T. Sung
2 Request for Comments: 1791 Novell, Inc.
3 Category: Experimental April 1995
4
5
6 <span class="h1">TCP And UDP Over IPX Networks With Fixed Path MTU</span>
7
8 Status of this Memo
9
10 This document defines an Experimental Protocol for the Internet
11 community. This does not specify an Internet standard of any kind.
12 Discussion and suggestions for improvement are requested.
13 Distribution of this memo is unlimited.
14
15 IESG Note:
16
17 Internet Engineering Steering Group comment from the Area Director
18 for Transport Services: Please note well that this memo is an
19 individual product of the author. Implementation experience,
20 particularly on the effectiveness of the protocols in dual-stack
21 environments, is needed.
22
23 <span class="h2"><a class="selflink" id="section-1" href="#section-1">1</a>. Introduction</span>
24
25 Most of network applications run on some sort of transports. And, if
26 one is to let such applications to run over a foreign network
27 protocol, the simplest way would be to allow the applications'
28 transports to run over that network protocol. For TCP/IP
29 applications, that transport is TCP or UDP. Hence, to let TCP/IP
30 applications run over IPX, we would need to have TCP and UDP run
31 over IPX. And, once TCP and UDP are allowed to run over IPX, all TCP
32 and UDP based applications, such as HTTP for WWW, or NFS, can easily
33 be made to work over IPX networks.
34
35 DLsw is another example of such applications. As it is a TCP
36 application (and TCP requires IP), the administrator is forced to run
37 IP on his network in order to support DLsw. If the site was an IPX
38 shop, it means that he now must manage IP protocol/addresses in
39 addition to IPX. If TCP could be made to run on IPX, then he would
40 not have to add IP to his repertoire of network protocols to manage.
41
42 TCP/IPX allows TCP/IP applications to run over IPX networks by
43 letting TCP and UDP run over IPX. And this memo specifies the packet
44 format and operational procedures for running TCP and UDP over IPX.
45
46
47
48
49
50
51
52 <span class="grey">Sung [Page 1]</span></pre>
53 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-2" ></span>
54 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
55
56
57 <span class="h2"><a class="selflink" id="section-2" href="#section-2">2</a>. Running UDP Over IPX</span>
58
59 Since UDP datagrams can be up to 64K octets long, and the size of IPX
60 packet is limited to that of the path MTU, large UDP datagrams must
61 be fragmented. And, since IPX does not support fragmentation, large
62 UDP datagrams must be fragmented before they are passed to IPX. For
63 that purpose, a new protocol called IPXF (IPX Fragmentation layer),
64 is invented. UDP must run on IPXF rather than directly on IPX. IPXF
65 layer is described in <a href="#section-4">section 4</a>.
66
67 To IPXF service users, IPXF behaves just like IPX except that IPXF
68 accepts datagram larger than the IPX path MTU. As such, we describe
69 UDP in this section as if it is running on IPX.
70
71 UDP must send and receive the packets on IPX/IPXF socket 0x9092.
72 Though it may be possible to send a packet from sockets other than
73 0x9092, such sockets cannot receive UDP datagram destined to a well
74 known socket 0x9092. Hence, the bidirectional communcation may not
75 be established if a socket other than 0x9092 is used to send UDP
76 datagram. For that reason. UDP/IPX does not allow source sockets
77 other than 0x9092. If a datagram with source socket number other
78 than 0x9092 is received, UDP/IPX should discard the packet silently.
79 (And increment udpInDatagramErr MIB counter if it is instrumented.)
80
81 UDP over IPX uses the IPX packet type 4, a normal IPX packet type.
82 The IPX packet type has no meaning to TCP/IPX protocol. It simply is
83 a number required by IPX for general IPX packets.
84
85 See <a href="#appendix-B.1">Appendix B.1</a> and B.2 for UDP over IPX packet format.
86
87 The UDP/IPX checksum uses a pseudo header similar to UDP/IP pseudo
88 header. The only difference is that IP addresses and protocol ID are
89 replaced by IPX addresses and socket numbers.
90
91 See <a href="#appendix-B.3">Appendix B.3</a> for the UDP/IPX pseudo header format.
92
93 <span class="h2"><a class="selflink" id="section-3" href="#section-3">3</a>. Running TCP Over IPX</span>
94
95 Unlike UDP, TCP runs directly over IPX. Since IPX does not support
96 fragmentation, no TCP segment sent over IPX can be larger than the
97 path MTU for the connection. The discovery of the path MTU is
98 outside of scope of this paper. If the implementation does not have
99 a way to dynamically determine the path MTU for each connection, it
100 should at least allow a way to statically configure a reasonable
101 value for all connections. For example, if the internetwork made of
102 ethernets only, the user may configure the segment size to be 1470
103 including the TCP header. If the configuration of the segment size
104 is not possible, the implementation should assume that the IPX path
105
106
107
108 <span class="grey">Sung [Page 2]</span></pre>
109 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-3" ></span>
110 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
111
112
113 MTU is 576 octects, and not send any TCP segment larger than 546
114 octets including TCP header. That will result in IPX packet of 576
115 octets which is the minimum path MTU for IPX. The implementation is
116 then advised to comunicate the configured/default segment size to the
117 peer TCP by exchanging MSS option.
118
119 Note that this memo does not preclude the possibility of running TCP
120 over IPXF instead of IPX. Running on IPXF can be done in the same
121 manner as running UDP over IPXF. However, in general, TCP should
122 refrain from sending large segments that may result in fragmentation.
123 Hence, running TCP over IPXF is not recommended.
124
125 The IPX socket number 0x9091 is reserved for the TCP. All TCP packets
126 must be sent from and received on the socket 0x9091. If the received
127 TCP/IPX packet has the source IPX socket number other than 0x9091,
128 the packet should be discarded silently. (And increment tcpInErrs MIB
129 counter if it is instrumented.)
130
131 TCP, like UDP, uses IPX packet type 4. The IPX packet type has no
132 meaning to TCP/IPX protocol. It is packet type required by IPX for
133 general IPX packets.
134
135 See <a href="#appendix-A.1">appendix A.1</a> for TCP/IPX packet format.
136
137 The TCP pseudo header, used in checksuming for TCP over IPX, is
138 similar to TCP pseudo header for TCP over IP. Again, the difference
139 is that IPX addresses and IPX socket number are substituted in place
140 of IP addresses and IP protocol number.
141
142 See <a href="#appendix-A.2">Appendix A.2</a> for the TCP/IPX pseudo header format.
143
144 <span class="h2"><a class="selflink" id="section-4" href="#section-4">4</a>. IPXF Layer</span>
145
146 A large UDP datagram cannot be sent directly over IPX as IPX does not
147 support datagrams larger than the path MTU. Hence, large UDP
148 datagrams must be fragmented before it can be sent over IPX. To have
149 large UDP datagrams fragmented, UDP runs over IPXF layer instead of
150 running directly IPX.
151
152 IPXF users treats IPXF as if it is IPX layer. That is, they pass
153 datagrams to IPXF specifying the destination IPX address/socket along
154 with the packet. They also must set the source socket number of the
155 datagram to its actual IPX socket number, as it would when sending
156 packets to IPX layer. (For UDP, both source and destination sockets
157 are 0x9092.)
158
159 Datagrams passed to IPXF can be upto 64K octets long.
160
161
162
163
164 <span class="grey">Sung [Page 3]</span></pre>
165 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-4" ></span>
166 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
167
168
169 IPXF fragments a datagram as necessary, prepends each fragment with
170 the IPXF header and send them to the IPX socket 0x9093 in the
171 destination IPX address. The actual destination socket number
172 (0x9092 for UDP) in the orignal IPX datagram is preserved in IPXF
173 header. Refer to <a href="#appendix-B.2">Appendix B.2</a> for UDP/IPXF/IPX packet format.
174
175 The largest possible IPX datagram that can be sent over the IPX path
176 is limited by the path MTU size. The mechanism to discover the path
177 MTU is outside of the scope of the paper. If an IPXF implementation
178 does not have a mean to determine the path MTU, it should assume that
179 the largest IPX packet size is 576. In that case, any UDP datagram
180 larger than 546 octects will have to be fragmented.
181
182 If the datagram does not require fragmentation, IPXF acts as a null
183 layer. That is, the whole packet is directly sent to the actual IPX
184 destination socket without the IPXF fragmentation header. Refer to
185 <a href="#appendix-B.1">Appendix B.1</a> for UDP/IPX packet format without the IPXF header.
186
187 An IPXF user receives datagrams by opening a socket with IPXF just as
188 it would with IPX. For example, UDP opens the socket 0x9092 with
189 IPXF to receive UDP datagrams. IPXF, in turn, opens IPX socket of
190 the same number with IPX, so that unfragmented packets directed to
191 that socket will be delivered by IPX directly to the IPXF user.
192
193 IPXF fragments are received by IPXF on the IPX socket 0x9093. The
194 receiving IPXF then reassembles the fragments into a complete IPX
195 datagram, restores the actual detination IPX socket number from the
196 IPXF header and delivers the reassembled IPX datagram to its actual
197 recipient designated by the restored socket number.
198
199 Upon receiving a fragment, IPXF must ignore the source socket number
200 in the IPX header of the fragment. The source IPX socket field in
201 IPX header contains the actual source of the IPX datagram. As such,
202 the source IPX socket number in IPX header usually is not 0x9093, and
203 it is meaningful only to the actual recepient of the assembled
204 datagram.
205
206 The fragmentation/reassembly algorithm used by IPXF is identical to
207 that of IP, except for the following exceptions: 1) the offset of
208 fragments are measured in units of octets rather than in units of 8
209 octets. 2) if the receiving IPXF does not have sufficient resource
210 for the reassembly, it should discard fragments immediately. The
211 receiving IPXF can determine if it has sufficient resources by
212 looking at the length of the original datagram included in every
213 fragment.
214
215 Note that, though it is required only for UDP in this memo, IPXF can
216 also be used by any protocol that requires IPX fragmentation support.
217
218
219
220 <span class="grey">Sung [Page 4]</span></pre>
221 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-5" ></span>
222 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
223
224
225 <span class="h2"><a class="selflink" id="section-5" href="#section-5">5</a>. TCP/IPX Checksuming</span>
226
227 TCP/IPX is checksummed in exactly same manner as TCP/IP. It uses 16
228 bit 1's complement of 1's compliment sum of all 16 bit words in the
229 pseudo header and text. See <a href="#appendix-A.2">Appendix A.2</a> and B.3 for the pseudo
230 header format for TCP and UDP.
231
232 <span class="h2"><a class="selflink" id="section-6" href="#section-6">6</a>. Multiplexing</span>
233
234 TCP and UDP data over IPX are delivered to the application in the
235 same manner as in TCP/IP. That is, they are delivered to the most
236 specific matching endpoint, with the match made on local port, remote
237 port, local IPX address and remote IPX address.
238
239 When TCP or UDP is running over both IPX and IP, the connection
240 endpoint also identifies the network layer on which the endpoint is.
241 Hence, the triplet of network address, network address family, and
242 the port number forms the socket. And, the endpoint match must be
243 made on the the network address familty as well.
244
245 For exmple, an endpoint bound to IPX network layer would be
246 identified by AF_IPX, IPX address and TCP port number. On the other
247 hand, endpoints bound to IP network layer would be identified by
248 AF_IP, IP address, and TCP port. Finally, endpoints not bound to any
249 network layer would be identified by AF_UNSPEC and TCP port.
250
251 First, an attempt is made to deliver the data to the most specific
252 endpoint that is bound to the network layer that the packet arrived
253 from. If there is no such endpoint, then the packet is delivered to
254 the best matching endpoint that is not bound to any network layer at
255 all. For example, if the packet arrived over IPX network, then the
256 packet is delivered to the most specific matching endpoint that is
257 bound to IPX. If there is no matching endpoint over IPX, then it is
258 delivered to an endpoint that did not specify any network layer.
259
260 The use of endpoints not bound to any network layer is similar to
261 TCP/IP endpoints with no IP address bound to it. Such endpoints are
262 usually used for listening for connection requests from any of the
263 interfaces within the host. Similarly, endpoints with no network
264 layer bound to it are used to field the connection requests from any
265 of the network layers.
266
267 Acknowledgement
268
269 The author wishes to thank following folks, in alphabetical order,
270 and others for their helpful comments and contributions to the work:
271 Lester Bird, Doug Kogan, Greg Minshall and Don Provan.
272
273
274
275
276 <span class="grey">Sung [Page 5]</span></pre>
277 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-6" ></span>
278 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
279
280
281 Security Considerations
282
283 Security issues are not discussed in this memo.
284
285 Author's Address
286
287 Tae Sung
288 Novell, Inc.
289 2180 Fortune Drive
290 San Jose, California, 95131
291
292 Phone: (408)577-8439
293 EMail: [email protected]
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332 <span class="grey">Sung [Page 6]</span></pre>
333 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-7" ></span>
334 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
335
336
337 <span class="h3"><a class="selflink" id="appendix-A.1" href="#appendix-A.1">Appendix A.1</a> - TCP/IPX Packet Format</span>
338
339 A TCP/IPX Packet has following format:
340
341 +-------+-------+-------+-------+
342 | IPX Checksum | IPX Pkt Len |
343 +-------+-------+-------+-------+
344 | Zero |IPX PT | IPX Dest -
345 +-------+-------+-------+-------+
346 Network | IPX Dest -
347 +-------+-------+-------+-------+
348 Node |
349 +-------+-------+-------+-------+
350 | IPX Dest Skt | IPX Src -
351 +-------+-------+-------+-------+
352 Network | IPX Src -
353 +-------+-------+-------+-------+
354 Node |
355 +-------+-------+-------+-------+
356 | IPX Src Skt | TCP Header and
357 +---------------+-------+-------+
358 Data...
359 +----...
360
361 IPX PT field contains the IPX packet type. It is set to 4 for
362 TCP/IPX packet.
363
364 Both Src Skt and Dest Skt field in IPX header must be set to 0x9091
365 for TCP/IPX packet. If the Src Skt is not set to 0x9091, the
366 receiving TCP/IPX should discard the packet silently. (And increment
367 tcpInErrs mib object if it is instrumented.)
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388 <span class="grey">Sung [Page 7]</span></pre>
389 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-8" ></span>
390 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
391
392
393 <span class="h3"><a class="selflink" id="appendix-A.2" href="#appendix-A.2">Appendix A.2</a> - TCP/IPX Pseudo Header Format</span>
394
395 TCP/IPX uses following pseudo header to compute checksum:
396
397 +-------+-------+-------+-------+
398 | IPX Src Network |
399 +-------+-------+-------+-------+
400 | IPX Src Node
401 +-------+-------+-------+-------+
402 | IPX Src Skt |
403 +-------+-------+-------+-------+
404 | IPX Dest Network |
405 +-------+-------+-------+-------+
406 | IPX Dest Node
407 +-------+-------+-------+-------+
408 | IPX Dest Skt |
409 +-------+-------+-------+-------+
410 | Zero | TCP Length |
411 +---------------+---------------+
412
413 IPX Src/Dest Network/Node/Skt are the fields from the IPX header.
414 TCP Length is the IPX Pkt Len minus the IPX header length in octets.
415
416 Note that IPX Src Skt is expected to be 0x9091 for TCP. As such, one
417 may insert 0x9091 in IPX Src Skt field rather than getting the value
418 from IPX header. Then the implementation will not have to check the
419 IPX Src Skt field in the fast path since the checksum failure will
420 also cover the unexpected value. In that case, the implementation
421 may want to examine if the checksum failure was due to the IPX Src
422 Skt value other than 0x9091, so that it can increment appropriate
423 counter, if proprietary counters other than tcpInErrs are used.
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444 <span class="grey">Sung [Page 8]</span></pre>
445 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-9" ></span>
446 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
447
448
449 <span class="h3"><a class="selflink" id="appendix-B.1" href="#appendix-B.1">Appendix B.1</a> - UDP/IPX Packet Format without Fragmentation</span>
450
451 IPXF transmits UDP packets over IPX in this format if the UDP
452 datagram does not have to be fragmented:
453
454 +-------+-------+-------+-------+
455 | IPX Checksum | IPX Pkt Len |
456 +-------+-------+-------+-------+
457 | Zero |IPX PT | IPX Dest -
458 +-------+-------+-------+-------+
459 Network | IPX Dest -
460 +-------+-------+-------+-------+
461 Node |
462 +-------+-------+-------+-------+
463 | IPX Dest Skt | IPX Src -
464 +-------+-------+-------+-------+
465 Network | IPX Src -
466 +-------+-------+-------+-------+
467 Node |
468 +-------+-------+-------+-------+
469 | IPX Src Skt | UDP Header and
470 +---------------+-------+-------+
471 Data...
472 +----...
473
474 The IPX PT field contains IPX packet type. It should be set to 4 for
475 all UDP/IPX packets.
476
477 Both IPX Src Skt and IPX Dest Skt field must be set 0x9092. The
478 receiving UDP/IPX should discard the packet silently if the IPX Src
479 Skt field is not set to 0x9092. (And increment udpInErrors mib
480 object if it is instrumented.)
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500 <span class="grey">Sung [Page 9]</span></pre>
501 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-10" ></span>
502 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
503
504
505 <span class="h3"><a class="selflink" id="appendix-B.2" href="#appendix-B.2">Appendix B.2</a> - UDP/IPX Packet Format With Fragmentation</span>
506
507 IPXF transmits fragmented datagrams over IPX in the following format:
508
509 +-------+-------+-------+-------+
510 | IPX Checksum | IPX Pkt Len |
511 +-------+-------+-------+-------+
512 | Zero |IPX PT | IPX Dest -
513 +-------+-------+-------+-------+
514 Network | IPX Dest -
515 +-------+-------+-------+-------+
516 Node |
517 +-------+-------+-------+-------+
518 IPX Dest Skt | IPX Src -
519 +-------+-------+-------+-------+
520 Network | IPX Src -
521 +-------+-------+-------+-------+
522 Node |
523 +-------+-------+-------+-------+
524 | IPX Src Skt | IPXF Offset |
525 +---------------+-------+-------+
526 | IPXF Frag Identification |
527 +-------------------------------+
528 | IPXF Dest Skt | IPXF DG Len |
529 +-------------------------------+
530 | UDP Header and Data ...
531 +--------...
532
533 The IPX PT field contains IPX packet type. It is set to the value
534 set by the IPXF user in the IPX packet passed to IPXF. (UDP sets it
535 to 4.)
536
537 IPX Dest Skt field must be set to 0x9093 for all IPXF Packets.
538
539 The value for IPX Src Skt field is variable, and must be set to the
540 actual IPX socket number of the IPXF user. (For example, it must be
541 set to 0x9092 for UDP.)
542
543 IPXF Offset field indicates where the fragment belongs in the
544 datagram. The offset is measured is octet from the begining of the
545 UDP datagram. The first fragment has the offset of 0.
546
547 IPXF Frag Identification field is assigned a same value by the sender
548 for all fragements belonging to the same datagram. The receiver then
549 uses this field to reassemble all fragments with same ID into a
550 datagram.
551
552
553
554
555
556 <span class="grey">Sung [Page 10]</span></pre>
557 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-11" ></span>
558 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
559
560
561 IPXF Dest Skt field contains the IPX socket number of the actual
562 recipient that the reassembled datagram will be delivered to. (It is
563 0x9092 for UDP.) All fragments of a datagram must have the same
564 value in this field.
565
566 IPXF DG Len field is the total length of the IPX datagram before the
567 fragmentation. The sender should set it to the value of IPX Pkt Len
568 of the original IPX datagram. All fragments of a IPX datagram must
569 have the same value in this field.
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612 <span class="grey">Sung [Page 11]</span></pre>
613 <hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-12" ></span>
614 <span class="grey"><a href="./rfc1791">RFC 1791</a> TCP And UDP Over IPX April 1995</span>
615
616
617 <span class="h3"><a class="selflink" id="appendix-B.3" href="#appendix-B.3">Appendix B.3</a> - UDP/IPX Pseudo Header Format</span>
618
619 UDP/IPX uses following pseudo header for computing the checksum:
620
621 +-------+-------+-------+-------+
622 | IPX Src Network |
623 +-------+-------+-------+-------+
624 | IPX Src Node
625 +-------+-------+-------+-------+
626 | IPX Src Skt |
627 +-------+-------+-------+-------+
628 | IPX Dest Network |
629 +-------+-------+-------+-------+
630 | IPX Dest Node
631 +-------+-------+-------+-------+
632 | IPX Dest Skt |
633 +-------+-------+-------+-------+
634 | Zero | UDP Length |
635 +---------------+---------------+
636
637 IPX Src/Dest Network/Node/Skt fields are from the IPX packet. Note
638 that, if UDP is running over IPXF, the IPX Dest Skt field in IPX
639 packet header is copied over from IPXF header before the reassembled
640 IPX packet is delivered to UDP, Hence, the pseudo header must be
641 derived from the reassembled IPX header.
642
643 UDP Length is from UDP header.
644
645 Note that IPX Src Skt is expected to be 0x9092 for UDP. As such, one
646 may insert 0x9092 in IPX Src Skt field rather than getting the value
647 from IPX header. Then the implementation will not have to check the
648 IPX Src Skt field in the fast path since the checksum failure will
649 also cover the unexpected value. In that case, the implementation
650 may want to examine if the checksum failure was due to the IPX Src
651 Skt value other than 0x9092, so that it can increment appropriate
652 counter, if proprietary counters other than udpInDatagramErr are
653 Datagr
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668 Sung [Page 12]
669 </pre>