FreeBSD/Linux Kernel Cross Reference
sys/net/slcompress.c
1 /* $NetBSD: slcompress.c,v 1.41 2019/04/06 08:38:23 msaitoh Exp $ */
2 /* Id: slcompress.c,v 1.3 1996/05/24 07:04:47 paulus Exp */
3
4 /*
5 * Copyright (c) 1989, 1993, 1994
6 * The Regents of the University of California. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * @(#)slcompress.c 8.2 (Berkeley) 4/16/94
33 */
34
35 /*
36 * Routines to compress and uncompess tcp packets (for transmission
37 * over low speed serial lines.
38 *
39 * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
40 * - Initial distribution.
41 */
42
43 #include <sys/cdefs.h>
44 __KERNEL_RCSID(0, "$NetBSD: slcompress.c,v 1.41 2019/04/06 08:38:23 msaitoh Exp $");
45
46 #ifdef _KERNEL_OPT
47 #include "opt_inet.h"
48 #endif
49
50 #ifdef INET
51 #include <sys/param.h>
52 #include <sys/mbuf.h>
53 #include <sys/systm.h>
54 #include <sys/module.h>
55
56 #include <netinet/in.h>
57 #include <netinet/in_systm.h>
58 #include <netinet/ip.h>
59 #include <netinet/tcp.h>
60
61 #include <net/slcompress.h>
62
63 #ifndef SL_NO_STATS
64 #define INCR(counter) ++comp->counter;
65 #else
66 #define INCR(counter)
67 #endif
68
69
70 void
71 sl_compress_init(struct slcompress *comp)
72 {
73 u_int i;
74 struct cstate *tstate = comp->tstate;
75
76 memset(comp, 0, sizeof(*comp));
77 for (i = MAX_STATES - 1; i > 0; --i) {
78 tstate[i].cs_id = i;
79 tstate[i].cs_next = &tstate[i - 1];
80 }
81 tstate[0].cs_next = &tstate[MAX_STATES - 1];
82 tstate[0].cs_id = 0;
83 comp->last_cs = &tstate[0];
84 comp->last_recv = 255;
85 comp->last_xmit = 255;
86 comp->flags = SLF_TOSS;
87 }
88
89
90 /*
91 * Like sl_compress_init, but we get to specify the maximum connection
92 * ID to use on transmission.
93 */
94 void
95 sl_compress_setup(struct slcompress *comp, int max_state)
96 {
97 u_int i;
98 struct cstate *tstate = comp->tstate;
99
100 if (max_state == -1) {
101 max_state = MAX_STATES - 1;
102 memset(comp, 0, sizeof(*comp));
103 } else {
104 /* Don't reset statistics */
105 memset(comp->tstate, 0, sizeof(comp->tstate));
106 memset(comp->rstate, 0, sizeof(comp->rstate));
107 }
108 for (i = max_state; i > 0; --i) {
109 tstate[i].cs_id = i;
110 tstate[i].cs_next = &tstate[i - 1];
111 }
112 tstate[0].cs_next = &tstate[max_state];
113 tstate[0].cs_id = 0;
114 comp->last_cs = &tstate[0];
115 comp->last_recv = 255;
116 comp->last_xmit = 255;
117 comp->flags = SLF_TOSS;
118 }
119
120
121 /*
122 * ENCODE encodes a number that is known to be non-zero. ENCODEZ checks for
123 * zero (since zero has to be encoded in the long, 3 byte form).
124 */
125 #define ENCODE(n) { \
126 if ((uint16_t)(n) >= 256) { \
127 *cp++ = 0; \
128 cp[1] = (n); \
129 cp[0] = (n) >> 8; \
130 cp += 2; \
131 } else { \
132 *cp++ = (n); \
133 } \
134 }
135 #define ENCODEZ(n) { \
136 if ((uint16_t)(n) >= 256 || (uint16_t)(n) == 0) { \
137 *cp++ = 0; \
138 cp[1] = (n); \
139 cp[0] = (n) >> 8; \
140 cp += 2; \
141 } else { \
142 *cp++ = (n); \
143 } \
144 }
145
146 #define DECODEL(f) { \
147 if (*cp == 0) {\
148 (f) = htonl(ntohl(f) + ((cp[1] << 8) | cp[2])); \
149 cp += 3; \
150 } else { \
151 (f) = htonl(ntohl(f) + (uint32_t)*cp++); \
152 } \
153 }
154
155 #define DECODES(f) { \
156 if (*cp == 0) {\
157 (f) = htons(ntohs(f) + ((cp[1] << 8) | cp[2])); \
158 cp += 3; \
159 } else { \
160 (f) = htons(ntohs(f) + (uint32_t)*cp++); \
161 } \
162 }
163
164 #define DECODEU(f) { \
165 if (*cp == 0) {\
166 (f) = htons((cp[1] << 8) | cp[2]); \
167 cp += 3; \
168 } else { \
169 (f) = htons((uint32_t)*cp++); \
170 } \
171 }
172
173 u_int
174 sl_compress_tcp(struct mbuf *m, struct ip *ip, struct slcompress *comp,
175 int compress_cid)
176 {
177 struct cstate *cs = comp->last_cs->cs_next;
178 u_int hlen = ip->ip_hl;
179 struct tcphdr *oth;
180 struct tcphdr *th;
181 u_int deltaS, deltaA;
182 u_int changes = 0;
183 u_char new_seq[16];
184 u_char *cp = new_seq;
185
186 /*
187 * Bail if this is an IP fragment or if the TCP packet isn't
188 * `compressible' (i.e., ACK isn't set or some other control bit is
189 * set). (We assume that the caller has already made sure the
190 * packet is IP proto TCP).
191 */
192 if ((ip->ip_off & htons(0x3fff)) || m->m_len < 40)
193 return TYPE_IP;
194
195 th = (struct tcphdr *)&((int32_t *)ip)[hlen];
196 if ((th->th_flags & (TH_SYN|TH_FIN|TH_RST|TH_ACK)) != TH_ACK)
197 return TYPE_IP;
198 /*
199 * Packet is compressible -- we're going to send either a
200 * COMPRESSED_TCP or UNCOMPRESSED_TCP packet. Either way we need
201 * to locate (or create) the connection state. Special case the
202 * most recently used connection since it's most likely to be used
203 * again & we don't have to do any reordering if it's used.
204 */
205 INCR(sls_packets)
206 if (ip->ip_src.s_addr != cs->cs_ip.ip_src.s_addr ||
207 ip->ip_dst.s_addr != cs->cs_ip.ip_dst.s_addr ||
208 *(int32_t *)th != ((int32_t *)&cs->cs_ip)[cs->cs_ip.ip_hl]) {
209 /*
210 * Wasn't the first -- search for it.
211 *
212 * States are kept in a circularly linked list with last_cs
213 * pointing to the end of the list. The list is kept in lru
214 * order by moving a state to the head of the list whenever it
215 * is referenced. Since the list is short and, empirically,
216 * the connection we want is almost always near the front, we
217 * locate states via linear search. If we don't find a state
218 * for the datagram, the oldest state is (re-)used.
219 */
220 struct cstate *lcs;
221 struct cstate *lastcs = comp->last_cs;
222
223 do {
224 lcs = cs; cs = cs->cs_next;
225 INCR(sls_searches)
226 if (ip->ip_src.s_addr == cs->cs_ip.ip_src.s_addr
227 && ip->ip_dst.s_addr == cs->cs_ip.ip_dst.s_addr
228 && *(int32_t *)th ==
229 ((int32_t *)&cs->cs_ip)[cs->cs_ip.ip_hl])
230 goto found;
231 } while (cs != lastcs);
232
233 /*
234 * Didn't find it -- re-use oldest cstate. Send an
235 * uncompressed packet that tells the other side what
236 * connection number we're using for this conversation.
237 * Note that since the state list is circular, the oldest
238 * state points to the newest and we only need to set
239 * last_cs to update the lru linkage.
240 */
241 INCR(sls_misses)
242 comp->last_cs = lcs;
243 hlen += th->th_off;
244 hlen <<= 2;
245 if (hlen > m->m_len)
246 return TYPE_IP;
247 goto uncompressed;
248
249 found:
250 /* Found it -- move to the front on the connection list. */
251 if (cs == lastcs)
252 comp->last_cs = lcs;
253 else {
254 lcs->cs_next = cs->cs_next;
255 cs->cs_next = lastcs->cs_next;
256 lastcs->cs_next = cs;
257 }
258 }
259
260 /*
261 * Make sure that only what we expect to change changed. The first
262 * line of the `if' checks the IP protocol version, header length &
263 * type of service. The 2nd line checks the "Don't fragment" bit.
264 * The 3rd line checks the time-to-live and protocol (the protocol
265 * check is unnecessary but costless). The 4th line checks the TCP
266 * header length. The 5th line checks IP options, if any. The 6th
267 * line checks TCP options, if any. If any of these things are
268 * different between the previous & current datagram, we send the
269 * current datagram `uncompressed'.
270 */
271 oth = (struct tcphdr *)&((int32_t *)&cs->cs_ip)[hlen];
272 deltaS = hlen;
273 hlen += th->th_off;
274 hlen <<= 2;
275 if (hlen > m->m_len)
276 return TYPE_IP;
277
278 if (((uint16_t *)ip)[0] != ((uint16_t *)&cs->cs_ip)[0] ||
279 ((uint16_t *)ip)[3] != ((uint16_t *)&cs->cs_ip)[3] ||
280 ((uint16_t *)ip)[4] != ((uint16_t *)&cs->cs_ip)[4] ||
281 th->th_off != oth->th_off ||
282 (deltaS > 5 &&
283 memcmp(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2)) ||
284 (th->th_off > 5 &&
285 memcmp(th + 1, oth + 1, (th->th_off - 5) << 2)))
286 goto uncompressed;
287
288 /*
289 * Figure out which of the changing fields changed. The receiver
290 * expects changes in the order: urgent, window, ack, seq (the order
291 * minimizes the number of temporaries needed in this section of code).
292 */
293 if (th->th_flags & TH_URG) {
294 deltaS = ntohs(th->th_urp);
295 ENCODEZ(deltaS);
296 changes |= NEW_U;
297 } else if (th->th_urp != oth->th_urp)
298 /*
299 * argh! URG not set but urp changed -- a sensible
300 * implementation should never do this but RFC793 doesn't
301 * prohibit the change so we have to deal with it.
302 */
303 goto uncompressed;
304
305 deltaS = (uint16_t)(ntohs(th->th_win) - ntohs(oth->th_win));
306 if (deltaS) {
307 ENCODE(deltaS);
308 changes |= NEW_W;
309 }
310
311 deltaA = ntohl(th->th_ack) - ntohl(oth->th_ack);
312 if (deltaA) {
313 if (deltaA > 0xffff)
314 goto uncompressed;
315 ENCODE(deltaA);
316 changes |= NEW_A;
317 }
318
319 deltaS = ntohl(th->th_seq) - ntohl(oth->th_seq);
320 if (deltaS) {
321 if (deltaS > 0xffff)
322 goto uncompressed;
323 ENCODE(deltaS);
324 changes |= NEW_S;
325 }
326
327 switch (changes) {
328 case 0:
329 /*
330 * Nothing changed. If this packet contains data and the
331 * last one didn't, this is probably a data packet following
332 * an ack (normal on an interactive connection) and we send
333 * it compressed. Otherwise it's probably a retransmit,
334 * retransmitted ack or window probe. Send it uncompressed
335 * in case the other side missed the compressed version.
336 */
337 if (ip->ip_len != cs->cs_ip.ip_len &&
338 ntohs(cs->cs_ip.ip_len) == hlen)
339 break;
340
341 /* FALLTHROUGH */
342
343 case SPECIAL_I:
344 case SPECIAL_D:
345 /*
346 * actual changes match one of our special case encodings --
347 * send packet uncompressed.
348 */
349 goto uncompressed;
350
351 case NEW_S|NEW_A:
352 if (deltaS == deltaA &&
353 deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {
354 /* special case for echoed terminal traffic */
355 changes = SPECIAL_I;
356 cp = new_seq;
357 }
358 break;
359
360 case NEW_S:
361 if (deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {
362 /* special case for data xfer */
363 changes = SPECIAL_D;
364 cp = new_seq;
365 }
366 break;
367 }
368
369 deltaS = ntohs(ip->ip_id) - ntohs(cs->cs_ip.ip_id);
370 if (deltaS != 1) {
371 ENCODEZ(deltaS);
372 changes |= NEW_I;
373 }
374 if (th->th_flags & TH_PUSH)
375 changes |= TCP_PUSH_BIT;
376 /*
377 * Grab the cksum before we overwrite it below. Then update our
378 * state with this packet's header.
379 */
380 deltaA = ntohs(th->th_sum);
381 memcpy(&cs->cs_ip, ip, hlen);
382
383 /*
384 * We want to use the original packet as our compressed packet.
385 * (cp - new_seq) is the number of bytes we need for compressed
386 * sequence numbers. In addition we need one byte for the change
387 * mask, one for the connection id and two for the tcp checksum.
388 * So, (cp - new_seq) + 4 bytes of header are needed. hlen is how
389 * many bytes of the original packet to toss so subtract the two to
390 * get the new packet size.
391 */
392 deltaS = cp - new_seq;
393 cp = (u_char *)ip;
394 if (compress_cid == 0 || comp->last_xmit != cs->cs_id) {
395 comp->last_xmit = cs->cs_id;
396 hlen -= deltaS + 4;
397 cp += hlen;
398 *cp++ = changes | NEW_C;
399 *cp++ = cs->cs_id;
400 } else {
401 hlen -= deltaS + 3;
402 cp += hlen;
403 *cp++ = changes;
404 }
405 m->m_len -= hlen;
406 m->m_data += hlen;
407 *cp++ = deltaA >> 8;
408 *cp++ = deltaA;
409 memcpy(cp, new_seq, deltaS);
410 INCR(sls_compressed)
411 return TYPE_COMPRESSED_TCP;
412
413 /*
414 * Update connection state cs & send uncompressed packet
415 * ('uncompressed' means a regular ip/tcp packet but with the
416 * 'conversation id' we hope to use on future compressed packets in the
417 * protocol field).
418 */
419 uncompressed:
420 memcpy(&cs->cs_ip, ip, hlen);
421 ip->ip_p = cs->cs_id;
422 comp->last_xmit = cs->cs_id;
423 return TYPE_UNCOMPRESSED_TCP;
424 }
425
426
427 int
428 sl_uncompress_tcp(u_char **bufp, int len, u_int type, struct slcompress *comp)
429 {
430 u_char *hdr, *cp;
431 int vjlen;
432 u_int hlen;
433
434 cp = bufp ? *bufp : NULL;
435 vjlen = sl_uncompress_tcp_core(cp, len, len, type, comp, &hdr, &hlen);
436 if (vjlen < 0)
437 return 0; /* error */
438 if (vjlen == 0)
439 return len; /* was uncompressed already */
440
441 cp += vjlen;
442 len -= vjlen;
443
444 /*
445 * At this point, cp points to the first byte of data in the
446 * packet. If we're not aligned on a 4-byte boundary, copy the
447 * data down so the ip & tcp headers will be aligned. Then back up
448 * cp by the tcp/ip header length to make room for the reconstructed
449 * header (we assume the packet we were handed has enough space to
450 * prepend 128 bytes of header).
451 */
452 if ((long)cp & 3) {
453 if (len > 0)
454 memmove((void *)((long)cp &~ 3), cp, len);
455 cp = (u_char *)((long)cp &~ 3);
456 }
457 cp -= hlen;
458 len += hlen;
459 memcpy(cp, hdr, hlen);
460
461 *bufp = cp;
462 return len;
463 }
464
465 /*
466 * Uncompress a packet of total length total_len. The first buflen bytes are
467 * at buf; this must include the entire (compressed or uncompressed) TCP/IP
468 * header. This procedure returns the length of the VJ header, with a pointer
469 * to the uncompressed IP header in *hdrp and its length in *hlenp.
470 */
471 int
472 sl_uncompress_tcp_core(u_char *buf, int buflen, int total_len, u_int type,
473 struct slcompress *comp, u_char **hdrp, u_int *hlenp)
474 {
475 u_char *cp;
476 u_int hlen, changes;
477 struct tcphdr *th;
478 struct cstate *cs;
479 struct ip *ip;
480 uint16_t *bp;
481 u_int vjlen;
482
483 switch (type) {
484
485 case TYPE_UNCOMPRESSED_TCP:
486 if (buf == NULL)
487 goto bad;
488 ip = (struct ip *) buf;
489 if (ip->ip_p >= MAX_STATES)
490 goto bad;
491 cs = &comp->rstate[comp->last_recv = ip->ip_p];
492 comp->flags &=~ SLF_TOSS;
493 ip->ip_p = IPPROTO_TCP;
494 /*
495 * Calculate the size of the TCP/IP header and make sure that
496 * we don't overflow the space we have available for it.
497 */
498 hlen = ip->ip_hl << 2;
499 if (hlen + sizeof(struct tcphdr) > buflen)
500 goto bad;
501 hlen += ((struct tcphdr *)&((char *)ip)[hlen])->th_off << 2;
502 if (hlen > MAX_HDR || hlen > buflen)
503 goto bad;
504 memcpy(&cs->cs_ip, ip, hlen);
505 cs->cs_hlen = hlen;
506 INCR(sls_uncompressedin)
507 *hdrp = (u_char *)&cs->cs_ip;
508 *hlenp = hlen;
509 return 0;
510
511 default:
512 goto bad;
513
514 case TYPE_COMPRESSED_TCP:
515 break;
516 }
517 /* We've got a compressed packet. */
518 INCR(sls_compressedin)
519 if (buf == NULL)
520 goto bad;
521 cp = buf;
522 changes = *cp++;
523 if (changes & NEW_C) {
524 /*
525 * Make sure the state index is in range, then grab the state.
526 * If we have a good state index, clear the 'discard' flag.
527 */
528 if (*cp >= MAX_STATES)
529 goto bad;
530
531 comp->flags &=~ SLF_TOSS;
532 comp->last_recv = *cp++;
533 } else {
534 /*
535 * this packet has an implicit state index. If we've had a
536 * line error since the last time we got an explicit state
537 * index, we have to toss the packet.
538 */
539 if (comp->flags & SLF_TOSS) {
540 INCR(sls_tossed)
541 return -1;
542 }
543 }
544 cs = &comp->rstate[comp->last_recv];
545 hlen = cs->cs_ip.ip_hl << 2;
546 th = (struct tcphdr *)&((u_char *)&cs->cs_ip)[hlen];
547 th->th_sum = htons((*cp << 8) | cp[1]);
548 cp += 2;
549 if (changes & TCP_PUSH_BIT)
550 th->th_flags |= TH_PUSH;
551 else
552 th->th_flags &=~ TH_PUSH;
553
554 switch (changes & SPECIALS_MASK) {
555 case SPECIAL_I:
556 {
557 u_int i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;
558 th->th_ack = htonl(ntohl(th->th_ack) + i);
559 th->th_seq = htonl(ntohl(th->th_seq) + i);
560 }
561 break;
562
563 case SPECIAL_D:
564 th->th_seq = htonl(ntohl(th->th_seq) + ntohs(cs->cs_ip.ip_len)
565 - cs->cs_hlen);
566 break;
567
568 default:
569 if (changes & NEW_U) {
570 th->th_flags |= TH_URG;
571 DECODEU(th->th_urp)
572 } else
573 th->th_flags &=~ TH_URG;
574 if (changes & NEW_W)
575 DECODES(th->th_win)
576 if (changes & NEW_A)
577 DECODEL(th->th_ack)
578 if (changes & NEW_S)
579 DECODEL(th->th_seq)
580 break;
581 }
582 if (changes & NEW_I) {
583 DECODES(cs->cs_ip.ip_id)
584 } else
585 cs->cs_ip.ip_id = htons(ntohs(cs->cs_ip.ip_id) + 1);
586
587 /*
588 * At this point, cp points to the first byte of data in the packet.
589 * Fill in the IP total length and update the IP header checksum.
590 */
591 vjlen = cp - buf;
592 buflen -= vjlen;
593 if (buflen < 0)
594 /*
595 * We must have dropped some characters (crc should detect
596 * this but the old slip framing won't)
597 */
598 goto bad;
599
600 total_len += cs->cs_hlen - vjlen;
601 cs->cs_ip.ip_len = htons(total_len);
602
603 /* Recompute the ip header checksum */
604 bp = (uint16_t *)&cs->cs_ip;
605 cs->cs_ip.ip_sum = 0;
606 for (changes = 0; hlen > 0; hlen -= 2)
607 changes += *bp++;
608 changes = (changes & 0xffff) + (changes >> 16);
609 changes = (changes & 0xffff) + (changes >> 16);
610 cs->cs_ip.ip_sum = ~ changes;
611
612 *hdrp = (u_char *)&cs->cs_ip;
613 *hlenp = cs->cs_hlen;
614 return vjlen;
615
616 bad:
617 comp->flags |= SLF_TOSS;
618 INCR(sls_errorin)
619 return -1;
620 }
621 #endif
622
623 MODULE(MODULE_CLASS_MISC, slcompress, NULL);
624
625 static int
626 slcompress_modcmd(modcmd_t cmd, void *arg)
627 {
628 switch (cmd) {
629 case MODULE_CMD_INIT:
630 case MODULE_CMD_FINI:
631 #ifdef INET
632 return 0;
633 #endif
634 case MODULE_CMD_STAT:
635 case MODULE_CMD_AUTOUNLOAD:
636 default:
637 return ENOTTY;
638 }
639 }
Cache object: 2c3be64d487bc0de056ac4fcfd781281
|