[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net/slcompress.c

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: slcompress.c,v 1.38 2009/04/18 15:20:06 tsutsui 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.38 2009/04/18 15:20:06 tsutsui Exp $");
   45 
   46 #include "opt_inet.h"
   47 #ifdef INET
   48 #include <sys/param.h>
   49 #include <sys/mbuf.h>
   50 #include <sys/systm.h>
   51 
   52 #include <netinet/in.h>
   53 #include <netinet/in_systm.h>
   54 #include <netinet/ip.h>
   55 #include <netinet/tcp.h>
   56 
   57 #include <net/slcompress.h>
   58 
   59 #ifndef SL_NO_STATS
   60 #define INCR(counter) ++comp->counter;
   61 #else
   62 #define INCR(counter)
   63 #endif
   64 
   65 
   66 void
   67 sl_compress_init(struct slcompress *comp)
   68 {
   69         u_int i;
   70         struct cstate *tstate = comp->tstate;
   71 
   72         memset(comp, 0, sizeof(*comp));
   73         for (i = MAX_STATES - 1; i > 0; --i) {
   74                 tstate[i].cs_id = i;
   75                 tstate[i].cs_next = &tstate[i - 1];
   76         }
   77         tstate[0].cs_next = &tstate[MAX_STATES - 1];
   78         tstate[0].cs_id = 0;
   79         comp->last_cs = &tstate[0];
   80         comp->last_recv = 255;
   81         comp->last_xmit = 255;
   82         comp->flags = SLF_TOSS;
   83 }
   84 
   85 
   86 /*
   87  * Like sl_compress_init, but we get to specify the maximum connection
   88  * ID to use on transmission.
   89  */
   90 void
   91 sl_compress_setup(struct slcompress *comp, int max_state)
   92 {
   93         u_int i;
   94         struct cstate *tstate = comp->tstate;
   95 
   96         if (max_state == -1) {
   97                 max_state = MAX_STATES - 1;
   98                 memset(comp, 0, sizeof(*comp));
   99         } else {
  100                 /* Don't reset statistics */
  101                 memset(comp->tstate, 0, sizeof(comp->tstate));
  102                 memset(comp->rstate, 0, sizeof(comp->rstate));
  103         }
  104         for (i = max_state; i > 0; --i) {
  105                 tstate[i].cs_id = i;
  106                 tstate[i].cs_next = &tstate[i - 1];
  107         }
  108         tstate[0].cs_next = &tstate[max_state];
  109         tstate[0].cs_id = 0;
  110         comp->last_cs = &tstate[0];
  111         comp->last_recv = 255;
  112         comp->last_xmit = 255;
  113         comp->flags = SLF_TOSS;
  114 }
  115 
  116 
  117 /* ENCODE encodes a number that is known to be non-zero.  ENCODEZ
  118  * checks for zero (since zero has to be encoded in the long, 3 byte
  119  * form).
  120  */
  121 #define ENCODE(n) { \
  122         if ((uint16_t)(n) >= 256) { \
  123                 *cp++ = 0; \
  124                 cp[1] = (n); \
  125                 cp[0] = (n) >> 8; \
  126                 cp += 2; \
  127         } else { \
  128                 *cp++ = (n); \
  129         } \
  130 }
  131 #define ENCODEZ(n) { \
  132         if ((uint16_t)(n) >= 256 || (uint16_t)(n) == 0) { \
  133                 *cp++ = 0; \
  134                 cp[1] = (n); \
  135                 cp[0] = (n) >> 8; \
  136                 cp += 2; \
  137         } else { \
  138                 *cp++ = (n); \
  139         } \
  140 }
  141 
  142 #define DECODEL(f) { \
  143         if (*cp == 0) {\
  144                 (f) = htonl(ntohl(f) + ((cp[1] << 8) | cp[2])); \
  145                 cp += 3; \
  146         } else { \
  147                 (f) = htonl(ntohl(f) + (uint32_t)*cp++); \
  148         } \
  149 }
  150 
  151 #define DECODES(f) { \
  152         if (*cp == 0) {\
  153                 (f) = htons(ntohs(f) + ((cp[1] << 8) | cp[2])); \
  154                 cp += 3; \
  155         } else { \
  156                 (f) = htons(ntohs(f) + (uint32_t)*cp++); \
  157         } \
  158 }
  159 
  160 #define DECODEU(f) { \
  161         if (*cp == 0) {\
  162                 (f) = htons((cp[1] << 8) | cp[2]); \
  163                 cp += 3; \
  164         } else { \
  165                 (f) = htons((uint32_t)*cp++); \
  166         } \
  167 }
  168 
  169 u_int
  170 sl_compress_tcp(struct mbuf *m, struct ip *ip, struct slcompress *comp,
  171     int compress_cid)
  172 {
  173         struct cstate *cs = comp->last_cs->cs_next;
  174         u_int hlen = ip->ip_hl;
  175         struct tcphdr *oth;
  176         struct tcphdr *th;
  177         u_int deltaS, deltaA;
  178         u_int changes = 0;
  179         u_char new_seq[16];
  180         u_char *cp = new_seq;
  181 
  182         /*
  183          * Bail if this is an IP fragment or if the TCP packet isn't
  184          * `compressible' (i.e., ACK isn't set or some other control bit is
  185          * set).  (We assume that the caller has already made sure the
  186          * packet is IP proto TCP).
  187          */
  188         if ((ip->ip_off & htons(0x3fff)) || m->m_len < 40)
  189                 return (TYPE_IP);
  190 
  191         th = (struct tcphdr *)&((int32_t *)ip)[hlen];
  192         if ((th->th_flags & (TH_SYN|TH_FIN|TH_RST|TH_ACK)) != TH_ACK)
  193                 return (TYPE_IP);
  194         /*
  195          * Packet is compressible -- we're going to send either a
  196          * COMPRESSED_TCP or UNCOMPRESSED_TCP packet.  Either way we need
  197          * to locate (or create) the connection state.  Special case the
  198          * most recently used connection since it's most likely to be used
  199          * again & we don't have to do any reordering if it's used.
  200          */
  201         INCR(sls_packets)
  202         if (ip->ip_src.s_addr != cs->cs_ip.ip_src.s_addr ||
  203             ip->ip_dst.s_addr != cs->cs_ip.ip_dst.s_addr ||
  204             *(int32_t *)th != ((int32_t *)&cs->cs_ip)[cs->cs_ip.ip_hl]) {
  205                 /*
  206                  * Wasn't the first -- search for it.
  207                  *
  208                  * States are kept in a circularly linked list with
  209                  * last_cs pointing to the end of the list.  The
  210                  * list is kept in lru order by moving a state to the
  211                  * head of the list whenever it is referenced.  Since
  212                  * the list is short and, empirically, the connection
  213                  * we want is almost always near the front, we locate
  214                  * states via linear search.  If we don't find a state
  215                  * for the datagram, the oldest state is (re-)used.
  216                  */
  217                 struct cstate *lcs;
  218                 struct cstate *lastcs = comp->last_cs;
  219 
  220                 do {
  221                         lcs = cs; cs = cs->cs_next;
  222                         INCR(sls_searches)
  223                         if (ip->ip_src.s_addr == cs->cs_ip.ip_src.s_addr
  224                             && ip->ip_dst.s_addr == cs->cs_ip.ip_dst.s_addr
  225                             && *(int32_t *)th ==
  226                             ((int32_t *)&cs->cs_ip)[cs->cs_ip.ip_hl])
  227                                 goto found;
  228                 } while (cs != lastcs);
  229 
  230                 /*
  231                  * Didn't find it -- re-use oldest cstate.  Send an
  232                  * uncompressed packet that tells the other side what
  233                  * connection number we're using for this conversation.
  234                  * Note that since the state list is circular, the oldest
  235                  * state points to the newest and we only need to set
  236                  * last_cs to update the lru linkage.
  237                  */
  238                 INCR(sls_misses)
  239                 comp->last_cs = lcs;
  240                 hlen += th->th_off;
  241                 hlen <<= 2;
  242                 if (hlen > m->m_len)
  243                         return (TYPE_IP);
  244                 goto uncompressed;
  245 
  246         found:
  247                 /*
  248                  * Found it -- move to the front on the connection list.
  249                  */
  250                 if (cs == lastcs)
  251                         comp->last_cs = lcs;
  252                 else {
  253                         lcs->cs_next = cs->cs_next;
  254                         cs->cs_next = lastcs->cs_next;
  255                         lastcs->cs_next = cs;
  256                 }
  257         }
  258 
  259         /*
  260          * Make sure that only what we expect to change changed. The first
  261          * line of the `if' checks the IP protocol version, header length &
  262          * type of service.  The 2nd line checks the "Don't fragment" bit.
  263          * The 3rd line checks the time-to-live and protocol (the protocol
  264          * check is unnecessary but costless).  The 4th line checks the TCP
  265          * header length.  The 5th line checks IP options, if any.  The 6th
  266          * line checks TCP options, if any.  If any of these things are
  267          * different between the previous & current datagram, we send the
  268          * current datagram `uncompressed'.
  269          */
  270         oth = (struct tcphdr *)&((int32_t *)&cs->cs_ip)[hlen];
  271         deltaS = hlen;
  272         hlen += th->th_off;
  273         hlen <<= 2;
  274         if (hlen > m->m_len)
  275                 return (TYPE_IP);
  276 
  277         if (((uint16_t *)ip)[0] != ((uint16_t *)&cs->cs_ip)[0] ||
  278             ((uint16_t *)ip)[3] != ((uint16_t *)&cs->cs_ip)[3] ||
  279             ((uint16_t *)ip)[4] != ((uint16_t *)&cs->cs_ip)[4] ||
  280             th->th_off != oth->th_off ||
  281             (deltaS > 5 &&
  282              memcmp(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2)) ||
  283             (th->th_off > 5 &&
  284              memcmp(th + 1, oth + 1, (th->th_off - 5) << 2)))
  285                 goto uncompressed;
  286 
  287         /*
  288          * Figure out which of the changing fields changed.  The
  289          * receiver expects changes in the order: urgent, window,
  290          * ack, seq (the order minimizes the number of temporaries
  291          * 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                 /* argh! URG not set but urp changed -- a sensible
  299                  * implementation should never do this but RFC793
  300                  * doesn't prohibit the change so we have to deal
  301                  * with it. */
  302                  goto uncompressed;
  303 
  304         deltaS = (uint16_t)(ntohs(th->th_win) - ntohs(oth->th_win));
  305         if (deltaS) {
  306                 ENCODE(deltaS);
  307                 changes |= NEW_W;
  308         }
  309 
  310         deltaA = ntohl(th->th_ack) - ntohl(oth->th_ack);
  311         if (deltaA) {
  312                 if (deltaA > 0xffff)
  313                         goto uncompressed;
  314                 ENCODE(deltaA);
  315                 changes |= NEW_A;
  316         }
  317 
  318         deltaS = ntohl(th->th_seq) - ntohl(oth->th_seq);
  319         if (deltaS) {
  320                 if (deltaS > 0xffff)
  321                         goto uncompressed;
  322                 ENCODE(deltaS);
  323                 changes |= NEW_S;
  324         }
  325 
  326         switch (changes) {
  327 
  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                 /* (fall through) */
  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 ('uncompressed'
  415          * means a regular ip/tcp packet but with the 'conversation id' we hope
  416          * to use on future compressed packets in the protocol field).
  417          */
  418 uncompressed:
  419         memcpy(&cs->cs_ip, ip, hlen);
  420         ip->ip_p = cs->cs_id;
  421         comp->last_xmit = cs->cs_id;
  422         return (TYPE_UNCOMPRESSED_TCP);
  423 }
  424 
  425 
  426 int
  427 sl_uncompress_tcp(u_char **bufp, int len, u_int type, struct slcompress *comp)
  428 {
  429         u_char *hdr, *cp;
  430         int vjlen;
  431         u_int hlen;
  432 
  433         cp = bufp ? *bufp : NULL;
  434         vjlen = sl_uncompress_tcp_core(cp, len, len, type, comp, &hdr, &hlen);
  435         if (vjlen < 0)
  436                 return (0);     /* error */
  437         if (vjlen == 0)
  438                 return (len);   /* was uncompressed already */
  439 
  440         cp += vjlen;
  441         len -= vjlen;
  442 
  443         /*
  444          * At this point, cp points to the first byte of data in the
  445          * packet.  If we're not aligned on a 4-byte boundary, copy the
  446          * data down so the ip & tcp headers will be aligned.  Then back up
  447          * cp by the tcp/ip header length to make room for the reconstructed
  448          * header (we assume the packet we were handed has enough space to
  449          * prepend 128 bytes of header).
  450          */
  451         if ((long)cp & 3) {
  452                 if (len > 0)
  453                         memmove((void *)((long)cp &~ 3), cp, len);
  454                 cp = (u_char *)((long)cp &~ 3);
  455         }
  456         cp -= hlen;
  457         len += hlen;
  458         memcpy(cp, hdr, hlen);
  459 
  460         *bufp = cp;
  461         return (len);
  462 }
  463 
  464 /*
  465  * Uncompress a packet of total length total_len.  The first buflen
  466  * bytes are at buf; this must include the entire (compressed or
  467  * uncompressed) TCP/IP header.  This procedure returns the length
  468  * of the VJ header, with a pointer to the uncompressed IP header
  469  * 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                 /* Make sure the state index is in range, then grab the state.
  525                  * If we have a good state index, clear the 'discard' flag. */
  526                 if (*cp >= MAX_STATES)
  527                         goto bad;
  528 
  529                 comp->flags &=~ SLF_TOSS;
  530                 comp->last_recv = *cp++;
  531         } else {
  532                 /* this packet has an implicit state index.  If we've
  533                  * had a line error since the last time we got an
  534                  * explicit state index, we have to toss the packet. */
  535                 if (comp->flags & SLF_TOSS) {
  536                         INCR(sls_tossed)
  537                         return (-1);
  538                 }
  539         }
  540         cs = &comp->rstate[comp->last_recv];
  541         hlen = cs->cs_ip.ip_hl << 2;
  542         th = (struct tcphdr *)&((u_char *)&cs->cs_ip)[hlen];
  543         th->th_sum = htons((*cp << 8) | cp[1]);
  544         cp += 2;
  545         if (changes & TCP_PUSH_BIT)
  546                 th->th_flags |= TH_PUSH;
  547         else
  548                 th->th_flags &=~ TH_PUSH;
  549 
  550         switch (changes & SPECIALS_MASK) {
  551         case SPECIAL_I:
  552                 {
  553                 u_int i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;
  554                 th->th_ack = htonl(ntohl(th->th_ack) + i);
  555                 th->th_seq = htonl(ntohl(th->th_seq) + i);
  556                 }
  557                 break;
  558 
  559         case SPECIAL_D:
  560                 th->th_seq = htonl(ntohl(th->th_seq) + ntohs(cs->cs_ip.ip_len)
  561                                    - cs->cs_hlen);
  562                 break;
  563 
  564         default:
  565                 if (changes & NEW_U) {
  566                         th->th_flags |= TH_URG;
  567                         DECODEU(th->th_urp)
  568                 } else
  569                         th->th_flags &=~ TH_URG;
  570                 if (changes & NEW_W)
  571                         DECODES(th->th_win)
  572                 if (changes & NEW_A)
  573                         DECODEL(th->th_ack)
  574                 if (changes & NEW_S)
  575                         DECODEL(th->th_seq)
  576                 break;
  577         }
  578         if (changes & NEW_I) {
  579                 DECODES(cs->cs_ip.ip_id)
  580         } else
  581                 cs->cs_ip.ip_id = htons(ntohs(cs->cs_ip.ip_id) + 1);
  582 
  583         /*
  584          * At this point, cp points to the first byte of data in the
  585          * packet.  Fill in the IP total length and update the IP
  586          * header checksum.
  587          */
  588         vjlen = cp - buf;
  589         buflen -= vjlen;
  590         if (buflen < 0)
  591                 /* we must have dropped some characters (crc should detect
  592                  * this but the old slip framing won't) */
  593                 goto bad;
  594 
  595         total_len += cs->cs_hlen - vjlen;
  596         cs->cs_ip.ip_len = htons(total_len);
  597 
  598         /* recompute the ip header checksum */
  599         bp = (uint16_t *) &cs->cs_ip;
  600         cs->cs_ip.ip_sum = 0;
  601         for (changes = 0; hlen > 0; hlen -= 2)
  602                 changes += *bp++;
  603         changes = (changes & 0xffff) + (changes >> 16);
  604         changes = (changes & 0xffff) + (changes >> 16);
  605         cs->cs_ip.ip_sum = ~ changes;
  606 
  607         *hdrp = (u_char *) &cs->cs_ip;
  608         *hlenp = cs->cs_hlen;
  609         return vjlen;
  610 
  611 bad:
  612         comp->flags |= SLF_TOSS;
  613         INCR(sls_errorin)
  614         return (-1);
  615 }
  616 #endif

Cache object: 2c3be64d487bc0de056ac4fcfd781281


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.