source: rtems/cpukit/libnetworking/net/slcompress.c @ 1cb54d1f

4.104.11
Last change on this file since 1cb54d1f was 1cb54d1f, checked in by Ralf Corsepius <ralf.corsepius@…>, on Dec 11, 2008 at 12:47:56 AM

#include <stdint.h> instead of <rtems/stdint.h>.

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