RFC 887
Resource Location Protocol
RFC 887: RESOURCE LOCATION PROTOCOL 🎀
Network Working Group 🌸 Author: M. Accetta, Carnegie-Mellon University 🧚 Date: December 1983 📅 Status: draft standard for the ARPA Internet community ✨
The header here doesn't list anything this RFC obsoletes or updates. 🙈
okay bestie, this note is about the Resource Location Protocol 💖 It's for hosts on the ARPA Internet that need to find where some service or resource lives. It's most useful on networks that support some kind of broadcast addressing, but it works on other networks too 🦋 For maximum slay, every host that gives significant resources or services to other hosts on the Internet should implement this protocol. Hosts that skip it are literally at risk of being ignored by other hosts trying to find resources on the Internet 💀 This RFC is a draft standard for the ARPA Internet community 👑
The Resource Location Protocol (RLP) runs on top of the User Datagram Protocol (UDP) [1], which then uses the Internet Protocol (IP) [3] to deliver its datagrams 📦 Check out Appendix A and [6] for the right port and protocol number assignments 🔥
Unless otherwise indicated, every numeric quantity in this document is a decimal number 🔢
1. Introduction ✨
From time to time, Internet hosts need to figure out where on the Internet a certain network service or resource is being provided 🔍 For example, this happens when a host wants to send a packet to some external network, but it has to hand it to a gateway on its directly connected network and doesn't know of any gateways 🚪 Another case: a host needs to turn a domain name into an Internet address and doesn't know any name servers it can ask for the translation 🌈 In situations like these, a host can use the Resource Location Protocol to find that info 💜
Almost always, the resource location problem just means finding the IP address of some one host (usually any one) that understands a given protocol, either on the directly connected network or somewhere else on the Internet 🫶 Most of the time, the querying host understands that protocol too. It usually wants to use the protocol with the host it found once it knows the address, like asking a name server for name to address translations 💅 Less often, the querying host doesn't understand the protocol itself. Like when it's looking for a gateway, it's just trying to find some other host that does 🧚 For example, it's looking for a good place to forward a packet that can't be delivered locally 😭
2. Resource Naming 🎀
Okay so the resource location problem can usually be boiled down to finding a host that implements some Internet based protocol, but that's not the whole story ✨ Just finding a host that runs a particular lowest level Internet protocol (one that has a protocol number for transport over IP) isn't quite enough 🙈 A lot of big network services are actually provided through higher level protocols that just use the lower level protocols to get their data places. For instance, the FTP protocol [2] uses the TCP protocol [4] for its lower level transport 🦋 And honestly, this nesting can keep going to any depth 🌀
So the Resource Location Protocol names a resource with two things: the protocol number of its lowest level Internet transport protocol, plus a variable length protocol/resource specific identifier 💖 For example, the UDP based Echo Protocol can be named by its assigned protocol number (17) and its assigned 16-bit "well-known" port number (7) 🫧 Or, the Internet Control Message Protocol [5] (which has no higher level client protocols) is named just by its assigned protocol number (1) and an empty protocol specific identifier 🍓 Then there's some resource protocol that's not even defined yet, maybe running over TCP. It could be named by the protocol number (6), its 16-bit "well-known" TCP port number, and then some extra fixed or variable length identifier that belongs to that TCP port 👑
Generally, the parts of the protocol/resource specific identifier are the "natural" quantities used to de-multiplex the protocol one level up at a time 💜 See section 5 for some sample assignments 🌸
3. Protocol Summary 💅
The Resource Location Protocol is a simple request/reply procedure ✨ The querying host builds a list of resources it wants to find and sends a request message out on the network 📣 A request message can go to one particular IP address and host, or, on networks with broadcast address capability, to the IP address that refers to all hosts on that network (see [7]) 🌈 For example, a host looking for a domain name server might build a request containing the resource name [17, 53] (that's the Domain Name Server protocol on "well-known" UDP port 53) and then broadcast that request on its local network 🦋
Each receiving host looks at the list of resources named in the request packet, works out which of them it provides, and sends back a reply message to the querying host to confirm 💖 A receiving host figures out whether it provides a resource by breaking down the resource name step by step, until either the name runs out or it hits a component it doesn't support 🧩 In the example above, every host on the network that gets the broadcast would first check its tables to see if it provides UDP service 🔍 If that works, it would look at the UDP port component of the name and check its UDP table to see if it provides service on UDP port 53 🫶 At that point the name is used up, and if both checks worked, the host sends back a reply message saying it supports that resource 🎀
3.1. Request Messages 🧚
RLP has two basic types of request messages that a querying host can send 💜 The first type makes any host that gets the request send back a reply only if it provides at least one of the resources named in the request list 🙈 The second type makes any host that gets the message always send back a reply, even if it provides none of the named resources 💅
So here are the two types:
<Who-Provides?>: This type makes any host that gets the message send back a proper reply that names all of the resources from the request list that it provides 🌸 If the receiving host provides none of the named resources, then no reply may be sent back ✨<Do-You-Provide?>: This one is exactly like<Who-Provides?>, but with an extra rule: a reply must always be sent back 🦋 If a receiving host provides none of the requested resources, it just sends back an empty reply list 🫧 That empty list lets the querying host immediately see that the confirming host doesn't provide any of the named resources, so it doesn't have to wait out a timeout after retransmitting the request over and over 😭
<Who-Provides?> is mostly used when broadcasting to a whole IP network 📣 <Do-You-Provide?> is mostly used when confirming that one particular host does or doesn't provide one or more specific resources 🍓 It may not be broadcast, though, because that would flood the querying host with replies from every host on the network 💀
On top of the two basic types, a querying host can also send two variant types of request messages 🌈 These give a "third-party" resource location capability 🧚 They're different from the basic types because each listed resource gets extra space for a qualifier that names "third-party" hosts the confirming host believes may provide that resource 💖 Like before, the first variant type makes any host that gets the request send back a reply only if it knows of some host that provides at least one of the named resources 🫶 The second variant type makes any host that gets the message always send back a reply, even if it doesn't know of any hosts that provide the named resources 👑
So the last two types are:
<Who-Anywhere-Provides?>: This one matches<Who-Provides?>, just with the "third-party" variant I mentioned 🎀 The confirming host has to send back at least its own IP address (if it provides the named resource), plus the IP addresses of any other hosts it believes may provide it ✨ Here's the tricky bit though: the confirming host may never return an IP address for a resource that's the same as an IP address listed with that resource name in the request message 🙈 In that case it must treat the resource as unsupported at that IP address and leave it out of the reply list 💅<Does-Anyone-Provide?>: This one matches<Do-You-Provide?>, again with the "third-party" variant 🦋 As before, the confirming host has to return its own IP address, plus the IP addresses of any other hosts it believes may provide the named resource 💜 It's also not allowed to return the same IP address in the reply resource specifier that was listed in the request resource specifier 🚫 And just like with<Do-You-Provide?>, for the same reason, this message also may not be broadcast 📵
These variant request messages let "smart" hosts give resource location info for networks without broadcast capability, as long as every host on that network always "knows" the address of one or more of those "smart" hosts 🧠 They also let "smart" gateways pass along resource location info for services that aren't provided anywhere on a directly connected network 🌐 Those gateways might have asked other networks they're attached to, or gotten the info some other way 🫧
The rule about not returning the same IP address in a reply as the one in the request is a basic way to leave certain known addresses out of a reply (see section 5, example 3) 🔍 It can also be used to override the receiving host's preference for its own IP address in "third-party" replies, when that's needed 🌸
3.2. Reply Messages 💖
Every type of request message has a matching type of reply message ✨ The basic reply type gets sent back for both <Who-Provides?> and <Do-You-Provide?> requests, and it shares info about the resources the confirming host provides 🎀 The other reply type is the "third-party" variant, sent back for both <Who-Anywhere-Provides?> and <Does-Anyone-Provide?> requests, and it shares info about resources provided by hosts the confirming host knows about 🧚
So there are two reply message types:
<I-Provide>: This reply contains a list of exactly those resources from the request list that the confirming host provides 🦋 These resources must show up in the reply list in precisely the same order they were listed in the request message 🫶<They-Provide>: This reply similarly contains a list of exactly those resources from the request list (qualified with IP addresses) that the confirming host provides or believes another host provides 🌈 Again, these resources must show up in the reply list in precisely the same order they were listed in the request message 💅
Neither type of reply message may be broadcast 📵
A querying host that receives a <They-Provide> reply message from a part 2 picks up right here 👀✨
confirming host on behalf of a third host isn't required to just trust the indirect info 🙅♀️. Honestly, this info should usually be treated as a hint 🔍. In most cases the querying host SHOULD send a specific <Do-You-Provide?> request to the third host and confirm the resource is actually provided at that IP address before it moves on 💅✨.
4. Message Formats ✨
okay so RLP messages get wrapped up inside UDP packets 🎀. Why? Because you get multiplexing from the UDP source and destination ports, plus the extra reliability of the UDP checksum 🔐. Request messages go out from a convenient source port on the querying host to the assigned RLP destination port of a receiving host 📨. Reply messages come back from the assigned RLP source port of the confirming host to whatever destination port the querying host picked, which is determined by the source port in the request message 🦋.
The message formats are shown in the diagrams below 🌸. Any numeric value taking up more than one octet is stored high-order octet first, down to low-order octet, like the usual Internet protocol standard 💜. All the packet diagrams read left to right, then top to bottom, in the order the octets show up in the data part of the encapsulating UDP packet 📖.
Every RLP packet looks like this:
+--------+--------+--------+--------+
| | | |
| Type | Flags | Message-ID |
| | | |
+--------+--------+--------+--------+
| -
| Resource-List -
| -
+--------+--------+--------+---\\---+
- +
- Resource-List |
- |
+--------+--------+--------+---\\---+where:
<Type> is a single octet that tells you what kind of message it is 🧩. These are the types that exist right now:
0 <Who-Provides?>
1 <Do-You-Provide?>
2 <Who-Anywhere-Provides?>
3 <Does-Anyone-Provide?>
4 <I-Provide>
5 <They-Provide>
6-255 Reserved.<Flags> is a single octet that can tweak how <Type> gets read 🌈. Bits are numbered from left to right, starting at bit 1 (that's the most significant one) 🧐. These are the flag bits defined so far:
- Bit 1
<Local-Only>🏠: any reply generated for a request with this bit set MAY only name IP addresses that sit on the same IP network as the request's sender. This flag also means multi-homed hosts answering broadcast<Who-Provides?>requests MUST use the right local network IP source address in their reply. This bit MUST be zero in reply messages. - Bits 2-8 Reserved. MUST be zero. 🙅♀️
<Message-ID> is a two-octet (16-bit) value that identifies the request 🪪. It's only there to help match requests up with replies, so it's basically a little name tag 🏷️. The sending host SHOULD set it to some convenient value when it builds a request. The receiving host MUST send back this exact same value in the <Message-ID> field of any reply it generates for that request 💖.
<Resource-List> is the list of resources being asked about, or the list of resources where location info is being given 🗂️. It's a run of octets that starts right after <Message-ID> and goes all the way to the end of the UDP packet 🏁. The format of this field gets its own section next, so stay tuned 👑. The size of the list is implied by the length of the encapsulating UDP datagram, so no extra length field needed 🤌.
4.1. Resource Lists
A <Resource-List> is made of zero or more resource specifiers 🎀. Each resource specifier is just a sequence of octets, and they all start with the same common resource name format:
+--------+--------+--------+---\\---+
| | | |
|Protocol|IDLength| Resource-ID |
| | | |
+--------+--------+--------+---\\---+where:
<Protocol> is the protocol number assigned to the lowest-level Internet protocol used to access the resource 🛠️.
<IDLength> is the length of the resource identifier tied to this <Protocol> 📏. That length can be fixed or variable, depending on the resource 🔄. It's included so that specifiers for resources a host might not provide can just be skipped over, without the receiver needing to know the exact structure of that resource identifier 🦘. If the <Protocol> doesn't have a natural identifier, this length is 0 🫥.
<Resource-ID> is the qualifying identifier that narrows down the resource being queried 🔎. If <IDLength> was 0, this field is empty and takes up no space in the resource specifier ✨.
Also, resource specifiers in all <Who-Anywhere-Provides?>, <Does-Anyone-Provide?> and <They-Provide> messages carry one more qualifier after the <Protocol-ID> 💅. It looks like this:
+--------+--------+--------+--------+---//---+
| | |
|IPLength| IP-Address-List |
| | |
+--------+--------+--------+--------+---//---+where:
<IPLength> is the number of IP addresses in the following <IP-Address-List> (so that field takes up the last 4*<IPLength> octets in its resource specifier) 🔢. In request messages, this is the maximum number of qualifying addresses that may be included in the matching reply resource specifier 🙋♀️. Not super useful, I know, but it MAY be 0, and in that case there's no room for qualifying the resource name with IP addresses in the returned specifier 🤷♀️. In reply messages, this is the number of qualifying addresses known to provide the resource 🙌. It MUST NOT exceed the number given in the matching request specifier 🚫. This field MUST NOT be 0 in a reply message unless it was supplied as 0 in the request, and the confirming host would have returned one or more IP addresses if there had been any space for them 🥺.
<IP-Address-List> is a list of four-octet IP addresses used to qualify the resource specifier for those particular addresses 📍. In reply messages, these are the IP addresses of the confirming host (when it makes sense) and the addresses of any other hosts known to provide that resource, subject to the list length limits 🌐. In request messages, these are the IP addresses of hosts whose resource info may not be returned 🙈. In those messages, these addresses SHOULD normally be set to some "harmless" value (like the querying host's own address), unless you're really trying to exclude those specific addresses from any reply 🛡️.
Here's how the receiving host works out whether it provides any of the resources named in the request list 🕵️♀️. It takes each resource name and breaks it down step by step 🧩. The first level is the Internet protocol number, which can presumably be looked up in a table to see if the host supports that protocol 📚. Later breakdowns are based on the earlier components, and this keeps going until one of three things happens 🌀:
- the current component identifies some aspect of the previous components that the host doesn't support,
- the resource name from the request list runs out, or
- the resource name from the request list isn't used up yet, but the host doesn't expect any more components after the ones it already has.
In case 1, the receiving host has figured out that it does NOT provide the named resource 🙅♀️. The resource specifier may not be included in any reply message that comes back 🫠.
In case 2, the receiving host has figured out that it DOES provide the named resource 🥳. (Note: this can happen even if the host would have expected the name to have more components than were actually there 🤭.) The resource specifier MUST be included in any reply message that comes back, subject to IP address prohibitions 🎉.
In case 3, the receiving host has figured out that it doesn't completely provide the named resource 😬. There are name components left that it doesn't understand, which might happen with specializations of or extensions to a known protocol that aren't universally recognized 🧪. The resource specifier may not be included in any reply message that comes back 💀.
5. Sample Usage 🌸
The scenarios below show some typical ways RLP gets used 🦋. In every case, the messages shown are encapsulated in a UDP datagram with the right source and destination port numbers, message length, and checksum 🧁. That datagram is then wrapped in an IP datagram with the sending host's source address and the receiving host's destination address, which can be either broadcast or individual 📡.
All numeric protocol examples are as specified in the appropriate RFC 💜.
protocol description docs listed in the references 📖, so go check there for the real numbers 🤓✨
1. A freshly rebooted host 🔄
Okay so picture host H: it just rebooted, has zero clue about the outside world, and needs a gateway on its own directly connected network so it can send its very first external packet 🚀. So it broadcasts this:
<Who-Provides?> <Flags>=<Local-Only> <Message-ID>=12345
<Resource-List>={[GGP], [EGP]}and it's encoded as the 8 octet message 💖
+-----+-----+-----+-----+-----+-----+-----+-----+
| 0 | 128 | 12345 | 3 | 0 | 8 | 0 |
+-----+-----+-----+-----+-----+-----+-----+-----+on its local network.
Gateway G1 🦋 (which understands EGP) receives the request and sends back this reply:
<I-Provide> <Flags>=none <Message-ID>=12345
<Resource-List>={[EGP]}encoded as the 6 octet message:
+-----+-----+-----+-----+-----+-----+
| 4 | 0 | 12345 | 8 | 0 |
+-----+-----+-----+-----+-----+-----+sent to host H, which then remembers that gateway G1 may be used to route traffic to the rest of the Internet. Main character energy 👑
Gateway G2 🌈 (which understands both GGP and EGP) might also catch the request at the same time and send back:
<I-Provide> <Flags>=none <Message-ID>=12345
<Resource-List>={[GGP], [EGP]}encoded as the 8 octet message:
+-----+-----+-----+-----+-----+-----+-----+-----+
| 4 | 0 | 12345 | 3 | 0 | 8 | 0 |
+-----+-----+-----+-----+-----+-----+-----+-----+sent to host H, which might then also add gateway G2 to its list if it chooses 🧚
2. A host having a seriously bad day 💀
Now host H is a stand-alone system that just hit some fatal software error 😭 and it needs to find a crash dump server to save its state before reloading. The crash dump protocol on the local network is built on the Trivial File Transfer Protocol (TFTP) [8]. Also, the special file name "CRASH-DUMP" is what signals crash dump processing. (The server might make up its own unique file name for each dump it gets from a host, which is honestly so smart 🧠.) So host H broadcasts this:
<Who-Provides?> <Flags>=none <Message-ID>=54321
<Resource-List>={[UDP, TFTP, WRQ, "CRASH-DUMP"]}encoded as the 21 octet message 🎀
+-----+-----+-----+-----+-----+-----+-----+-----+
| 0 | 0 | 54321 | 17 | 15 | 69 |
+-----+-----+-----+-----+-----+-----+-----+-----+
| 2 | 'C' 'R' 'A' 'S' 'H' '-' |
+-----+-----+-----+-----+-----+-----+-----+-----+
| 'D' 'U' 'M' 'P' 0 |
+-----+-----+-----+-----+-----+to its local network. Quick note 🫶: the file name component ends with a null on purpose, so the protocol can still be specialized further down the road without things getting awkward.
Host C 💅 (which supports this specialization of TFTP) gets the request and replies:
<I-Provide> <Flags>=none <Message-ID>=54321
<Resource-List>={[UDP, TFTP, WRQ, "CRASH-DUMP"]}encoded as the 21 octet message:
+-----+-----+-----+-----+-----+-----+-----+-----+
| 4 | 0 | 54321 | 17 | 15 | 69 |
+-----+-----+-----+-----+-----+-----+-----+-----+
| 2 | 'C' 'R' 'A' 'S' 'H' '-' |
+-----+-----+-----+-----+-----+-----+-----+-----+
| 'D' 'U' 'M' 'P' 0 |
+-----+-----+-----+-----+-----+sent to host H, which can then ship its crash dump off to host C and reload 🔥
Host D 🙈 is the other one. It does provide TFTP but NOT the crash dump specialization. It might get the request and figure out that it has no support for the resource, since the resource name has components after the UDP port number that it doesn't understand. So host D just returns no reply to host H. Not me being left on read 💀
3. Hunting for a domain name server 🕵️
Final boss time 🌸. Host M wants to find some domain name translation server (UDP or TCP based) anywhere on the Internet. The twist: host M is on an IP network that doesn't provide broadcast address capabilities, and host R is a "known" resource location server for that network.
First, host M prefers a domain name server on its own local network if one exists, so it sends this to host R:
<Does-Anyone-Provide?> <Flags>=<Local-Only>
<Message-ID>=12321 <Resource-List>=
{[TCP, <DOMAIN-NAME-SERVER-PORT>] {M},
[UDP, <DOMAIN-NAME-SERVER-PORT>] {M}}encoded as the 22 octet message:
+-----+-----+-----+-----+
| 3 | 128 | 12321 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 6 | 2 | 53 | 1 | M |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 17 | 2 | 53 | 1 | M |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+Host R checks its tables for any hosts that support either kind of domain name service. It finds entries saying that hosts S and T both provide UDP based domain name service, but neither one is on the same IP network as host H. So host R has to send the negative confirmation reply 😤
<They-Provide> <Flags>=none <Message-ID>=12321
<Resource-List>={}encoded as the 4 octet message:
+-----+-----+-----+-----+
| 5 | 0 | 12321 |
+-----+-----+-----+-----+back to host M.
Host M gets this reply and, honestly, it's time to let go of the local server dream 🥲. So it reformats the request to allow ANY host address and resends:
<Does-Anyone-Provide?> <Flags>=none <Message-ID>=12322
<Resource-List>=
{[TCP, <DOMAIN-NAME-SERVER-PORT>] {M},
[UDP, <DOMAIN-NAME-SERVER-PORT>] {M}}encoded as the 22 octet message:
+-----+-----+-----+-----+
| 3 | 0 | 12322 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 6 | 2 | 53 | 1 | M |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 17 | 2 | 53 | 1 | M |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+to host R again.
Host R gets this new request and is no longer limited to only local addresses, yay 🎉. BUT each request resource specifier only had room for a single qualifying IP address, so host R can't give back both addresses right away. It's forced to return only the first one, which is S, so the reply is:
<They-Provide> <Flags>=none <Message-ID>=12322
<Resource-List>={[UDP, <DOMAIN-NAME-SERVER-PORT>] {S}}encoded as the 13 octet message:
+-----+-----+-----+-----+-----+-----+-----+-----+
| 5 | 0 | 12322 | 17 | 2 | 53 |
+-----+-----+-----+-----+-----+-----+-----+-----+
| 1 | S |
+-----+-----+-----+-----+-----+sent to host M.
Host M receives the reply and, being the suspicious sort 🫣, decides to double-check with host S. It sends:
<Do-You-Provide?> <Flags>=none <Message-ID>=12323
<Resource-List>={[UDP, <DOMAIN-NAME-SERVER-PORT>]}encoded as the 8 octet message:
+-----+-----+-----+-----+-----+-----+-----+-----+
| 1 | 0 | 12323 | 17 | 2 | 53 |
+-----+-----+-----+-----+-----+-----+-----+-----+to host S, and host S sends back:
<I-Provide> <Flags>=none <Message-ID>=12323
<Resource-List>={}encoded as the 4 octet message:
+-----+-----+-----+-----+
| 4 | 0 | 12323 |
+-----+-----+-----+-----+which is a flat out denial of any support for UDP based domain name service. Yikes 💀
In desperation 😩, host M queries host R again, this time excluding host S from consideration:
<Does-Anyone-Provide?> <Flags>=none <Message-ID>=12324
<Resource-List>=
{[TCP, <DOMAIN-NAME-SERVER-PORT>] {S},
[UDP, <DOMAIN-NAME-SERVER-PORT>] {S}}encoded as the 22 octet message:
+-----+-----+-----+-----+
| 3 | 0 | 12324 |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 6 | 2 | 53 | 1 | S |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| 17 | 2 | 53 | 1 | S |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+This time host R replies with:
<They-Provide> <Flags>=none <Message-ID>=12324
<Resource-List>={[UDP, <DOMAIN-NAME-SERVER-PORT>] {T}}encoded as the 13 octet message:
+-----+-----+-----+-----+-----+-----+-----+-----+
| 5 | 0 | 12324 | 17 | 2 | 53 |
+-----+-----+-----+-----+-----+-----+-----+-----+
| 1 | T |
+-----+-----+-----+-----+-----+Host M, of course, insists on confirming with host T by sending:
<Do-You-Provide?> <Flags>=none <Message-ID>=12325
<Resource-List>=
{[UDP, <DOMAIN-NAME-SERVER-PORT>]}encoded as the 8 octet message:
+-----+-----+-----+-----+-----+-----+-----+-----+
| 1 | 0 | 12325 | 17 | 2 | 53 |
+-----+-----+-----+-----+-----+-----+-----+-----+to host T. Finally, host T confirms with:
<I-Provide> <Flags>=none <Message-ID>=12325
<Resource-List>={[UDP, <DOMAIN-NAME-SERVER-PORT>]}encoded as the 8 octet message:
+-----+-----+-----+-----+-----+-----+-----+-----+
| 4 | 0 | 12325 | 17 | 2 | 53 |
+-----+-----+-----+-----+-----+-----+-----+-----+So host M finally gets its answer: host T really does provide domain name translation service at UDP port 53 ✨👑🎉
A. Assigned Numbers 🔢
The "well-known" UDP port number for the Resource Location Protocol is 39 (47 octal). 🌟
REFERENCES 📚
[1] Postel, J. User Datagram Protocol. RFC 768, USC/Information Sciences Institute, August, 1980.
[2] Postel, J. File Transfer Protocol. RFC 765, USC/Information Sciences Institute, June, 1980.
[3] Postel, J. Internet Protocol - DARPA Internet Program Protocol Specification. RFC 791, USC/Information Sciences Institute, September, 1981.
[4] Postel, J. Transmission Control Protocol- DARPA Internet Program Protocol Specification. RFC 793, USC/Information Sciences Institute, September, 1981.
[5] Postel, J. Internet Control Message Protocol - DARPA Internet Program Protocol Specification. RFC 792, USC/Information Sciences Institute, September, 1981.
[6] Reynolds, J., and J. Postel. Assigned Numbers. RFC 870, USC/Information Sciences Institute, October, 1983.
[7] Gurwitz, R., and R. Hinden. IP - Local Area Network Addressing Issues. IEN 212, Bolt Beranek and Newman, September, 1982.
[8] Sollins, K. The TFTP Protocol (revision 2). RFC 783, MIT/Laboratory for Computer Science, June, 1981.
📦 where this page comes from
- ietf: rfc887 1983-12
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms