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);