RFC 1683

RFC 1683: Multiprotocol Interoperability In IPng 🎀

Okay bestie, so this is RFC 1683, and its title is Multiprotocol Interoperability In IPng 💖. It came from R. Clark, M. Ammar, and K. Calvert at the Georgia Institute of Technology, and it's dated August 1994 📅. It's an Informational doc, so it's giving "here's some good info," not "this is a standard" 🧚. The title block doesn't list anything it obsoletes or updates, so it's just doing its own thing ✨. It came out of the Network Working Group, which is giving very early-internet main character energy 💅.

---

Status of this Memo 📜

This memo is here to give information to the Internet community 🌸. It does not specify an Internet standard of any kind 🙈. Distribution of this memo is unlimited, so you can share the tea as much as you want 🍓.

Abstract 🦋

This document was sent to the IETF IPng area as a response to RFC 1550 💌. Publishing it doesn't mean the IPng area has accepted any of the ideas inside, so don't read it as an endorsement 🙃. Comments should go to the big-internet@munnari.oz.au mailing list 📬.

1. Executive Summary ✨

Okay so the two biggest reasons everyone keeps saying we need IPng are address depletion and routing table growth in IPv4 😩. The internet is also getting more and more diverse, with more protocols and services showing up all the time 🌈. When we compare IPng options, we need to look at how well each one handles the problems that come with that diversity. In this doc we spot several features that affect how well a protocol can work in a multiprotocol environment, and we propose building those features into IPng 🔥.

Our thesis, succinctly stated, is: The next generation Internet Protocol should have features that support its use with a variety of protocol architectures. 👑

2. Introduction 🎀

The Internet is not a single protocol network [4] 🙃. TCP/IP is still the main protocol suite, but other protocols (e.g., IPX, AppleTalk, OSI) are around too, either running natively or wrapped up as data inside IP 🧃. As new protocols keep getting developed, a big chunk of traffic in future networks probably won't be single-protocol chats 💬. Multiprotocol networking isn't just a transition issue, bestie 🫶. For example, we'll keep tunneling IPX traffic over the Internet between two Novell networks 🦋. Also, introducing IPng isn't going to wipe out IPv4 anytime soon. Even when IPng is the primary protocol on the Internet, there will still be IPv4 systems in use 💜. We should think about these multiprotocol uses when we design future protocols that have to handle mixed protocol traffic efficiently 🧚.

A lot of these issues were traditionally called "less important" by protocol designers 🙄, because their goal was to optimize for the case where every system ran the same protocol. With more and more diversity, that approach isn't practical anymore 😤. If we deal with the issues in this paper, we can make IPng way easier to introduce to the Internet and lower the risk for network managers who have to support a new protocol 🌷. That means faster, wider acceptance of IPng and better interoperability between Internet hosts 💅. And if we design IPng to handle all this, introducing future protocols like IPng2 will be even easier 🚀.

The outline for this doc goes like this 🗺️. In Section 3 we show why multiprotocol networking matters with an example system 🍭. In Section 4 we describe three main techniques for dealing with multiple protocols 🌈. Section 5 then covers the various protocol features that matter for putting those three techniques into practice ⭐. Finally, Section 6 wraps everything up with a summary of the issues we raised 👑.

3. Multiprotocol Systems 🦋

Check out the multiprotocol architecture in Figure 1 👀. A system that supports this setup gives you a generic file-transfer service over either the Internet or OSI protocol stacks 💌. The generic service gives the user one consistent interface, no matter which protocols are actually being used 💁. The user can transfer files between this host and hosts that support either of the single protocol stacks in Figures 2a and 2b 📂. The user doesn't have to pick protocols or switch between different application interfaces, which is honestly so iconic 😭.

             +-----------------------------------+
             |       File Transfer Service       |
             +-----------+-----------------------+
             |           |         FTAM          |
             |           +-----------------------+
             |   FTP     |       ISO 8823        |
             |           +-----------------------+
             |           |       ISO 8327        |
             |           +-----------+-----------+
             |           |TP0/RFC1006|   TP4     |
             +-----------+-----------+           |
             |          TCP          |           |
             +-----------+-----------+-----------+
             |    IP     |         CLNP          |
             +-----------+-----------------------+


 Figure 1:  Multiprotocol architecture providing file-transfer service

   +-----------+     +-----------+     +-----------+     +-----------+
   |   FTP     |     |   FTAM    |     |   FTAM    |     |   FTP     |
   +-----------+     +-----------+     +-----------+     +-----------+
   |   TCP     |     | ISO 8823  |     | ISO 8823  |     |   TCP     |
   +-----------+     +-----------+     +-----------+     +-----------+
   |    IP     |     | ISO 8327  |     | ISO 8327  |     |   CLNP    |
   +-----------+     +-----------+     +-----------+     +-----------+
                     |   TP4     |     |TP0/RFC1006|
                     +-----------+     +-----------+
                     |   CLNP    |     |   TCP     |
                     +-----------+     +-----------+
                                       |    IP     |
                                       +-----------+

    a) TCP/IP         b) OSI            c) RFC 1006       d) TUBA


      Figure 2:  Protocol stacks providing file-transfer service.

Figure 2c is a mixed stack that gives you the upper layer OSI services but runs them over the Internet protocols 🧁. It's an example of a "transition architecture" for providing OSI applications without needing a full OSI implementation 🔥. Figure 2d is also a mixed stack, but this one gives you upper layer Internet applications running over the OSI network protocol 🌸. Besides talking to the two simple stacks, the multiprotocol system in Figure 1 also includes everything it needs to talk to these two mixed stacks 🫶.

Honestly, it's likely that lots of future network systems will be set up to support multiple protocols, including IPng 🌈. As IPng gets deployed, it's unrealistic to expect users to give up any part of their current connectivity just for the promise of something better 😤. Most IPng installs will happen "in addition to" the current protocols 💜. The resulting systems will look like Figure 1, since they'll be able to communicate with systems that support several different protocols 🧚.

Unfortunately, in most current examples, the architecture in Figure 1 is built as independent protocol stacks 😭. That means that even though both TCP and CLNP exist on the system, there's no way to use TCP and CLNP in the same communication 💀. The problem with current implementations of architectures like Figure 1 is that they're designed as co-existence architectures and not integrated interoperability systems 🙈. We believe future systems should include mechanisms to get past this traditional limitation ✨. If we integrate the components of multiple protocol stacks in a systematic way, we can interoperate with hosts that support any of the individual stacks, as well as hosts that support various combinations of the stacks 👑.

In order to effectively use multiple protocols, a system must identify which of the available protocols to use for a given communication task. We call this the Protocol Determination [2] task. 🔍

In performing this task, a system figures out the combination of protocols it needs to provide the service it's supposed to provide 🧩. For interoperability, protocols get picked from the intersection of the ones supported on the systems that must communicate 🤝.

4. Multiprotocol Techniques 💅

Here we identify three main techniques for dealing with multiprotocol networks. They're in use today and they'll keep being used on the Internet 🌷. The first two, tunneling and conversion, are categorized as intermediate-system techniques, since they support multiprotocol networking without changing the end-systems 🧃. The third technique explicitly calls for supporting multiple protocols in the end-systems 🎀. By describing these techniques here, we can show why we need the specific protocol features described in Section 5 🦋.

4.1. Encapsulation/Tunneling 🌸

Encapsulation, or tunneling, is commonly used when two networks that support a common protocol have to be connected through a third intermediate network that runs a different protocol 🧁. Protocol packets from the two end networks get carried as data inside the protocol of the intermediate network 📦. This technique is only appropriate when both end-systems support the same protocol stack 😬. It doesn't provide interoperability between those end systems and systems that only support the protocol stack of the intermediate network 🙅‍♀️. Some examples of this technique are a mechanism for providing OSI transport services on top of the Internet protocols [13], encapsulating IEEE 802.2 frames in IPX network packets [5], and tunneling IPX [10] and AppleTalk traffic over the Internet backbone 🌈. We expect IPng to be used for tunneling other network protocols over IPng and to be encapsulated 🚀.

4.2. Translation/Conversion 🔥

Even though translation or conversion gateways have known limitations [8], they're another technique for handling multiple protocols [11, 12] 💅. These gateways directly convert network traffic from one protocol to another 🔄. The most common examples are the many electronic mail gateways in use across the Internet right now 📧. In certain cases it may also be feasible to convert lower layer protocols, like the network layer 🧠. This technique has been suggested as part of the transition plan for some of the current IPng proposals [3, 15] 🦋.

4.3. Multiprotocol End-Systems 🦋

okay so we totally expect IPng to show up as an additional protocol in tons of network systems 🌸 which means IPng should be able to coexist with other protocols on both end- and intermediate-systems 💅. Specifically, IPng should be designed to support the Protocol Determination task described in Section 3 ✨.

One technique we're considering for solving the Protocol Determination problem is using a directory service to distribute system protocol configuration information 🧚. We've developed and implemented a mechanism for using the Internet Domain Name System (DNS) [6, 7] to distribute this protocol information [2] 💜. With this mechanism, a multiprotocol host can figure out the protocol configuration of a desired host when it looks up the network address for that host 👀. Then the multiprotocol host can match the desired host's configuration against its own and work out which protocols should be used to carry out the requested communication service 🔥.

Another option for figuring out protocol info about another host is Protocol Discovery 🕵️‍♀️. With this approach, a host decides which protocols to use by trial-and-error with whatever protocols are currently available 😭. The initiating host keeps an eye on successive attempts to communicate and uses what it learns from that monitoring to build a knowledge base of the possible protocols of the remote system 📚.

That knowledge is used to determine whether or not a communication link can be established and, if it can, which protocol should be used 💅.

An important thing about Protocol Discovery is that it requires an error and control feedback system similar to ICMP [9], but with additional functionality (See Section 5) 🫶.

---

5. Protocol Features 👑

In this section we identify features that affect a protocol's ability to support the multiprotocol techniques described in the previous section 🌈. These features point out specific areas that should be considered when comparing proposed protocols ✨. We present two different types of protocol features: those that should be included as part of the IPng protocol standard, and those that should be considered as part of the implementation and deployment requirements for IPng 🎀.

5.1. Protocol Standard Features 💖

• Addressing 🏡

A big problem in multiprotocol networks is that most of the popular network protocols use different addressing mechanisms 😩. The problem isn't just different lengths, it's also different semantics (e.g., hierarchical vs. flat addresses) 🙈. To accommodate these multiple formats, IPng should have the flexibility to incorporate many address formats within its addressing mechanism 🦋.

A specific example would be IPng being able to include an IPv4 or IPX address as a subfield of the IPng address 💅. This would cut down the complexity of address conversion by limiting the number of external mechanisms (e.g., lookup tables) needed to convert an address 🧠. That reduction in complexity would make both tunneling and conversion easier, and it would also simplify using IPng with legacy applications that rely on a particular address format 🔥.

• Header Option Handling 🎁

In any widely used protocol, it's advantageous to define option mechanisms for including header information that isn't required in all packets or isn't defined yet 🌸. This is especially true in multiprotocol networks, where user requirements vary wildly 🙃. IPng should provide efficient, flexible support for future header options 💜. This will better accommodate different user needs and will make conversion between IPng and other protocols with different standard features easier ✨.

As part of protocol option support, IPng should include a mechanism for specifying how a system should handle unsupported options 🚦. If a network system adds an option header, it should be able to specify whether another system that doesn't support the option should drop the packet, drop the packet and return an error, forward it as is, or forward it without the option header 🧩. The ability to request the "forward as is" option is important when conversion is used 🔁. When two protocols have different features, a converter may add an option header that an intermediate node doesn't understand but that may be required to interpret the packet at the ultimate destination 🫠. On the other hand, imagine a source using IPng with a critical option like encryption 🔐. In that case the user would NOT want a conversion performed where the converter doesn't understand the option 😤. The "drop the packet" or "drop and return error" options would likely be the ones used in that scenario 💀.

• Multiplexing 🌀

The future Internet protocol should support distinguishing between multiple users of the network 🫂. That includes handling traditional "transport layer" protocols like TCP and UDP, as well as other payload types such as encapsulated AppleTalk packets or future real-time protocols 🎶. This kind of protocol multiplexing can be supported with an explicit header field, as in IPv4, or by reserving part of the address format, as is done with OSI NSEL's 🍓.

In a multiprotocol network there will likely be a huge number of different protocols running atop IPng 🤯. It shouldn't be necessary to use a transport layer protocol just to provide multiplexing for the various network users 🙅‍♀️. The cost of this extra multiplexing is prohibitive for future high-speed networks [14] 💸. To avoid needing an extra level of multiplexing, IPng should either use a payload selector larger than the 8-bits used in IPv4 or provide an option for including additional payload type information within the header 🧠✨.

• Status/Control Feedback 📡

With multiple protocols, a packet's correct transmission might involve encapsulation in another protocol and/or multiple conversions to different protocols before it finally reaches its destination 🌀. That means there are lots of places the transmission can fail, and figuring out what went wrong is going to be a challenge 😵‍💫.

To handle this, a critical feature of multiprotocol networks is a powerful error reporting mechanism 🔥.

On top of traditional network level errors, like the ones reported by ICMP [9], the IPng error mechanism should include feedback on tunneling and conversion failures 🛠️. Also, since it's impossible to know exactly which part of a packet is an encapsulated header, it's important that the feedback mechanism include as much of the failed packet as possible in the returned error message 🎯.

Beyond providing new types of feedback, this mechanism should support variable resolution, so a transmitting system can request limited feedback or complete information about the communication process 🎚️. This level of control would really help the Protocol Discovery process described in Section 4.3 💅. For example, a multiprotocol system could request maximal feedback when it sends packets to a destination it hasn't communicated with for some time 🕰️. After the first few packets to that "new" destination, the system would go back to limited feedback, freeing up the resources used by the network feedback mechanisms 🦋.

Finally, it's important that the information from the feedback mechanism be available outside the IPng implementation 🌐. In multiprotocol networks, fixing a communication problem often requires an adjustment in one of the protocols outside the network layer 😮‍💨. For that to happen, the other protocols must be able to access and interpret these feedback messages 🫶.

• MTU Discovery or Fragmentation 📦

A form of multiprotocol support that has long been part of networking is the use of diverse data link and physical layers 🌈. One aspect of this that affects the network layer is the different Maximum Transmission Units (MTU) used by various media formats 📏. For efficiency, many protocols try to avoid fragmentation at intermediate nodes by using the largest packet size possible, without exceeding the minimum MTU along the route 🏃‍♀️. To do this, a network protocol performs MTU discovery to find the smallest MTU on a path 🔍.

The choice of mechanism for dealing with differing MTUs also matters when doing conversion or tunneling with multiple protocols 🎀. When tunneling is performed by an intermediate node, the resulting packets may be too large to meet MTU requirements 😬. Similarly, if conversion at an intermediate node results in a larger protocol header, the new packets may also be too large 🙃. In both cases, it may be desirable to have the source host reduce the transmission size it uses, so additional fragmentation isn't needed 💅. This information could be sent to the source host as part of the feedback mechanism described earlier, or as an additional MTU discovery message 📨.

5.2. Implementation/Deployment Features 🛠️

• Switching 🔀

We define switching in a protocol as the capability to simultaneously use more than one different underlying protocol [1] 🧃. For network layer protocols, this implies using different datalink layers 🔗. For example, it may be necessary to choose between the 802.3 LLC and traditional Ethernet interfaces when connecting a host to an "ethernet" network 🔌. Also, in some systems IPng won't be used directly over a datalink layer but will be encapsulated within another network protocol before being transmitted 📮. It's important that IPng be designed to support different underlying datalink services and that it provide mechanisms that let IPng users specify which of the available services should be used 🎛️✨.

• Directory Service Requirements 📖

While not specifically part of the IPng protocol, it's clear that the future Internet will include a directory service for obtaining address information for IPng 🌟. Given that, there are some features of the directory service that should be considered vis-a-vis their support for multiple protocols 🧐.

First, the directory service should be able to distribute address formats for several different protocol families, not just IPng and IPv4 🌍. This is necessary for tunneling, conversion, and support of multiprotocol systems 💜. Second, the directory service should include support for distributing protocol configuration information in addition to addressing information for network hosts 🎀. This feature will support the protocol determination task that multiprotocol systems carry out [2] 🫶.

6. Conclusion ✨

okay so bestie, here's the big takeaway 💅 future networks are going to be multiprotocol, because different users have different needs 🌈 that means a ton of Internet traffic won't be single-protocol chats (think TCPng/IPng 🦋). and this isn't just a short-term transition thing, it's going to stick around for most of the Internet 😭 so when we pick IPng, we HAVE to think about multiprotocol networks, especially mixed-protocol traffic that involves tunneling, conversion, and multiprotocol end-systems 🫶

7. Acknowledgments 🎀

the authors wanted to give a shoutout to the support they got from a grant from the National Science Foundation (NCR-9305115) and the TRANSOPEN project of the Army Research Lab (formerly AIRMICS) under contract number DAKF11-91-D-0004 🙏

8. References 📚

[1] Clark, R., Ammar, M., and K. Calvert, "Multi-protocol architectures as a paradigm for achieving inter-operability", In Proceedings of IEEE INFOCOM, April 1993.

[2] Clark, R., Calvert, K. and M. Ammar, "On the use of directory services to support multiprotocol interoperability", To appear in proceedings of IEEE INFOCOM, 1994. Technical Report GIT-CC-93/56, College of Computing, Georgia Institute of Technology, ATLANTA, GA 30332-0280, August 1993.

[3] Gilligan, R., Nordmark, E., and B. Hinden, "IPAE: the SIPP Interoperability and Transition Mechanism, Work in Progress, November 1993.

[4] Leiner, B., and Y. Rekhter, "The Multiprotocol Internet", RFC 1560, USRA, IBM, December 1993.

[5] McLaughlin, L., "Standard for the Transmission of 802.2 Packets over IPX Networks", RFC 1132, The Wollongong Group, November 1989.

[6] Mockapetris, P., "Domain Names - Concepts and Facilities", STD 13, RFC 1034, USC/Information Sciences Institute, November 1987.

[7] Mockapetris, P., "Domain Names - Implementation and Specification. STD 13, RFC 1035, USC/Information Sciences Institute, November 1987.

[8] Padlipsky, M., Gateways, Architectures, and Heffalumps", RFC 875, MITRE, September 1982.

[9] Postel, J., "Internet Control Message Protocol", STD 5, RFC 792, USC/Information Sciences Institute, September 1981.

[10] Provan, D., "Tunneling IPX Traffic Through IP Networks", RFC 1234, Novell, Inc., June 1991.

[11] Rose, M., "The Open Book", Prentice-Hall, Englewood Cliffs, New Jersey, 1990.

[12] Rose, M., "The ISO Development Environment User's Manual - Version 7.0.", Performance Systems International, July 1991.

[13] Rose, M., and D. Cass, "ISO Transport Services on top of the TCP", STD 35, RFC 1006, Northrop Research and Technology Center, May 1987.

[14] Tennenhouse, D., "Layered multiplexing considered harmful", In IFIP Workshop on Protocols for High-Speed Networks. Elsevier, May 1989.

[15] Ullmann, R., "CATNIP: Common architecture technology for next- generation internet protocol", Work in Progress, October 1993.

9. Security Considerations 🙈

security issues are not discussed in this memo. 💀 (no cap, this is a big deal and you should keep it in mind when you're building anything multiprotocol!)

10. Authors' Addresses 💜

Russell J. Clark College of Computing Georgia Institute of Technology Atlanta, GA 30332-0280

EMail: rjc@cc.gatech.edu

Mostafa H. Ammar College of Computing Georgia Institute of Technology Atlanta, GA 30332-0280

EMail: ammar@cc.gatech.edu

Kenneth L. Calvert College of Computing Georgia Institute of Technology Atlanta, GA 30332-0280

EMail: calvert@cc.gatech.edu