2 * Routines to compress and uncompess tcp packets (for transmission
3 * over low speed serial lines.
5 * Copyright (c) 1989 Regents of the University of California.
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by the University of California, Berkeley. The name of the
14 * University may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 * $FreeBSD: src/usr.sbin/ppp/slcompress.c,v 1.31.2.2 2002/09/01 02:12:32 brian Exp $
22 * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
23 * - Initial distribution.
26 #include <sys/param.h>
27 #include <netinet/in_systm.h>
28 #include <netinet/in.h>
29 #include <netinet/tcp.h>
30 #include <netinet/ip.h>
31 #include <sys/socket.h>
44 #include "slcompress.h"
45 #include "descriptor.h"
49 #include "throughput.h"
68 sl_compress_init(struct slcompress
*comp
, int max_state
)
71 struct cstate
*tstate
= comp
->tstate
;
73 memset(comp
, '\0', sizeof *comp
);
74 for (i
= max_state
; i
> 0; --i
) {
76 tstate
[i
].cs_next
= &tstate
[i
- 1];
78 tstate
[0].cs_next
= &tstate
[max_state
];
80 comp
->last_cs
= &tstate
[0];
81 comp
->last_recv
= 255;
82 comp
->last_xmit
= 255;
83 comp
->flags
= SLF_TOSS
;
87 /* ENCODE encodes a number that is known to be non-zero. ENCODEZ
88 * checks for zero (since zero has to be encoded in the 32-bit, 3 byte
92 if ((u_short)(n) >= 256) { \
101 #define ENCODEZ(n) { \
102 if ((u_short)(n) >= 256 || (u_short)(n) == 0) { \
112 #define DECODEL(f) { \
114 (f) = htonl(ntohl(f) + ((cp[1] << 8) | cp[2])); \
117 (f) = htonl(ntohl(f) + (u_int32_t)*cp++); \
121 #define DECODES(f) { \
123 (f) = htons(ntohs(f) + ((cp[1] << 8) | cp[2])); \
126 (f) = htons(ntohs(f) + (u_int32_t)*cp++); \
130 #define DECODEU(f) { \
132 (f) = htons((cp[1] << 8) | cp[2]); \
135 (f) = htons((u_int32_t)*cp++); \
141 sl_compress_tcp(struct mbuf
* m
,
143 struct slcompress
*comp
,
144 struct slstat
*slstat
,
147 struct cstate
*cs
= comp
->last_cs
->cs_next
;
148 u_int hlen
= ip
->ip_hl
;
151 u_int deltaS
, deltaA
;
154 u_char
*cp
= new_seq
;
157 * Bail if this is an IP fragment or if the TCP packet isn't `compressible'
158 * (i.e., ACK isn't set or some other control bit is set). (We assume that
159 * the caller has already made sure the packet is IP proto TCP).
161 if ((ip
->ip_off
& htons(0x3fff)) || m
->m_len
< 40) {
162 log_Printf(LogDEBUG
, "??? 1 ip_off = %x, m_len = %lu\n",
163 ip
->ip_off
, (unsigned long)m
->m_len
);
164 log_DumpBp(LogDEBUG
, "", m
);
167 th
= (struct tcphdr
*) & ((int *) ip
)[hlen
];
168 if ((th
->th_flags
& (TH_SYN
| TH_FIN
| TH_RST
| TH_ACK
)) != TH_ACK
) {
169 log_Printf(LogDEBUG
, "??? 2 th_flags = %x\n", th
->th_flags
);
170 log_DumpBp(LogDEBUG
, "", m
);
175 * Packet is compressible -- we're going to send either a COMPRESSED_TCP or
176 * UNCOMPRESSED_TCP packet. Either way we need to locate (or create) the
177 * connection state. Special case the most recently used connection since
178 * it's most likely to be used again & we don't have to do any reordering
181 slstat
->sls_packets
++;
182 if (ip
->ip_src
.s_addr
!= cs
->cs_ip
.ip_src
.s_addr
||
183 ip
->ip_dst
.s_addr
!= cs
->cs_ip
.ip_dst
.s_addr
||
184 *(int *) th
!= ((int *) &cs
->cs_ip
)[cs
->cs_ip
.ip_hl
]) {
187 * Wasn't the first -- search for it.
189 * States are kept in a circularly linked list with last_cs pointing to the
190 * end of the list. The list is kept in lru order by moving a state to
191 * the head of the list whenever it is referenced. Since the list is
192 * short and, empirically, the connection we want is almost always near
193 * the front, we locate states via linear search. If we don't find a
194 * state for the datagram, the oldest state is (re-)used.
197 struct cstate
*lastcs
= comp
->last_cs
;
202 slstat
->sls_searches
++;
203 if (ip
->ip_src
.s_addr
== cs
->cs_ip
.ip_src
.s_addr
204 && ip
->ip_dst
.s_addr
== cs
->cs_ip
.ip_dst
.s_addr
205 && *(int *) th
== ((int *) &cs
->cs_ip
)[cs
->cs_ip
.ip_hl
])
207 } while (cs
!= lastcs
);
210 * Didn't find it -- re-use oldest cstate. Send an uncompressed packet
211 * that tells the other side what connection number we're using for this
212 * conversation. Note that since the state list is circular, the oldest
213 * state points to the newest and we only need to set last_cs to update
216 slstat
->sls_misses
++;
218 #define THOFFSET(th) (th->th_off)
228 * Found it -- move to the front on the connection list.
233 lcs
->cs_next
= cs
->cs_next
;
234 cs
->cs_next
= lastcs
->cs_next
;
235 lastcs
->cs_next
= cs
;
240 * Make sure that only what we expect to change changed. The first line of
241 * the `if' checks the IP protocol version, header length & type of
242 * service. The 2nd line checks the "Don't fragment" bit. The 3rd line
243 * checks the time-to-live and protocol (the protocol check is unnecessary
244 * but costless). The 4th line checks the TCP header length. The 5th line
245 * checks IP options, if any. The 6th line checks TCP options, if any. If
246 * any of these things are different between the previous & current
247 * datagram, we send the current datagram `uncompressed'.
249 oth
= (struct tcphdr
*) & ((int *) &cs
->cs_ip
)[hlen
];
256 if (((u_short
*) ip
)[0] != ((u_short
*) & cs
->cs_ip
)[0] ||
257 ((u_short
*) ip
)[3] != ((u_short
*) & cs
->cs_ip
)[3] ||
258 ((u_short
*) ip
)[4] != ((u_short
*) & cs
->cs_ip
)[4] ||
259 THOFFSET(th
) != THOFFSET(oth
) ||
261 memcmp(ip
+ 1, &cs
->cs_ip
+ 1, (deltaS
- 5) << 2)) ||
263 memcmp(th
+ 1, oth
+ 1, (THOFFSET(th
) - 5) << 2))) {
268 * Figure out which of the changing fields changed. The receiver expects
269 * changes in the order: urgent, window, ack, seq (the order minimizes the
270 * number of temporaries needed in this section of code).
272 if (th
->th_flags
& TH_URG
) {
273 deltaS
= ntohs(th
->th_urp
);
276 } else if (th
->th_urp
!= oth
->th_urp
) {
279 * argh! URG not set but urp changed -- a sensible implementation should
280 * never do this but RFC793 doesn't prohibit the change so we have to
285 deltaS
= (u_short
) (ntohs(th
->th_win
) - ntohs(oth
->th_win
));
290 deltaA
= ntohl(th
->th_ack
) - ntohl(oth
->th_ack
);
292 if (deltaA
> 0xffff) {
298 deltaS
= ntohl(th
->th_seq
) - ntohl(oth
->th_seq
);
300 if (deltaS
> 0xffff) {
311 * Nothing changed. If this packet contains data and the last one didn't,
312 * this is probably a data packet following an ack (normal on an
313 * interactive connection) and we send it compressed. Otherwise it's
314 * probably a retransmit, retransmitted ack or window probe. Send it
315 * uncompressed in case the other side missed the compressed version.
317 if (ip
->ip_len
!= cs
->cs_ip
.ip_len
&&
318 ntohs(cs
->cs_ip
.ip_len
) == hlen
)
327 * actual changes match one of our special case encodings -- send packet
333 if (deltaS
== deltaA
&&
334 deltaS
== ntohs(cs
->cs_ip
.ip_len
) - hlen
) {
335 /* special case for echoed terminal traffic */
342 if (deltaS
== ntohs(cs
->cs_ip
.ip_len
) - hlen
) {
343 /* special case for data xfer */
350 deltaS
= ntohs(ip
->ip_id
) - ntohs(cs
->cs_ip
.ip_id
);
355 if (th
->th_flags
& TH_PUSH
)
356 changes
|= TCP_PUSH_BIT
;
359 * Grab the cksum before we overwrite it below. Then update our state with
360 * this packet's header.
362 deltaA
= ntohs(th
->th_sum
);
363 memcpy(&cs
->cs_ip
, ip
, hlen
);
366 * We want to use the original packet as our compressed packet. (cp -
367 * new_seq) is the number of bytes we need for compressed sequence numbers.
368 * In addition we need one byte for the change mask, one for the connection
369 * id and two for the tcp checksum. So, (cp - new_seq) + 4 bytes of header
370 * are needed. hlen is how many bytes of the original packet to toss so
371 * subtract the two to get the new packet size.
373 deltaS
= cp
- new_seq
;
377 * Since fastq traffic can jump ahead of the background traffic, we don't
378 * know what order packets will go on the line. In this case, we always
379 * send a "new" connection id so the receiver state stays synchronized.
381 if (comp
->last_xmit
== cs
->cs_id
&& compress_cid
) {
386 comp
->last_xmit
= cs
->cs_id
;
389 *cp
++ = changes
| NEW_C
;
396 memcpy(cp
, new_seq
, deltaS
);
397 slstat
->sls_compressed
++;
398 return (TYPE_COMPRESSED_TCP
);
401 * Update connection state cs & send uncompressed packet ('uncompressed'
402 * means a regular ip/tcp packet but with the 'conversation id' we hope to
403 * use on future compressed packets in the protocol field).
406 memcpy(&cs
->cs_ip
, ip
, hlen
);
407 ip
->ip_p
= cs
->cs_id
;
408 comp
->last_xmit
= cs
->cs_id
;
409 return (TYPE_UNCOMPRESSED_TCP
);
414 sl_uncompress_tcp(u_char
** bufp
, int len
, u_int type
, struct slcompress
*comp
,
415 struct slstat
*slstat
, int max_state
)
426 case TYPE_UNCOMPRESSED_TCP
:
427 ip
= (struct ip
*) * bufp
;
428 if (ip
->ip_p
> max_state
)
430 cs
= &comp
->rstate
[comp
->last_recv
= ip
->ip_p
];
431 comp
->flags
&= ~SLF_TOSS
;
432 ip
->ip_p
= IPPROTO_TCP
;
435 * Calculate the size of the TCP/IP header and make sure that we don't
436 * overflow the space we have available for it.
438 hlen
= ip
->ip_hl
<< 2;
439 if ((int)(hlen
+ sizeof(struct tcphdr
)) > len
)
441 th
= (struct tcphdr
*) & ((char *) ip
)[hlen
];
442 hlen
+= THOFFSET(th
) << 2;
445 memcpy(&cs
->cs_ip
, ip
, hlen
);
447 slstat
->sls_uncompressedin
++;
453 case TYPE_COMPRESSED_TCP
:
457 /* We've got a compressed packet. */
458 slstat
->sls_compressedin
++;
461 log_Printf(LogDEBUG
, "compressed: changes = %02x\n", changes
);
463 if (changes
& NEW_C
) {
465 * Make sure the state index is in range, then grab the state. If we have
466 * a good state index, clear the 'discard' flag.
468 if (*cp
> max_state
|| comp
->last_recv
== 255)
471 comp
->flags
&= ~SLF_TOSS
;
472 comp
->last_recv
= *cp
++;
475 * this packet has an implicit state index. If we've had a line error
476 * since the last time we got an explicit state index, we have to toss
479 if (comp
->flags
& SLF_TOSS
) {
480 slstat
->sls_tossed
++;
484 cs
= &comp
->rstate
[comp
->last_recv
];
485 hlen
= cs
->cs_ip
.ip_hl
<< 2;
486 th
= (struct tcphdr
*) & ((u_char
*) & cs
->cs_ip
)[hlen
];
487 th
->th_sum
= htons((*cp
<< 8) | cp
[1]);
489 if (changes
& TCP_PUSH_BIT
)
490 th
->th_flags
|= TH_PUSH
;
492 th
->th_flags
&= ~TH_PUSH
;
494 switch (changes
& SPECIALS_MASK
) {
499 i
= ntohs(cs
->cs_ip
.ip_len
) - cs
->cs_hlen
;
500 th
->th_ack
= htonl(ntohl(th
->th_ack
) + i
);
501 th
->th_seq
= htonl(ntohl(th
->th_seq
) + i
);
506 th
->th_seq
= htonl(ntohl(th
->th_seq
) + ntohs(cs
->cs_ip
.ip_len
)
511 if (changes
& NEW_U
) {
512 th
->th_flags
|= TH_URG
;
515 th
->th_flags
&= ~TH_URG
;
520 if (changes
& NEW_S
) {
521 log_Printf(LogDEBUG
, "NEW_S: %02x, %02x, %02x\n",
527 if (changes
& NEW_I
) {
528 DECODES(cs
->cs_ip
.ip_id
)
530 cs
->cs_ip
.ip_id
= htons(ntohs(cs
->cs_ip
.ip_id
) + 1);
532 log_Printf(LogDEBUG
, "Uncompress: id = %04x, seq = %08lx\n",
533 cs
->cs_ip
.ip_id
, (u_long
)ntohl(th
->th_seq
));
536 * At this point, cp points to the first byte of data in the packet.
537 * Back up cp by the tcp/ip header length to make room for the
538 * reconstructed header (we assume the packet we were handed has enough
539 * space to prepend 128 bytes of header). Adjust the length to account
540 * for the new header & fill in the IP total length.
545 * we must have dropped some characters (crc should detect this but the
546 * old slip framing won't)
550 *bufp
= cp
- cs
->cs_hlen
;
552 cs
->cs_ip
.ip_len
= htons(len
);
554 /* recompute the ip header checksum */
555 cs
->cs_ip
.ip_sum
= 0;
556 bp
= (u_short
*)&cs
->cs_ip
;
557 for (changes
= 0; hlen
> 0; hlen
-= 2)
559 changes
= (changes
& 0xffff) + (changes
>> 16);
560 changes
= (changes
& 0xffff) + (changes
>> 16);
561 cs
->cs_ip
.ip_sum
= ~changes
;
563 /* And copy the result into our buffer */
564 memcpy(*bufp
, &cs
->cs_ip
, cs
->cs_hlen
);
568 comp
->flags
|= SLF_TOSS
;
569 slstat
->sls_errorin
++;
574 sl_Show(struct cmdargs
const *arg
)
576 prompt_Printf(arg
->prompt
, "VJ compression statistics:\n");
577 prompt_Printf(arg
->prompt
, " Out: %d (compress) / %d (total)",
578 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_compressed
,
579 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_packets
);
580 prompt_Printf(arg
->prompt
, " %d (miss) / %d (search)\n",
581 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_misses
,
582 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_searches
);
583 prompt_Printf(arg
->prompt
, " In: %d (compress), %d (uncompress)",
584 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_compressedin
,
585 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_uncompressedin
);
586 prompt_Printf(arg
->prompt
, " %d (error), %d (tossed)\n",
587 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_errorin
,
588 arg
->bundle
->ncp
.ipcp
.vj
.slstat
.sls_tossed
);