Project

General

Profile

NDNLPv2 » History » Version 55

Davide Pesavento, 07/09/2019 10:02 PM

1 1 Junxiao Shi
# NDNLPv2
2 2 Alex Afanasyev
3 45 Davide Pesavento
{{>toc}}
4
5 16 Junxiao Shi
NDNLPv2 is a link protocol for [Named Data Networking](https://named-data.net/).
6 1 Junxiao Shi
7 50 Davide Pesavento
It provides the following **features**:
8 2 Alex Afanasyev
9
* fragmentation and reassembly: fragment a network layer packet to fit in link MTU
10
* failure detection: rapidly detect link failure and recovery
11
* reliability: reduce packet loss
12
* integrity: prevent packet injection
13
* forwarding instruction: NACK, nexthop choice, cache control, etc
14
* packet information: for management and monitoring
15
16
NDNLPv2 is designed to be a **unified protocol** that can be used on all kinds of links, including but not limited to: UNIX sockets, Ethernet unicast/multicast, UDP unicast/multicast, TCP connections, WebSockets, etc.
17
18
NDNLPv2 protocol operates as a **link adaptation layer**; it is above link layer and below network layer.
19
Please, do not call this "layer 2.5": there is no such notion in RFC protocols.
20
21
Different links need different features, or different designs of a feature.
22 1 Junxiao Shi
NDNLPv2 ensures **all features are optional** and can be turned on or off per-link.
23
NDNLPv2 also allows different designs of a feature to be adopted per-link.
24 2 Alex Afanasyev
25
NDNLPv2 deprecates and replaces: [original NDNLP (aka NDNLPv1)](https://named-data.net/publications/techreports/trlinkprotocol/), [NDNLPv1 multicast extension](https://github.com/NDN-Routing/NDNFD/blob/master/docs/NDNLP.md), [NDNLPv1-TLV](https://redmine.named-data.net/projects/nfd/wiki/NDNLP-TLV/7), [NDNLP-BFD](https://redmine.named-data.net/attachments/download/231/NDNLP-BFDSummaryReport.pdf), [NFD LocalControlHeader](https://redmine.named-data.net/projects/nfd/wiki/LocalControlHeader/25).
26
27 50 Davide Pesavento
## General NDNLPv2 Packet Format
28 2 Alex Afanasyev
29 46 Davide Pesavento
NDNLPv2 packet adopts a Type-Length-Value (TLV) structure similar to [NDN Packet Format](https://named-data.net/doc/NDN-packet-spec/current/tlv.html).
30 1 Junxiao Shi
31 47 Junxiao Shi
    LpPacket = LP-PACKET-TYPE TLV-LENGTH
32
                 *LpHeaderField
33
                 [Fragment]
34 17 Davide Pesavento
35 47 Junxiao Shi
    LpHeaderField = Sequence
36 17 Davide Pesavento
37 47 Junxiao Shi
    Sequence = SEQUENCE-TYPE TLV-LENGTH 8OCTET
38 17 Davide Pesavento
39 47 Junxiao Shi
    Fragment = FRAGMENT-TYPE TLV-LENGTH 1*OCTET
40 17 Davide Pesavento
41 53 Davide Pesavento
Outermost packet transmitted on a NDNLPv2 link is **LpPacket**.
42 16 Junxiao Shi
In addition, a host MUST also accept bare network packets (Interest and Data) on a NDNLPv2 link, which SHOULD be interpreted as an LpPacket with the bare network packet as its Fragment. However, such packets could be dropped later in processing if the link configured to require a certain NDNLPv2 feature but a field is missing.
43 2 Alex Afanasyev
44
**LpHeaderField** is a repeatable optional structure in LpHeader.
45
NDNLPv2 features MAY add new header fields by extending the definition of LpHeaderField.
46
Unless otherwise specified, the same field shall appear at most once.
47
Unless otherwise specified, fields MUST appear in the order of increasing TLV-TYPE codes.
48
49
If an incoming LpPacket contains an unknown LpHeaderField, the following rules apply:
50
51 27 Davide Pesavento
1. if the unknown field is in the range `[800, 959]` and the two least significant bits are both zero, the receiver SHOULD ignore the field and continue processing the packet;
52 2 Alex Afanasyev
2. otherwise, the receiver MUST drop the packet, but SHOULD NOT consider the link has an error.
53
54 27 Davide Pesavento
Note: if a field is recognized but the relevant feature is disabled, it's not considered "unknown".
55 2 Alex Afanasyev
56
**Sequence** contains a sequence number that is useful in multiple features.
57
This field is REQUIRED if any enabled feature is using sequence numbers, otherwise it's OPTIONAL.
58 48 Davide Pesavento
Bit width of the sequence number is determined on a per-link basis, 8 octets are recommended for today's links.
59 2 Alex Afanasyev
A host MUST generate consecutive sequence numbers for outgoing packets on the same face.
60
61
**Fragment** contains a fragment of one or more network layer packets.
62 1 Junxiao Shi
The fragmentation and reassembly feature defines how Fragment field is constructed and interpreted.
63 2 Alex Afanasyev
When fragmentation and reassembly feature is disabled, the Fragment field contains a whole network layer packet.
64 1 Junxiao Shi
Fragment is OPTIONAL; an LpPacket without Fragment is an **IDLE packet**.
65
66 2 Alex Afanasyev
## Indexed Fragmentation
67
68
Indexed fragmentation provides fragmentation and reassembly feature on datagram links that do not guarantee in-order delivery.
69
70
This feature defines two header fields:
71
72 47 Junxiao Shi
    LpHeaderField =/ FragIndex / FragCount
73 2 Alex Afanasyev
74 47 Junxiao Shi
    FragIndex = FRAG-INDEX-TYPE TLV-LENGTH nonNegativeInteger
75 1 Junxiao Shi
76 47 Junxiao Shi
    FragCount = FRAG-COUNT-TYPE TLV-LENGTH nonNegativeInteger
77 2 Alex Afanasyev
78 14 Davide Pesavento
The sender slices a network layer packet into one or more fragments.
79
The size of each fragment MUST be small enough so that the LpPacket carrying every fragment is below the link MTU.
80 2 Alex Afanasyev
It is RECOMMENDED that all except the last fragments have the same size.
81
82
**FragCount** field indicates the number of fragments belonging to the same network layer packet.
83
It MUST be the same in all fragments belonging to the same network layer packet.
84
85
**FragIndex** field indicates the zero-based index of the current packet.
86
It MUST be assigned consecutively for fragments belonging to the same network layer packet, starting from zero.
87
The feature is named "indexed fragmentation" because every fragment is given an index in this field.
88
89
**Sequence** field is REQUIRED when this feature is enabled.
90
Fragments belonging to the same network layer packet MUST be assigned consecutive sequence numbers, in the same order with FragIndex.
91
92
For example, a 5000-octet network layer packet may be sliced as illustrated:
93
94
    +-------------+-------------+    +-------------+-------------+
95
    | LpPacket    | Fragment    |    | LpPacket    | Fragment    |
96
    | seq=8801    |             |    | seq=8802    |             |
97
    | FragIndex=0 | [0:1400]    |    | FragIndex=1 | [1400:2800] |
98
    | FragCount=4 |             |    | FragCount=4 |             |
99
    +-------------+-------------+    +-------------+-------------+
100
101
    +-------------+-------------+    +-------------+-------------+
102 1 Junxiao Shi
    | LpPacket    | Fragment    |    | LpPacket    | Fragment    |
103 2 Alex Afanasyev
    | seq=8803    |             |    | seq=8804    |             |
104
    | FragIndex=2 | [2800:4200] |    | FragIndex=3 | [4200:5000] |
105
    | FragCount=4 |             |    | FragCount=4 |             |
106
    +-------------+-------------+    +-------------+-------------+
107 1 Junxiao Shi
108 14 Davide Pesavento
The receiver stores fragments in a *PartialMessageStore* data structure, which is a collection of PartialMessages, indexed by MessageIdentifier=Sequence-FragIndex.
109 1 Junxiao Shi
Since both Sequence and FragIndex are assigned consecutively, MessageIdentifier would be the sequence number of the first fragment of a network layer packet.
110 14 Davide Pesavento
After collecting all fragments belonging to a network layer packet, the receiver stitches them together, and delivers the complete network layer packet to the upper layer.
111 2 Alex Afanasyev
112 14 Davide Pesavento
The receiver SHOULD maintain a reassembly timer for each PartialMessage, which is reset each time a new fragment is received.
113 2 Alex Afanasyev
If this timer expires, the PartialMessage is dropped.
114 14 Davide Pesavento
The default duration of this timer is 500ms.
115 2 Alex Afanasyev
116 1 Junxiao Shi
If this feature is enabled but FragIndex is missing, it is assumed to be 0 (zero).
117 14 Davide Pesavento
If this feature is enabled but FragCount is missing, it is assumed to be 1 (one).
118 1 Junxiao Shi
If this feature is disabled but either header field is received, the packet MUST be dropped.
119
120 14 Davide Pesavento
Unless otherwise specified, header fields from other features MUST appear only in the first fragment.
121 2 Alex Afanasyev
If a header field appears on a subsequent fragment, it MUST be ignored, unless otherwise specified.
122
123
## Network NACK
124
125
A network NACK is a forwarding instruction from upstream to downstream that indicates the upstream is unable to satisfy an Interest.
126
127
This feature defines a header field:
128
129 47 Junxiao Shi
    LpHeaderField =/ Nack
130 2 Alex Afanasyev
131 47 Junxiao Shi
    Nack = NACK-TYPE TLV-LENGTH [NackReason]
132 2 Alex Afanasyev
133 47 Junxiao Shi
    NackReason = NACK-REASON-TYPE TLV-LENGTH nonNegativeInteger
134 2 Alex Afanasyev
135
**Nack** header field indicates an Interest is a NACK, and is not a normal Interest.
136
The receiver MUST NOT process the packet as an Interest.
137
138
**NackReason** element MAY be included to indicate why the NACK is transmitted.  
139
The following NackReason values are defined:
140
141
Code  | Reason       | Description
142
----- | ------------ | --------------------------------------------------------------
143
0     | None         | (reserved)
144
50    | Congestion   | there is a congestion in the link between upstream and downstream, or on the best-known path between upstream and content source
145
100   | Duplicate    | the upstream has detected a duplicate Nonce in the Interest sent by the downstream
146
150   | NoRoute      | the upstream has no path to reach a content source due to routing problem or link failure
147
148
A receiver MUST be prepared to process a NACK without a reason.  
149
If NackReason element contains an unrecognized reason, the receiver MUST treat this NACK as a NACK without reason, and MUST NOT drop the packet.
150
151
Example of NACK of an Interest for `/example` with NACK reason "Duplicate":
152
153
    +--------------------------+---------------+
154
    | LpPacket                 | Interest      |
155 1 Junxiao Shi
    |                          | Name=/example |
156 2 Alex Afanasyev
    | +-Nack-----------------+ | Nonce=35      |
157 1 Junxiao Shi
    | | NackReason=Duplicate | |               |
158 2 Alex Afanasyev
    | +----------------------+ |               |
159
    +--------------------------+---------------+
160
161
It's RECOMMENDED to enable this feature on every link.  
162
If this feature is disabled but Nack is received, the packet MUST be dropped.
163
164
Nack header field is permitted only on an LpPacket carrying an Interest.  
165
When Nack appears on an LpPacket carrying a network layer packet other than an Interest, the packet MUST be dropped.
166 13 Davide Pesavento
167 54 Davide Pesavento
## PIT Token
168
169
    LpHeaderField =/ PitToken
170
171
    PitToken = PIT-TOKEN-TYPE TLV-LENGTH 1*32OCTET
172
173
The **PitToken** field is similar to the "Interest digest" as described in #3333, but it is hop-by-hop and does not require universal agreement.
174
A downstream attaches one or more bytes as the TLV-VALUE of this field when transmitting an Interest. These bytes are opaque to the upstream.
175
When the upstream responds to this Interest with a Data or Nack packet, it SHALL attach a PitToken field with the same bytes.
176
The downstream MUST verify these bytes before assuming the Data/Nack matches the Interest.
177
178 2 Alex Afanasyev
## Consumer-Controlled Forwarding
179 13 Davide Pesavento
180 2 Alex Afanasyev
Consumer-controlled forwarding allows a local consumer application to explicitly specify the nexthop face to forward an Interest.
181
182
This feature defines a header field:
183
184 47 Junxiao Shi
    LpHeaderField =/ NextHopFaceId
185 2 Alex Afanasyev
186 47 Junxiao Shi
    NextHopFaceId = NEXT-HOP-FACE-ID-TYPE TLV-LENGTH nonNegativeInteger
187 1 Junxiao Shi
188 2 Alex Afanasyev
**NextHopFaceId** indicates the nexthop FaceId to which an Interest should be forwarded.
189 1 Junxiao Shi
A local consumer application MAY add this field to an LpPacket carrying an Interest.
190 2 Alex Afanasyev
The local forwarder SHOULD follow this instruction and forward the Interest to the specified nexthop, after ContentStore lookup does not find a match.
191 1 Junxiao Shi
192 2 Alex Afanasyev
This feature is designed to be used on local faces only.
193
It SHOULD NOT be enabled on non-local faces.
194
If this feature is enabled but NextHopFaceId refers to a non-existent face, the Interest SHOULD be processed as if there is no available route.
195
If this feature is disabled but NextHopFaceId is received, the packet SHOULD be dropped, or this field MUST be ignored.
196
197 16 Junxiao Shi
NextHopFaceId header field is permitted only on an LpPacket carrying an Interest, from an application to the forwarder.
198 2 Alex Afanasyev
When NextHopFaceId appears on an LpPacket carrying a network layer packet other than an Interest, the packet MUST be dropped.
199
When NextHopFaceId appears on an LpPacket that has a Nack header field, the packet SHOULD be dropped.
200
When NextHopFaceId is received by an application from a forwarder, this field MUST be ignored.
201
202 51 Davide Pesavento
## Incoming Face Indication
203
204
Incoming face indication feature allows the forwarder to inform local applications about the face on which a packet is received.
205
206
This feature defines a header field:
207
208
    LpHeaderField =/ IncomingFaceId
209
210
    IncomingFaceId = INCOMING-FACE-ID-TYPE TLV-LENGTH nonNegativeInteger
211
212
**IncomingFaceId** contains the FaceId from which the network layer packet is received.
213
When this feature is enabled, the forwarder SHOULD attach this field to every network layer packet going to a local application, and indicate the FaceId on which this network layer packet is received by the forwarder.
214
If a Data packet comes from the ContentStore, IncomingFaceId SHOULD contain a special FaceId that represents the ContentStore, rather than the FaceId on which this Data packet was originally received.
215
Even if this feature is enabled, the application MUST be prepared to receive a packet without IncomingFaceId field.
216
217
This feature is designed to be used on local faces only.
218
It SHOULD NOT be enabled on non-local faces.
219
220
IncomingFaceId header field is permitted only on an LpPacket from the forwarder to an application.
221
When IncomingFaceId is received by the forwarder from an application, this field MUST be ignored.
222
223 2 Alex Afanasyev
## Local Cache Policy
224
225
Local cache policy feature allows a local producer application to instruct ContentStore on whether and how to cache a Data packet.
226
227
This feature defines a header field:
228
229 47 Junxiao Shi
    LpHeaderField =/ CachePolicy
230 2 Alex Afanasyev
231 47 Junxiao Shi
    CachePolicy = CACHE-POLICY-TYPE TLV-LENGTH CachePolicyType
232 2 Alex Afanasyev
233 47 Junxiao Shi
    CachePolicyType = CACHE-POLICY-TYPE-TYPE TLV-LENGTH nonNegativeInteger
234 2 Alex Afanasyev
235
**CachePolicy** header field gives a suggestion to the ContentStore.
236
The ContentStore MAY follow this suggestion.
237
238
**CachePolicyType** element MUST be included to indicate the suggestion.
239
The following CachePolicyType values are defined:
240
241
Code | Policy  | Description
242
-----|---------|--------------------------------
243
0    | None    | (reserved)
244
1    | NoCache | ContentStore SHOULD NOT admit the Data packet
245
246
If CachePolicyType field contains an unknown policy code, the forwarder SHOULD drop the packet.
247 1 Junxiao Shi
248 2 Alex Afanasyev
The design places the policy code in the CachePolicyType element nested under CachePolicy, instead of having the code appear directly in CachePolicy header field, because in the future other policies that require additional arguments can be defined, and those arguments can appear as elements after CachePolicyType.
249
250
Example for a Data packet with "NoCache" policy:
251
252
    +-----------------------------+---------------+
253 47 Junxiao Shi
    | LpPacket                    | Data          |
254 2 Alex Afanasyev
    |                             | Name=/example |
255 47 Junxiao Shi
    | +-CachePolicy-------------+ | Content=xxxx  |
256 2 Alex Afanasyev
    | | CachePolicyType=NoCache | | Signature=xx  |
257
    | +-------------------------+ |               |
258
    +-----------------------------+---------------+
259
260 1 Junxiao Shi
This feature is designed to be used on local faces only.
261 2 Alex Afanasyev
It SHOULD NOT be enabled on non-local faces.
262 1 Junxiao Shi
If this feature is disabled but CachePolicy is received, this field MUST be ignored.
263 2 Alex Afanasyev
264 1 Junxiao Shi
CachePolicy header field is permitted only on an LpPacket carrying a Data packet, from an application to the forwarder.
265 2 Alex Afanasyev
When CachePolicy header field appears on an LpPacket carrying a network layer packet other than a Data packet, the packet MUST be dropped.
266
When CachePolicy is received by an application from a forwarder, this field MUST be ignored.
267
268 1 Junxiao Shi
## Congestion Marking
269
270 5 Eric Newberry
A host can signal the current congestion state to other hosts using the **CongestionMark** field. A value of 0 indicates *no congestion*; a value greater than 0 indicates some level of congestion. The exact meaning of the bits in this field is left up to the congestion control strategy in use.
271 1 Junxiao Shi
272
This features defines a header field:
273 5 Eric Newberry
274 47 Junxiao Shi
    LpHeaderField =/ CongestionMark
275 5 Eric Newberry
276 47 Junxiao Shi
    CongestionMark = CONGESTION-MARK-TYPE TLV-LENGTH nonNegativeInteger
277 1 Junxiao Shi
278 5 Eric Newberry
## Link Layer Reliability
279 9 Eric Newberry
280
To provide increased reliability and indicate potential congestion on a unicast link, a sender can expect frames successfully received by another host to be acknowledged.
281 14 Davide Pesavento
282 53 Davide Pesavento
After sending a link-layer frame (potentially fragmented, as described above), a host will expect an **Ack** field to be received on a frame returned in the opposite direction. This field will contain the **TxSequence** of the acknowledged frame. TxSequence numbers are assigned sequentially on the link, and are independent of the sequence number of the stored fragment. If the host does not receive this acknowledgement within the RTO (determined using the formula described below) and the frame has not been retransmitted more than a pre-determined number of times (the maximum number of retransmissions), the frame will be retransmitted on the link with the same sequence number, but a new TxSequence. In addition, if a configurable number of Acks (three by default) for greater TxSequences are received by the sender of the frame, the frame will be considered lost and the previously discussed retransmission logic will be followed.
283 15 Eric Newberry
284 9 Eric Newberry
To facilitate the retransmission of frames, each frame will be cached on the sender until it is acknowledged, at which point it can be deleted from the cache. The sender also keeps track of which frames were fragmented from which network-layer packet (if fragmentation occurred) and which unacknowledged TxSequences reference which transmitted frame. If one fragment of a network-layer packet exceeds the maximum number of retransmissions, the RTO timers of all fragments in the packet will be cancelled, all fragments of the packet will be deleted from the frame cache, and the entire packet will be considered lost. The sender will keep track of which sequence numbers are associated with which network-layer packets.
285 14 Davide Pesavento
286 9 Eric Newberry
The receiver will extract the TxSequence of every received frame and will insert these numbers into a queue of pending Acks destined for the sender. When a frame is being transmitted in the opposite direction, any excess space under the MTU will be filled with TxSequences removed from this queue. An idle Ack timer is used to handle links that have gone idle. If a packet with a TxSequence is received and the packet has not been started, or has expired, the timer is started with a period of 5ms (or another configurable non-zero time period). Upon expiration of the timer, all Acks in the queue will be sent in IDLE packets.
287 11 Eric Newberry
288 9 Eric Newberry
The RTO is determined using the standard TCP formula: `RTO = SRTT + 4 * RTTVAR`. The round-trip time (RTT) of a packet is measured as the difference between the time the frame was transmitted and when an Ack was received for it. Frames that have been retransmitted are not taken into account by this formula.
289 12 Eric Newberry
290
Multiple Ack fields can be sent in one LpPacket. If an Ack is received for an unknown TxSequence, the Ack will be ignored.
291
292 47 Junxiao Shi
    LpHeaderField =/ TxSequence / Ack
293 1 Junxiao Shi
294 47 Junxiao Shi
    TxSequence = TX-SEQUENCE-TYPE TLV-LENGTH 8OCTET
295 9 Eric Newberry
296 47 Junxiao Shi
    Ack = ACK-TYPE TLV-LENGTH 8OCTET
297 1 Junxiao Shi
298 9 Eric Newberry
**Modified from "Hop-By-Hop Best Effort Link Layer Reliability in Named Data Networking" by S. Vusirikala, et al.**
299 45 Davide Pesavento
300 1 Junxiao Shi
## Self-Learning Forwarding Support
301 23 Junxiao Shi
302 1 Junxiao Shi
[NDN self-learning](https://named-data.net/publications/on_broadcast-based_self-learning_ndn/) is a forwarding protocol that can automatically discover contents and forwarding paths in local area networks. This feature adds two hop-by-hop headers to support this forwarding protocol.
303 23 Junxiao Shi
304 47 Junxiao Shi
    LpHeaderField =/ NonDiscovery / PrefixAnnouncement
305 23 Junxiao Shi
306 47 Junxiao Shi
    NonDiscovery = NON-DISCOVERY-TYPE
307
                   TLV-LENGTH ; == 0
308 23 Junxiao Shi
309 52 Davide Pesavento
    PrefixAnnouncement = PREFIX-ANNOUNCEMENT-TYPE TLV-LENGTH Data
310 28 Teng Liang
311 23 Junxiao Shi
Self-learning distinguishes an Interest as either "discovery" or "non-discovery". A node transmits a discovery Interest to explore new forwarding paths, or transmits a non-discovery Interest to exploit existing forwarding paths. The **NonDiscovery** field indicates an Interest is "non-discovery"; otherwise, an Interest without this field is "discovery".
312
This field can only appear on an Interest. If this field appears on a Data or a Nack, the LpPacket MUST be dropped. If the self-learning forwarding protocol support feature is disabled or the chosen forwarding strategy does not support self-learning, this field SHOULD be ignored.
313
314 43 Teng Liang
When replying to a discovery Interest, the upstream node SHOULD transmit the Data with a **PrefixAnnouncementHeader** field. This field indicates what name prefix the producer is serving, and assists the downstream node in updating its FIB. A PrefixAnnouncement contains a single Data TLV element, and the Data format follows the [[PrefixAnnouncement]] Protocol.
315 42 Davide Pesavento
316 43 Teng Liang
 
317 41 Teng Liang
This field can only appear on a Data. If this field appears on an Interest or a Nack, the LpPacket MUST be dropped. If the self-learning forwarding protocol support feature is disabled or the chosen forwarding strategy does not support self-learning, this field SHOULD be ignored.
318 22 Teng Liang
319 16 Junxiao Shi
## TLV-TYPE Number Assignments
320 2 Alex Afanasyev
321 26 Davide Pesavento
type                     | number (dec)     | number (hex)
322
-------------------------|------------------|------------------
323 25 Junxiao Shi
Fragment                 | 80               | 0x50
324
Sequence                 | 81               | 0x51
325 1 Junxiao Shi
FragIndex                | 82               | 0x52
326
FragCount                | 83               | 0x53
327 25 Junxiao Shi
HopCount (ndnSIM)        | 84               | 0x54
328 55 Davide Pesavento
PitToken                 | 98               | 0x62
329 26 Davide Pesavento
LpPacket                 | 100              | 0x64
330 25 Junxiao Shi
Nack                     | 800              | 0x0320
331
NackReason               | 801              | 0x0321
332
NextHopFaceId            | 816              | 0x0330
333
IncomingFaceId           | 817              | 0x0331
334
CachePolicy              | 820              | 0x0334
335
CachePolicyType          | 821              | 0x0335
336
CongestionMark           | 832              | 0x0340
337
Ack                      | 836              | 0x0344
338
TxSequence               | 840              | 0x0348
339 20 Davide Pesavento
NonDiscovery             | 844              | 0x034C
340 2 Alex Afanasyev
PrefixAnnouncement       | 848              | 0x0350
341 1 Junxiao Shi
342 2 Alex Afanasyev
### Reserved Blocks
343
344 45 Davide Pesavento
Two blocks of TLV-TYPEs have been reserved by link protocols:
345 2 Alex Afanasyev
346 27 Davide Pesavento
* `[80, 100]`: 1-octet encoding
347
* `[800, 1000]`: 3-octet encoding
348 2 Alex Afanasyev
349 16 Junxiao Shi
TLV-TYPE numbers for LpHeaderField SHOULD be assigned according to the following rules:
350 2 Alex Afanasyev
351 27 Davide Pesavento
1. if the field can be safely ignored by a receiver that doesn't understand the field, pick an unused number in the range `[800, 959]` whose two least significant bits are `00`.
352
2. if the field would occur frequently, pick an unused number in the range `[81, 99]`.
353
3. otherwise, pick an unused number in the range `[800, 959]` whose two least significant bits are `01`.
354 2 Alex Afanasyev
355 16 Junxiao Shi
Note: number assignment for a TLV-TYPE nested within a LpHeaderField is not restricted by the above rules.