sys/net/ppp_layer/slcompress.c

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