idnits 2.17.1 draft-ietf-rohc-tcp-06.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- ** Looks like you're using RFC 2026 boilerplate. This must be updated to follow RFC 3978/3979, as updated by RFC 4748. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- ** The document seems to lack a 1id_guidelines paragraph about 6 months document validity -- however, there's a paragraph with a matching beginning. Boilerplate error? ** The document seems to lack a 1id_guidelines paragraph about the list of current Internet-Drafts -- however, there's a paragraph with a matching beginning. Boilerplate error? == No 'Intended status' indicated for this document; assuming Proposed Standard Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- ** The abstract seems to contain references ([RFC-1323], [RFC-1144,RFC-2507], [RFC-2018,RFC-2883]), which it shouldn't. Please replace those with straight textual mentions of the documents in question. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the RFC 3978 Section 5.4 Copyright Line does not match the current year -- The document seems to lack a disclaimer for pre-RFC5378 work, but may have content which was first submitted before 10 November 2008. If you have contacted all the original authors and they are all willing to grant the BCP78 rights to the IETF Trust, then this is fine, and you can ignore this comment. If not, you may need to add the pre-RFC5378 disclaimer. (See the Legal Provisions document at https://trustee.ietf.org/license-info for more information.) -- The document date (April 2, 2004) is 7328 days in the past. Is this intentional? Checking references for intended status: Proposed Standard ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) -- Looks like a reference, but probably isn't: '0' on line 2746 -- Looks like a reference, but probably isn't: '1' on line 2746 -- Looks like a reference, but probably isn't: '2' on line 2746 -- Looks like a reference, but probably isn't: '4' on line 2746 == Unused Reference: 'RFC-791' is defined on line 2914, but no explicit reference was found in the text == Unused Reference: 'RFC-793' is defined on line 2917, but no explicit reference was found in the text == Unused Reference: 'RFC-2026' is defined on line 2920, but no explicit reference was found in the text == Unused Reference: 'RFC-2119' is defined on line 2923, but no explicit reference was found in the text == Unused Reference: 'RFC-2460' is defined on line 2926, but no explicit reference was found in the text == Unused Reference: 'IP-ONLY' is defined on line 2939, but no explicit reference was found in the text == Unused Reference: 'RFC-1072' is defined on line 2944, but no explicit reference was found in the text == Unused Reference: 'RFC-1644' is defined on line 2953, but no explicit reference was found in the text == Unused Reference: 'RFC-1693' is defined on line 2956, but no explicit reference was found in the text == Unused Reference: 'RFC-1889' is defined on line 2959, but no explicit reference was found in the text == Unused Reference: 'RFC-2018' is defined on line 2970, but no explicit reference was found in the text == Unused Reference: 'RFC-2883' is defined on line 2977, but no explicit reference was found in the text == Unused Reference: 'E2E' is defined on line 2981, but no explicit reference was found in the text == Unused Reference: 'Mobi96' is defined on line 2984, but no explicit reference was found in the text -- Possible downref: Non-RFC (?) normative reference: ref. 'ROHC-CR' -- Possible downref: Non-RFC (?) normative reference: ref. 'ROHC-FN' ** Obsolete normative reference: RFC 793 (Obsoleted by RFC 9293) ** Obsolete normative reference: RFC 2460 (Obsoleted by RFC 8200) -- Obsolete informational reference (is this intentional?): RFC 1072 (Obsoleted by RFC 1323, RFC 2018, RFC 6247) -- Obsolete informational reference (is this intentional?): RFC 1323 (Obsoleted by RFC 7323) -- Obsolete informational reference (is this intentional?): RFC 1644 (Obsoleted by RFC 6247) -- Obsolete informational reference (is this intentional?): RFC 1693 (Obsoleted by RFC 6247) -- Obsolete informational reference (is this intentional?): RFC 1889 (Obsoleted by RFC 3550) -- Obsolete informational reference (is this intentional?): RFC 1948 (Obsoleted by RFC 6528) -- Obsolete informational reference (is this intentional?): RFC 2001 (Obsoleted by RFC 2581) Summary: 6 errors (**), 0 flaws (~~), 16 warnings (==), 15 comments (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 Network Working Group Ghyslain Pelletier, Editor, Ericsson AB 3 INTERNET-DRAFT Lars-Erik Jonsson, Ericsson AB 4 Expires: October 2004 Mark A West, Siemens/Roke Manor 5 Richard Price, Siemens/Roke Manor 7 April 2, 2004 9 RObust Header Compression (ROHC): 10 A Profile for TCP/IP (ROHC-TCP) 11 13 Status of this memo 15 This document is an Internet-Draft and is in full conformance with 16 all provisions of Section 10 of RFC2026. 18 Internet-Drafts are working documents of the Internet Engineering 19 Task Force (IETF), its areas, and its working groups. Note that other 20 groups may also distribute working documents as Internet-Drafts. 22 Internet-Drafts are draft documents valid for a maximum of six months 23 and may be updated, replaced, or obsoleted by other documents at any 24 time. It is inappropriate to use Internet-Drafts as reference 25 material or cite them other than as "work in progress". 27 The list of current Internet-Drafts can be accessed at 28 http://www.ietf.org/ietf/lid-abstracts.txt 30 The list of Internet-Draft Shadow Directories can be accessed at 31 http://www.ietf.org/shadow.html 33 Abstract 35 This document specifies a ROHC (Robust Header Compression) profile 36 for compression of TCP/IP packets. The profile, called ROHC-TCP, is a 37 robust header compression scheme for TCP/IP that provides improved 38 compression efficiency and enhanced capabilities for compression of 39 various header fields including TCP options. 41 Existing TCP/IP header compression schemes do not work well when used 42 over links with significant error rates and long round-trip times. 43 For many bandwidth limited links where header compression is 44 essential, such characteristics are common. In addition, existing 45 schemes [RFC-1144, RFC-2507] have not addressed how to compress TCP 46 options such as SACK (Selective Acknowledgements) [RFC-2018, RFC- 47 2883] and Timestamps [RFC-1323]. 49 Table of contents 51 1. Introduction....................................................4 53 2. Terminology.....................................................4 55 3. Background......................................................5 57 3.1. Existing TCP/IP header compression schemes................5 58 3.2. Classification of TCP/IP header fields....................6 59 3.3. Characteristics of short-lived TCP transfers..............8 61 4. Overview of the TCP/IP profile..................................9 63 4.1. General concepts..........................................9 64 4.2. Context replication.......................................9 65 4.3. State machines and profile operation......................9 66 4.4. Packet formats and encoding methods.......................9 68 5. Compression and decompression state machines....................9 70 5.1. Compressor states and logic...............................9 71 5.1.1. Initialization and Refresh (IR) state..................10 72 5.1.2. Compression (CO) state.................................10 73 5.1.3. Feedback logic.........................................10 74 5.1.4. State transition logic.................................11 75 5.1.4.1. Optimistic approach, upward transition...............11 76 5.1.4.2. Optional acknowledgements (ACKs), upward transition..11 77 5.1.4.3. Timeouts, downward transition........................11 78 5.1.4.4. Negative ACKs (NACKs), downward transition...........12 79 5.1.4.5. Need for updates, downward transition................12 80 5.1.5. State machine supporting context replication...........12 81 5.2. Decompressor states and logic............................12 82 5.2.1. No Context (NC) state..................................13 83 5.2.2. Static Context (SC) state..............................13 84 5.2.3. Full Context (FC) state................................13 85 5.2.4. Allowing decompression.................................14 86 5.2.5. Reconstruction and verification........................15 87 5.2.6. Actions upon CRC failure...............................15 88 5.2.7. Feedback logic.........................................15 90 6. ROHC-TCP - TCP/IP compression (Profile 0x0006).................16 92 6.1. Feedback channel considerations..........................16 93 6.2. Master Sequence Number (MSN).............................17 94 6.3. Initialization...........................................17 95 6.4. Packet types.............................................18 96 6.4.1. Initialization and Refresh packets (IR)................18 97 6.4.2. Context replication packets (IR-CR)....................19 98 6.4.3. Compressed packets (CO)................................21 99 6.5. Packet formats...........................................21 100 6.5.1. Uncompressed TCP/IP packet.............................22 101 6.5.2. Default encoding methods...............................23 102 6.5.3. Compressed TCP Options using list encoding.............26 103 6.5.4. Packet type IR and IR-DYN..............................30 104 6.5.5. Compressed TCP/IP packets..............................32 105 6.5.5.1. Packet type IR-CR....................................32 106 6.5.5.2. Packet type CO.......................................38 107 6.6. Feedback formats and options.............................57 108 6.6.1. Feedback formats.......................................57 109 6.6.2. Feedback options.......................................58 110 6.6.3. The CONTEXT_MEMORY Feedback Option.....................58 112 7. Security considerations........................................58 114 8. IANA considerations............................................59 116 9. Acknowledgements...............................................59 118 10. References....................................................59 120 10.1. Normative references.....................................59 121 10.2. Informative references...................................60 123 11. Authors' addresses............................................61 125 Full Copyright Statement...........................................63 127 1. Introduction 129 There are several reasons to perform header compression on low- or 130 medium-speed links for TCP/IP traffic, and these have already been 131 discussed in [RFC-2507]. [TCP-REQ] introduces additional 132 considerations making robustness an important objective for a TCP 133 compression scheme. Finally, existing TCP/IP header compression 134 schemes [RFC-1144, RFC-2507] are limited in their handling of the TCP 135 options field and cannot compress the headers of handshaking packets 136 (SYNs and FINs). 138 It is thus desirable for a header compression scheme to be able to 139 handle loss on the link between the compression and decompression 140 point as well as loss before the compression point. The header 141 compression scheme also needs to consider how to efficiently compress 142 short-lived TCP transfers and TCP options, such as SACK [RFC-2018, 143 RFC-2883] and Timestamps [RFC-1323]. 145 The ROHC WG has developed a header compression framework on top of 146 which various profiles can be defined for different protocol sets, or 147 for different compression strategies. This document defines a TCP/IP 148 compression profile for the ROHC framework [RFC-3095], compliant with 149 the requirements on ROHC TCP/IP header compression [TCP-REQ]. 150 Specifically, it describes a header compression scheme for TCP/IP 151 header compression (ROHC-TCP) that is robust against packet loss and 152 that offers enhanced capabilities, in particular for the compression 153 of header fields including TCP options. The profile identifier for 154 TCP/IP compression is 0x0006. 156 2. Terminology 158 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 159 "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this 160 document are to be interpreted as described in RFC2119. 162 This document reuses some of the terminology found in [RFC-3095]. In 163 addition, this document defines the following terms: 165 Base context 167 The base context is a context that has been validated by both the 168 compressor and the decompressor. A base context can be used as the 169 reference when building a new context using replication. 171 Base CID 173 The Base Context Identifier is the CID used to identify the Base 174 Context, where information needed for context replication can 175 be extracted from. 177 Context replication 179 Context replication is the mechanism that establishes and 180 initializes a new context based on another existing valid context 181 (a base context). This mechanism is introduced to reduce the 182 overhead of the context establishment procedure, and is especially 183 useful for compression of multiple short-lived TCP connections that 184 may be occurring simultaneously or near-simultaneously. 186 Short-lived TCP Transfer 188 Short-lived TCP transfers refer to the TCP connections transmitting 189 only small amounts of data for each single connection. Short TCP 190 flows seldom need to operate beyond the slow-start phase of TCP to 191 complete their transfer, which also means that the transmission 192 ends before any significant increase of the TCP congestion window 193 may occur. 195 3. Background 197 This chapter provides some background information on TCP/IP header 198 compression. The fundamentals of general header compression may be 199 found in [RFC-3095]. In the following sections, two existing TCP/IP 200 header compression schemes are first described along with a 201 discussion of their limitations, followed by the classification of 202 TCP/IP header fields. Finally, some of the characteristics of short- 203 lived TCP transfers are summarized. 205 The behavior analysis of TCP/IP header fields among multiple short- 206 lived connections may be found in [TCP-BEH]. 208 3.1. Existing TCP/IP header compression schemes 210 Compressed TCP (CTCP) and IP Header Compression (IPHC) are two 211 different schemes that may be used to compress TCP/IP headers. Both 212 schemes transmit only the differences from the previous header in 213 order to reduce the large overhead of the TCP/IP header. 215 The CTCP [RFC-1144] compressor detects transport-level 216 retransmissions and sends a header that updates the context 217 completely when they occur. While CTCP works well over reliable 218 links, it is vulnerable when used over less reliable links as even a 219 single packet loss results in loss of synchronization between the 220 compressor and the decompressor. This in turn leads to the TCP 221 receiver discarding all remaining packets in the current window 222 because of a checksum error. This effectively prevents the TCP Fast 223 Retransmit algorithm [RFC-2001] from being triggered. In such case, 224 the compressor must wait until the TCP timeout to resynchronize. 226 To reduce the errors due to the inconsistent contexts between 227 compressor and decompressor when compressing TCP, IPHC [RFC-2507] 228 improves somewhat on CTCP by augmenting the repair mechanism of CTCP 229 with a local repair mechanism called TWICE and with a link-level 230 nacking mechanism to request a header that updates the context. 232 The TWICE algorithm assumes that only the Sequence Number field of 233 TCP segments are changing with the deltas between consecutive packets 234 being constant in most cases. This assumption is however not always 235 true, especially when TCP Timestamps and SACK options are used. 237 The full header request mechanism requires a feedback channel that 238 may be unavailable in some circumstances. This channel is used to 239 explicitly request that the next packet be sent with an uncompressed 240 header to allow resynchronization without waiting for a TCP timeout. 241 In addition, this mechanism does not perform well on links with long 242 round-trip time. 244 Both CTCP and IPHC are also limited in their handling of the TCP 245 options field. For IPHC, any change in the options field (caused by 246 timestamps or SACK, for example) renders the entire field 247 uncompressible, while for CTCP such a change in the options field 248 effectively disables TCP/IP header compression altogether. 250 Finally, existing TCP/IP compression schemes do not compress the 251 headers of handshaking packets (SYNs and FINs). Compressing these 252 packets may greatly improve the overall header compression ratio for 253 the cases where many short-lived TCP connections share the same link. 255 3.2. Classification of TCP/IP header fields 257 Header compression is possible due to the fact that there is much 258 redundancy between header field values within packets, especially 259 between consecutive packets. To utilize these properties for TCP/IP 260 header compression, it is important to understand the change patterns 261 of the various header fields. 263 All fields of the TCP/IP packet header have been classified in detail 264 in [TCP-BEH]. The main conclusion is that most of the header fields 265 can easily be compressed away since they never or seldom change. The 266 following fields do however require more sophisticated mechanisms: 268 - IPv4 Identification (16 bits) - IP-ID 269 - TCP Sequence Number (32 bits) - SN 270 - TCP Acknowledgement Number (32 bits) - ACKN 271 - TCP Reserved (4 bits) 272 - TCP ECN flags (2 bits) - ECN 273 - TCP Window (16 bits) - WINDOW 274 - TCP Options 275 - Maximum Segment Size (4 octets) - MSS 276 - Window Scale (3 octets) - WSopt 277 - SACK Permitted (2 octets) 278 - TCP SACK - SACK 279 - TCP Timestamp (32 bits) - TS 281 The assignment of IP-ID values can be done in various ways, which are 282 Sequential, Sequential jump, Random or constant to a value of zero. 283 However, designers of IPv4 stacks for cellular terminals should use 284 an assignment policy close to Sequential. Some IPv4 stacks do use a 285 sequential assignment when generating IP-ID values but do not 286 transmit the contents this field in network byte order; instead it is 287 sent with the two octets reversed. In this case, the compressor can 288 compress the IP-ID field after swapping the bytes. Consequently, the 289 decompressor also swaps the bytes of the IP-ID after decompression to 290 regenerate the original IP-ID. In [RFC-3095], the IP-ID is generally 291 inferred from the RTP Sequence Number. However, with respect to TCP 292 compression, the analysis in [TCP-BEH] reveals that there is no 293 obvious candidate to this purpose among the TCP fields. 295 The change pattern of several TCP fields (Sequence Number, 296 Acknowledgement Number, Window, etc.) are very hard to predict and 297 differs entirely from the behavior of RTP fields discussed in [RFC- 298 3095]. Of particular importance to a TCP/IP header compression scheme 299 is the understanding of the sequence and acknowledgement number [TCP- 300 BEH]. Specifically, at any point on the path (i.e. wherever a 301 compressor might be deployed), the sequence number can be anywhere 302 within a range defined by the TCP window. Missing packets or 303 retransmissions can cause the TCP sequence number to fluctuate within 304 the limits of this window. The jumps in acknowledgement number are 305 also bounded by this TCP window. 307 Another important behavior of the TCP/IP header is the dependency 308 between the sequence number and the acknowledgment number. It is 309 well-known that most TCP connections only have one-way traffic (web 310 browsing and FTP downloading, for example). This means that on the 311 forward path (from server to client), only the sequence number is 312 changing while the acknowledgement number remains constant for most 313 packets; on the backward path (from client to server), only the 314 sequence number is changing and the acknowledgement number remains 315 constant for most packets. 317 With respect to TCP options, it is noted that most options (such as 318 MSS, WSopt, SACK-permitted, etc.) may appear only on a SYN segment. 319 Every implementation should (and we expect most will) ignore unknown 320 options on SYN segments. 322 Headers specific to Mobile IP (for IPv4 or IPv6) do not receive any 323 special treatment in this document, for similar reasons as those 324 described in [RFC-3095]. 326 3.3. Characteristics of short-lived TCP transfers 328 Recent studies shows that the majority of TCP flows are short-lived 329 transfers with an average and a median size no larger than 10KB. 330 Short-lived TCP transfers will degrade the performance of header 331 compression schemes that establish a new context by initially sending 332 full headers. 334 It is hard to improve the performance for a single, unpredictable, 335 short-lived connection. However, there are common cases where there 336 will be multiple TCP connections between the same pair of hosts. A 337 mobile user browsing several web pages from the same web server (this 338 is more the case with HTTP/1.0 than HTTP/1.1) is one example. 340 In such case, multiple short-lived TCP/IP flows occur simultaneously 341 or near simultaneously within a relatively short time interval. It 342 may be expected that most (if not all) of the IP header of the these 343 connections will be almost identical to each other, with only small 344 relative jumps for the IP-ID field. 346 Furthermore, a subset of the TCP fields may also be very similar from 347 one connection to another. For example, one of the port numbers may 348 be reused (the service port) while the other (the ephemeral port) may 349 be changed only by a small amount relative to the just-closed 350 connection. 352 With regard to header compression, this means that parts of a 353 compression context used for a TCP connection may be reusable for 354 another TCP connection. A mechanism supporting context replication, 355 where a new context is initialized from an existing one, provide 356 useful optimizations for a sequence of short-lived TCP connections. 358 Context replication is possible due to the fact that there is much 359 similarity in header field values and context values among multiple 360 simultaneous or near simultaneous connections. All header fields and 361 related context values have been classified in detail in [TCP-BEH]. 362 The main conclusion is that most part of the IP sub-context, some TCP 363 fields, and some context values can easily be replicated since they 364 seldom change or change with only a small jump. 366 4. Overview of the TCP/IP profile 368 4.1. General concepts 370 Many of the concepts behind the ROHC-TCP profile are similar to those 371 described in [RFC-3095]. Like for other ROHC profiles, ROHC-TCP makes 372 use of the ROHC protocol as described in [RFC-3095, sections 5.1 to 373 5.2.6]. This include data structures, reserved packet types, general 374 packet formats, segmentation and initial decompressor processing. 376 4.2. Context replication 378 For ROHC-TCP, context replication may be particularly useful for 379 short-lived TCP flows [TCP-REQ]. ROHC-TCP therefore supports context 380 replication as defined in [ROHC-CR]; the compressor MAY support 381 context replication, while a decompressor implementation is REQUIRED 382 to support decompression of the IR-CR packet type. 384 4.3. State machines and profile operation 386 Header compression with ROHC can be characterized as an interaction 387 between two state machines, one compressor machine and one 388 decompressor machine, each instantiated once per context. 390 For ROHC-TCP compression, the compressor has two states and the 391 decompressor has three states. The two compressor states are the 392 Initialization and Refresh (IR) state, and the Compression (CO) 393 state. The three states of the decompressor are No Context (NC), 394 Static Context (SC) and Full Context (FC). The compressor may also 395 implement a third state, the Context Replication (CR) state, to 396 support context replication [ROHC-CR]. Transitions need not be 397 synchronized between the two state machines. 399 4.4. Packet formats and encoding methods 401 The packet formats used for ROHC-TCP and found in this document are 402 defined using the formal notation [ROHC-FN]. The formal notation is 403 used to provide an unambiguous representation of the packet formats 404 and a clear definition of the encoding methods. The encoding methods 405 used in the packet formats for ROHC-TCP are defined in [ROHC-FN]. 406 5. Compressor and decompressor state machines 408 The header compression state machines and their associated logic as 409 specified in this section are a simplified version of the ones found 410 in [RFC-3095]. 412 5.1. Compressor states and logic 414 The two compressor states are the Initialization and Refresh (IR) 415 state, and the Compression (CO) state. The compressor always start in 416 the lower compression state (IR). The compressor will normally 417 operate in the higher compression state (CO), under the constraint 418 that the compressor is sufficiently confident that the decompressor 419 has the information necessary to reconstruct a header compressed 420 according to this state. 422 The figure below shows the state machine for the compressor. The 423 details of each state, state transitions, and compression logic are 424 given in sub-sections following the figure. 426 Optimistic approach / ACK ACK 427 +------>------>------>------+ +->-+ 428 | | | | 429 | v | v 430 +----------+ +----------+ 431 | IR State | | CO State | 432 +----------+ +----------+ 433 ^ | 434 | Timeout / NACK / STATIC-NACK | 435 +-------<-------<-------<--------+ 437 The transition from IR state to CO state is based on the following 438 principles: the need for update and the optimistic approach principle 439 or, if a feedback channel is established, feedback received from the 440 decompressor. 442 5.1.1. Initialization and Refresh (IR) state 444 The purpose of the IR state is to initialize the static parts of the 445 context at the decompressor or to recover after failure. In this 446 state, the compressor sends complete header information. This 447 includes static and non-static fields in uncompressed form plus some 448 additional information. 450 The compressor stays in the IR state until it is fairly confident 451 that the decompressor has received the static information correctly. 453 5.1.2. Compression (CO) state 455 The purpose of the CO state is to efficiently communicate 456 irregularities in the packet stream when needed while maintaining the 457 most optimal compression ratio. When operating in this state, the 458 compressor normally sends most or all of the information in a 459 compressed form. 461 5.1.3. Feedback logic 463 The compressor state machine makes use of feedback from decompressor 464 to compressor for transitions in the backward direction, and 465 optionally to improve the forward transition. 467 The reception of either positive feedback (ACKs) or negative feedback 468 (NACKs) establishes the feedback channel from the decompressor. Once 469 there is an established feedback channel, the compressor makes use of 470 this feedback for optionally improving the transitions among 471 different states. This helps increasing the compression efficiency by 472 providing the information needed for the compressor to achieve the 473 necessary confidence level. When the feedback channel is established, 474 it becomes superfluous for the compressor to send periodic refreshes. 476 5.1.4. State transition logic 478 Decisions about transitions between the IR and the CO states are 479 taken by the compressor on the basis of: 481 - variations in the packet headers 482 - positive feedback from decompressor (Acknowledgements -- ACKs) 483 - negative feedback from decompressor (Negative ACKS -- NACKs) 484 - confidence level regarding error-free decompression of a packet 486 5.1.4.1. Optimistic approach, upward transition 488 Transition to the CO state is carried out according to the optimistic 489 approach principle. This means that the compressor transits to the CO 490 state when it is fairly confident that the decompressor has received 491 enough information to correctly decompress packets sent according to 492 the higher compression state. 494 In general, there are many approaches where the compressor can obtain 495 such information. A simple and general approach can be achieved by 496 sending uncompressed or partial full headers periodically. 498 5.1.4.2. Optional acknowledgements (ACKs), upward transition 500 The compressor can also transit to the CO state based on feedback 501 received by the decompressor. If a feedback channel is available, the 502 decompressor MAY use positive feedback (ACKs) to acknowledge 503 successful decompression of packets. Upon reception of an ACK for a 504 context updating packet, the compressor knows that the decompressor 505 has received the acknowledged packet and the transition to the CO 506 state can be carried out immediately. 508 This functionality is optional, so a compressor MUST NOT expect to 509 get such ACKs initially or during normal operation, even if a 510 feedback channel is available or established. 512 5.1.4.3. Timeouts, downward transition 514 When the optimistic approach is used (i.e. until a feedback channel 515 is established), there will always be a possibility of failure since 516 the decompressor may not have received sufficient information for 517 correct decompression. Therefore, unless a feedback channel has been 518 established by the decompressor, the compressor MUST periodically 519 transit to the IR state. 521 5.1.4.4. Negative ACKs (NACKs), downward transition 523 Negative acknowledgments (NACKs) are also called context requests. 524 Upon reception of a NACK, the compressor transits back to the IR 525 state and sends updates (such as IR-DYN or IR) to the decompressor. 527 5.1.4.5. Need for updates, downward transition 529 When the header to be compressed does not conform to the established 530 pattern or when the compressor is not confident whether the 531 decompressor has the synchronized context, the compressor will 532 transit to the IR state. 534 5.1.5. State machine supporting context replication 536 For a profile supporting context replication, the additional 537 compressor logic (including corresponding state transition and 538 feedback logic) found in [ROHC-CR] must be added to the compressor 539 state machine described above. The following figure shows the 540 resulting state machine: 542 Optimistic approach / ACK 543 +--->------>------>------>------>------>------>---+ 544 | | 545 | BCID Selection Optimistic approach / ACK | ACK 546 | +------>----->------+ +----->----->----->-----+ | +->-+ 547 | | | | | | | | 548 | | v | v v | v 549 +---------+ +---------+ +---------+ 550 | IR | | CR | | CO | 551 | State | | State | | State | 552 +---------+ +---------+ +---------+ 553 ^ ^ | | 554 | | NACK / STATIC-NACK | | 555 | +---<-----<-----<----+ | 556 | | 557 | Timeout / NACK / STATIC-NACK | 558 +-----<-------<-------<-------<-------<-------<----+ 560 5.2. Decompressor states and logic 562 The three states of the decompressor are No Context (NC), Static 563 Context (SC) and Full Context (FC). The decompressor starts in its 564 lowest compression state, the NC state. Successful decompression will 565 always move the decompressor to the FC state. The decompressor state 566 machine normally never leaves the FC state once it has entered this 567 state; only repeated decompression failures will force the 568 decompressor to transit downwards to a lower state. 570 Below is the state machine for the decompressor. Details of the 571 transitions between states and decompression logic are given in the 572 sub-sections following the figure. 574 Success 575 +-->------>------>------>------>------>--+ 576 | | 577 No Static | No Dynamic Success | Success 578 +-->--+ | +-->--+ +--->----->---+ +-->--+ 579 | | | | | | | | | 580 | v | | v | v | v 581 +-----------------+ +---------------------+ +-------------------+ 582 | No Context (NC) | | Static Context (SC) | | Full Context (FC) | 583 +-----------------+ +---------------------+ +-------------------+ 584 ^ | ^ | 585 | k_2 out of n_2 failures | | k_1 out of n_1 failures | 586 +-----<------<------<-----+ +-----<------<------<-----+ 588 5.2.1. No Context (NC) state 590 Initially, while working in the NC state, the decompressor has not 591 yet successfully decompressed a packet. 593 Upon receiving an IR or an IR-DYN packet, the decompressor will 594 verify the correctness of this packet by validating its header using 595 the CRC check. If the decompressed packet is successfully verified, 596 the decompressor will update the context and use this packet as the 597 reference packet. Once a packet has been decompressed correctly, the 598 decompressor can transit to the FC state, and only upon repeated 599 failures will it transit back to a lower state. 601 5.2.2. Static Context (SC) state 603 In the SC state, the decompressor assumes static context damage when 604 the CRC check of k_2 out of the last n_2 decompressed packets have 605 failed. The decompressor moves to the NC state and discards all 606 packets until a packet (e.g. IR or IR-DYN packet) that successfully 607 passes the verification check is received. The decompressor may send 608 feedback (see section 5.2.7.) when assuming static context damage. 610 Note that appropriate values for k and n, are related to the residual 611 error rate of the link. When the residual error rate is close to 612 zero, k = n = 1 may be appropriate. 614 5.2.3. Full Context (FC) state 616 In the FC state, the decompressor assumes context damage when the CRC 617 check of k_1 out of the last n_1 decompressed packets have failed, 618 (where k and n are related to the residual error rate of the link as 619 in section 5.2.2.). The decompressor moves to the SC state and 620 discards all packets until a packet carrying a 7- or 8-bit CRC that 621 successfully passes the verification check is received. The 622 decompressor may send feedback (see section 5.2.7.) when assuming 623 context damage. 625 Upon receiving an IR or an IR-DYN packet, the decompressor SHOULD 626 verify the correctness of its header using CRC validation. If the 627 verification succeeds, the decompressor will update the context and 628 use this packet as the reference packet. Consequently, the 629 decompressor will convert the packet into the original packet and 630 pass it to the network layer of the system. 632 Upon receiving other types of packet, the decompressor will 633 decompress it. The decompressor MUST verify the correctness of the 634 decompressed packet by CRC check. If this verification succeeds, the 635 decompressor passes the decompressed packet to the system's network 636 layer. The decompressor will then use this packet as the reference 637 value, if it is not older than the current reference packet (based on 638 sequence numbers in the compressed packet or in the uncompressed 639 header). 641 5.2.4. Allowing decompression 643 <# Editor's Note: CO packets containing a large amount of context #> 644 <# updating information will use a 7-(or 8)bit CRC #> 645 <# their packet format, in the next version of this #> 646 <# draft #> 648 In the No Context state, only packets carrying sufficient information 649 on the static fields (i.e. IR packets) can be decompressed. 651 In the Static Context state, only packets carrying a 7- or 8-bit CRC 652 may be decompressed (i.e. IR, IR-DYN and some CO packets). 654 In the Full Context state, decompression may be attempted regardless 655 of the type of packet received. 657 If decompression may not be performed, the packet is discarded. 659 As per [ROHC-CR], IR-CR packets may be decompressed in any state. 661 5.2.5. Reconstruction and verification 663 <# Editor's Note: The definition of the CRC polynomials will be #> 664 <# included in the library of encoding methods in #> 665 <# ROHC-FN. #> 667 The CRC carried within compressed headers MUST be used to verify 668 decompression. When the decompression is verified and successful, the 669 decompressor updates the context with the information received in the 670 current header; otherwise if the reconstructed header fails the CRC 671 check, these updates MUST NOT be performed. 673 5.2.6. Actions upon CRC failure 675 When a CRC check fails, the decompressor MUST discard the packet. The 676 actions to be taken when a CRC verification fails following the 677 decompression of an IR-CR packet are specified in [ROHC-CR]. For 678 other packet types carrying a CRC, if feedback is used the logic 679 specified in section 5.2.7 must be followed when a CRC verification 680 fails. 682 Note: Decompressor implementations may attempt corrective or repair 683 measures prior to performing the above actions, and the result of any 684 attempt MUST be verified using the CRC check. 686 5.2.7. Feedback logic 688 The decompressor may send positive feedback (ACKs) to initially 689 establish the feedback channel for a particular flow. Either positive 690 feedback (ACKs) or negative feedback (NACKs) will establish this 691 channel. The feedback channel will then be used by the decompressor 692 to send error recovery requests and (optionally) acknowledgements of 693 significant context updates. 695 Once a feedback channel is established by the decompressor, the 696 compressor will operate using an optimistic logic. In particular, 697 this means that the compressor will rely on a specific decompressor 698 feedback logic: 700 - the decompressor will send negative acknowledgements in case 701 when context damage is assumed or in other failure situations; 702 - the decompressor is not strictly expected to send feedback upon 703 successful decompression, other than for the purpose of 704 improving the forward state transition. 706 Once the feedback channel is established, the decompressor is 707 REQUIRED to continue sending feedback for the lifetime of the packet 708 stream as follow: 710 In NC state: 712 The decompressor SHOULD send a STATIC-NACK if a packet of a type 713 other than IR is received, or if an IR packet has failed the CRC 714 check. 716 In SC state: 718 The decompressor SHOULD send a STATIC-NACK when decompression of 719 an IR, an IR-DYN or a CO packet carrying a 7-bit CRC fails and 720 if static context damage is assumed (see also section 5.2.2.). 721 If any other packet type is received, the decompressor SHOULD 722 treat it as a CRC mismatch when deciding if feedback is to be 723 sent. 725 In FC state: 727 The decompressor SHOULD send a NACK when decompression of any 728 packet type fails and if context damage is assumed (see also 729 section 5.2.3.). 731 When decompression fails, the feedback rate SHOULD be limited. For 732 example, feedback could be sent only when decompression of several 733 consecutive packets have failed. In addition, the decompressor should 734 also limit the rate at which feedback is sent on successful 735 decompression, if sent at all. The decompressor may limit the 736 feedback rate by sending feedback for one out of a number of packets 737 providing the same type of feedback. 739 The decompressor MAY optionally send ACKs upon successful 740 decompression of any packet type. In particular, when an IR, an IR- 741 DYN or any CO packet carrying a 7- or 8-bit CRC is correctly 742 decompressed, the compressor may optionally send an ACK. 744 6. ROHC-TCP - TCP/IP compression (Profile 0x0006) 746 This section describes a ROHC profile for TCP/IP compression. The 747 profile identifier for ROHC-TCP is 0x0006. 749 6.1. Feedback channel considerations 751 The ROHC-TCP profile may be used in environments with or without 752 feedback capabilities from decompressor to compressor. ROHC-TCP 753 however assumes that if a ROHC feedback channel is available and is 754 used at least once by the decompressor, this channel will be present 755 during the entire compression operation. Otherwise, if the connection 756 is broken and the channel disappears, header compression should be 757 restarted. 759 To parallel [RFC-3095], this is similar to allowing only one mode 760 transition per compressor: from the initial unidirectional mode to 761 the bi-directional mode of operation, with the transition being 762 triggered by the reception of the first packet containing feedback 763 from the decompressor. This effectively means that ROHC-TCP does not 764 explicitly define any operational modes. 766 6.2. Master Sequence Number (MSN) 768 Feedback packets of types ACK and NACK carry information about 769 sequence number or acknowledgement number from decompressor to 770 compressor. Unfortunately, there is no guarantee that sequence number 771 and acknowledgement number fields will be used by every IP protocol 772 stack. In addition, the combined size of the sequence number field 773 and the acknowledgement number field is rather large, and they can 774 therefore not be carried efficiently within the feedback packet. 776 To overcome this problem, ROHC-TCP introduces a control field called 777 the Master Sequence Number (MSN) field. The MSN field is created at 778 the compressor, rather than using one of the fields already present 779 in the uncompressed header. It has the following two functions: 781 1. Differentiating between packets when sending feedback data. 783 2. Inferring the value of incrementing fields such as the IP-ID. 785 The MSN field is present in every packets sent by the compressor. The 786 MSN is LSB encoded within the CO packets, and the 16-bit MSN is sent 787 in full in IR/IR-DYN packets. The decompressor always sends the MSN 788 as part of the feedback information. The MSN can later be used by the 789 compressor to infer which packet is being acknowledged by the 790 decompressor. 792 6.3. Initialization 794 The static context of ROHC TCP streams can be initialized in either 795 two ways: 797 1) By using an IR packet as in section 5.4.1, where the profile is 798 six (6) and the static chain ends with the static part of a TCP 799 packet. At the compressor, the MSN is initialized to a random value 800 [RFC-1948] when the initial IR packet is sent. 802 2) By replicating an existing context using the mechanism defined in 803 [ROHC-CR]. This is done with an IR-CR packet as in section 5.4.3, 804 where the profile number is six (6) and the static replication chain 805 ends with the static part of a TCP packet. At the compressor, the MSN 806 is then reinitialized to a random value [RFC-1948] when the initial 807 IR-CR packet is sent. 809 6.4. Packet types 811 ROHC-TCP defines two different packet types: the Initialization and 812 Refresh (IR) packet type, and the Compressed packet type (CO). Each 813 type correspond to one of the possible states of the compressor. 815 Each packet type also define a number of packet formats: 30 packet 816 formats are defined for compressed headers (CO), and two for 817 initialization and refresh (IR). 819 Finally, the profile-specific part of the IR-CR packet [ROHC-CR] is 820 also defined in this section. 822 6.4.1. Initialization and Refresh packets (IR) 824 The ROHC-TCP IR packet follows the general format of the ROHC IR 825 packet, as defined in [RFC-3095, section 5.2.3]. 827 Packet type: IR 829 This packet type communicates the static part and the dynamic part 830 of the context. 832 The ROHC-TCP IR packet has the following format: 834 0 1 2 3 4 5 6 7 835 --- --- --- --- --- --- --- --- 836 : Add-CID octet : if for small CIDs and (CID != 0) 837 +---+---+---+---+---+---+---+---+ 838 | 1 1 1 1 1 1 0 0 | IR type octet 839 +---+---+---+---+---+---+---+---+ 840 : : 841 / 0-2 octets of CID / 1-2 octets if for large CIDs 842 : : 843 +---+---+---+---+---+---+---+---+ 844 | Profile | 1 octet 845 +---+---+---+---+---+---+---+---+ 846 | CRC | 1 octet 847 +---+---+---+---+---+---+---+---+ 848 | | 849 / profile_specific_part / variable length 850 | | 851 - - - - - - - - - - - - - - - - 852 | | 853 / Payload / variable length 854 | | 855 - - - - - - - - - - - - - - - - 857 CRC: 8-bit CRC, computed according to [RFC-3095, section 5.9.1.]. 859 profile_specific_part: The format of this field is defined using 860 the formal notation in section 6.5.4. 862 Payload: The payload of the corresponding original packet, if 863 any. The presence of a payload is inferred from the packet 864 length. 866 Packet type: IR-DYN 868 This packet type communicates the dynamic part of the context. 870 The ROHC-TCP IR-DYN packet has the following format: 872 0 1 2 3 4 5 6 7 873 --- --- --- --- --- --- --- --- 874 : Add-CID octet : if for small CIDs and (CID != 0) 875 +---+---+---+---+---+---+---+---+ 876 | 1 1 1 1 1 0 0 0 | IR-DYN type octet 877 +---+---+---+---+---+---+---+---+ 878 : : 879 / 0-2 octets of CID / 1-2 octets if for large CIDs 880 : : 881 +---+---+---+---+---+---+---+---+ 882 | Profile | 1 octet 883 +---+---+---+---+---+---+---+---+ 884 | CRC | 1 octet 885 +---+---+---+---+---+---+---+---+ 886 | | 887 / profile_specific_part / variable length 888 | | 889 - - - - - - - - - - - - - - - - 890 | | 891 / Payload / variable length 892 | | 893 - - - - - - - - - - - - - - - - 895 CRC: 8-bit CRC, computed according to [RFC-3095, section 5.9.1.]. 897 profile_specific_part: The format of this field is defined using 898 the formal notation in section 6.5.4. 900 Payload: The payload of the corresponding original packet, if 901 any. The presence of a payload is inferred from the packet 902 length. 904 6.4.2. Context Replication packets (IR-CR) 906 ROHC-TCP supports the context replication mechanism defined in [ROHC- 907 CR]. Context replication requires a dedicated IR packet format that 908 uniquely identifies the IR-CR packet for this profile. 910 Packet type: IR-CR 912 This packet type communicates a reference to a base context along 913 with the static and dynamic parts of the replicated context that 914 differs from the base context. 916 The ROHC-TCP IR-CR packet follows the general format of the ROHC CR 917 packet, as defined in [ROHC-CR, section 3.4.2.]. With consideration 918 to the extensibility of the IR packet type defined in [RFC-3095], the 919 ROHC-TCP profile supports context replication through the profile 920 specific part of the IR packet. This is achieved using the bit (x) 921 left in the IR packet header for "Profile specific information". For 922 ROHC-TCP, this bit is defined as a flag indicating whether this 923 packet is an IR packet or an IR-CR packet. For the ROHC-TCP IR-CR 924 packet, the value of the x bit must be set to one. 926 The ROHC-TCP IR-CR has the following format: 928 0 1 2 3 4 5 6 7 929 --- --- --- --- --- --- --- --- 930 : Add-CID octet : if for small CIDs and (CID != 0) 931 +---+---+---+---+---+---+---+---+ 932 | 1 1 1 1 1 1 0 1 | IR-CR type octet 933 +---+---+---+---+---+---+---+---+ 934 : : 935 / 0-2 octets of CID / 1-2 octets if for large CIDs 936 : : 937 +---+---+---+---+---+---+---+---+ 938 | Profile | 1 octet 939 +---+---+---+---+---+---+---+---+ 940 | CRC | 1 octet 941 +---+---+---+---+---+---+---+---+ 942 | B | CRC7 | 1 octet 943 +---+---+---+---+---+---+---+---+ 944 | | present if B = 1, 945 / Base CID / 1 octet if for small CIDs, or 946 | | 1-2 octets if for large CIDs 947 +---+---+---+---+---+---+---+---+ 948 | | 949 | profile_specific_part / variable length 950 | | 951 - - - - - - - - - - - - - - - - 952 | | 953 / Payload / variable length 954 | | 955 - - - - - - - - - - - - - - - - 957 B: B = 1 indicates that the Base CID field is present. 959 CRC7: The CRC over the original, uncompressed, header. This 7-bit 960 CRC is computed according to [ROHC-CR, section 3.4.1.1]. 962 profile_specific_part: Static and dynamic subheader information 963 used for replication. What information is present is inferred 964 from a list of discriminators within the IR-CR packet format. 965 The format of this field is defined using the formal notation 966 in section 6.5.5.1. 968 Payload: The payload of the corresponding original packet, if 969 any. The presence of a payload is inferred from the packet 970 length. 972 6.4.3. Compressed packets (CO) 974 The ROHC-TCP CO packets communicates irregularities in the packet 975 header. All CO packets carry a CRC and can update the context. 977 6.5. Packet formats 979 <# #> 980 <# Editor's Note: The packet formats are unchanged from the #> 981 <# previous version of this draft. #> 982 <# The packet formats will be updated in the next #> 983 <# version to support IPv6, to fix some problems #> 984 <# with the current formats, to octet-align the #> 985 <# fields in the compressed formats and generally #> 986 <# improve the formatting. #> 987 <# Some explanatory text improving clarity should #> 988 <# also be added throughout this section. #> 989 <# #> 991 This section describes the set of compressed TCP/IP packet formats. 992 The normative description of the packet formats is given using the 993 Formal Notation for Robust Header Compression [ROHC-FN]. The ROHC-FN 994 description of the packet formats specifies all of the information 995 needed to compress and decompress a header relative to the context. 996 In particular, it provides a list of all the fields present in the 997 uncompressed and compressed TCP/IP headers, and defines how to map 998 from each uncompressed packet to its compressed equivalent and vice 999 versa. See [ROHC-FN] for an explanation of the Formal Notation 1000 itself, and the encoding methods used to compress each of the fields 1001 in the TCP/IP header. 1003 The following constants are defined to improve readability of the 1004 packet formats in this section: 1006 sequential_ip_id ::= constant(0), 1007 random_ip_id ::= constant(1), 1008 zero_ip_id ::= constant(0), 1009 nonzero_ip_id ::= constant(1), 1010 tcp_ecn_used ::= constant(0), 1011 tcp_ecn_unused ::= constant(1), 1013 6.5.1. Uncompressed TCP/IP packet 1015 The uncompressed format of the TCP/IP header specified using the 1016 formal notation is as follow: 1018 tcp_ip ::= multiple_packet_formats, 1020 uncompressed_format ::= ip_version, % 4 bits 1021 ip_header_length, % 4 bits 1022 ip_tos, % 6 bits 1023 ip_ecn, % 2 bits 1024 ip_length, % 16 bits 1025 ip_id, % 16 bits 1026 ip_reserved, % 1 bit 1027 ip_dont_frag, % 1 bit 1028 ip_more_fragments, % 1 bit 1029 ip_offset, % 13 bits 1030 ip_ttl, % 8 bits 1031 ip_protocol, % 8 bits 1032 ip_checksum, % 16 bits 1033 ip_src_addr, % 32 bits 1034 ip_dest_addr, % 32 bits 1035 tcp_src_port, % 16 bits 1036 tcp_dest_port, % 16 bits 1037 tcp_seq_number, % 32 bits 1038 tcp_ack_number, % 32 bits 1039 tcp_data_offset, % 4 bits 1040 tcp_reserved, % 4 bits 1041 tcp_flags_ecn, % 2 bits 1042 tcp_flags_urg, % 1 bit 1043 tcp_flags_ack, % 1 bit 1044 tcp_flags_psh, % 1 bit 1045 tcp_flags_rsf, % 3 bits 1046 tcp_window, % 16 bits 1047 tcp_checksum, % 16 bits 1048 tcp_urg_point, % 16 bits 1049 tcp_options, % data_offset * 32 1050 % - 160 bits 1052 <# Editor's Note: Explanatory text regarding tcp options should #> 1053 <# be added #> 1055 6.5.2. Default encoding methods 1057 The following notation defines a set of default encoding methods for 1058 fields in the TCP/IP header. If a particular CO packet format does 1059 not specify how to encode a field, then it is assumed to use the 1060 default encoding method. 1062 default_methods ::= ... , 1064 { ip_version ::= value(4, 4), 1065 ip_header_length ::= value(4, 5), 1066 ip_tos ::= static, 1067 ip_ecn ::= derived_value, 1068 { field_length ::= constant(2), 1069 field_value ::= 1070 expression((uncomp(tcp_ip.tcp_ecn_and_reserved) // 16) mod 4) 1071 }, 1072 ip_length ::= inferred_size(16, 0), 1074 ip_id ::= multiple_packet_formats, 1076 { uncompressed_format ::= ip_id, % 16 bits 1078 co_num_formats ::= constant(2), 1080 co_format_0 ::= discriminator, % 0 bit 1081 ip_id, % 16 bits 1083 { discriminator ::= '', 1084 discriminator.format ::= same_as(nonzero_ip_id), 1085 ip_id ::= irregular(16) 1086 }, 1088 co_format_1 ::= discriminator, % 0 bit 1089 ip_id, % 0 bit 1091 { discriminator ::= '', 1092 discriminator.format ::= same_as(zero_ip_id), 1093 ip_id ::= value(16, 0) 1094 } 1095 }, 1097 ip_reserved ::= static, 1098 ip_dont_frag ::= static, 1099 ip_more_fragments ::= value(1, 0), 1100 ip_offset ::= value(13, 0), 1101 ip_ttl ::= static, 1102 ip_protocol ::= value(8, 6), 1103 ip_checksum ::= inferred_ip_checksum, 1104 ip_src_addr ::= static, 1105 ip_dest_addr ::= static, 1106 tcp_src_port ::= static, 1107 tcp_dest_port ::= static, 1109 tcp_seq_number ::= derived_value, 1110 { field_length ::= constant(32), 1111 field_value ::= 1112 expression(uncomp(tcp_seq_number_scaled) * 1113 uncomp(tcp_payload_size) + 1114 uncomp(tcp_seq_number_residue)) 1115 }, 1117 tcp_ack_number ::= static, 1119 tcp_data_offset ::= derived_value, 1120 { field_length ::= constant(4), 1121 field_value ::= 1122 expression((uncomp(tcp_ip.tcp_options.list_length) + 160) // 32) 1123 }, 1125 tcp_reserved ::= derived_value, 1126 { field_length ::= constant(4), 1127 field_value ::= 1128 expression(uncomp(tcp_ip.tcp_ecn_and_reserved) mod 16) 1129 }, 1131 tcp_flags_ecn ::= derived_value, 1132 { field_length ::= constant(2), 1133 field_value ::= 1134 expression(uncomp(tcp_ip.tcp_ecn_and_reserved) // 64) 1135 }, 1137 tcp_flags_urg ::= value(1, 0), 1138 tcp_window ::= static, 1139 tcp_urg_point ::= static, 1141 tcp_ecn_and_reserved ::= control_field, 1143 { base_field ::= group, 1145 { field_list ::= tcp_ip.tcp_flags_ecn, 1146 tcp_ip.ip_ecn, 1147 tcp_ip.tcp_reserved 1148 }, 1150 compressed_method ::= multiple_packet_formats, 1152 { uncompressed_format ::= tcp_ecn_and_reserved, % 8 bits 1154 co_num_formats ::= constant(2), 1155 co_format_0 ::= discriminator, % 0 bit 1156 tcp_ecn_and_reserved, % 0 bit 1158 { discriminator ::= '', 1159 discriminator.format ::= same_as(tcp_ecn_unused), 1160 tcp_ecn_and_reserved ::= value(8, 0) 1161 }, 1163 co_format_1 ::= discriminator, % 0 bit 1164 tcp_ecn_and_reserved, % 8 bits 1166 { discriminator ::= '', 1167 discriminator.format ::= same_as(tcp_ecn_used), 1168 tcp_ecn_and_reserved ::= irregular(8) 1169 } 1170 } 1171 }, 1173 tcp_seq_number_scaled ::= control_field, 1175 { base_field ::= 1176 expression(uncomp(tcp_ip.tcp_seq_number) // 1177 uncomp(tcp_ip.tcp_payload_size)), 1178 compressed_method ::= static 1179 }, 1181 tcp_seq_number_residue ::= control_field, 1183 { base_field ::= 1184 expression(uncomp(tcp_ip.tcp_seq_number) mod 1185 uncomp(tcp_ip.tcp_payload_size)), 1186 compressed_method ::= static 1187 }, 1189 order_flag ::= control_field, 1191 { base_field ::= 1192 same_as(tcp_ip.tcp_options.order_flag), 1194 compressed_method ::= value(1, 0) 1195 }, 1197 presence_flag ::= control_field, 1199 { base_field ::= 1200 same_as(tcp_ip.tcp_options.presence_flag), 1202 compressed_method ::= value(1, 0) 1203 }, 1205 6.5.3. Compressed TCP Options using list encoding 1207 The following notation defines how to compress the TCP options: 1209 tcp_options ::= list_of_known_length, 1210 { 1211 list_length ::= 1212 expression(uncomp(tcp_ip.tcp_data_offset) 1213 * 32 - 160), 1215 list_items ::= mss, 1216 wsopt, 1217 sack_permitted, 1218 timestamp, 1219 nop, 1220 eol, 1221 sack, 1222 generic, 1223 order_flag ::= from_list(tcp_ip.order_flag), 1224 presence_flag ::= from_list(tcp_ip.presence_flag), 1226 mss ::= single_packet_format, 1227 { 1228 uncompressed_data ::= kind, % 8 bits 1229 length, % 8 bits 1230 mss, % 16 bits 1232 compressed_data ::= mss, % 16 bits 1234 kind ::= value(8, 2), 1235 length ::= value(8, 4), 1236 mss ::= irregular(16) 1237 }, 1239 wsopt ::= single_packet_format, 1240 { 1241 uncompressed_data ::= kind, % 8 bits 1242 length, % 8 bits 1243 scale, % 8 bits 1245 compressed_data ::= wscale, % 8 bits 1247 kind ::= value(8, 3), 1248 length ::= value(8, 3), 1249 wscale ::= irregular(8) 1250 }, 1252 eol ::= value(8, 0), 1254 nop ::= value(8, 1), 1255 sack ::= single_packet_format, 1256 { 1257 uncompressed_data ::= kind, % 8 bits 1258 length, % 8 bits 1259 sack_blocks, % list_length bits 1261 compressed_data ::= sack_blocks, 1263 kind ::= value(8, 5), 1264 length ::= static, 1266 sack_blocks ::= list_of_known_length, 1267 { 1268 list_length ::= expression(uncomp(length) * 8 - 16), 1270 list_items ::= sack_block, 1271 sack_block, 1272 sack_block, 1273 sack_block, 1275 sack_block ::= multiple_packet_formats, 1276 { 1277 uncompressed_data ::= block_start, % 32 bits 1278 block_end, % 32 bits 1280 co_format_count ::= constant(3), 1282 co_format_0 ::= discriminator, % 2 bits 1283 block_start, % 32 bits 1284 block_end.offset, % 14 bits 1285 { 1286 discriminator ::= '00', 1287 block_start ::= irregular(32), 1288 block_end ::= inferred_offset(32), 1289 { 1290 base_field ::= same_as(block_start), 1291 offset ::= irregular(14) 1292 } 1293 }, 1295 co_format_1 ::= discriminator, % 2 bits 1296 block_start, % 32 bits 1297 block_end.offset, % 22 bits 1298 { 1299 discriminator ::= '01', 1300 block_start ::= irregular(32), 1301 block_end ::= inferred_offset(32), 1302 { 1303 base_field ::= same_as(block_start), 1304 offset ::= irregular(22) 1305 } 1307 }, 1309 co_format_2 ::= discriminator, % 2 bits 1310 block_start, % 32 bits 1311 block_end.offset, % 30 bits 1312 { 1313 discriminator ::= '10', 1314 block_start ::= irregular(32), 1315 block_end ::= inferred_offset(32), 1316 { 1317 base_field ::= same_as(block_start), 1318 offset ::= irregular(30) 1319 } 1320 } 1321 } 1322 } 1323 }, 1325 timestamp ::= multiple_packet_formats, 1326 { 1327 co_num_formats ::= constant(5), 1329 uncompressed_format ::= kind, % 8 bits 1330 length, % 8 bits 1331 value, % 32 bits 1332 echo_reply, % 32 bits 1334 co_format_0 ::= discriminator, % 4 bits 1335 value, % 14 bits 1336 echo_reply, % 14 bits 1338 { discriminator ::= '0000', 1339 kind ::= value(8, 8), 1340 length ::= value(8, 10), 1341 value ::= lsb(14, 0), 1342 echo_reply ::= lsb(14, 0) 1343 }, 1345 co_format_1 ::= discriminator, % 4 bits 1346 value, % 14 bits 1347 echo_reply, % 22 bits 1349 { discriminator ::= '0001', 1350 kind ::= value(8, 8), 1351 length ::= value(8, 10), 1352 value ::= lsb(14, 0), 1353 echo_reply ::= lsb(22, 0) 1354 }, 1356 co_format_2 ::= discriminator, % 4 bits 1357 value, % 22 bits 1358 echo_reply, % 14 bits 1360 { discriminator ::= '0010', 1361 kind ::= value(8, 8), 1362 length ::= value(8, 10), 1363 value ::= lsb(22, 0), 1364 echo_reply ::= lsb(14, 0) 1365 }, 1367 co_format_3 ::= discriminator, % 4 bits 1368 value, % 22 bits 1369 echo_reply, % 22 bits 1371 { discriminator ::= '0011', 1372 kind ::= value(8, 8), 1373 length ::= value(8, 10), 1374 value ::= lsb(22, 0), 1375 echo_reply ::= lsb(22, 0) }, 1377 co_format_4 ::= discriminator, % 8 bits 1378 value, % 32 bits 1379 echo_reply, % 32 bits 1381 { discriminator ::= '10000000', 1382 kind ::= value(8, 8), 1383 length ::= value(8, 10), 1384 value ::= irregular(32), 1385 echo_reply ::= irregular(32) 1386 } 1387 }, 1389 generic ::= single_packet_format, 1391 { uncompressed_data ::= kind, % 8 bits 1392 length, % 8 bits 1393 data_item, % data_size bits 1395 compressed_data ::= data_item, 1397 kind ::= static, 1398 length ::= static, 1399 data_item ::= 1400 uncompressible(tcp_ip.tcp_options.generic.length, 8, 1, -16) 1401 } 1402 } 1403 } 1404 }. 1406 6.5.4. Packet type IR and IR-DYN 1408 <# Editor's Note: Is the coverage part of the definition of the #> 1409 <# CRC encoding method in the formal notation? #> 1410 <# Editor's Note: This section attempts to make a binding #> 1411 <# between the packet format using the formal #> 1412 <# notation and the notation in rfc-3095. #> 1414 ROHC-TCP uses the basic structure of the ROHC IR and IR-DYN packets 1415 as defined in [RFC-3095, section 5.2.3. and 5.2.4. respectively]. The 1416 8-bit CRC is computed according to [RFC-3095, section 5.9.1.]. 1418 For the ROHC-TCP IR packet, the value of the x bit must be set to 1419 zero. The profile-specific information of the IR packet consists of 1420 the static chain, the dynamic chain and TCP options, as follow: 1422 profile_specific_part ::= ir_static_part, 1423 ir_dynamic_part, 1424 tcp_ip.options. 1426 For the ROHC-TCP IR-DYN packet, the profile-specific information of 1427 the IR-DYN packet consists of the dynamic chain and TCP options only, 1428 as follow: 1430 profile_specific_part ::= ir_dynamic_part, 1431 tcp_ip.options . 1433 The static and dynamic parts have the following format: 1435 ir_static_part ::= ip_src_addr, % 32 bits 1436 ip_dest_addr, % 32 bits 1437 tcp_src_port, % 16 bits 1438 tcp_dest_port, % 16 bits 1440 { ip_src_addr ::= irregular(32), 1441 ip_dest_addr ::= irregular(32), 1442 tcp_src_port ::= irregular(16), 1443 tcp_dest_port ::= irregular(16) }, 1445 ir_dynamic_part ::= discriminator, % 2 bits 1446 format, % 1 bit 1447 ip_id.discriminator, % 1 bit 1449 tcp_ecn_and_reserved.discriminator, 1450 % 1 bit 1451 order_flag, % 1 bit 1452 presence_flag, % 1 bit 1453 ip_reserved, % 1 bit 1454 msn, % 16 bits 1455 ip_tos, % 6 bits 1456 ip_dont_frag, % 1 bit 1457 tcp_flags_ack, % 1 bit 1458 ip_ttl, % 8 bits 1459 tcp_seq_number, % 32 bits 1460 tcp_ack_number % 32 bits 1461 tcp_window, % 16 bits 1462 tcp_checksum, % 16 bits 1463 tcp_urg_point, % 16 bits 1464 tcp_data_offset, % 4 bits 1465 tcp_flags_psh, % 1 bit 1466 tcp_flags_rsf, % 3 bits 1467 ip_id, % 0 or 16 bits 1468 tcp_ecn_and_reserved,% 0 or 8 bits 1469 tcp_options,% variable no. of bits 1471 { discriminator ::= '00', 1472 { num_formats ::= constant(2) }, 1473 discriminator.format ::= irregular(1), 1474 msn ::= control_field, 1475 { base_field ::= counter(16), 1476 compressed_method ::= irregular(16) }, 1477 ip_tos ::= irregular(6), 1478 ip_id ::= multiple_packet_formats, 1479 { uncompressed_format ::= ip_id, % 16 bits 1480 co_num_formats ::= constant(2), 1481 co_format_0 ::= discriminator, % 1 bit 1482 ip_id, % 16 bits 1483 { discriminator ::= '0', 1484 discriminator.format ::= value(1, 0), % non-zero IP ID 1485 ip_id ::= irregular(16) }, 1486 co_format_1 ::= discriminator, % 1 bit 1487 ip_id, % 0 bit 1488 { discriminator ::= '1', 1489 discriminator.format ::= value(1, 1), % zero IP ID 1490 ip_id ::= value(16, 0) } 1491 } 1492 ip_reserved ::= irregular(1), 1493 ip_dont_frag ::= irregular(1), 1494 ip_ttl ::= irregular(8), 1495 tcp_seq_number ::= irregular(32), 1496 tcp_ack_number ::= irregular(32), 1497 tcp_data_offset ::= irregular(4), 1498 tcp_flags_ack ::= irregular(1), 1499 tcp_flags_psh ::= irregular(1), 1500 tcp_flags_rsf ::= irregular(3), 1501 tcp_window ::= irregular(16), 1502 tcp_checksum ::= irregular(16), 1503 tcp_urg_point ::= irregular(16), 1504 tcp_ecn_and_reserved ::= control_field, 1505 { base_field ::= group, 1506 { field_list ::= tcp_ip.tcp_flags_ecn, 1507 tcp_ip.ip_ecn, 1508 tcp_ip.tcp_reserved }, 1509 compressed_method ::= multiple_packet_formats, 1510 { uncompressed_format ::= tcp_ecn_and_reserved, % 8 bits 1511 co_num_formats ::= constant(2), 1512 co_format_0 ::= discriminator, % 1 bit 1513 tcp_ecn_and_reserved, % 0 bit 1514 { discriminator ::= '0', 1515 discriminator.format ::= value(1, 0), % ECN/reserved 1516 % unused 1517 tcp_ecn_and_reserved ::= value(8, 0) }, 1519 co_format_1 ::= discriminator, % 1 bit 1520 tcp_ecn_and_reserved,% 8 bits 1522 { discriminator ::= '1', 1523 discriminator.format ::= value(1, 1), % ECN/reserved 1524 % used 1525 tcp_ecn_and_reserved ::= irregular(8) 1526 } 1527 } 1528 }, 1530 order_flag ::= control_field, 1532 { base_field ::= 1533 same_as(tcp_ip.default_methods.tcp_options.order_flag), 1535 compressed_method ::= irregular(1) 1536 }, 1538 presence_flag ::= control_field, 1540 { base_field ::= 1541 same_as(tcp_ip.default_methods.tcp_options.presence_flag), 1543 compressed_method ::= irregular(1) 1544 } 1545 }, 1547 6.5.5. Compressed TCP/IP packets 1549 6.5.5.1. Packet type IR-CR 1551 The profile-specific information of the IR-CR packet consists of a 1552 replicated part common to all IR-CR formats along with fields 1553 specific to the particular format, as follow: 1555 profile_specific_part ::= replicate_formats, 1556 tcp_ip.options. 1558 The following notation describes the IR-REPLICATE packet. Options are 1559 as per IR/IR-DYNAMIC packets. 1561 replicate_format_0 ::= discriminator, % 4 bits 1562 format, % 1 bit 1563 ip_id.discriminator, % 1 bit 1564 ip_src_addr.discriminator, % 1 bit 1565 ip_dst_addr.discriminator, % 1 bit 1566 ip_tos.discriminator, % 1 bit 1567 ip_ttl.discriminator, % 1 bit 1568 tcp_src_port.discriminator, % 2 bits 1569 tcp_dst_port.discriminator, % 2 bits 1570 tcp_ack_number.discriminator, % 1 bit 1571 tcp_ecn_and_reserved.discriminator,% 1 bit 1572 order_flag, % 1 bit 1573 presence_flag, % 1 bit 1574 ip_dont_frag, % 1 bit 1575 tcp_flags_urg, % 1 bit 1576 tcp_flags_ack, % 1 bit 1577 tcp_flags_psh, % 1 bit 1578 tcp_flags_rsf, % 2 bits 1579 header_crc, % 8 bits 1580 msn, % 16 bits 1581 tcp_seq_number, % 32 bits 1582 ip_src_addr, % 0 or 32 bits 1583 ip_dst_addr, % 0 or 32 bits 1584 ip_id, % 0 or 16 bits 1585 tcp_src_port, % 0, 8 or 16 bits 1586 tcp_dst_port, % 0, 8 or 16 bits 1587 tcp_ack_number, % 0 or 32 bits 1588 tcp_ecn_and_reserved, % 0 or 8 bits 1589 tcp_options, % variable no. of bits 1591 { discriminator ::= '0000', 1592 discriminator.format ::= irregular(1), 1593 ip_dont_frag ::= irregular(1), 1594 msn ::= control_field, 1595 { base_field ::= counter(16), 1596 compressed_method ::= irregular(16) }, 1598 ip_id ::= multiple_packet_formats, 1599 { uncompressed_format ::= ip_id, % 16 bits 1601 co_num_formats ::= constant(2), 1603 co_format_0 ::= discriminator, % 1 bit 1604 ip_id, % 16 bits 1606 { discriminator ::= '0', 1607 discriminator.format ::= value(1, 0), 1608 % non-zero IP ID theoretically replicable, but only saves 1 bit 1609 ip_id ::= irregular(16) 1610 }, 1612 co_format_1 ::= discriminator, % 1 bit 1613 ip_id, % 0 bit 1615 { discriminator ::= '1', 1616 discriminator.format ::= value(1, 1), 1617 % zero IP ID theoretically replicable, but only saves 1 bit 1618 ip_id ::= value(16, 0) 1619 } 1620 }, 1622 header_crc ::= crc(8), 1624 ip_src_addr ::= multiple_packet_formats, 1625 { uncompressed_format ::= ip_src_addr, % 32 bits 1626 co_num_formats ::= constant(2), 1627 co_format_0 ::= discriminator, % 1 bit 1628 ip_src_addr, % 0 bit 1629 { discriminator ::= '0', 1630 ip_src_addr ::= static 1631 }, 1632 co_format_1 ::= discriminator, % 1 bit 1633 ip_src_addr, % 32 bits 1634 { discriminator ::= '1', 1635 ip_src_addr ::= irregular(32) 1636 } 1637 }, 1639 ip_dst_addr ::= multiple_packet_formats, 1640 { uncompressed_format ::= ip_dst_addr, % 32 bits 1641 co_num_formats ::= constant(2), 1642 co_format_0 ::= discriminator, % 1 bit 1643 ip_dst_addr, % 0 bit 1644 { discriminator ::= '0', 1645 ip_dst_addr ::= static 1646 }, 1647 co_format_1 ::= discriminator, % 1 bit 1648 ip_dst_addr, % 32 bits 1649 { discriminator ::= '1', 1650 ip_dst_addr ::= irregular(32) 1651 } 1652 }, 1654 ip_tos ::= multiple_packet_formats, 1655 { uncompressed_format ::= ip_tos, % 8 bits 1656 co_num_formats ::= constant(2), 1657 co_format_0 ::= discriminator, % 1 bit 1658 ip_tos, % 0 bit 1659 { discriminator ::= '0', 1660 ip_tos ::= static 1661 }, 1662 co_format_1 ::= discriminator, % 1 bit 1663 ip_tos, % 8 bits 1664 { discriminator ::= '1', 1665 ip_tos ::= irregular(8) 1666 } 1667 }, 1669 ip_ttl ::= multiple_packet_formats, 1670 { uncompressed_format ::= ip_ttl, % 8 bits 1671 co_num_formats ::= constant(2), 1672 co_format_0 ::= discriminator, % 1 bit 1673 ip_ttl, % 0 bit 1674 { discriminator ::= '0', 1675 ip_ttl ::= static 1676 }, 1677 co_format_1 ::= discriminator, % 1 bit 1678 ip_ttl, % 8 bits 1679 { discriminator ::= '1', 1680 ip_ttl ::= irregular(8) 1681 } 1682 }, 1684 tcp_flags_urg ::= irregular(1) 1685 tcp_flags_ack ::= irregular(1) 1686 tcp_flags_psh ::= irregular(1) 1688 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 1690 tcp_ecn_and_reserved ::= control_field, 1692 { base_field ::= group, 1694 { field_list ::= tcp_ip.tcp_flags_ecn, 1695 tcp_ip.ip_ecn, 1696 tcp_ip.tcp_reserved 1697 }, 1699 compressed_method ::= multiple_packet_formats, 1701 { uncompressed_format ::= tcp_ecn_and_reserved,% 8 bits 1703 co_num_formats ::= constant(2), 1705 co_format_0 ::= discriminator, % 1 bits 1706 tcp_ecn_and_reserved,% 0 bit 1708 { discriminator ::= '0', 1709 discriminator.format ::= value (1, 0), 1710 tcp_ecn_and_reserved ::= value(8, 0) 1712 }, 1714 co_format_1 ::= discriminator, % 1 bit 1715 tcp_ecn_and_reserved,% 8 bits 1717 { discriminator ::= '1', 1718 discriminator.format ::= value (1, 1), 1719 tcp_ecn_and_reserved ::= irregular(8) 1720 } 1721 } 1722 }, 1724 tcp_src_port ::= multiple_packet_formats, 1725 { uncompressed_format ::= tcp_src_port, % 32 bits 1726 co_num_formats ::= constant(3), 1727 co_format_0 ::= discriminator, % 2 bits 1728 tcp_src_port, % 0 bit 1729 { discriminator ::= '00', 1730 tcp_src_port ::= static 1731 }, 1732 co_format_1 ::= discriminator, % 2 bits 1733 tcp_src_port, % 8 bits 1734 { discriminator ::= '01', 1735 tcp_src_port ::= lsb(8,64) 1736 }, 1737 co_format_1 ::= discriminator, % 2 bits 1738 tcp_src_port, % 16 bits 1739 { discriminator ::= '10', 1740 tcp_src_port ::= irregular(16) 1741 }, 1742 }, 1744 tcp_dst_port ::= multiple_packet_formats, 1745 { uncompressed_format ::= tcp_dst_port, % 32 bits 1746 co_num_formats ::= constant(3), 1747 co_format_0 ::= discriminator, % 2 bits 1748 tcp_dst_port, % 0 bit 1749 { discriminator ::= '00', 1750 tcp_dst_port ::= static 1751 }, 1752 co_format_1 ::= discriminator, % 2 bits 1753 tcp_dst_port, % 8 bits 1754 { discriminator ::= '01', 1755 tcp_dst_port ::= lsb(8,64) 1756 }, 1757 co_format_1 ::= discriminator, % 2 bits 1758 tcp_dst_port, % 16 bits 1759 { discriminator ::= '10', 1760 tcp_dst_port ::= irregular(16) 1761 }, 1762 }, 1764 tcp_seq_number ::= irregular(32), 1765 tcp_ack_number ::= multiple_packet_formats, 1766 { uncompressed_format ::= tcp_ack_number % 32 bits 1767 co_num_formats ::= constant(2), 1768 co_format_0 ::= discriminator, % 1 bit 1769 tcp_ack_number, % 0 bit 1770 { discriminator ::= '0', 1771 tcp_ack_number ::= value(32,0) 1772 }, 1773 co_format_1 ::= discriminator, % 1 bit 1774 tcp_ack_number, % 32 bits 1775 { discriminator ::= '1', 1776 tcp_ack_number ::= irregular(32) 1777 } 1778 }, 1780 tcp_window ::= multiple_packet_formats, 1781 { uncompressed_format ::= tcp_window, % 16 bits 1782 co_num_formats ::= constant(2), 1783 co_format_0 ::= discriminator, % 1 bit 1784 tcp_window, % 0 bit 1785 { discriminator ::= '0', 1786 tcp_window ::= static 1787 }, 1788 co_format_1 ::= discriminator, % 1 bit 1789 tcp_window, % 16 bits 1790 { discriminator ::= '1', 1791 tcp_window ::= irregular(16) 1792 } 1793 }, 1795 tcp_urg_point ::= value(16, 0) 1797 order_flag ::= control_field, 1799 { base_field ::= 1800 same_as(tcp_ip.default_methods.tcp_options.order_flag), 1802 compressed_method ::= irregular(1) 1803 }, 1805 presence_flag ::= control_field, 1807 { base_field ::= 1808 same_as(tcp_ip.default_methods.tcp_options.presence_flag), 1810 compressed_method ::= irregular(1) 1811 } 1812 } 1814 6.5.5.2. Packet type CO 1816 The ROHC-TCP compressed header has the following format: 1818 % The following notation describes all of the 31 compressed (CO) 1819 packet formats 1820 % for the basic TCP/IP header (excluding TCP options, which are 1821 handled separately). 1823 % Open issue: Is this a sensible number of packet formats? 1825 co_num_formats ::= constant(31), 1827 co_format_0 ::= discriminator, % 3 bits 1828 msn, % 1 bit 1829 tcp_flags_psh, % 1 bit 1830 header_crc, % 3 bits 1831 tcp_checksum, % 16 bits 1832 tcp_ecn_and_reserved, % 0 or 8 bits 1834 { discriminator ::= '100', 1835 discriminator.format ::= same_as(sequential_ip_id), 1836 msn ::= control_field, 1837 { base_field ::= counter(16), 1838 compressed_method ::= lsb(1, -1) 1839 }, 1840 header_crc ::= crc(3), 1841 tcp_flags_ack ::= value(1, 1), 1842 tcp_flags_psh ::= irregular(1), 1843 tcp_flags_rsf ::= value(3, 0), 1844 tcp_checksum ::= irregular(16) 1845 }, 1847 co_format_1 ::= discriminator, % 8 bits 1848 tcp_checksum, % 16 bits 1849 msn, % 1 bit 1850 tcp_seq_number_scaled, % 7 bits 1851 tcp_seq_number_residue, % 0 bit 1852 tcp_flags_psh, % 1 bit 1853 ip_id, % 2 bits 1854 tcp_ack_number, % 2 bits 1855 header_crc, % 3 bits 1856 tcp_ecn_and_reserved, % 0 or 8 bits 1858 { discriminator ::= '11001100', 1859 discriminator.format ::= same_as(sequential_ip_id), 1860 msn ::= control_field, 1861 { base_field ::= counter(16), 1862 compressed_method ::= lsb(1, -1) 1863 }, 1864 header_crc ::= crc(3), 1865 ip_id ::= inferred_offset(16), 1866 { base_field ::= expression(uncomp(tcp_ip.msn)), 1867 compressed_method ::= lsb(2, 1) 1868 }, 1869 tcp_ack_number ::= lsb(2, 0), 1870 tcp_flags_ack ::= value(1, 1), 1871 tcp_flags_psh ::= irregular(1), 1872 tcp_flags_rsf ::= value(3, 0), 1873 tcp_checksum ::= irregular(16), 1874 tcp_seq_number_scaled ::= control_field, 1875 { base_field ::= 1876 expression(uncomp(tcp_ip.tcp_seq_number) // 1877 uncomp(tcp_ip.tcp_payload_size)), 1878 compressed_method ::= lsb(7, 63) 1879 } 1880 }, 1882 co_format_2 ::= discriminator, % 2 bits 1883 tcp_ack_number, % 14 bits 1884 tcp_checksum, % 16 bits 1885 msn, % 1 bit 1886 tcp_flags_psh, % 1 bit 1887 header_crc, % 3 bits 1888 tcp_seq_number_scaled, % 3 bits 1889 tcp_seq_number_residue, % 0 bit 1890 tcp_ecn_and_reserved, % 0 or 8 bits 1892 { discriminator ::= '01', 1893 discriminator.format ::= same_as(sequential_ip_id), 1894 msn ::= control_field, 1895 { base_field ::= counter(16), 1896 compressed_method ::= lsb(1, -1) }, 1897 header_crc ::= crc(3), 1898 tcp_ack_number ::= lsb(14, 0), 1899 tcp_flags_ack ::= value(1, 1), 1900 tcp_flags_psh ::= irregular(1), 1901 tcp_flags_rsf ::= value(3, 0), 1902 tcp_checksum ::= irregular(16), 1903 tcp_seq_number_scaled ::= control_field, 1904 { base_field ::= 1905 expression(uncomp(tcp_ip.tcp_seq_number) // 1906 uncomp(tcp_ip.tcp_payload_size)), 1907 compressed_method ::= lsb(3, 3) } }, 1909 co_format_3 ::= discriminator, % 6 bits 1910 msn, % 2 bits 1911 tcp_checksum, % 16 bits 1912 tcp_flags_psh, % 1 bit 1913 tcp_ack_number, % 2 bits 1914 header_crc, % 3 bits 1915 ip_id, % 3 bits 1916 tcp_flags_rsf, % 3 bits 1917 tcp_seq_number_scaled, % 4 bits 1918 tcp_seq_number_residue, % 0 bit 1919 tcp_ecn_and_reserved, % 0 or 8 bits 1921 { discriminator ::= '110000', 1922 discriminator.format ::= same_as(sequential_ip_id), 1923 msn ::= control_field, 1924 { base_field ::= counter(16), 1925 compressed_method ::= lsb(2, -1) 1926 }, 1927 header_crc ::= crc(3), 1928 ip_id ::= inferred_offset(16), 1929 { base_field ::= expression(uncomp(tcp_ip.msn)), 1930 compressed_method ::= lsb(3, 3) 1931 }, 1932 tcp_ack_number ::= lsb(2, 0), 1933 tcp_flags_ack ::= value(1, 1), 1934 tcp_flags_psh ::= irregular(1), 1935 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 1936 tcp_checksum ::= irregular(16), 1937 tcp_seq_number_scaled ::= control_field, 1938 { base_field ::= 1939 expression(uncomp(tcp_ip.tcp_seq_number) // 1940 uncomp(tcp_ip.tcp_payload_size)), 1941 compressed_method ::= lsb(4, 3) 1942 } 1943 }, 1945 co_format_4 ::= discriminator, % 3 bits 1946 msn, % 1 bit 1947 tcp_seq_number, % 12 bits 1948 tcp_checksum, % 16 bits 1949 tcp_flags_psh, % 1 bit 1950 header_crc, % 3 bits 1951 tcp_ack_number, % 12 bits 1952 tcp_ecn_and_reserved, % 0 or 8 bits 1954 { discriminator ::= '101', 1955 discriminator.format ::= same_as(sequential_ip_id), 1956 msn ::= control_field, 1957 { base_field ::= counter(16), 1958 compressed_method ::= lsb(1, -1) 1959 }, 1960 header_crc ::= crc(3), 1961 tcp_seq_number ::= lsb(12, 1023), 1962 tcp_ack_number ::= lsb(12, 0), 1963 tcp_flags_ack ::= value(1, 1), 1964 tcp_flags_psh ::= irregular(1), 1965 tcp_flags_rsf ::= value(3, 0), 1966 tcp_checksum ::= irregular(16) 1968 }, 1970 co_format_5 ::= discriminator, % 8 bits 1971 tcp_checksum, % 16 bits 1972 tcp_flags_psh, % 1 bit 1973 msn, % 2 bits 1974 tcp_seq_number, % 13 bits 1975 tcp_ack_number, % 2 bits 1976 header_crc, % 3 bits 1977 ip_id, % 3 bits 1978 tcp_ecn_and_reserved, % 0 or 8 bits 1980 { discriminator ::= '11001111', 1981 discriminator.format ::= same_as(sequential_ip_id), 1982 msn ::= control_field, 1983 { base_field ::= counter(16), 1984 compressed_method ::= lsb(2, -1) 1985 }, 1986 header_crc ::= crc(3), 1987 ip_id ::= inferred_offset(16), 1988 { base_field ::= expression(uncomp(tcp_ip.msn)), 1989 compressed_method ::= lsb(3, 3) 1990 }, 1991 tcp_seq_number ::= lsb(13, 1023), 1992 tcp_ack_number ::= lsb(2, 0), 1993 tcp_flags_ack ::= value(1, 1), 1994 tcp_flags_psh ::= irregular(1), 1995 tcp_flags_rsf ::= value(3, 1), 1996 tcp_checksum ::= irregular(16) 1997 }, 1999 co_format_6 ::= discriminator, % 8 bits 2000 tcp_checksum, % 16 bits 2001 tcp_flags_psh, % 1 bit 2002 msn, % 2 bits 2003 tcp_seq_number, % 13 bits 2004 tcp_ack_number, % 2 bits 2005 header_crc, % 3 bits 2006 ip_id, % 3 bits 2007 tcp_ecn_and_reserved, % 0 or 8 bits 2009 { discriminator ::= '11001001', 2010 discriminator.format ::= same_as(sequential_ip_id), 2011 msn ::= control_field, 2012 { base_field ::= counter(16), 2013 compressed_method ::= lsb(2, -1) 2014 }, 2015 header_crc ::= crc(3), 2016 ip_id ::= inferred_offset(16), 2017 { base_field ::= expression(uncomp(tcp_ip.msn)), 2018 compressed_method ::= lsb(3, 3) }, 2020 tcp_seq_number ::= lsb(13, 1023), 2021 tcp_ack_number ::= lsb(2, 0), 2022 tcp_flags_ack ::= value(1, 1), 2023 tcp_flags_psh ::= irregular(1), 2024 tcp_flags_rsf ::= value(3, 0), 2025 tcp_checksum ::= irregular(16) 2026 }, 2028 co_format_7 ::= discriminator, % 4 bits 2029 tcp_seq_number_scaled, % 4 bits 2030 tcp_seq_number_residue, % 0 bit 2031 tcp_checksum, % 16 bits 2032 tcp_flags_psh, % 1 bit 2033 header_crc, % 7 bits 2034 msn, % 2 bits 2035 tcp_ack_number, % 14 bits 2036 ip_id, % 3 bits 2037 tcp_window, % 13 bits 2038 tcp_ecn_and_reserved, % 0 or 8 bits 2040 { discriminator ::= '1101', 2041 discriminator.format ::= same_as(sequential_ip_id), 2042 msn ::= control_field, 2043 { base_field ::= counter(16), 2044 compressed_method ::= lsb(2, -1) 2045 }, 2046 header_crc ::= crc(7), 2047 ip_id ::= inferred_offset(16), 2048 { base_field ::= expression(uncomp(tcp_ip.msn)), 2049 compressed_method ::= lsb(3, 3) 2050 }, 2051 tcp_ack_number ::= lsb(14, 0), 2052 tcp_flags_ack ::= value(1, 1), 2053 tcp_flags_psh ::= irregular(1), 2054 tcp_flags_rsf ::= value(3, 0), 2055 tcp_window ::= lsb(13, 2047), 2056 tcp_checksum ::= irregular(16), 2057 tcp_seq_number_scaled ::= control_field, 2058 { base_field ::= 2059 expression(uncomp(tcp_ip.tcp_seq_number) // 2060 uncomp(tcp_ip.tcp_payload_size)), 2061 compressed_method ::= lsb(4, 3) 2062 } 2063 }, 2065 co_format_8 ::= discriminator, % 2 bits 2066 msn, % 1 bit 2067 tcp_window, % 13 bits 2068 tcp_checksum, % 16 bits 2069 tcp_flags_psh, % 1 bit 2070 header_crc, % 7 bits 2071 tcp_seq_number, % 12 bits 2072 tcp_ack_number, % 12 bits 2073 tcp_ecn_and_reserved, % 0 or 8 bits 2075 { discriminator ::= '00', 2076 discriminator.format ::= same_as(sequential_ip_id), 2077 msn ::= control_field, 2078 { base_field ::= counter(16), 2079 compressed_method ::= lsb(1, -1) 2080 }, 2081 header_crc ::= crc(7), 2082 tcp_seq_number ::= lsb(12, 1023), 2083 tcp_ack_number ::= lsb(12, 0), 2084 tcp_flags_ack ::= value(1, 1), 2085 tcp_flags_psh ::= irregular(1), 2086 tcp_flags_rsf ::= value(3, 0), 2087 tcp_window ::= lsb(13, 2047), 2088 tcp_checksum ::= irregular(16) 2089 }, 2091 co_format_9 ::= discriminator, % 9 bits 2092 msn, % 1 bit 2093 tcp_flags_psh, % 1 bit 2094 tcp_seq_number, % 2 bits 2095 header_crc, % 3 bits 2096 tcp_ack_number, % 32 bits 2097 tcp_checksum, % 16 bits 2098 tcp_ecn_and_reserved, % 0 or 8 bits 2100 { discriminator ::= '110010001', 2101 discriminator.format ::= same_as(sequential_ip_id), 2102 msn ::= control_field, 2103 { base_field ::= counter(16), 2104 compressed_method ::= lsb(1, -1) 2105 }, 2106 header_crc ::= crc(3), 2107 tcp_seq_number ::= lsb(2, 0), 2108 tcp_ack_number ::= irregular(32), 2109 tcp_flags_ack ::= value(1, 1), 2110 tcp_flags_psh ::= irregular(1), 2111 tcp_flags_rsf ::= value(3, 0), 2112 tcp_checksum ::= irregular(16) 2113 }, 2115 co_format_10 ::= discriminator, % 8 bits 2116 ip_id, % 16 bits 2117 tcp_checksum, % 16 bits 2118 tcp_flags_psh, % 1 bit 2119 msn, % 2 bits 2120 tcp_seq_number, % 13 bits 2121 tcp_ack_number, % 2 bits 2122 header_crc, % 3 bits 2123 tcp_flags_rsf, % 3 bits 2124 tcp_ecn_and_reserved, % 0 or 8 bits 2126 { discriminator ::= '11001110', 2127 discriminator.format ::= same_as(sequential_ip_id), 2128 msn ::= control_field, 2129 { base_field ::= counter(16), 2130 compressed_method ::= lsb(2, -1) 2131 }, 2132 header_crc ::= crc(3), 2133 ip_id ::= inferred_offset(16), 2134 { base_field ::= expression(uncomp(tcp_ip.msn)), 2135 compressed_method ::= irregular(16) 2136 }, 2137 tcp_seq_number ::= lsb(13, 1023), 2138 tcp_ack_number ::= lsb(2, 0), 2139 tcp_flags_ack ::= value(1, 1), 2140 tcp_flags_psh ::= irregular(1), 2141 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2142 tcp_checksum ::= irregular(16) }, 2144 co_format_11 ::= discriminator, % 7 bits 2145 tcp_flags_psh, % 1 bit 2146 tcp_window, % 16 bits 2147 tcp_checksum, % 16 bits 2148 msn, % 2 bits 2149 tcp_ack_number, % 14 bits 2150 ip_id, % 3 bits 2151 tcp_flags_rsf, % 3 bits 2152 tcp_seq_number_scaled, % 3 bits 2153 tcp_seq_number_residue, % 0 bit 2154 header_crc, % 7 bits 2155 tcp_ecn_and_reserved, % 0 or 8 bits 2157 { discriminator ::= '1100101', 2158 discriminator.format ::= same_as(sequential_ip_id), 2159 msn ::= control_field, 2160 { base_field ::= counter(16), 2161 compressed_method ::= lsb(2, -1) 2162 }, 2163 header_crc ::= crc(7), 2164 ip_id ::= inferred_offset(16), 2165 { base_field ::= expression(uncomp(tcp_ip.msn)), 2166 compressed_method ::= lsb(3, 3) 2167 }, 2168 tcp_ack_number ::= lsb(14, 0), 2169 tcp_flags_ack ::= value(1, 1), 2170 tcp_flags_psh ::= irregular(1), 2171 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2172 tcp_window ::= irregular(16), 2173 tcp_checksum ::= irregular(16), 2174 tcp_seq_number_scaled ::= control_field, 2175 { base_field ::= 2176 expression(uncomp(tcp_ip.tcp_seq_number) // 2177 uncomp(tcp_ip.tcp_payload_size)), 2178 compressed_method ::= lsb(3, 3) 2179 } 2180 }, 2182 co_format_12 ::= discriminator, % 6 bits 2183 tcp_ack_number, % 2 bits 2184 ip_id, % 16 bits 2185 ip_ttl, % 8 bits 2186 tcp_checksum, % 16 bits 2187 msn, % 1 bit 2188 header_crc, % 7 bits 2189 tcp_flags_psh, % 1 bit 2190 tcp_flags_rsf, % 3 bits 2191 tcp_seq_number, % 12 bits 2192 tcp_ecn_and_reserved, % 0 or 8 bits 2194 { discriminator ::= '110001', 2195 discriminator.format ::= same_as(sequential_ip_id), 2196 msn ::= control_field, 2197 { base_field ::= counter(16), 2198 compressed_method ::= lsb(1, -1) 2199 }, 2200 header_crc ::= crc(7), 2201 ip_id ::= inferred_offset(16), 2202 { base_field ::= expression(uncomp(tcp_ip.msn)), 2203 compressed_method ::= irregular(16) 2204 }, 2205 ip_ttl ::= irregular(8), 2206 tcp_seq_number ::= lsb(12, 1023), 2207 tcp_ack_number ::= lsb(2, 0), 2208 tcp_flags_ack ::= value(1, 1), 2209 tcp_flags_psh ::= irregular(1), 2210 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2211 tcp_checksum ::= irregular(16) 2212 }, 2214 co_format_13 ::= discriminator, % 9 bits 2215 header_crc, % 7 bits 2216 ip_id, % 16 bits 2217 ip_ttl, % 8 bits 2218 tcp_window, % 16 bits 2219 tcp_checksum, % 16 bits 2220 ip_dont_frag, % 1 bit 2221 tcp_flags_psh, % 1 bit 2222 ip_tos, % 6 bits 2223 msn, % 2 bits 2224 tcp_ack_number, % 14 bits 2225 tcp_flags_rsf, % 3 bits 2226 tcp_seq_number, % 13 bits 2227 tcp_ecn_and_reserved, % 0 or 8 bits 2229 { discriminator ::= '110010000', 2230 discriminator.format ::= same_as(sequential_ip_id), 2231 msn ::= control_field, 2232 { base_field ::= counter(16), 2233 compressed_method ::= lsb(2, -1) 2234 }, 2235 header_crc ::= crc(7), 2236 ip_tos ::= irregular(6), 2237 ip_id ::= inferred_offset(16), 2238 { base_field ::= expression(uncomp(tcp_ip.msn)), 2239 compressed_method ::= irregular(16) 2240 }, 2241 ip_dont_frag ::= irregular(1), 2242 ip_ttl ::= irregular(8), 2243 tcp_seq_number ::= lsb(13, 1023), 2244 tcp_ack_number ::= lsb(14, 0), 2245 tcp_flags_ack ::= value(1, 1), 2246 tcp_flags_psh ::= irregular(1), 2247 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2248 tcp_window ::= irregular(16), 2249 tcp_checksum ::= irregular(16) 2250 }, 2252 co_format_14 ::= discriminator, % 8 bits 2253 ip_id, % 16 bits 2254 ip_ttl, % 8 bits 2255 tcp_ack_number, % 32 bits 2256 tcp_window, % 16 bits 2257 tcp_checksum, % 16 bits 2258 msn, % 1 bit 2259 header_crc, % 7 bits 2260 tcp_flags_ack, % 1 bit 2261 tcp_flags_psh, % 1 bit 2262 tcp_flags_rsf, % 3 bits 2263 tcp_seq_number_scaled, % 3 bits 2264 tcp_seq_number_residue, % 0 bit 2265 tcp_ecn_and_reserved, % 0 or 8 bits 2267 { discriminator ::= '11001101', 2268 discriminator.format ::= same_as(sequential_ip_id), 2269 msn ::= control_field, 2270 { base_field ::= counter(16), 2271 compressed_method ::= lsb(1, -1) 2272 }, 2273 header_crc ::= crc(7), 2274 ip_id ::= inferred_offset(16), 2275 { base_field ::= expression(uncomp(tcp_ip.msn)), 2276 compressed_method ::= irregular(16) 2277 }, 2278 ip_ttl ::= irregular(8), 2279 tcp_ack_number ::= irregular(32), 2280 tcp_flags_ack ::= irregular(1), 2281 tcp_flags_psh ::= irregular(1), 2282 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2283 tcp_window ::= irregular(16), 2284 tcp_checksum ::= irregular(16), 2285 tcp_seq_number_scaled ::= control_field, 2286 { base_field ::= 2287 expression(uncomp(tcp_ip.tcp_seq_number) // 2288 uncomp(tcp_ip.tcp_payload_size)), 2289 compressed_method ::= lsb(3, 3) 2290 } 2291 }, 2293 co_format_15 ::= discriminator, % 3 bits 2294 msn, % 1 bit 2295 tcp_flags_psh, % 1 bit 2296 header_crc, % 3 bits 2297 tcp_checksum, % 16 bits 2298 tcp_ecn_and_reserved, % 0 or 8 bits 2299 ip_id, % 0 or 16 bits 2301 { discriminator ::= '100', 2302 discriminator.format ::= same_as(random_ip_id), 2303 msn ::= control_field, 2304 { base_field ::= counter(16), 2305 compressed_method ::= lsb(1, -1) 2306 }, 2307 header_crc ::= crc(3), 2308 tcp_flags_ack ::= value(1, 1), 2309 tcp_flags_psh ::= irregular(1), 2310 tcp_flags_rsf ::= value(3, 0), 2311 tcp_checksum ::= irregular(16) 2312 }, 2314 co_format_16 ::= discriminator, % 3 bits 2315 msn, % 1 bit 2316 tcp_flags_psh, % 1 bit 2317 header_crc, % 3 bits 2318 tcp_checksum, % 16 bits 2319 tcp_ack_number, % 2 bits 2320 tcp_flags_rsf, % 3 bits 2321 tcp_seq_number_scaled, % 3 bits 2322 tcp_seq_number_residue, % 0 bits 2323 tcp_ecn_and_reserved, % 0 or 8 bits 2324 ip_id, % 0 or 16 bits 2326 { discriminator ::= '101', 2327 discriminator.format ::= same_as(random_ip_id), 2328 msn ::= control_field, 2329 { base_field ::= counter(16), 2330 compressed_method ::= lsb(1, -1) 2331 }, 2332 header_crc ::= crc(3), 2333 tcp_ack_number ::= lsb(2, 0), 2334 tcp_flags_ack ::= value(1, 1), 2335 tcp_flags_psh ::= irregular(1), 2336 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2337 tcp_checksum ::= irregular(16), 2338 tcp_seq_number_scaled ::= control_field, 2339 { base_field ::= 2340 expression(uncomp(tcp_ip.tcp_seq_number) // 2341 uncomp(tcp_ip.tcp_payload_size)), 2342 compressed_method ::= lsb(3, 3) 2343 } 2344 }, 2346 co_format_17 ::= discriminator, % 6 bits 2347 msn, % 2 bits 2348 tcp_checksum, % 16 bits 2349 tcp_flags_psh, % 1 bit 2350 tcp_ack_number, % 2 bits 2351 header_crc, % 3 bits 2352 tcp_seq_number_scaled, % 10 bits 2353 tcp_seq_number_residue, % 0 bit 2354 tcp_ecn_and_reserved, % 0 or 8 bits 2355 ip_id, % 0 or 16 bits 2357 { discriminator ::= '110101', 2358 discriminator.format ::= same_as(random_ip_id), 2359 msn ::= control_field, 2360 { base_field ::= counter(16), 2361 compressed_method ::= lsb(2, -1) 2362 }, 2363 header_crc ::= crc(3), 2364 tcp_ack_number ::= lsb(2, 0), 2365 tcp_flags_ack ::= value(1, 1), 2366 tcp_flags_psh ::= irregular(1), 2367 tcp_flags_rsf ::= value(3, 0), 2368 tcp_checksum ::= irregular(16), 2369 tcp_seq_number_scaled ::= control_field, 2370 { base_field ::= 2371 expression(uncomp(tcp_ip.tcp_seq_number) // 2372 uncomp(tcp_ip.tcp_payload_size)), 2373 compressed_method ::= lsb(10, 255) 2374 } 2375 }, 2377 co_format_18 ::= discriminator, % 2 bits 2378 msn, % 1 bit 2379 tcp_flags_psh, % 1 bit 2380 tcp_seq_number, % 12 bits 2381 tcp_checksum, % 16 bits 2382 tcp_ack_number, % 2 bits 2383 header_crc, % 3 bits 2384 tcp_flags_rsf, % 3 bits 2385 tcp_ecn_and_reserved, % 0 or 8 bits 2386 ip_id, % 0 or 16 bits 2388 { discriminator ::= '01', 2389 discriminator.format ::= same_as(random_ip_id), 2390 msn ::= control_field, 2391 { base_field ::= counter(16), 2392 compressed_method ::= lsb(1, -1) 2393 }, 2394 header_crc ::= crc(3), 2395 tcp_seq_number ::= lsb(12, 1023), 2396 tcp_ack_number ::= lsb(2, 0), 2397 tcp_flags_ack ::= value(1, 1), 2398 tcp_flags_psh ::= irregular(1), 2399 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2400 tcp_checksum ::= irregular(16) 2401 }, 2403 co_format_19 ::= discriminator, % 6 bits 2404 msn, % 1 bit 2405 tcp_flags_psh, % 1 bit 2406 tcp_checksum, % 16 bits 2407 header_crc, % 3 bits 2408 tcp_seq_number, % 13 bits 2409 tcp_ecn_and_reserved, % 0 or 8 bits 2410 ip_id, % 0 or 16 bits 2412 { discriminator ::= '110100', 2413 discriminator.format ::= same_as(random_ip_id), 2414 msn ::= control_field, 2415 { base_field ::= counter(16), 2416 compressed_method ::= lsb(1, -1) 2417 }, 2418 header_crc ::= crc(3), 2419 tcp_seq_number ::= lsb(13, 1023), 2420 tcp_flags_ack ::= value(1, 1), 2421 tcp_flags_psh ::= irregular(1), 2422 tcp_flags_rsf ::= value(3, 0), 2423 tcp_checksum ::= irregular(16) 2424 }, 2426 co_format_20 ::= discriminator, % 7 bits 2427 msn, % 1 bit 2428 tcp_checksum, % 16 bits 2429 tcp_flags_psh, % 1 bit 2430 header_crc, % 3 bits 2431 tcp_ack_number, % 12 bits 2432 tcp_ecn_and_reserved, % 0 or 8 bits 2433 ip_id, % 0 or 16 bits 2435 { discriminator ::= '1100010', 2436 discriminator.format ::= same_as(random_ip_id), 2437 msn ::= control_field, 2438 { base_field ::= counter(16), 2439 compressed_method ::= lsb(1, -1) 2440 }, 2441 header_crc ::= crc(3), 2442 tcp_ack_number ::= lsb(12, 0), 2443 tcp_flags_ack ::= value(1, 1), 2444 tcp_flags_psh ::= irregular(1), 2445 tcp_flags_rsf ::= value(3, 0), 2446 tcp_checksum ::= irregular(16) 2447 }, 2449 co_format_21 ::= discriminator, % 6 bits 2450 msn, % 1 bit 2451 tcp_flags_psh, % 1 bit 2452 tcp_checksum, % 16 bits 2453 header_crc, % 3 bits 2454 tcp_seq_number_scaled, % 7 bits 2455 tcp_seq_number_residue, % 0 bit 2456 tcp_ack_number, % 14 bits 2457 tcp_ecn_and_reserved, % 0 or 8 bits 2458 ip_id, % 0 or 16 bits 2460 { discriminator ::= '110111', 2461 discriminator.format ::= same_as(random_ip_id), 2462 msn ::= control_field, 2463 { base_field ::= counter(16), 2464 compressed_method ::= lsb(1, -1) 2465 }, 2466 header_crc ::= crc(3), 2467 tcp_ack_number ::= lsb(14, 0), 2468 tcp_flags_ack ::= value(1, 1), 2469 tcp_flags_psh ::= irregular(1), 2470 tcp_flags_rsf ::= value(3, 0), 2471 tcp_checksum ::= irregular(16), 2472 tcp_seq_number_scaled ::= control_field, 2473 { base_field ::= 2474 expression(uncomp(tcp_ip.tcp_seq_number) // 2475 uncomp(tcp_ip.tcp_payload_size)), 2476 compressed_method ::= lsb(7, 63) 2477 } 2478 }, 2480 co_format_22 ::= discriminator, % 7 bits 2481 tcp_flags_psh, % 1 bit 2482 tcp_checksum, % 16 bits 2483 msn, % 2 bits 2484 tcp_ack_number, % 14 bits 2485 header_crc, % 3 bits 2486 tcp_seq_number, % 13 bits 2487 tcp_ecn_and_reserved, % 0 or 8 bits 2488 ip_id, % 0 or 16 bits 2490 { discriminator ::= '1101101', 2491 discriminator.format ::= same_as(random_ip_id), 2492 msn ::= control_field, 2493 { base_field ::= counter(16), 2494 compressed_method ::= lsb(2, -1) 2495 }, 2496 header_crc ::= crc(3), 2497 tcp_seq_number ::= lsb(13, 1023), 2498 tcp_ack_number ::= lsb(14, 0), 2499 tcp_flags_ack ::= value(1, 1), 2500 tcp_flags_psh ::= irregular(1), 2501 tcp_flags_rsf ::= value(3, 0), 2502 tcp_checksum ::= irregular(16) 2503 }, 2505 co_format_23 ::= discriminator, % 7 bits 2506 tcp_flags_psh, % 1 bit 2507 ip_ttl, % 8 bits 2508 tcp_checksum, % 16 bits 2509 msn, % 2 bits 2510 tcp_ack_number, % 2 bits 2511 header_crc, % 7 bits 2512 tcp_seq_number, % 13 bits 2513 tcp_ecn_and_reserved, % 0 or 8 bits 2514 ip_id, % 0 or 16 bits 2516 { discriminator ::= '1100000', 2517 discriminator.format ::= same_as(random_ip_id), 2518 msn ::= control_field, 2519 { base_field ::= counter(16), 2520 compressed_method ::= lsb(2, -1) 2521 }, 2522 header_crc ::= crc(7), 2523 ip_ttl ::= irregular(8), 2524 tcp_seq_number ::= lsb(13, 1023), 2525 tcp_ack_number ::= lsb(2, 0), 2526 tcp_flags_ack ::= value(1, 1), 2527 tcp_flags_psh ::= irregular(1), 2528 tcp_flags_rsf ::= value(3, 0), 2529 tcp_checksum ::= irregular(16) 2531 }, 2533 co_format_24 ::= discriminator, % 5 bits 2534 msn, % 1 bit 2535 tcp_flags_psh, % 1 bit 2536 header_crc, % 7 bits 2537 tcp_seq_number_scaled, % 7 bits 2538 tcp_seq_number_residue, % 0 bits 2539 tcp_window, % 13 bits 2540 tcp_ack_number, % 14 bits 2541 tcp_checksum, % 16 bits 2542 tcp_ecn_and_reserved, % 0 or 8 bits 2543 ip_id, % 0 or 16 bits 2545 { discriminator ::= '11001', 2546 discriminator.format ::= same_as(random_ip_id), 2547 msn ::= control_field, 2548 { base_field ::= counter(16), 2549 compressed_method ::= lsb(1, -1) 2550 }, 2551 header_crc ::= crc(7), 2552 tcp_ack_number ::= lsb(14, 0), 2553 tcp_flags_ack ::= value(1, 1), 2554 tcp_flags_psh ::= irregular(1), 2555 tcp_flags_rsf ::= value(3, 0), 2556 tcp_window ::= lsb(13, 2047), 2557 tcp_checksum ::= irregular(16), 2558 tcp_seq_number_scaled ::= control_field, 2559 { base_field ::= 2560 expression(uncomp(tcp_ip.tcp_seq_number) // 2561 uncomp(tcp_ip.tcp_payload_size)), 2562 compressed_method ::= lsb(7, 63) 2563 } 2564 }, 2566 co_format_25 ::= discriminator, % 9 bits 2567 msn, % 1 bit 2568 tcp_flags_psh, % 1 bit 2569 tcp_seq_number, % 2 bits 2570 header_crc, % 3 bits 2571 tcp_ack_number, % 32 bits 2572 tcp_checksum, % 16 bits 2573 tcp_ecn_and_reserved, % 0 or 8 bits 2574 ip_id, % 0 or 16 bits 2576 { discriminator ::= '110110001', 2577 discriminator.format ::= same_as(random_ip_id), 2578 msn ::= control_field, 2579 { base_field ::= counter(16), 2580 compressed_method ::= lsb(1, -1) 2581 }, 2583 header_crc ::= crc(3), 2584 tcp_seq_number ::= lsb(2, 0), 2585 tcp_ack_number ::= irregular(32), 2586 tcp_flags_ack ::= value(1, 1), 2587 tcp_flags_psh ::= irregular(1), 2588 tcp_flags_rsf ::= value(3, 0), 2589 tcp_checksum ::= irregular(16) }, 2591 co_format_26 ::= discriminator, % 2 bits 2592 msn, % 1 bit 2593 tcp_window, % 13 bits 2594 tcp_checksum, % 16 bits 2595 tcp_flags_psh, % 1 bit 2596 header_crc, % 7 bits 2597 tcp_seq_number, % 12 bits 2598 tcp_ack_number, % 12 bits 2599 tcp_ecn_and_reserved, % 0 or 8 bits 2600 ip_id, % 0 or 16 bits 2602 { discriminator ::= '00', 2603 discriminator.format ::= same_as(random_ip_id), 2604 msn ::= control_field, 2605 { base_field ::= counter(16), 2606 compressed_method ::= lsb(1, -1) 2607 }, 2608 header_crc ::= crc(7), 2609 tcp_seq_number ::= lsb(12, 1023), 2610 tcp_ack_number ::= lsb(12, 0), 2611 tcp_flags_ack ::= value(1, 1), 2612 tcp_flags_psh ::= irregular(1), 2613 tcp_flags_rsf ::= value(3, 0), 2614 tcp_window ::= lsb(13, 2047), 2615 tcp_checksum ::= irregular(16) }, 2617 co_format_27 ::= discriminator, % 7 bits 2618 msn, % 1 bit 2619 tcp_window, % 16 bits 2620 tcp_checksum, % 16 bits 2621 tcp_flags_psh, % 1 bit 2622 header_crc, % 7 bits 2623 tcp_flags_rsf, % 3 bits 2624 tcp_seq_number_scaled, % 7 bits 2625 tcp_seq_number_residue, % 0 bit 2626 tcp_ack_number, % 14 bits 2627 tcp_ecn_and_reserved, % 0 or 8 bits 2628 ip_id, % 0 or 16 bits 2630 { discriminator ::= '1100011', 2631 discriminator.format ::= same_as(random_ip_id), 2632 msn ::= control_field, 2633 { base_field ::= counter(16), 2634 compressed_method ::= lsb(1, -1) 2635 }, 2636 header_crc ::= crc(7), 2637 tcp_ack_number ::= lsb(14, 0), 2638 tcp_flags_ack ::= value(1, 1), 2639 tcp_flags_psh ::= irregular(1), 2640 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2641 tcp_window ::= irregular(16), 2642 tcp_checksum ::= irregular(16), 2643 tcp_seq_number_scaled ::= control_field, 2644 { base_field ::= 2645 expression(uncomp(tcp_ip.tcp_seq_number) // 2646 uncomp(tcp_ip.tcp_payload_size)), 2647 compressed_method ::= lsb(7, 63) 2648 } 2649 }, 2651 co_format_28 ::= discriminator, % 7 bits 2652 tcp_flags_psh, % 1 bit 2653 ip_ttl, % 8 bits 2654 tcp_checksum, % 16 bits 2655 msn, % 2 bits 2656 tcp_ack_number, % 14 bits 2657 tcp_seq_number_scaled, % 4 bits 2658 tcp_seq_number_residue, % 0 bit 2659 header_crc, % 7 bits 2660 tcp_window, % 13 bits 2661 tcp_ecn_and_reserved, % 0 or 8 bits 2662 ip_id, % 0 or 16 bits 2664 { discriminator ::= '1100001', 2665 discriminator.format ::= same_as(random_ip_id), 2666 msn ::= control_field, 2667 { base_field ::= counter(16), 2668 compressed_method ::= lsb(2, -1) 2669 }, 2670 header_crc ::= crc(7), 2671 ip_ttl ::= irregular(8), 2672 tcp_ack_number ::= lsb(14, 0), 2673 tcp_flags_ack ::= value(1, 1), 2674 tcp_flags_psh ::= irregular(1), 2675 tcp_flags_rsf ::= value(3, 0), 2676 tcp_window ::= lsb(13, 2047), 2677 tcp_checksum ::= irregular(16), 2678 tcp_seq_number_scaled ::= control_field, 2679 { base_field ::= 2680 expression(uncomp(tcp_ip.tcp_seq_number) // 2681 uncomp(tcp_ip.tcp_payload_size)), 2682 compressed_method ::= lsb(4, 3) 2683 } 2684 }, 2686 co_format_29 ::= discriminator, % 9 bits 2687 header_crc, % 7 bits 2688 ip_ttl, % 8 bits 2689 tcp_window, % 16 bits 2690 tcp_checksum, % 16 bits 2691 ip_dont_frag, % 1 bit 2692 tcp_flags_psh, % 1 bit 2693 ip_tos, % 6 bits 2694 msn, % 2 bits 2695 tcp_ack_number, % 14 bits 2696 tcp_flags_rsf, % 3 bits 2697 tcp_seq_number, % 13 bits 2698 tcp_ecn_and_reserved, % 0 or 8 bits 2699 ip_id, % 0 or 16 bits 2701 { discriminator ::= '110110000', 2702 discriminator.format ::= same_as(random_ip_id), 2703 msn ::= control_field, 2704 { base_field ::= counter(16), 2705 compressed_method ::= lsb(2, -1) 2706 }, 2707 header_crc ::= crc(7), 2708 ip_tos ::= irregular(6), 2709 ip_dont_frag ::= irregular(1), 2710 ip_ttl ::= irregular(8), 2711 tcp_seq_number ::= lsb(13, 1023), 2712 tcp_ack_number ::= lsb(14, 0), 2713 tcp_flags_ack ::= value(1, 1), 2714 tcp_flags_psh ::= irregular(1), 2715 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2716 tcp_window ::= irregular(16), 2717 tcp_checksum ::= irregular(16) 2718 }, 2720 co_format_30 ::= discriminator, % 8 bits 2721 ip_ttl, % 8 bits 2722 tcp_ack_number, % 32 bits 2723 tcp_window, % 16 bits 2724 tcp_checksum, % 16 bits 2725 msn, % 1 bit 2726 header_crc, % 7 bits 2727 tcp_flags_ack, % 1 bit 2728 tcp_flags_psh, % 1 bit 2729 tcp_flags_rsf, % 3 bits 2730 tcp_seq_number_scaled, % 3 bits 2731 tcp_seq_number_residue, % 0 bit 2732 tcp_ecn_and_reserved, % 0 or 8 bits 2733 ip_id, % 0 or 16 bits 2735 { discriminator ::= '11011001', 2736 discriminator.format ::= same_as(random_ip_id), 2737 msn ::= control_field, 2738 { base_field ::= counter(16), 2739 compressed_method ::= lsb(1, -1) 2740 }, 2741 header_crc ::= crc(7), 2742 ip_ttl ::= irregular(8), 2743 tcp_ack_number ::= irregular(32), 2744 tcp_flags_ack ::= irregular(1), 2745 tcp_flags_psh ::= irregular(1), 2746 tcp_flags_rsf ::= index(3, [0, 1, 2, 4]), 2747 tcp_window ::= irregular(16), 2748 tcp_checksum ::= irregular(16), 2749 tcp_seq_number_scaled ::= control_field, 2750 { base_field ::= 2751 expression(uncomp(tcp_ip.tcp_seq_number) // 2752 uncomp(tcp_ip.tcp_payload_size)), 2753 compressed_method ::= lsb(3, 3) 2754 } 2755 }, 2757 co_common ::= tcp_payload_size, % 0 bit 2758 tcp_options, % variable no. of bits 2760 { tcp_payload_size ::= expression(uncomp(tcp_ip.ip_length) - 2761 ((uncomp(tcp_ip.ip_header_length) + 2762 uncomp(tcp_ip.tcp_data_offset)) * 4)) 2763 }, 2765 6.6. Feedback formats and options 2767 6.6.1. Feedback formats 2769 This section describes the feedback format for ROHC-TCP. ROHC-TCP 2770 uses the ROHC feedback format described in [ROHC, section 5.2.2]. 2772 All feedback formats carry a field labeled SN. The SN field contains 2773 LSBs of the Master Sequence Number (MSN) described in section 4.1.3. 2774 The sequence number to use is the MSN corresponding to the header 2775 that caused the feedback information to be sent. If that MSN cannot 2776 be determined, for example when decompression fails, the MSN to use 2777 is that corresponding to the latest successfully decompressed header. 2779 FEEDBACK-1 2781 0 1 2 3 4 5 6 7 2782 +---+---+---+---+---+---+---+---+ 2783 | MSN | 2784 +---+---+---+---+---+---+---+---+ 2786 MSN: The lsb-encoded master sequence number. 2788 A FEEDBACK-1 is an ACK. In order to send a NACK or a STATIC-NACK, 2789 FEEDBACK-2 must be used. 2791 FEEDBACK-2 2793 0 1 2 3 4 5 6 7 2794 +---+---+---+---+---+---+---+---+ 2795 |Acktype| MSN | 2796 +---+---+---+---+---+---+---+---+ 2797 | MSN | 2798 +---+---+---+---+---+---+---+---+ 2799 / Feedback options / 2800 +---+---+---+---+---+---+---+---+ 2802 Acktype: 0 = ACK 2803 1 = NACK 2804 2 = STATIC-NACK 2805 3 is reserved (MUST NOT be used for parseability) 2807 MSN: The lsb-encoded master sequence number. 2809 Feedback options: A variable number of feedback options, see 2810 section 5.5.4.2. Options may appear in any order. 2812 6.6.2. Feedback options 2814 ROHC-TCP uses the same feedback options as the options defined in 2815 [RFC-3095, section 5.7.6], with the following exceptions: 2817 1) The MSN replaces RTP SN in the feedback information. 2818 2) The CLOCK option [RFC-3095, section 5.7.6.6] is not used. 2819 3) The JITTER option [RFC-3095, section 5.7.6.7] is not used. 2821 6.6.3. The CONTEXT_MEMORY Feedback Option 2823 The CONTEXT_MEMORY option informs the compressor that the 2824 decompressor does not have sufficient memory resources to handle the 2825 context of the packet stream, as the stream is currently compressed. 2827 0 1 2 3 4 5 6 7 2828 +---+---+---+---+---+---+---+---+ 2829 | Opt Type = X | Opt Len = 0 | 2830 +---+---+---+---+---+---+---+---+ 2832 When receiving a CONTEXT_MEMORY option, the compressor SHOULD take 2833 actions to compress the packet stream in a way that requires less 2834 decompressor memory resources, or stop compressing the packet stream. 2836 7. Security considerations 2838 Because encryption eliminates the redundancy that header compression 2839 schemes try to exploit, there is some inducement to forego encryption 2840 of headers in order to enable operation over low-bandwidth links. 2841 However, for those cases where encryption of data (and not headers) 2842 is sufficient, TCP does specify an alternative encryption method in 2843 which only the TCP payload is encrypted and the headers are left in 2844 the clear. That would still allow header compression to be applied. 2846 A malfunctioning or malicious header compressor could cause the 2847 header decompressor to reconstitute packets that do not match the 2848 original packets but still have valid IP, and TCP headers and 2849 possibly also valid TCP checksums. Such corruption may be detected 2850 with end-to-end authentication and integrity mechanisms which will 2851 not be affected by the compression. Moreover, this header 2852 compression scheme uses an internal checksum for verification of 2853 reconstructed headers. This reduces the probability of producing 2854 decompressed headers not matching the original ones without this 2855 being noticed. 2857 Denial-of-service attacks are possible if an intruder can introduce 2858 (for example) bogus IR, CO or FEEDBACK packets onto the link and 2859 thereby cause compression efficiency to be reduced. However, an 2860 intruder having the ability to inject arbitrary packets at the link 2861 layer in this manner raises additional security issues that dwarf 2862 those related to the use of header compression. 2864 8. IANA Considerations 2866 ROHC profile identifier 0x00XX <# Editor's Note: To be replaced 2867 before publication #> has been reserved by the IANA for the profile 2868 defined in this document. 2869 <# Editor's Note: To be removed before publication #> 2871 A ROHC profile identifier must be reserved by the IANA for the 2872 profile defined in this document. Profiles 0x0000-0x0005 have 2873 previously been reserved, which means this profile could be 0x0006. 2874 As for previous ROHC profiles, profile numbers 0xnnXX must also be 2875 reserved for future updates of this profile. A suggested 2876 registration in the "RObust Header Compression (ROHC) Profile 2877 Identifiers" name space would then be: 2879 Profile Usage Document 2880 identifier 2882 0x0006 ROHC TCP [RFCXXXX (this)] 2883 0xnn06 Reserved 2885 9. Acknowledgements 2887 The authors would like to thank Qian Zhang and Hong Bin Liao for 2888 their work with early versions of this specification. Thanks also to 2889 Kristofer Sandlund and Fredrik Lindstroem for reviewing the packet 2890 formats, and to Carsten Bormann and Robert Finking for valuable 2891 input. 2893 10. References 2895 10.1. Normative References 2897 [RFC-3095] Bormann, C., Burmeister, C., Degermark, M., Fukushima, 2898 H., Hannu, H., Jonsson, L-E., Hakenberg, R., Koren, T., 2899 Le, K., Liu, Z., Martensson, A., Miyazaki, A., Svanbro, 2900 K., Wiebke, T., Yoshimura, T. and H. Zheng, "RObust 2901 Header Compression (ROHC): Framework and four profiles: 2902 RTP, UDP, ESP, and uncompressed", RFC 3095, July 2001. 2904 [ROHC-CR] Pelletier, G., "Robust Header Compression (ROHC): Context 2905 replication for ROHC profiles", Internet Draft (work in 2906 progress), , April 2004. 2909 [ROHC-FN] R. Price et al., "Formal Notation for Robust Header 2910 Compression (ROHC-FN)", Internet Draft (work in 2911 progress),, 2912 October 2003. 2914 [RFC-791] Postel, J., "Internet Protocol", STD 5, RFC 791, 2915 September 1981. 2917 [RFC-793] Postel, J., "Transmission Control Protocol", STD 7, RFC 2918 793, September 1981. 2920 [RFC-2026] S. Bradner, "The Internet Standards Process - 2921 Revision 3", RFC-2026, October 1996. 2923 [RFC-2119] S. Bradner, "Key words for use in RFCs to Indicate 2924 Requirement Levels", RFC 2119, March 1997. 2926 [RFC-2460] Deering, S. and R. Hinden, "Internet Protocol, Version 6 2927 (IPv6) Specification", RFC 2460, December 1998. 2929 10.2. Informative References 2931 [TCP-REQ] Jonsson, L-E., "Requirements on ROHC IP/TCP header 2932 compression", Internet Draft (work in progress),, October 2002. 2935 [TCP-BEH] West, M. and S. McCann, "TCP/IP Field Behavior", Internet 2936 Draft (work in progress), , March 2003. 2939 [IP-ONLY] Jonsson, L. and G. Pelletier, "RObust Header Compression 2940 (ROHC): A compression profile for IP", Internet draft 2941 (work in progress), , 2942 October 2003. 2944 [RFC-1072] Jacobson, V., and R. Braden, "TCP Extensions for Long- 2945 Delay Paths", LBL, ISI, October 1988. 2947 [RFC-1144] Jacobson, V.,"Compressing TCP/IP Headers for Low-Speed 2948 Serial Links", RFC 1144, February 1990. 2950 [RFC-1323] Jacobson, V., Braden, R. and D. Borman, "TCP Extensions 2951 for High Performance", RFC 1323, May 1992. 2953 [RFC-1644] Braden, R. "T/TCP -- TCP Extensions for Transactions 2954 Functional Specification", ISI, July 1994. 2956 [RFC-1693] Connolly, T., et al, "An Extension to TCP : Partial Order 2957 Service", University of Delaware, November 1994. 2959 [RFC-1889] Schulzrinne, H., Casner, S., Frederick, R. and V. 2960 Jacobson, "RTP: A Transport Protocol for Real-Time 2961 Applications", RFC 1889, January 1996. 2963 [RFC-1948] Bellovin, S., "Defending Against Sequence Number 2964 Attacks", RFC 1948, May 1996. 2966 [RFC-2001] Stevens, W., "TCP Slow Start, Congestion Avoidance, Fast 2967 Retransmit, and Fast Recovery Algorithms", NOAO, January 2968 1997. 2970 [RFC-2018] Mathis, M., Mahdavi, J., Floyd, S., and A. Romanow, "TCP 2971 Selective Acknowledgment Options", RFC 2018, October 2972 1996. 2974 [RFC-2507] Degermark, M., Nordgren, B. and S. Pink, "IP Header 2975 Compression", RFC 2507, February 1999. 2977 [RFC-2883] Floyd, S., Mahdavi, J., Mathis, M. and M. Podolsky, "An 2978 Extension to the Selective Acknowledgement (SACK) Option 2979 for TCP", RFC 2883, July 2000. 2981 [E2E] Jacobson, V., "Fast Retransmit", Message to the end2end- 2982 interest mailing list, April 1990. 2984 [Mobi96] Degermark, M., Engan, M., Nordgren, B. and S. Pink, "Low- 2985 loss TCP/IP header compression for wireless networks", In 2986 the Proceedings of MobiCom, 1996. 2988 11. Authors' addresses 2990 Ghyslain Pelletier 2991 Ericsson AB 2992 Box 920 2993 SE-971 28 Lulea, Sweden 2995 Phone: +46 920 20 24 32 2996 Fax: +46 920 20 20 99 2997 Email: ghyslain.pelletier@ericsson.com 2999 Lars-Erik Jonsson 3000 Ericsson AB 3001 Box 920 3002 SE-971 28 Lulea, Sweden 3004 Phone: +46 920 20 21 07 3005 Fax: +46 920 20 20 99 3006 Email: lars-erik.jonsson@ericsson.com 3007 Mark A West 3008 Roke Manor Research Ltd 3009 Romsey, Hants, SO51 0ZN 3010 United Kingdom 3012 Phone: +44 1794 833311 3013 Email: mark.a.west@roke.co.uk 3015 Richard Price 3016 Roke Manor Research Ltd 3017 Romsey, Hants, SO51 0ZN 3018 United Kingdom 3020 Phone: +44 1794 833681 3021 Email: Richard.price@roke.co.uk 3023 Full Copyright Statement 3025 Copyright (C) The Internet Society (2003). All Rights Reserved. 3027 This document and translations of it may be copied and furnished to 3028 others, and derivative works that comment on or otherwise explain it 3029 or assist in its implementation may be prepared, copied, published 3030 and distributed, in whole or in part, without restriction of any 3031 kind, provided that the above copyright notice and this paragraph are 3032 included on all such copies and derivative works. However, this 3033 document itself may not be modified in any way, such as by removing 3034 the copyright notice or references to the Internet Society or other 3035 Internet organizations, except as needed for the purpose of 3036 developing Internet standards in which case the procedures for 3037 copyrights defined in the Internet Standards process must be 3038 followed, or as required to translate it into languages other than 3039 English. 3041 The limited permissions granted above are perpetual and will not be 3042 revoked by the Internet Society or its successors or assigns. 3044 This document and the information contained herein is provided on an 3045 "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING 3046 TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 3047 BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION 3048 HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF 3049 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 3051 This Internet-Draft expires October 2, 2004.