URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP_130/] [src/] [netif/] [ppp/] [vj.c] - Blame information for rev 780

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Routines to compress and uncompess tcp packets (for transmission
 * over low speed serial lines.
 *
 * Copyright (c) 1989 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
 *   Initial distribution.
 *
 * Modified June 1993 by Paul Mackerras, paulus@cs.anu.edu.au,
 * so that the entire packet being decompressed doesn't have
 * to be in contiguous memory (just the compressed header).
 *
 * Modified March 1998 by Guy Lancaster, glanca@gesn.com,
 * for a 16 bit processor.
 */
 
#include "lwip/opt.h"
 
#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
 
#include "ppp.h"
#include "pppdebug.h"
 
#include "vj.h"
 
#include <string.h>
 
#if VJ_SUPPORT
 
#if LINK_STATS
#define INCR(counter) ++comp->stats.counter
#else
#define INCR(counter)
#endif
 
#if defined(NO_CHAR_BITFIELDS)
#define getip_hl(base)  ((base).ip_hl_v&0xf)
#define getth_off(base) (((base).th_x2_off&0xf0)>>4)
#else
#define getip_hl(base)  ((base).ip_hl)
#define getth_off(base) ((base).th_off)
#endif
 
void
vj_compress_init(struct vjcompress *comp)
{
  register u_int i;
  register struct cstate *tstate = comp->tstate;
 
#if MAX_SLOTS == 0
  memset((char *)comp, 0, sizeof(*comp));
#endif
  comp->maxSlotIndex = MAX_SLOTS - 1;
  comp->compressSlot = 0;    /* Disable slot ID compression by default. */
  for (i = MAX_SLOTS - 1; i > 0; --i) {
    tstate[i].cs_id = i;
    tstate[i].cs_next = &tstate[i - 1];
  }
  tstate[0].cs_next = &tstate[MAX_SLOTS - 1];
  tstate[0].cs_id = 0;
  comp->last_cs = &tstate[0];
  comp->last_recv = 255;
  comp->last_xmit = 255;
  comp->flags = VJF_TOSS;
}
 
 
/* ENCODE encodes a number that is known to be non-zero.  ENCODEZ
 * checks for zero (since zero has to be encoded in the long, 3 byte
 * form).
 */
#define ENCODE(n) { \
  if ((u_short)(n) >= 256) { \
    *cp++ = 0; \
    cp[1] = (n); \
    cp[0] = (n) >> 8; \
    cp += 2; \
  } else { \
    *cp++ = (n); \
  } \
}
#define ENCODEZ(n) { \
  if ((u_short)(n) >= 256 || (u_short)(n) == 0) { \
    *cp++ = 0; \
    cp[1] = (n); \
    cp[0] = (n) >> 8; \
    cp += 2; \
  } else { \
    *cp++ = (n); \
  } \
}
 
#define DECODEL(f) { \
  if (*cp == 0) {\
    u32_t tmp = ntohl(f) + ((cp[1] << 8) | cp[2]); \
    (f) = htonl(tmp); \
    cp += 3; \
  } else { \
    u32_t tmp = ntohl(f) + (u32_t)*cp++; \
    (f) = htonl(tmp); \
  } \
}
 
#define DECODES(f) { \
  if (*cp == 0) {\
    u_short tmp = ntohs(f) + (((u_short)cp[1] << 8) | cp[2]); \
    (f) = htons(tmp); \
    cp += 3; \
  } else { \
    u_short tmp = ntohs(f) + (u_short)*cp++; \
    (f) = htons(tmp); \
  } \
}
 
#define DECODEU(f) { \
  if (*cp == 0) {\
    (f) = htons(((u_short)cp[1] << 8) | cp[2]); \
    cp += 3; \
  } else { \
    (f) = htons((u_short)*cp++); \
  } \
}
 
/*
 * vj_compress_tcp - Attempt to do Van Jacobsen header compression on a
 * packet.  This assumes that nb and comp are not null and that the first
 * buffer of the chain contains a valid IP header.
 * Return the VJ type code indicating whether or not the packet was
 * compressed.
 */
u_int
vj_compress_tcp(struct vjcompress *comp, struct pbuf *pb)
{
  register struct ip *ip = (struct ip *)pb->payload;
  register struct cstate *cs = comp->last_cs->cs_next;
  register u_short hlen = getip_hl(*ip);
  register struct tcphdr *oth;
  register struct tcphdr *th;
  register u_short deltaS, deltaA;
  register u_long deltaL;
  register u_int changes = 0;
  u_char new_seq[16];
  register u_char *cp = new_seq;
 
  /*
   * Check that the packet is IP proto TCP.
   */
  if (ip->ip_p != IPPROTO_TCP) {
    return (TYPE_IP);
  }
 
  /*
   * Bail if this is an IP fragment or if the TCP packet isn't
   * `compressible' (i.e., ACK isn't set or some other control bit is
   * set).
   */
  if ((ip->ip_off & htons(0x3fff)) || pb->tot_len < 40) {
    return (TYPE_IP);
  }
  th = (struct tcphdr *)&((long *)ip)[hlen];
  if ((th->th_flags & (TCP_SYN|TCP_FIN|TCP_RST|TCP_ACK)) != TCP_ACK) {
    return (TYPE_IP);
  }
  /*
   * Packet is compressible -- we're going to send either a
   * COMPRESSED_TCP or UNCOMPRESSED_TCP packet.  Either way we need
   * to locate (or create) the connection state.  Special case the
   * most recently used connection since it's most likely to be used
   * again & we don't have to do any reordering if it's used.
   */
  INCR(vjs_packets);
  if (ip->ip_src.s_addr != cs->cs_ip.ip_src.s_addr
      || ip->ip_dst.s_addr != cs->cs_ip.ip_dst.s_addr
      || *(long *)th != ((long *)&cs->cs_ip)[getip_hl(cs->cs_ip)]) {
    /*
     * Wasn't the first -- search for it.
     *
     * States are kept in a circularly linked list with
     * last_cs pointing to the end of the list.  The
     * list is kept in lru order by moving a state to the
     * head of the list whenever it is referenced.  Since
     * the list is short and, empirically, the connection
     * we want is almost always near the front, we locate
     * states via linear search.  If we don't find a state
     * for the datagram, the oldest state is (re-)used.
     */
    register struct cstate *lcs;
    register struct cstate *lastcs = comp->last_cs;
 
    do {
      lcs = cs; cs = cs->cs_next;
      INCR(vjs_searches);
      if (ip->ip_src.s_addr == cs->cs_ip.ip_src.s_addr
          && ip->ip_dst.s_addr == cs->cs_ip.ip_dst.s_addr
          && *(long *)th == ((long *)&cs->cs_ip)[getip_hl(cs->cs_ip)]) {
        goto found;
      }
    } while (cs != lastcs);
 
    /*
     * Didn't find it -- re-use oldest cstate.  Send an
     * uncompressed packet that tells the other side what
     * connection number we're using for this conversation.
     * Note that since the state list is circular, the oldest
     * state points to the newest and we only need to set
     * last_cs to update the lru linkage.
     */
    INCR(vjs_misses);
    comp->last_cs = lcs;
    hlen += getth_off(*th);
    hlen <<= 2;
    /* Check that the IP/TCP headers are contained in the first buffer. */
    if (hlen > pb->len) {
      return (TYPE_IP);
    }
    goto uncompressed;
 
    found:
    /*
     * Found it -- move to the front on the connection list.
     */
    if (cs == lastcs) {
      comp->last_cs = lcs;
    } else {
      lcs->cs_next = cs->cs_next;
      cs->cs_next = lastcs->cs_next;
      lastcs->cs_next = cs;
    }
  }
 
  oth = (struct tcphdr *)&((long *)&cs->cs_ip)[hlen];
  deltaS = hlen;
  hlen += getth_off(*th);
  hlen <<= 2;
  /* Check that the IP/TCP headers are contained in the first buffer. */
  if (hlen > pb->len) {
    PPPDEBUG((LOG_INFO, "vj_compress_tcp: header len %d spans buffers\n", hlen));
    return (TYPE_IP);
  }
 
  /*
   * Make sure that only what we expect to change changed. The first
   * line of the `if' checks the IP protocol version, header length &
   * type of service.  The 2nd line checks the "Don't fragment" bit.
   * The 3rd line checks the time-to-live and protocol (the protocol
   * check is unnecessary but costless).  The 4th line checks the TCP
   * header length.  The 5th line checks IP options, if any.  The 6th
   * line checks TCP options, if any.  If any of these things are
   * different between the previous & current datagram, we send the
   * current datagram `uncompressed'.
   */
  if (((u_short *)ip)[0] != ((u_short *)&cs->cs_ip)[0]
      || ((u_short *)ip)[3] != ((u_short *)&cs->cs_ip)[3]
      || ((u_short *)ip)[4] != ((u_short *)&cs->cs_ip)[4]
      || getth_off(*th) != getth_off(*oth)
      || (deltaS > 5 && BCMP(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2))
      || (getth_off(*th) > 5 && BCMP(th + 1, oth + 1, (getth_off(*th) - 5) << 2))) {
    goto uncompressed;
  }
 
  /*
   * Figure out which of the changing fields changed.  The
   * receiver expects changes in the order: urgent, window,
   * ack, seq (the order minimizes the number of temporaries
   * needed in this section of code).
   */
  if (th->th_flags & TCP_URG) {
    deltaS = ntohs(th->th_urp);
    ENCODEZ(deltaS);
    changes |= NEW_U;
  } else if (th->th_urp != oth->th_urp) {
    /* argh! URG not set but urp changed -- a sensible
     * implementation should never do this but RFC793
     * doesn't prohibit the change so we have to deal
     * with it. */
    goto uncompressed;
  }
 
  if ((deltaS = (u_short)(ntohs(th->th_win) - ntohs(oth->th_win))) != 0) {
    ENCODE(deltaS);
    changes |= NEW_W;
  }
 
  if ((deltaL = ntohl(th->th_ack) - ntohl(oth->th_ack)) != 0) {
    if (deltaL > 0xffff) {
      goto uncompressed;
    }
    deltaA = (u_short)deltaL;
    ENCODE(deltaA);
    changes |= NEW_A;
  }
 
  if ((deltaL = ntohl(th->th_seq) - ntohl(oth->th_seq)) != 0) {
    if (deltaL > 0xffff) {
      goto uncompressed;
    }
    deltaS = (u_short)deltaL;
    ENCODE(deltaS);
    changes |= NEW_S;
  }
 
  switch(changes) {
  case 0:
    /*
     * Nothing changed. If this packet contains data and the
     * last one didn't, this is probably a data packet following
     * an ack (normal on an interactive connection) and we send
     * it compressed.  Otherwise it's probably a retransmit,
     * retransmitted ack or window probe.  Send it uncompressed
     * in case the other side missed the compressed version.
     */
    if (ip->ip_len != cs->cs_ip.ip_len &&
      ntohs(cs->cs_ip.ip_len) == hlen) {
      break;
    }
 
  /* (fall through) */
 
  case SPECIAL_I:
  case SPECIAL_D:
    /*
     * actual changes match one of our special case encodings --
     * send packet uncompressed.
     */
    goto uncompressed;
 
  case NEW_S|NEW_A:
    if (deltaS == deltaA && deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {
      /* special case for echoed terminal traffic */
      changes = SPECIAL_I;
      cp = new_seq;
    }
    break;
 
  case NEW_S:
    if (deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {
      /* special case for data xfer */
      changes = SPECIAL_D;
      cp = new_seq;
    }
    break;
  }
 
  deltaS = (u_short)(ntohs(ip->ip_id) - ntohs(cs->cs_ip.ip_id));
  if (deltaS != 1) {
    ENCODEZ(deltaS);
    changes |= NEW_I;
  }
  if (th->th_flags & TCP_PSH) {
    changes |= TCP_PUSH_BIT;
  }
  /*
   * Grab the cksum before we overwrite it below.  Then update our
   * state with this packet's header.
   */
  deltaA = ntohs(th->th_sum);
  BCOPY(ip, &cs->cs_ip, hlen);
 
  /*
   * We want to use the original packet as our compressed packet.
   * (cp - new_seq) is the number of bytes we need for compressed
   * sequence numbers.  In addition we need one byte for the change
   * mask, one for the connection id and two for the tcp checksum.
   * So, (cp - new_seq) + 4 bytes of header are needed.  hlen is how
   * many bytes of the original packet to toss so subtract the two to
   * get the new packet size.
   */
  deltaS = (u_short)(cp - new_seq);
  if (!comp->compressSlot || comp->last_xmit != cs->cs_id) {
    comp->last_xmit = cs->cs_id;
    hlen -= deltaS + 4;
    if(pbuf_header(pb, -hlen)){
      /* Can we cope with this failing?  Just assert for now */
      LWIP_ASSERT("pbuf_header failed\n", 0);
    }
    cp = (u_char *)pb->payload;
    *cp++ = changes | NEW_C;
    *cp++ = cs->cs_id;
  } else {
    hlen -= deltaS + 3;
    if(pbuf_header(pb, -hlen)) {
      /* Can we cope with this failing?  Just assert for now */
      LWIP_ASSERT("pbuf_header failed\n", 0);
    }
    cp = (u_char *)pb->payload;
    *cp++ = changes;
  }
  *cp++ = deltaA >> 8;
  *cp++ = deltaA;
  BCOPY(new_seq, cp, deltaS);
  INCR(vjs_compressed);
  return (TYPE_COMPRESSED_TCP);
 
  /*
   * Update connection state cs & send uncompressed packet (that is,
   * a regular ip/tcp packet but with the 'conversation id' we hope
   * to use on future compressed packets in the protocol field).
   */
uncompressed:
  BCOPY(ip, &cs->cs_ip, hlen);
  ip->ip_p = cs->cs_id;
  comp->last_xmit = cs->cs_id;
  return (TYPE_UNCOMPRESSED_TCP);
}
 
/*
 * Called when we may have missed a packet.
 */
void
vj_uncompress_err(struct vjcompress *comp)
{
  comp->flags |= VJF_TOSS;
  INCR(vjs_errorin);
}
 
/*
 * "Uncompress" a packet of type TYPE_UNCOMPRESSED_TCP.
 * Return 0 on success, -1 on failure.
 */
int
vj_uncompress_uncomp(struct pbuf *nb, struct vjcompress *comp)
{
  register u_int hlen;
  register struct cstate *cs;
  register struct ip *ip;
 
  ip = (struct ip *)nb->payload;
  hlen = getip_hl(*ip) << 2;
  if (ip->ip_p >= MAX_SLOTS
      || hlen + sizeof(struct tcphdr) > nb->len
      || (hlen += getth_off(*((struct tcphdr *)&((char *)ip)[hlen])) << 2)
          > nb->len
      || hlen > MAX_HDR) {
    PPPDEBUG((LOG_INFO, "vj_uncompress_uncomp: bad cid=%d, hlen=%d buflen=%d\n",
          ip->ip_p, hlen, nb->len));
    comp->flags |= VJF_TOSS;
    INCR(vjs_errorin);
    return -1;
  }
  cs = &comp->rstate[comp->last_recv = ip->ip_p];
  comp->flags &=~ VJF_TOSS;
  ip->ip_p = IPPROTO_TCP;
  BCOPY(ip, &cs->cs_ip, hlen);
  cs->cs_hlen = hlen;
  INCR(vjs_uncompressedin);
  return 0;
}
 
/*
 * Uncompress a packet of type TYPE_COMPRESSED_TCP.
 * The packet is composed of a buffer chain and the first buffer
 * must contain an accurate chain length.
 * The first buffer must include the entire compressed TCP/IP header.
 * This procedure replaces the compressed header with the uncompressed
 * header and returns the length of the VJ header.
 */
int
vj_uncompress_tcp(struct pbuf **nb, struct vjcompress *comp)
{
  u_char *cp;
  struct tcphdr *th;
  struct cstate *cs;
  u_short *bp;
  struct pbuf *n0 = *nb;
  u32_t tmp;
  u_int vjlen, hlen, changes;
 
  INCR(vjs_compressedin);
  cp = (u_char *)n0->payload;
  changes = *cp++;
  if (changes & NEW_C) {
    /*
     * Make sure the state index is in range, then grab the state.
     * If we have a good state index, clear the 'discard' flag.
     */
    if (*cp >= MAX_SLOTS) {
      PPPDEBUG((LOG_INFO, "vj_uncompress_tcp: bad cid=%d\n", *cp));
      goto bad;
    }
 
    comp->flags &=~ VJF_TOSS;
    comp->last_recv = *cp++;
  } else {
    /*
     * this packet has an implicit state index.  If we've
     * had a line error since the last time we got an
     * explicit state index, we have to toss the packet.
     */
    if (comp->flags & VJF_TOSS) {
      PPPDEBUG((LOG_INFO, "vj_uncompress_tcp: tossing\n"));
      INCR(vjs_tossed);
      return (-1);
    }
  }
  cs = &comp->rstate[comp->last_recv];
  hlen = getip_hl(cs->cs_ip) << 2;
  th = (struct tcphdr *)&((u_char *)&cs->cs_ip)[hlen];
  th->th_sum = htons((*cp << 8) | cp[1]);
  cp += 2;
  if (changes & TCP_PUSH_BIT) {
    th->th_flags |= TCP_PSH;
  } else {
    th->th_flags &=~ TCP_PSH;
  }
 
  switch (changes & SPECIALS_MASK) {
  case SPECIAL_I:
    {
      register u32_t i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;
      /* some compilers can't nest inline assembler.. */
      tmp = ntohl(th->th_ack) + i;
      th->th_ack = htonl(tmp);
      tmp = ntohl(th->th_seq) + i;
      th->th_seq = htonl(tmp);
    }
    break;
 
  case SPECIAL_D:
    /* some compilers can't nest inline assembler.. */
    tmp = ntohl(th->th_seq) + ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;
    th->th_seq = htonl(tmp);
    break;
 
  default:
    if (changes & NEW_U) {
      th->th_flags |= TCP_URG;
      DECODEU(th->th_urp);
    } else {
      th->th_flags &=~ TCP_URG;
    }
    if (changes & NEW_W) {
      DECODES(th->th_win);
    }
    if (changes & NEW_A) {
      DECODEL(th->th_ack);
    }
    if (changes & NEW_S) {
      DECODEL(th->th_seq);
    }
    break;
  }
  if (changes & NEW_I) {
    DECODES(cs->cs_ip.ip_id);
  } else {
    cs->cs_ip.ip_id = ntohs(cs->cs_ip.ip_id) + 1;
    cs->cs_ip.ip_id = htons(cs->cs_ip.ip_id);
  }
 
  /*
   * At this point, cp points to the first byte of data in the
   * packet.  Fill in the IP total length and update the IP
   * header checksum.
   */
  vjlen = (u_short)(cp - (u_char*)n0->payload);
  if (n0->len < vjlen) {
    /*
     * We must have dropped some characters (crc should detect
     * this but the old slip framing won't)
     */
    PPPDEBUG((LOG_INFO, "vj_uncompress_tcp: head buffer %d too short %d\n",
          n0->len, vjlen));
    goto bad;
  }
 
#if BYTE_ORDER == LITTLE_ENDIAN
  tmp = n0->tot_len - vjlen + cs->cs_hlen;
  cs->cs_ip.ip_len = htons(tmp);
#else
  cs->cs_ip.ip_len = htons(n0->tot_len - vjlen + cs->cs_hlen);
#endif
 
  /* recompute the ip header checksum */
  bp = (u_short *) &cs->cs_ip;
  cs->cs_ip.ip_sum = 0;
  for (tmp = 0; hlen > 0; hlen -= 2) {
    tmp += *bp++;
  }
  tmp = (tmp & 0xffff) + (tmp >> 16);
  tmp = (tmp & 0xffff) + (tmp >> 16);
  cs->cs_ip.ip_sum = (u_short)(~tmp);
 
  /* Remove the compressed header and prepend the uncompressed header. */
  if(pbuf_header(n0, -((s16_t)(vjlen)))) {
    /* Can we cope with this failing?  Just assert for now */
    LWIP_ASSERT("pbuf_header failed\n", 0);
    goto bad;
  }
 
  if(LWIP_MEM_ALIGN(n0->payload) != n0->payload) {
    struct pbuf *np, *q;
    u8_t *bufptr;
 
    np = pbuf_alloc(PBUF_RAW, n0->len + cs->cs_hlen, PBUF_POOL);
    if(!np) {
      PPPDEBUG((LOG_WARNING, "vj_uncompress_tcp: realign failed\n"));
      goto bad;
    }
 
    if(pbuf_header(np, -cs->cs_hlen)) {
      /* Can we cope with this failing?  Just assert for now */
      LWIP_ASSERT("pbuf_header failed\n", 0);
      goto bad;
    }
 
    bufptr = n0->payload;
    for(q = np; q != NULL; q = q->next) {
      MEMCPY(q->payload, bufptr, q->len);
      bufptr += q->len;
    }
 
    if(n0->next) {
      pbuf_chain(np, n0->next);
      pbuf_dechain(n0);
    }
    pbuf_free(n0);
    n0 = np;
  }
 
  if(pbuf_header(n0, cs->cs_hlen)) {
    struct pbuf *np;
 
    LWIP_ASSERT("vj_uncompress_tcp: cs->cs_hlen <= PBUF_POOL_BUFSIZE", cs->cs_hlen <= PBUF_POOL_BUFSIZE);
    np = pbuf_alloc(PBUF_RAW, cs->cs_hlen, PBUF_POOL);
    if(!np) {
      PPPDEBUG((LOG_WARNING, "vj_uncompress_tcp: prepend failed\n"));
      goto bad;
    }
    pbuf_cat(np, n0);
    n0 = np;
  }
  LWIP_ASSERT("n0->len >= cs->cs_hlen", n0->len >= cs->cs_hlen);
  MEMCPY(n0->payload, &cs->cs_ip, cs->cs_hlen);
 
  *nb = n0;
 
  return vjlen;
 
bad:
  comp->flags |= VJF_TOSS;
  INCR(vjs_errorin);
  return (-1);
}
 
#endif /* VJ_SUPPORT */
 
#endif /* PPP_SUPPORT */

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP_130/] [src/] [netif/] [ppp/] [vj.c] - Blame information for rev 780

Line No.	Rev	Author	Line
1	606	jeremybenn	`/*`
2			`* Routines to compress and uncompess tcp packets (for transmission`
3			`* over low speed serial lines.`
4			`*`
5			`* Copyright (c) 1989 Regents of the University of California.`
6			`* All rights reserved.`
7			`*`
8			`* Redistribution and use in source and binary forms are permitted`
9			`* provided that the above copyright notice and this paragraph are`
10			`* duplicated in all such forms and that any documentation,`
11			`* advertising materials, and other materials related to such`
12			`* distribution and use acknowledge that the software was developed`
13			`* by the University of California, Berkeley. The name of the`
14			`* University may not be used to endorse or promote products derived`
15			`* from this software without specific prior written permission.`
16			* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17			`* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED`
18			`* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.`
19			`*`
20			`* Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:`
21			`* Initial distribution.`
22			`*`
23			`* Modified June 1993 by Paul Mackerras, paulus@cs.anu.edu.au,`
24			`* so that the entire packet being decompressed doesn't have`
25			`* to be in contiguous memory (just the compressed header).`
26			`*`
27			`* Modified March 1998 by Guy Lancaster, glanca@gesn.com,`
28			`* for a 16 bit processor.`
29			`*/`
30
31			`#include "lwip/opt.h"`
32
33			`#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */`
34
35			`#include "ppp.h"`
36			`#include "pppdebug.h"`
37
38			`#include "vj.h"`
39
40			`#include <string.h>`
41
42			`#if VJ_SUPPORT`
43
44			`#if LINK_STATS`
45			`#define INCR(counter) ++comp->stats.counter`
46			`#else`
47			`#define INCR(counter)`
48			`#endif`
49
50			`#if defined(NO_CHAR_BITFIELDS)`
51			`#define getip_hl(base) ((base).ip_hl_v&0xf)`
52			`#define getth_off(base) (((base).th_x2_off&0xf0)>>4)`
53			`#else`
54			`#define getip_hl(base) ((base).ip_hl)`
55			`#define getth_off(base) ((base).th_off)`
56			`#endif`
57
58			`void`
59			`vj_compress_init(struct vjcompress *comp)`
60			`{`
61			`register u_int i;`
62			`register struct cstate *tstate = comp->tstate;`
63
64			`#if MAX_SLOTS == 0`
65			`memset((char )comp, 0, sizeof(comp));`
66			`#endif`
67			`comp->maxSlotIndex = MAX_SLOTS - 1;`
68			`comp->compressSlot = 0; /* Disable slot ID compression by default. */`
69			`for (i = MAX_SLOTS - 1; i > 0; --i) {`
70			`tstate[i].cs_id = i;`
71			`tstate[i].cs_next = &tstate[i - 1];`
72			`}`
73			`tstate[0].cs_next = &tstate[MAX_SLOTS - 1];`
74			`tstate[0].cs_id = 0;`
75			`comp->last_cs = &tstate[0];`
76			`comp->last_recv = 255;`
77			`comp->last_xmit = 255;`
78			`comp->flags = VJF_TOSS;`
79			`}`
80
81
82			`/* ENCODE encodes a number that is known to be non-zero. ENCODEZ`
83			`* checks for zero (since zero has to be encoded in the long, 3 byte`
84			`* form).`
85			`*/`
86			`#define ENCODE(n) { \`
87			`if ((u_short)(n) >= 256) { \`
88			`*cp++ = 0; \`
89			`cp[1] = (n); \`
90			`cp[0] = (n) >> 8; \`
91			`cp += 2; \`
92			`} else { \`
93			`*cp++ = (n); \`
94			`} \`
95			`}`
96			`#define ENCODEZ(n) { \`
97			`if ((u_short)(n) >= 256 \|\| (u_short)(n) == 0) { \`
98			`*cp++ = 0; \`
99			`cp[1] = (n); \`
100			`cp[0] = (n) >> 8; \`
101			`cp += 2; \`
102			`} else { \`
103			`*cp++ = (n); \`
104			`} \`
105			`}`
106
107			`#define DECODEL(f) { \`
108			`if (*cp == 0) {\`
109			`u32_t tmp = ntohl(f) + ((cp[1] << 8) \| cp[2]); \`
110			`(f) = htonl(tmp); \`
111			`cp += 3; \`
112			`} else { \`
113			`u32_t tmp = ntohl(f) + (u32_t)*cp++; \`
114			`(f) = htonl(tmp); \`
115			`} \`
116			`}`
117
118			`#define DECODES(f) { \`
119			`if (*cp == 0) {\`
120			`u_short tmp = ntohs(f) + (((u_short)cp[1] << 8) \| cp[2]); \`
121			`(f) = htons(tmp); \`
122			`cp += 3; \`
123			`} else { \`
124			`u_short tmp = ntohs(f) + (u_short)*cp++; \`
125			`(f) = htons(tmp); \`
126			`} \`
127			`}`
128
129			`#define DECODEU(f) { \`
130			`if (*cp == 0) {\`
131			`(f) = htons(((u_short)cp[1] << 8) \| cp[2]); \`
132			`cp += 3; \`
133			`} else { \`
134			`(f) = htons((u_short)*cp++); \`
135			`} \`
136			`}`
137
138			`/*`
139			`* vj_compress_tcp - Attempt to do Van Jacobsen header compression on a`
140			`* packet. This assumes that nb and comp are not null and that the first`
141			`* buffer of the chain contains a valid IP header.`
142			`* Return the VJ type code indicating whether or not the packet was`
143			`* compressed.`
144			`*/`
145			`u_int`
146			`vj_compress_tcp(struct vjcompress comp, struct pbuf pb)`
147			`{`
148			`register struct ip ip = (struct ip )pb->payload;`
149			`register struct cstate *cs = comp->last_cs->cs_next;`
150			`register u_short hlen = getip_hl(*ip);`
151			`register struct tcphdr *oth;`
152			`register struct tcphdr *th;`
153			`register u_short deltaS, deltaA;`
154			`register u_long deltaL;`
155			`register u_int changes = 0;`
156			`u_char new_seq[16];`
157			`register u_char *cp = new_seq;`
158
159			`/*`
160			`* Check that the packet is IP proto TCP.`
161			`*/`
162			`if (ip->ip_p != IPPROTO_TCP) {`
163			`return (TYPE_IP);`
164			`}`
165
166			`/*`
167			`* Bail if this is an IP fragment or if the TCP packet isn't`
168			* `compressible' (i.e., ACK isn't set or some other control bit is
169			`* set).`
170			`*/`
171			`if ((ip->ip_off & htons(0x3fff)) \|\| pb->tot_len < 40) {`
172			`return (TYPE_IP);`
173			`}`
174			`th = (struct tcphdr )&((long )ip)[hlen];`
175			`if ((th->th_flags & (TCP_SYN\|TCP_FIN\|TCP_RST\|TCP_ACK)) != TCP_ACK) {`
176			`return (TYPE_IP);`
177			`}`
178			`/*`
179			`* Packet is compressible -- we're going to send either a`
180			`* COMPRESSED_TCP or UNCOMPRESSED_TCP packet. Either way we need`
181			`* to locate (or create) the connection state. Special case the`
182			`* most recently used connection since it's most likely to be used`
183			`* again & we don't have to do any reordering if it's used.`
184			`*/`
185			`INCR(vjs_packets);`
186			`if (ip->ip_src.s_addr != cs->cs_ip.ip_src.s_addr`
187			`\|\| ip->ip_dst.s_addr != cs->cs_ip.ip_dst.s_addr`
188			`\|\| (long )th != ((long *)&cs->cs_ip)[getip_hl(cs->cs_ip)]) {`
189			`/*`
190			`* Wasn't the first -- search for it.`
191			`*`
192			`* States are kept in a circularly linked list with`
193			`* last_cs pointing to the end of the list. The`
194			`* list is kept in lru order by moving a state to the`
195			`* head of the list whenever it is referenced. Since`
196			`* the list is short and, empirically, the connection`
197			`* we want is almost always near the front, we locate`
198			`* states via linear search. If we don't find a state`
199			`* for the datagram, the oldest state is (re-)used.`
200			`*/`
201			`register struct cstate *lcs;`
202			`register struct cstate *lastcs = comp->last_cs;`
203
204			`do {`
205			`lcs = cs; cs = cs->cs_next;`
206			`INCR(vjs_searches);`
207			`if (ip->ip_src.s_addr == cs->cs_ip.ip_src.s_addr`
208			`&& ip->ip_dst.s_addr == cs->cs_ip.ip_dst.s_addr`
209			`&& (long )th == ((long *)&cs->cs_ip)[getip_hl(cs->cs_ip)]) {`
210			`goto found;`
211			`}`
212			`} while (cs != lastcs);`
213
214			`/*`
215			`* Didn't find it -- re-use oldest cstate. Send an`
216			`* uncompressed packet that tells the other side what`
217			`* connection number we're using for this conversation.`
218			`* Note that since the state list is circular, the oldest`
219			`* state points to the newest and we only need to set`
220			`* last_cs to update the lru linkage.`
221			`*/`
222			`INCR(vjs_misses);`
223			`comp->last_cs = lcs;`
224			`hlen += getth_off(*th);`
225			`hlen <<= 2;`
226			`/* Check that the IP/TCP headers are contained in the first buffer. */`
227			`if (hlen > pb->len) {`
228			`return (TYPE_IP);`
229			`}`
230			`goto uncompressed;`
231
232			`found:`
233			`/*`
234			`* Found it -- move to the front on the connection list.`
235			`*/`
236			`if (cs == lastcs) {`
237			`comp->last_cs = lcs;`
238			`} else {`
239			`lcs->cs_next = cs->cs_next;`
240			`cs->cs_next = lastcs->cs_next;`
241			`lastcs->cs_next = cs;`
242			`}`
243			`}`
244
245			`oth = (struct tcphdr )&((long )&cs->cs_ip)[hlen];`
246			`deltaS = hlen;`
247			`hlen += getth_off(*th);`
248			`hlen <<= 2;`
249			`/* Check that the IP/TCP headers are contained in the first buffer. */`
250			`if (hlen > pb->len) {`
251			`PPPDEBUG((LOG_INFO, "vj_compress_tcp: header len %d spans buffers\n", hlen));`
252			`return (TYPE_IP);`
253			`}`
254
255			`/*`
256			`* Make sure that only what we expect to change changed. The first`
257			* line of the `if' checks the IP protocol version, header length &
258			`* type of service. The 2nd line checks the "Don't fragment" bit.`
259			`* The 3rd line checks the time-to-live and protocol (the protocol`
260			`* check is unnecessary but costless). The 4th line checks the TCP`
261			`* header length. The 5th line checks IP options, if any. The 6th`
262			`* line checks TCP options, if any. If any of these things are`
263			`* different between the previous & current datagram, we send the`
264			* current datagram `uncompressed'.
265			`*/`
266			`if (((u_short )ip)[0] != ((u_short )&cs->cs_ip)[0]`
267			`\|\| ((u_short )ip)[3] != ((u_short )&cs->cs_ip)[3]`
268			`\|\| ((u_short )ip)[4] != ((u_short )&cs->cs_ip)[4]`
269			`\|\| getth_off(th) != getth_off(oth)`
270			`\|\| (deltaS > 5 && BCMP(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2))`
271			`\|\| (getth_off(th) > 5 && BCMP(th + 1, oth + 1, (getth_off(th) - 5) << 2))) {`
272			`goto uncompressed;`
273			`}`
274
275			`/*`
276			`* Figure out which of the changing fields changed. The`
277			`* receiver expects changes in the order: urgent, window,`
278			`* ack, seq (the order minimizes the number of temporaries`
279			`* needed in this section of code).`
280			`*/`
281			`if (th->th_flags & TCP_URG) {`
282			`deltaS = ntohs(th->th_urp);`
283			`ENCODEZ(deltaS);`
284			`changes \|= NEW_U;`
285			`} else if (th->th_urp != oth->th_urp) {`
286			`/* argh! URG not set but urp changed -- a sensible`
287			`* implementation should never do this but RFC793`
288			`* doesn't prohibit the change so we have to deal`
289			`* with it. */`
290			`goto uncompressed;`
291			`}`
292
293			`if ((deltaS = (u_short)(ntohs(th->th_win) - ntohs(oth->th_win))) != 0) {`
294			`ENCODE(deltaS);`
295			`changes \|= NEW_W;`
296			`}`
297
298			`if ((deltaL = ntohl(th->th_ack) - ntohl(oth->th_ack)) != 0) {`
299			`if (deltaL > 0xffff) {`
300			`goto uncompressed;`
301			`}`
302			`deltaA = (u_short)deltaL;`
303			`ENCODE(deltaA);`
304			`changes \|= NEW_A;`
305			`}`
306
307			`if ((deltaL = ntohl(th->th_seq) - ntohl(oth->th_seq)) != 0) {`
308			`if (deltaL > 0xffff) {`
309			`goto uncompressed;`
310			`}`
311			`deltaS = (u_short)deltaL;`
312			`ENCODE(deltaS);`
313			`changes \|= NEW_S;`
314			`}`
315
316			`switch(changes) {`
317			`case 0:`
318			`/*`
319			`* Nothing changed. If this packet contains data and the`
320			`* last one didn't, this is probably a data packet following`
321			`* an ack (normal on an interactive connection) and we send`
322			`* it compressed. Otherwise it's probably a retransmit,`
323			`* retransmitted ack or window probe. Send it uncompressed`
324			`* in case the other side missed the compressed version.`
325			`*/`
326			`if (ip->ip_len != cs->cs_ip.ip_len &&`
327			`ntohs(cs->cs_ip.ip_len) == hlen) {`
328			`break;`
329			`}`
330
331			`/* (fall through) */`
332
333			`case SPECIAL_I:`
334			`case SPECIAL_D:`
335			`/*`
336			`* actual changes match one of our special case encodings --`
337			`* send packet uncompressed.`
338			`*/`
339			`goto uncompressed;`
340
341			`case NEW_S\|NEW_A:`
342			`if (deltaS == deltaA && deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {`
343			`/* special case for echoed terminal traffic */`
344			`changes = SPECIAL_I;`
345			`cp = new_seq;`
346			`}`
347			`break;`
348
349			`case NEW_S:`
350			`if (deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {`
351			`/* special case for data xfer */`
352			`changes = SPECIAL_D;`
353			`cp = new_seq;`
354			`}`
355			`break;`
356			`}`
357
358			`deltaS = (u_short)(ntohs(ip->ip_id) - ntohs(cs->cs_ip.ip_id));`
359			`if (deltaS != 1) {`
360			`ENCODEZ(deltaS);`
361			`changes \|= NEW_I;`
362			`}`
363			`if (th->th_flags & TCP_PSH) {`
364			`changes \|= TCP_PUSH_BIT;`
365			`}`
366			`/*`
367			`* Grab the cksum before we overwrite it below. Then update our`
368			`* state with this packet's header.`
369			`*/`
370			`deltaA = ntohs(th->th_sum);`
371			`BCOPY(ip, &cs->cs_ip, hlen);`
372
373			`/*`
374			`* We want to use the original packet as our compressed packet.`
375			`* (cp - new_seq) is the number of bytes we need for compressed`
376			`* sequence numbers. In addition we need one byte for the change`
377			`* mask, one for the connection id and two for the tcp checksum.`
378			`* So, (cp - new_seq) + 4 bytes of header are needed. hlen is how`
379			`* many bytes of the original packet to toss so subtract the two to`
380			`* get the new packet size.`
381			`*/`
382			`deltaS = (u_short)(cp - new_seq);`
383			`if (!comp->compressSlot \|\| comp->last_xmit != cs->cs_id) {`
384			`comp->last_xmit = cs->cs_id;`
385			`hlen -= deltaS + 4;`
386			`if(pbuf_header(pb, -hlen)){`
387			`/* Can we cope with this failing? Just assert for now */`
388			`LWIP_ASSERT("pbuf_header failed\n", 0);`
389			`}`
390			`cp = (u_char *)pb->payload;`
391			`*cp++ = changes \| NEW_C;`
392			`*cp++ = cs->cs_id;`
393			`} else {`
394			`hlen -= deltaS + 3;`
395			`if(pbuf_header(pb, -hlen)) {`
396			`/* Can we cope with this failing? Just assert for now */`
397			`LWIP_ASSERT("pbuf_header failed\n", 0);`
398			`}`
399			`cp = (u_char *)pb->payload;`
400			`*cp++ = changes;`
401			`}`
402			`*cp++ = deltaA >> 8;`
403			`*cp++ = deltaA;`
404			`BCOPY(new_seq, cp, deltaS);`
405			`INCR(vjs_compressed);`
406			`return (TYPE_COMPRESSED_TCP);`
407
408			`/*`
409			`* Update connection state cs & send uncompressed packet (that is,`
410			`* 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			`* Called when we may have missed a packet.`
422			`*/`
423			`void`
424			`vj_uncompress_err(struct vjcompress *comp)`
425			`{`
426			`comp->flags \|= VJF_TOSS;`
427			`INCR(vjs_errorin);`
428			`}`
429
430			`/*`
431			`* "Uncompress" a packet of type TYPE_UNCOMPRESSED_TCP.`
432			`* Return 0 on success, -1 on failure.`
433			`*/`
434			`int`
435			`vj_uncompress_uncomp(struct pbuf nb, struct vjcompress comp)`
436			`{`
437			`register u_int hlen;`
438			`register struct cstate *cs;`
439			`register struct ip *ip;`
440
441			`ip = (struct ip *)nb->payload;`
442			`hlen = getip_hl(*ip) << 2;`
443			`if (ip->ip_p >= MAX_SLOTS`
444			`\|\| hlen + sizeof(struct tcphdr) > nb->len`
445			`\|\| (hlen += getth_off(((struct tcphdr )&((char *)ip)[hlen])) << 2)`
446			`> nb->len`
447			`\|\| hlen > MAX_HDR) {`
448			`PPPDEBUG((LOG_INFO, "vj_uncompress_uncomp: bad cid=%d, hlen=%d buflen=%d\n",`
449			`ip->ip_p, hlen, nb->len));`
450			`comp->flags \|= VJF_TOSS;`
451			`INCR(vjs_errorin);`
452			`return -1;`
453			`}`
454			`cs = &comp->rstate[comp->last_recv = ip->ip_p];`
455			`comp->flags &=~ VJF_TOSS;`
456			`ip->ip_p = IPPROTO_TCP;`
457			`BCOPY(ip, &cs->cs_ip, hlen);`
458			`cs->cs_hlen = hlen;`
459			`INCR(vjs_uncompressedin);`
460			`return 0;`
461			`}`
462
463			`/*`
464			`* Uncompress a packet of type TYPE_COMPRESSED_TCP.`
465			`* The packet is composed of a buffer chain and the first buffer`
466			`* must contain an accurate chain length.`
467			`* The first buffer must include the entire compressed TCP/IP header.`
468			`* This procedure replaces the compressed header with the uncompressed`
469			`* header and returns the length of the VJ header.`
470			`*/`
471			`int`
472			`vj_uncompress_tcp(struct pbuf *nb, struct vjcompress comp)`
473			`{`
474			`u_char *cp;`
475			`struct tcphdr *th;`
476			`struct cstate *cs;`
477			`u_short *bp;`
478			`struct pbuf n0 = nb;`
479			`u32_t tmp;`
480			`u_int vjlen, hlen, changes;`
481
482			`INCR(vjs_compressedin);`
483			`cp = (u_char *)n0->payload;`
484			`changes = *cp++;`
485			`if (changes & NEW_C) {`
486			`/*`
487			`* Make sure the state index is in range, then grab the state.`
488			`* If we have a good state index, clear the 'discard' flag.`
489			`*/`
490			`if (*cp >= MAX_SLOTS) {`
491			`PPPDEBUG((LOG_INFO, "vj_uncompress_tcp: bad cid=%d\n", *cp));`
492			`goto bad;`
493			`}`
494
495			`comp->flags &=~ VJF_TOSS;`
496			`comp->last_recv = *cp++;`
497			`} else {`
498			`/*`
499			`* this packet has an implicit state index. If we've`
500			`* had a line error since the last time we got an`
501			`* explicit state index, we have to toss the packet.`
502			`*/`
503			`if (comp->flags & VJF_TOSS) {`
504			`PPPDEBUG((LOG_INFO, "vj_uncompress_tcp: tossing\n"));`
505			`INCR(vjs_tossed);`
506			`return (-1);`
507			`}`
508			`}`
509			`cs = &comp->rstate[comp->last_recv];`
510			`hlen = getip_hl(cs->cs_ip) << 2;`
511			`th = (struct tcphdr )&((u_char )&cs->cs_ip)[hlen];`
512			`th->th_sum = htons((*cp << 8) \| cp[1]);`
513			`cp += 2;`
514			`if (changes & TCP_PUSH_BIT) {`
515			`th->th_flags \|= TCP_PSH;`
516			`} else {`
517			`th->th_flags &=~ TCP_PSH;`
518			`}`
519
520			`switch (changes & SPECIALS_MASK) {`
521			`case SPECIAL_I:`
522			`{`
523			`register u32_t i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;`
524			`/* some compilers can't nest inline assembler.. */`
525			`tmp = ntohl(th->th_ack) + i;`
526			`th->th_ack = htonl(tmp);`
527			`tmp = ntohl(th->th_seq) + i;`
528			`th->th_seq = htonl(tmp);`
529			`}`
530			`break;`
531
532			`case SPECIAL_D:`
533			`/* some compilers can't nest inline assembler.. */`
534			`tmp = ntohl(th->th_seq) + ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;`
535			`th->th_seq = htonl(tmp);`
536			`break;`
537
538			`default:`
539			`if (changes & NEW_U) {`
540			`th->th_flags \|= TCP_URG;`
541			`DECODEU(th->th_urp);`
542			`} else {`
543			`th->th_flags &=~ TCP_URG;`
544			`}`
545			`if (changes & NEW_W) {`
546			`DECODES(th->th_win);`
547			`}`
548			`if (changes & NEW_A) {`
549			`DECODEL(th->th_ack);`
550			`}`
551			`if (changes & NEW_S) {`
552			`DECODEL(th->th_seq);`
553			`}`
554			`break;`
555			`}`
556			`if (changes & NEW_I) {`
557			`DECODES(cs->cs_ip.ip_id);`
558			`} else {`
559			`cs->cs_ip.ip_id = ntohs(cs->cs_ip.ip_id) + 1;`
560			`cs->cs_ip.ip_id = htons(cs->cs_ip.ip_id);`
561			`}`
562
563			`/*`
564			`* At this point, cp points to the first byte of data in the`
565			`* packet. Fill in the IP total length and update the IP`
566			`* header checksum.`
567			`*/`
568			`vjlen = (u_short)(cp - (u_char*)n0->payload);`
569			`if (n0->len < vjlen) {`
570			`/*`
571			`* We must have dropped some characters (crc should detect`
572			`* this but the old slip framing won't)`
573			`*/`
574			`PPPDEBUG((LOG_INFO, "vj_uncompress_tcp: head buffer %d too short %d\n",`
575			`n0->len, vjlen));`
576			`goto bad;`
577			`}`
578
579			`#if BYTE_ORDER == LITTLE_ENDIAN`
580			`tmp = n0->tot_len - vjlen + cs->cs_hlen;`
581			`cs->cs_ip.ip_len = htons(tmp);`
582			`#else`
583			`cs->cs_ip.ip_len = htons(n0->tot_len - vjlen + cs->cs_hlen);`
584			`#endif`
585
586			`/* recompute the ip header checksum */`
587			`bp = (u_short *) &cs->cs_ip;`
588			`cs->cs_ip.ip_sum = 0;`
589			`for (tmp = 0; hlen > 0; hlen -= 2) {`
590			`tmp += *bp++;`
591			`}`
592			`tmp = (tmp & 0xffff) + (tmp >> 16);`
593			`tmp = (tmp & 0xffff) + (tmp >> 16);`
594			`cs->cs_ip.ip_sum = (u_short)(~tmp);`
595
596			`/* Remove the compressed header and prepend the uncompressed header. */`
597			`if(pbuf_header(n0, -((s16_t)(vjlen)))) {`
598			`/* Can we cope with this failing? Just assert for now */`
599			`LWIP_ASSERT("pbuf_header failed\n", 0);`
600			`goto bad;`
601			`}`
602
603			`if(LWIP_MEM_ALIGN(n0->payload) != n0->payload) {`
604			`struct pbuf np, q;`
605			`u8_t *bufptr;`
606
607			`np = pbuf_alloc(PBUF_RAW, n0->len + cs->cs_hlen, PBUF_POOL);`
608			`if(!np) {`
609			`PPPDEBUG((LOG_WARNING, "vj_uncompress_tcp: realign failed\n"));`
610			`goto bad;`
611			`}`
612
613			`if(pbuf_header(np, -cs->cs_hlen)) {`
614			`/* Can we cope with this failing? Just assert for now */`
615			`LWIP_ASSERT("pbuf_header failed\n", 0);`
616			`goto bad;`
617			`}`
618
619			`bufptr = n0->payload;`
620			`for(q = np; q != NULL; q = q->next) {`
621			`MEMCPY(q->payload, bufptr, q->len);`
622			`bufptr += q->len;`
623			`}`
624
625			`if(n0->next) {`
626			`pbuf_chain(np, n0->next);`
627			`pbuf_dechain(n0);`
628			`}`
629			`pbuf_free(n0);`
630			`n0 = np;`
631			`}`
632
633			`if(pbuf_header(n0, cs->cs_hlen)) {`
634			`struct pbuf *np;`
635
636			`LWIP_ASSERT("vj_uncompress_tcp: cs->cs_hlen <= PBUF_POOL_BUFSIZE", cs->cs_hlen <= PBUF_POOL_BUFSIZE);`
637			`np = pbuf_alloc(PBUF_RAW, cs->cs_hlen, PBUF_POOL);`
638			`if(!np) {`
639			`PPPDEBUG((LOG_WARNING, "vj_uncompress_tcp: prepend failed\n"));`
640			`goto bad;`
641			`}`
642			`pbuf_cat(np, n0);`
643			`n0 = np;`
644			`}`
645			`LWIP_ASSERT("n0->len >= cs->cs_hlen", n0->len >= cs->cs_hlen);`
646			`MEMCPY(n0->payload, &cs->cs_ip, cs->cs_hlen);`
647
648			`*nb = n0;`
649
650			`return vjlen;`
651
652			`bad:`
653			`comp->flags \|= VJF_TOSS;`
654			`INCR(vjs_errorin);`
655			`return (-1);`
656			`}`
657
658			`#endif /* VJ_SUPPORT */`
659
660			`#endif /* PPP_SUPPORT */`