RFC 1791
TCP And UDP Over IPX Networks With Fixed Path MTU
RFC 1791 🎀 TCP And UDP Over IPX Networks With Fixed Path MTU
Okay bestie, so this one is by T. Sung over at Novell, Inc. 💅 It's in the Experimental category and dated April 1995 📅 It doesn't list anything it obsoletes or updates, so it's giving independent main character energy 🦋
Status of this Memo 🎀
So this doc defines an Experimental Protocol for the Internet community. It does not specify an Internet standard of any kind, lowkey 🫶 Discussion and suggestions for improvement are requested, and distribution of this memo is unlimited 💖
IESG Note 🙈
Internet Engineering Steering Group comment from the Area Director for Transport Services: Please note well that this memo is an individual product of the author. Implementation experience, particularly on the effectiveness of the protocols in dual-stack environments, is needed 🧚
1. Introduction ✨
Most network applications run on some sort of transport 🌸 And if you want to let those applications run over a foreign network protocol, the simplest way is to let the application's transport run over that protocol. For TCP/IP applications, that transport is TCP or UDP. So to let TCP/IP applications run over IPX, we need TCP and UDP to run over IPX. Once TCP and UDP can run over IPX, every TCP and UDP based application, like HTTP for WWW or NFS, can easily work over IPX networks 💅
DLsw is another example 👑 Since it's a TCP application (and TCP requires IP), the administrator is forced to run IP on the network just to support DLsw. If the site is an IPX shop, they now have to manage IP protocols and addresses on top of IPX. If TCP could run on IPX, they wouldn't have to add IP to their list of network protocols to manage 😭
So TCP/IPX lets TCP/IP applications run over IPX networks by letting TCP and UDP run over IPX 🦋 This memo specifies the packet format and operational procedures for running TCP and UDP over IPX ✨
2. Running UDP Over IPX 💖
Since UDP datagrams can be up to 64K octets long, and the size of an IPX packet is limited to that of the path MTU, large UDP datagrams MUST be fragmented. And since IPX does not support fragmentation, large UDP datagrams MUST be fragmented before they are passed to IPX. For that purpose, a new protocol called IPXF (IPX Fragmentation layer) is invented 🧚 UDP MUST run on IPXF rather than directly on IPX. The IPXF layer is described in section 4 🎀
To IPXF service users, IPXF behaves just like IPX, except that IPXF accepts datagrams larger than the IPX path MTU. So as far as UDP is concerned, we describe it in this section as if it is running on IPX 🫶
UDP MUST send and receive the packets on IPX/IPXF socket 0x9092 🌈 Though it may be possible to send a packet from sockets other than 0x9092, those sockets cannot receive UDP datagrams destined to the well known socket 0x9092. Hence, the bidirectional communication may not be established if a socket other than 0x9092 is used to send a UDP datagram. For that reason, UDP/IPX does not allow source sockets other than 0x9092. If a datagram with a source socket number other than 0x9092 is received, UDP/IPX SHOULD discard the packet silently. (And increment the udpInDatagramErr MIB counter if it is instrumented.) 😭
UDP over IPX uses the IPX packet type 4, which is a normal IPX packet type 💅 The IPX packet type has no meaning to the TCP/IPX protocol. It simply is a number required by IPX for general IPX packets 🍓
See Appendix B.1 and B.2 for the UDP over IPX packet format 🦋
The UDP/IPX checksum uses a pseudo header similar to the UDP/IP pseudo header. The only difference is that IP addresses and the protocol ID are replaced by IPX addresses and socket numbers ✨
See Appendix B.3 for the UDP/IPX pseudo header format 💜
3. Running TCP Over IPX 🦋
Unlike UDP, TCP runs directly over IPX 🌸 Since IPX does not support fragmentation, no TCP segment sent over IPX can be larger than the path MTU for the connection. The discovery of the path MTU is outside of the scope of this paper 🙈 If the implementation does not have a way to dynamically determine the path MTU for each connection, it SHOULD at least allow a way to statically configure a reasonable value for all connections. For example, if the internetwork is made of ethernets only, the user MAY configure the segment size to be 1470 including the TCP header 🍓 If the configuration of the segment size is not possible, the implementation SHOULD assume that the IPX path MTU is 576 octets, and not send any TCP segment larger than 546 octets including the TCP header. That will result in an IPX packet of 576 octets, which is the minimum path MTU for IPX 💅 The implementation is then advised to communicate the configured or default segment size to the peer TCP by exchanging the MSS option 🫶
This memo does not preclude the possibility of running TCP over IPXF instead of IPX 🧚 Running on IPXF can be done in the same manner as running UDP over IPXF. However, in general, TCP SHOULD refrain from sending large segments that may result in fragmentation. Hence, running TCP over IPXF is NOT RECOMMENDED 🙅♀️
🚨 The IPX socket number0x9091is reserved for TCP. All TCP packets MUST be sent from and received on the socket0x9091. If the received TCP/IPX packet has a source IPX socket number other than0x9091, the packet SHOULD be discarded silently. (And increment thetcpInErrsMIB counter if it is instrumented.) 💀
TCP, like UDP, uses IPX packet type 4 🌈 The IPX packet type has no meaning to the TCP/IPX protocol. It is a packet type required by IPX for general IPX packets 🎀
See appendix A.1 for the TCP/IPX packet format ✨
The TCP pseudo header, used in checksumming for TCP over IPX, is similar to the TCP pseudo header for TCP over IP. Again, the difference is that IPX addresses and the IPX socket number are substituted in place of IP addresses and the IP protocol number 💖
See Appendix A.2 for the TCP/IPX pseudo header format 🦋
4. IPXF Layer 🧚
A large UDP datagram cannot be sent directly over IPX, since IPX does not support datagrams larger than the path MTU. Hence, large UDP datagrams MUST be fragmented before they can be sent over IPX 😭 To have large UDP datagrams fragmented, UDP runs over the IPXF layer instead of running directly over IPX 🫶
IPXF users treat IPXF as if it is the IPX layer 💅 That is, they pass datagrams to IPXF specifying the destination IPX address and socket along with the packet. They also MUST set the source socket number of the datagram to its actual IPX socket number, just as they would when sending packets to the IPX layer. (For UDP, both the source and destination sockets are 0x9092.) 🌸
Datagrams passed to IPXF can be up to 64K octets long 🍓
IPXF fragments a datagram as necessary, prepends each fragment with the IPXF header, and sends them to the IPX socket 0x9093 at the destination IPX address. The actual destination socket number (0x9092 for UDP) in the original IPX datagram is preserved in the IPXF header. Refer to Appendix B.2 for the UDP/IPXF/IPX packet format 🦋
The largest possible IPX datagram that can be sent over the IPX path is limited by the path MTU size. The mechanism to discover the path MTU is outside of the scope of this paper 🙈 If an IPXF implementation does not have a means to determine the path MTU, it SHOULD assume that the largest IPX packet size is 576. In that case, any UDP datagram larger than 546 octets will have to be fragmented 💜
If the datagram does not require fragmentation, IPXF acts as a null layer ✨ That is, the whole packet is sent directly to the actual IPX destination socket without the IPXF fragmentation header. Refer to Appendix B.1 for the UDP/IPX packet format without the IPXF header 🎀
An IPXF user receives datagrams by opening a socket with IPXF, just as it would with IPX. For example, UDP opens the socket 0x9092 with IPXF to receive UDP datagrams. IPXF, in turn, opens an IPX socket of the same number with IPX, so that unfragmented packets directed to that socket will be delivered by IPX directly to the IPXF user 🌈
IPXF fragments are received by IPXF on the IPX socket 0x9093. The receiving IPXF then reassembles the fragments into a complete IPX datagram, restores the actual destination IPX socket number from the IPXF header, and delivers the reassembled IPX datagram to its actual recipient, as designated by the restored socket number 🧚
Upon receiving a fragment, IPXF MUST ignore the source socket number in the IPX header of the fragment 🙅♀️ The source IPX socket field in the IPX header contains the actual source of the IPX datagram. So the source IPX socket number in the IPX header usually is not 0x9093, and it is meaningful only to the actual recipient of the assembled datagram 💅
The fragmentation and reassembly algorithm used by IPXF is identical to that of IP, except for the following exceptions: 1) the offset of fragments is measured in units of octets rather than in units of 8 octets; 2) if the receiving IPXF does not have sufficient resources for the reassembly, it SHOULD discard fragments immediately 😭 The receiving IPXF can determine whether it has sufficient resources by looking at the length of the original datagram included in every fragment 🫶
Note that, though it is REQUIRED only for UDP in this memo, IPXF can also be used by any protocol that requires IPX fragmentation support 🌸
5. TCP/IPX Checksumming 💅
TCP/IPX is checksummed in exactly the same manner as TCP/IP 🍓 It uses the 16 bit 1's complement of the 1's complement sum of all 16 bit words in the pseudo header and text. See Appendix A.2 and B.3 for the pseudo header format for TCP and UDP 🦋
6. Multiplexing 🌈
TCP and UDP data over IPX are delivered to the application in the same manner as in TCP/IP ✨ That is, they are delivered to the most specific matching endpoint, with the match made on local port, remote port, local IPX address and remote IPX address 💖
When TCP or UDP is running over both IPX and IP, the connection endpoint also identifies the network layer on which the endpoint sits 🧚 Hence, the triplet of network address, network address family, and port number forms the socket. And the endpoint match MUST be made on the network address family as well 👑
For example, an endpoint bound to the IPX network layer would be identified by AF_IPX, an IPX address, and a TCP port number. On the other hand, endpoints bound to the IP network layer would be identified by AF_IP, an IP address, and a TCP port. Finally, endpoints not bound to any network layer would be identified by AF_UNSPEC and a TCP port 🎀
First, an attempt is made to deliver the data to the most specific endpoint that is bound to the network layer the packet arrived from 🌸 If there is no such endpoint, then the packet is delivered to the best matching endpoint that is not bound to any network layer at all. For example, if the packet arrived over an IPX network, then the packet is delivered to the most specific matching endpoint that is bound to IPX. If there is no matching endpoint over IPX, then it is delivered to an endpoint that did not specify any network layer 🦋
The use of endpoints not bound to any network layer is similar to TCP/IP endpoints with no IP address bound to them. Such endpoints are usually used for listening for connection requests from any of the interfaces within the host. Similarly, endpoints with no network layer bound to them are used to field connection requests from any of the network layers 🌈
to be continued in part 2 🫶💖
Acknowledgement ✨
The author wanted to thank these legends, listed alphabetically, plus everyone else who gave helpful comments and contributions to the work 🫶: Lester Bird, Doug Kogan, Greg Minshall and Don Provan 💖
Security Considerations 🔒
Okay, real talk: security issues are not discussed in this memo 🙈 So don't go hunting for them here, bestie.
Author's Address 📮
Tae Sung
Novell, Inc.
2180 Fortune Drive
San Jose, California, 95131
Phone: (408)577-8439
EMail: tae@novell.ComAppendix A.1 - TCP/IPX Packet Format 🎀
A TCP/IPX packet is shaped like this, so let's look at it together 💅
+-------+-------+-------+-------+
| IPX Checksum | IPX Pkt Len |
+-------+-------+-------+-------+
| Zero |IPX PT | IPX Dest -
+-------+-------+-------+-------+
Network | IPX Dest -
+-------+-------+-------+-------+
Node |
+-------+-------+-------+-------+
| IPX Dest Skt | IPX Src -
+-------+-------+-------+-------+
Network | IPX Src -
+-------+-------+-------+-------+
Node |
+-------+-------+-------+-------+
| IPX Src Skt | TCP Header and
+---------------+-------+-------+
Data...
+----...The IPX PT field holds the IPX packet type, and for a TCP/IPX packet it's set to 4 🧚
Both the Src Skt and Dest Skt fields in the IPX header MUST be set to 0x9091 for a TCP/IPX packet 👑 If the Src Skt isn't set to 0x9091, the receiving TCP/IPX SHOULD discard the packet silently. (And increment the tcpInErrs MIB object if it's instrumented.) Literally the tea ☕
Appendix A.2 - TCP/IPX Pseudo Header Format 🦋
TCP/IPX uses this pseudo header to compute the checksum, and it's giving structure 🤌
+-------+-------+-------+-------+
| IPX Src Network |
+-------+-------+-------+-------+
| IPX Src Node
+-------+-------+-------+-------+
| IPX Src Skt |
+-------+-------+-------+-------+
| IPX Dest Network |
+-------+-------+-------+-------+
| IPX Dest Node
+-------+-------+-------+-------+
| IPX Dest Skt |
+-------+-------+-------+-------+
| Zero | TCP Length |
+---------------+---------------+The IPX Src/Dest Network/Node/Skt fields are just the fields from the IPX header ✨ TCP Length is the IPX Pkt Len minus the IPX header length, measured in octets.
Note that IPX Src Skt is expected to be 0x9091 for TCP 🫶 So one MAY insert 0x9091 into the IPX Src Skt field instead of pulling the value from the IPX header. The implementation then won't have to check the IPX Src Skt field in the fast path, because the checksum failure will also cover the unexpected value. In that case, the implementation MAY want to examine whether the checksum failure was caused by an IPX Src Skt value other than 0x9091, so it can increment the right counter if proprietary counters other than tcpInErrs are used 🧠
Appendix B.1 - UDP/IPX Packet Format without Fragmentation 🌸
IPXF sends UDP packets over IPX in this format when the UDP datagram doesn't need to be fragmented 💖
+-------+-------+-------+-------+
| IPX Checksum | IPX Pkt Len |
+-------+-------+-------+-------+
| Zero |IPX PT | IPX Dest -
+-------+-------+-------+-------+
Network | IPX Dest -
+-------+-------+-------+-------+
Node |
+-------+-------+-------+-------+
| IPX Dest Skt | IPX Src -
+-------+-------+-------+-------+
Network | IPX Src -
+-------+-------+-------+-------+
Node |
+-------+-------+-------+-------+
| IPX Src Skt | UDP Header and
+---------------+-------+-------+
Data...
+----...The IPX PT field contains the IPX packet type 🍓 It SHOULD be set to 4 for all UDP/IPX packets.
Both IPX Src Skt and IPX Dest Skt fields MUST be set 0x9092 💅 The receiving UDP/IPX SHOULD discard the packet silently if the IPX Src Skt field isn't set to 0x9092. (And increment the udpInErrors MIB object if it's instrumented.) Iconic behaviour, honestly 🙈
Appendix B.2 - UDP/IPX Packet Format With Fragmentation 🧚♀️
When the datagram does get fragmented, IPXF sends it over IPX in this format 🦋
+-------+-------+-------+-------+
| IPX Checksum | IPX Pkt Len |
+-------+-------+-------+-------+
| Zero |IPX PT | IPX Dest -
+-------+-------+-------+-------+
Network | IPX Dest -
+-------+-------+-------+-------+
Node |
+-------+-------+-------+-------+
IPX Dest Skt | IPX Src -
+-------+-------+-------+-------+
Network | IPX Src -
+-------+-------+-------+-------+
Node |
+-------+-------+-------+-------+
| IPX Src Skt | IPXF Offset |
+---------------+-------+-------+
| IPXF Frag Identification |
+-------------------------------+
| IPXF Dest Skt | IPXF DG Len |
+-------------------------------+
| UDP Header and Data ...
+--------...Here's the breakdown, bestie:
- The IPX PT field holds whatever packet type the IPXF user sets in the IPX packet it passes to IPXF. (UDP sets it to
4.) - IPX Dest Skt MUST be set to
0x9093for all IPXF packets 🫶 - The IPX Src Skt field is variable, and MUST be set to the actual IPX socket number of the IPXF user. (For example, it MUST be set to
0x9092for UDP.) - The IPXF Offset field shows where the fragment goes in the datagram. It's measured in octets from the beginning of the UDP datagram, and the first fragment has an offset of
0📍 - The IPXF Frag Identification field gets the same value from the sender for every fragment that belongs to the same datagram. The receiver then uses that field to put all the fragments with the same ID back together into one datagram 🧩
- The IPXF Dest Skt field holds the IPX socket number of the actual recipient that the reassembled datagram gets delivered to. (It's
0x9092for UDP.) All fragments of a datagram MUST have the same value in this field 🎀 - The IPXF DG Len field is the total length of the IPX datagram before fragmentation. The sender SHOULD set it to the IPX Pkt Len value of the original IPX datagram. All fragments of an IPX datagram MUST have the same value in this field 💜
Appendix B.3 - UDP/IPX Pseudo Header Format 🌈
UDP/IPX uses this pseudo header to compute the checksum ✨
+-------+-------+-------+-------+
| IPX Src Network |
+-------+-------+-------+-------+
| IPX Src Node
+-------+-------+-------+-------+
| IPX Src Skt |
+-------+-------+-------+-------+
| IPX Dest Network |
+-------+-------+-------+-------+
| IPX Dest Node
+-------+-------+-------+-------+
| IPX Dest Skt |
+-------+-------+-------+-------+
| Zero | UDP Length |
+---------------+---------------+The IPX Src/Dest Network/Node/Skt fields come from the IPX packet. Now here's the plot twist 😭 If UDP is running over IPXF, the IPX Dest Skt field in the IPX packet header is copied over from the IPXF header before the reassembled IPX packet is delivered to UDP. Hence, the pseudo header MUST be derived from the reassembled IPX header 💀
UDP Length comes from the UDP header 🌷
Note that IPX Src Skt is expected to be 0x9092 for UDP 🫶 So one MAY insert 0x9092 into the IPX Src Skt field instead of pulling the value from the IPX header. The implementation then won't have to check the IPX Src Skt field in the fast path, because the checksum failure will also cover the unexpected value. In that case, the implementation MAY want to examine whether the checksum failure was caused by an IPX Src Skt value other than 0x9092, so it can increment the right counter if proprietary counters other than udpInDatagramErr are Datagr
📦 where this page comes from
- ietf: rfc1791 1995-04
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms