linux/drivers/net/slip/slhc.c
<<
>>
Prefs
   1/*
   2 * Routines to compress and uncompress 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 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19 *
  20 *      Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
  21 *      - Initial distribution.
  22 *
  23 *
  24 * modified for KA9Q Internet Software Package by
  25 * Katie Stevens (dkstevens@ucdavis.edu)
  26 * University of California, Davis
  27 * Computing Services
  28 *      - 01-31-90      initial adaptation (from 1.19)
  29 *      PPP.05  02-15-90 [ks]
  30 *      PPP.08  05-02-90 [ks]   use PPP protocol field to signal compression
  31 *      PPP.15  09-90    [ks]   improve mbuf handling
  32 *      PPP.16  11-02    [karn] substantially rewritten to use NOS facilities
  33 *
  34 *      - Feb 1991      Bill_Simpson@um.cc.umich.edu
  35 *                      variable number of conversation slots
  36 *                      allow zero or one slots
  37 *                      separate routines
  38 *                      status display
  39 *      - Jul 1994      Dmitry Gorodchanin
  40 *                      Fixes for memory leaks.
  41 *      - Oct 1994      Dmitry Gorodchanin
  42 *                      Modularization.
  43 *      - Jan 1995      Bjorn Ekwall
  44 *                      Use ip_fast_csum from ip.h
  45 *      - July 1995     Christos A. Polyzols
  46 *                      Spotted bug in tcp option checking
  47 *
  48 *
  49 *      This module is a difficult issue. It's clearly inet code but it's also clearly
  50 *      driver code belonging close to PPP and SLIP
  51 */
  52
  53#include <linux/module.h>
  54#include <linux/slab.h>
  55#include <linux/types.h>
  56#include <linux/string.h>
  57#include <linux/errno.h>
  58#include <linux/kernel.h>
  59#include <net/slhc_vj.h>
  60
  61#ifdef CONFIG_INET
  62/* Entire module is for IP only */
  63#include <linux/mm.h>
  64#include <linux/socket.h>
  65#include <linux/sockios.h>
  66#include <linux/termios.h>
  67#include <linux/in.h>
  68#include <linux/fcntl.h>
  69#include <linux/inet.h>
  70#include <linux/netdevice.h>
  71#include <net/ip.h>
  72#include <net/protocol.h>
  73#include <net/icmp.h>
  74#include <net/tcp.h>
  75#include <linux/skbuff.h>
  76#include <net/sock.h>
  77#include <linux/timer.h>
  78#include <linux/uaccess.h>
  79#include <net/checksum.h>
  80#include <asm/unaligned.h>
  81
  82static unsigned char *encode(unsigned char *cp, unsigned short n);
  83static long decode(unsigned char **cpp);
  84static unsigned char * put16(unsigned char *cp, unsigned short x);
  85static unsigned short pull16(unsigned char **cpp);
  86
  87/* Allocate compression data structure
  88 *      slots must be in range 0 to 255 (zero meaning no compression)
  89 * Returns pointer to structure or ERR_PTR() on error.
  90 */
  91struct slcompress *
  92slhc_init(int rslots, int tslots)
  93{
  94        register short i;
  95        register struct cstate *ts;
  96        struct slcompress *comp;
  97
  98        if (rslots < 0 || rslots > 255 || tslots < 0 || tslots > 255)
  99                return ERR_PTR(-EINVAL);
 100
 101        comp = kzalloc(sizeof(struct slcompress), GFP_KERNEL);
 102        if (! comp)
 103                goto out_fail;
 104
 105        if (rslots > 0) {
 106                size_t rsize = rslots * sizeof(struct cstate);
 107                comp->rstate = kzalloc(rsize, GFP_KERNEL);
 108                if (! comp->rstate)
 109                        goto out_free;
 110                comp->rslot_limit = rslots - 1;
 111        }
 112
 113        if (tslots > 0) {
 114                size_t tsize = tslots * sizeof(struct cstate);
 115                comp->tstate = kzalloc(tsize, GFP_KERNEL);
 116                if (! comp->tstate)
 117                        goto out_free2;
 118                comp->tslot_limit = tslots - 1;
 119        }
 120
 121        comp->xmit_oldest = 0;
 122        comp->xmit_current = 255;
 123        comp->recv_current = 255;
 124        /*
 125         * don't accept any packets with implicit index until we get
 126         * one with an explicit index.  Otherwise the uncompress code
 127         * will try to use connection 255, which is almost certainly
 128         * out of range
 129         */
 130        comp->flags |= SLF_TOSS;
 131
 132        if ( tslots > 0 ) {
 133                ts = comp->tstate;
 134                for(i = comp->tslot_limit; i > 0; --i){
 135                        ts[i].cs_this = i;
 136                        ts[i].next = &(ts[i - 1]);
 137                }
 138                ts[0].next = &(ts[comp->tslot_limit]);
 139                ts[0].cs_this = 0;
 140        }
 141        return comp;
 142
 143out_free2:
 144        kfree(comp->rstate);
 145out_free:
 146        kfree(comp);
 147out_fail:
 148        return ERR_PTR(-ENOMEM);
 149}
 150
 151
 152/* Free a compression data structure */
 153void
 154slhc_free(struct slcompress *comp)
 155{
 156        if ( comp == NULLSLCOMPR )
 157                return;
 158
 159        if ( comp->tstate != NULLSLSTATE )
 160                kfree( comp->tstate );
 161
 162        if ( comp->rstate != NULLSLSTATE )
 163                kfree( comp->rstate );
 164
 165        kfree( comp );
 166}
 167
 168
 169/* Put a short in host order into a char array in network order */
 170static inline unsigned char *
 171put16(unsigned char *cp, unsigned short x)
 172{
 173        *cp++ = x >> 8;
 174        *cp++ = x;
 175
 176        return cp;
 177}
 178
 179
 180/* Encode a number */
 181static unsigned char *
 182encode(unsigned char *cp, unsigned short n)
 183{
 184        if(n >= 256 || n == 0){
 185                *cp++ = 0;
 186                cp = put16(cp,n);
 187        } else {
 188                *cp++ = n;
 189        }
 190        return cp;
 191}
 192
 193/* Pull a 16-bit integer in host order from buffer in network byte order */
 194static unsigned short
 195pull16(unsigned char **cpp)
 196{
 197        short rval;
 198
 199        rval = *(*cpp)++;
 200        rval <<= 8;
 201        rval |= *(*cpp)++;
 202        return rval;
 203}
 204
 205/* Decode a number */
 206static long
 207decode(unsigned char **cpp)
 208{
 209        register int x;
 210
 211        x = *(*cpp)++;
 212        if(x == 0){
 213                return pull16(cpp) & 0xffff;    /* pull16 returns -1 on error */
 214        } else {
 215                return x & 0xff;                /* -1 if PULLCHAR returned error */
 216        }
 217}
 218
 219/*
 220 * icp and isize are the original packet.
 221 * ocp is a place to put a copy if necessary.
 222 * cpp is initially a pointer to icp.  If the copy is used,
 223 *    change it to ocp.
 224 */
 225
 226int
 227slhc_compress(struct slcompress *comp, unsigned char *icp, int isize,
 228        unsigned char *ocp, unsigned char **cpp, int compress_cid)
 229{
 230        register struct cstate *ocs = &(comp->tstate[comp->xmit_oldest]);
 231        register struct cstate *lcs = ocs;
 232        register struct cstate *cs = lcs->next;
 233        register unsigned long deltaS, deltaA;
 234        register short changes = 0;
 235        int hlen;
 236        unsigned char new_seq[16];
 237        register unsigned char *cp = new_seq;
 238        struct iphdr *ip;
 239        struct tcphdr *th, *oth;
 240        __sum16 csum;
 241
 242
 243        /*
 244         *      Don't play with runt packets.
 245         */
 246
 247        if(isize<sizeof(struct iphdr))
 248                return isize;
 249
 250        ip = (struct iphdr *) icp;
 251
 252        /* Bail if this packet isn't TCP, or is an IP fragment */
 253        if (ip->protocol != IPPROTO_TCP || (ntohs(ip->frag_off) & 0x3fff)) {
 254                /* Send as regular IP */
 255                if(ip->protocol != IPPROTO_TCP)
 256                        comp->sls_o_nontcp++;
 257                else
 258                        comp->sls_o_tcp++;
 259                return isize;
 260        }
 261        /* Extract TCP header */
 262
 263        th = (struct tcphdr *)(((unsigned char *)ip) + ip->ihl*4);
 264        hlen = ip->ihl*4 + th->doff*4;
 265
 266        /*  Bail if the TCP packet isn't `compressible' (i.e., ACK isn't set or
 267         *  some other control bit is set). Also uncompressible if
 268         *  it's a runt.
 269         */
 270        if(hlen > isize || th->syn || th->fin || th->rst ||
 271            ! (th->ack)){
 272                /* TCP connection stuff; send as regular IP */
 273                comp->sls_o_tcp++;
 274                return isize;
 275        }
 276        /*
 277         * Packet is compressible -- we're going to send either a
 278         * COMPRESSED_TCP or UNCOMPRESSED_TCP packet.  Either way,
 279         * we need to locate (or create) the connection state.
 280         *
 281         * States are kept in a circularly linked list with
 282         * xmit_oldest pointing to the end of the list.  The
 283         * list is kept in lru order by moving a state to the
 284         * head of the list whenever it is referenced.  Since
 285         * the list is short and, empirically, the connection
 286         * we want is almost always near the front, we locate
 287         * states via linear search.  If we don't find a state
 288         * for the datagram, the oldest state is (re-)used.
 289         */
 290        for ( ; ; ) {
 291                if( ip->saddr == cs->cs_ip.saddr
 292                 && ip->daddr == cs->cs_ip.daddr
 293                 && th->source == cs->cs_tcp.source
 294                 && th->dest == cs->cs_tcp.dest)
 295                        goto found;
 296
 297                /* if current equal oldest, at end of list */
 298                if ( cs == ocs )
 299                        break;
 300                lcs = cs;
 301                cs = cs->next;
 302                comp->sls_o_searches++;
 303        }
 304        /*
 305         * Didn't find it -- re-use oldest cstate.  Send an
 306         * uncompressed packet that tells the other side what
 307         * connection number we're using for this conversation.
 308         *
 309         * Note that since the state list is circular, the oldest
 310         * state points to the newest and we only need to set
 311         * xmit_oldest to update the lru linkage.
 312         */
 313        comp->sls_o_misses++;
 314        comp->xmit_oldest = lcs->cs_this;
 315        goto uncompressed;
 316
 317found:
 318        /*
 319         * Found it -- move to the front on the connection list.
 320         */
 321        if(lcs == ocs) {
 322                /* found at most recently used */
 323        } else if (cs == ocs) {
 324                /* found at least recently used */
 325                comp->xmit_oldest = lcs->cs_this;
 326        } else {
 327                /* more than 2 elements */
 328                lcs->next = cs->next;
 329                cs->next = ocs->next;
 330                ocs->next = cs;
 331        }
 332
 333        /*
 334         * Make sure that only what we expect to change changed.
 335         * Check the following:
 336         * IP protocol version, header length & type of service.
 337         * The "Don't fragment" bit.
 338         * The time-to-live field.
 339         * The TCP header length.
 340         * IP options, if any.
 341         * TCP options, if any.
 342         * If any of these things are different between the previous &
 343         * current datagram, we send the current datagram `uncompressed'.
 344         */
 345        oth = &cs->cs_tcp;
 346
 347        if(ip->version != cs->cs_ip.version || ip->ihl != cs->cs_ip.ihl
 348         || ip->tos != cs->cs_ip.tos
 349         || (ip->frag_off & htons(0x4000)) != (cs->cs_ip.frag_off & htons(0x4000))
 350         || ip->ttl != cs->cs_ip.ttl
 351         || th->doff != cs->cs_tcp.doff
 352         || (ip->ihl > 5 && memcmp(ip+1,cs->cs_ipopt,((ip->ihl)-5)*4) != 0)
 353         || (th->doff > 5 && memcmp(th+1,cs->cs_tcpopt,((th->doff)-5)*4) != 0)){
 354                goto uncompressed;
 355        }
 356
 357        /*
 358         * Figure out which of the changing fields changed.  The
 359         * receiver expects changes in the order: urgent, window,
 360         * ack, seq (the order minimizes the number of temporaries
 361         * needed in this section of code).
 362         */
 363        if(th->urg){
 364                deltaS = ntohs(th->urg_ptr);
 365                cp = encode(cp,deltaS);
 366                changes |= NEW_U;
 367        } else if(th->urg_ptr != oth->urg_ptr){
 368                /* argh! URG not set but urp changed -- a sensible
 369                 * implementation should never do this but RFC793
 370                 * doesn't prohibit the change so we have to deal
 371                 * with it. */
 372                goto uncompressed;
 373        }
 374        if((deltaS = ntohs(th->window) - ntohs(oth->window)) != 0){
 375                cp = encode(cp,deltaS);
 376                changes |= NEW_W;
 377        }
 378        if((deltaA = ntohl(th->ack_seq) - ntohl(oth->ack_seq)) != 0L){
 379                if(deltaA > 0x0000ffff)
 380                        goto uncompressed;
 381                cp = encode(cp,deltaA);
 382                changes |= NEW_A;
 383        }
 384        if((deltaS = ntohl(th->seq) - ntohl(oth->seq)) != 0L){
 385                if(deltaS > 0x0000ffff)
 386                        goto uncompressed;
 387                cp = encode(cp,deltaS);
 388                changes |= NEW_S;
 389        }
 390
 391        switch(changes){
 392        case 0: /* Nothing changed. If this packet contains data and the
 393                 * last one didn't, this is probably a data packet following
 394                 * an ack (normal on an interactive connection) and we send
 395                 * it compressed.  Otherwise it's probably a retransmit,
 396                 * retransmitted ack or window probe.  Send it uncompressed
 397                 * in case the other side missed the compressed version.
 398                 */
 399                if(ip->tot_len != cs->cs_ip.tot_len &&
 400                   ntohs(cs->cs_ip.tot_len) == hlen)
 401                        break;
 402                goto uncompressed;
 403        case SPECIAL_I:
 404        case SPECIAL_D:
 405                /* actual changes match one of our special case encodings --
 406                 * send packet uncompressed.
 407                 */
 408                goto uncompressed;
 409        case NEW_S|NEW_A:
 410                if(deltaS == deltaA &&
 411                    deltaS == ntohs(cs->cs_ip.tot_len) - hlen){
 412                        /* special case for echoed terminal traffic */
 413                        changes = SPECIAL_I;
 414                        cp = new_seq;
 415                }
 416                break;
 417        case NEW_S:
 418                if(deltaS == ntohs(cs->cs_ip.tot_len) - hlen){
 419                        /* special case for data xfer */
 420                        changes = SPECIAL_D;
 421                        cp = new_seq;
 422                }
 423                break;
 424        }
 425        deltaS = ntohs(ip->id) - ntohs(cs->cs_ip.id);
 426        if(deltaS != 1){
 427                cp = encode(cp,deltaS);
 428                changes |= NEW_I;
 429        }
 430        if(th->psh)
 431                changes |= TCP_PUSH_BIT;
 432        /* Grab the cksum before we overwrite it below.  Then update our
 433         * state with this packet's header.
 434         */
 435        csum = th->check;
 436        memcpy(&cs->cs_ip,ip,20);
 437        memcpy(&cs->cs_tcp,th,20);
 438        /* We want to use the original packet as our compressed packet.
 439         * (cp - new_seq) is the number of bytes we need for compressed
 440         * sequence numbers.  In addition we need one byte for the change
 441         * mask, one for the connection id and two for the tcp checksum.
 442         * So, (cp - new_seq) + 4 bytes of header are needed.
 443         */
 444        deltaS = cp - new_seq;
 445        if(compress_cid == 0 || comp->xmit_current != cs->cs_this){
 446                cp = ocp;
 447                *cpp = ocp;
 448                *cp++ = changes | NEW_C;
 449                *cp++ = cs->cs_this;
 450                comp->xmit_current = cs->cs_this;
 451        } else {
 452                cp = ocp;
 453                *cpp = ocp;
 454                *cp++ = changes;
 455        }
 456        *(__sum16 *)cp = csum;
 457        cp += 2;
 458/* deltaS is now the size of the change section of the compressed header */
 459        memcpy(cp,new_seq,deltaS);      /* Write list of deltas */
 460        memcpy(cp+deltaS,icp+hlen,isize-hlen);
 461        comp->sls_o_compressed++;
 462        ocp[0] |= SL_TYPE_COMPRESSED_TCP;
 463        return isize - hlen + deltaS + (cp - ocp);
 464
 465        /* Update connection state cs & send uncompressed packet (i.e.,
 466         * a regular ip/tcp packet but with the 'conversation id' we hope
 467         * to use on future compressed packets in the protocol field).
 468         */
 469uncompressed:
 470        memcpy(&cs->cs_ip,ip,20);
 471        memcpy(&cs->cs_tcp,th,20);
 472        if (ip->ihl > 5)
 473          memcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4);
 474        if (th->doff > 5)
 475          memcpy(cs->cs_tcpopt, th+1, ((th->doff) - 5) * 4);
 476        comp->xmit_current = cs->cs_this;
 477        comp->sls_o_uncompressed++;
 478        memcpy(ocp, icp, isize);
 479        *cpp = ocp;
 480        ocp[9] = cs->cs_this;
 481        ocp[0] |= SL_TYPE_UNCOMPRESSED_TCP;
 482        return isize;
 483}
 484
 485
 486int
 487slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize)
 488{
 489        register int changes;
 490        long x;
 491        register struct tcphdr *thp;
 492        register struct iphdr *ip;
 493        register struct cstate *cs;
 494        int len, hdrlen;
 495        unsigned char *cp = icp;
 496
 497        /* We've got a compressed packet; read the change byte */
 498        comp->sls_i_compressed++;
 499        if(isize < 3){
 500                comp->sls_i_error++;
 501                return 0;
 502        }
 503        changes = *cp++;
 504        if(changes & NEW_C){
 505                /* Make sure the state index is in range, then grab the state.
 506                 * If we have a good state index, clear the 'discard' flag.
 507                 */
 508                x = *cp++;      /* Read conn index */
 509                if(x < 0 || x > comp->rslot_limit)
 510                        goto bad;
 511
 512                /* Check if the cstate is initialized */
 513                if (!comp->rstate[x].initialized)
 514                        goto bad;
 515
 516                comp->flags &=~ SLF_TOSS;
 517                comp->recv_current = x;
 518        } else {
 519                /* this packet has an implicit state index.  If we've
 520                 * had a line error since the last time we got an
 521                 * explicit state index, we have to toss the packet. */
 522                if(comp->flags & SLF_TOSS){
 523                        comp->sls_i_tossed++;
 524                        return 0;
 525                }
 526        }
 527        cs = &comp->rstate[comp->recv_current];
 528        thp = &cs->cs_tcp;
 529        ip = &cs->cs_ip;
 530
 531        thp->check = *(__sum16 *)cp;
 532        cp += 2;
 533
 534        thp->psh = (changes & TCP_PUSH_BIT) ? 1 : 0;
 535/*
 536 * we can use the same number for the length of the saved header and
 537 * the current one, because the packet wouldn't have been sent
 538 * as compressed unless the options were the same as the previous one
 539 */
 540
 541        hdrlen = ip->ihl * 4 + thp->doff * 4;
 542
 543        switch(changes & SPECIALS_MASK){
 544        case SPECIAL_I:         /* Echoed terminal traffic */
 545                {
 546                register short i;
 547                i = ntohs(ip->tot_len) - hdrlen;
 548                thp->ack_seq = htonl( ntohl(thp->ack_seq) + i);
 549                thp->seq = htonl( ntohl(thp->seq) + i);
 550                }
 551                break;
 552
 553        case SPECIAL_D:                 /* Unidirectional data */
 554                thp->seq = htonl( ntohl(thp->seq) +
 555                                  ntohs(ip->tot_len) - hdrlen);
 556                break;
 557
 558        default:
 559                if(changes & NEW_U){
 560                        thp->urg = 1;
 561                        if((x = decode(&cp)) == -1) {
 562                                goto bad;
 563                        }
 564                        thp->urg_ptr = htons(x);
 565                } else
 566                        thp->urg = 0;
 567                if(changes & NEW_W){
 568                        if((x = decode(&cp)) == -1) {
 569                                goto bad;
 570                        }
 571                        thp->window = htons( ntohs(thp->window) + x);
 572                }
 573                if(changes & NEW_A){
 574                        if((x = decode(&cp)) == -1) {
 575                                goto bad;
 576                        }
 577                        thp->ack_seq = htonl( ntohl(thp->ack_seq) + x);
 578                }
 579                if(changes & NEW_S){
 580                        if((x = decode(&cp)) == -1) {
 581                                goto bad;
 582                        }
 583                        thp->seq = htonl( ntohl(thp->seq) + x);
 584                }
 585                break;
 586        }
 587        if(changes & NEW_I){
 588                if((x = decode(&cp)) == -1) {
 589                        goto bad;
 590                }
 591                ip->id = htons (ntohs (ip->id) + x);
 592        } else
 593                ip->id = htons (ntohs (ip->id) + 1);
 594
 595        /*
 596         * At this point, cp points to the first byte of data in the
 597         * packet.  Put the reconstructed TCP and IP headers back on the
 598         * packet.  Recalculate IP checksum (but not TCP checksum).
 599         */
 600
 601        len = isize - (cp - icp);
 602        if (len < 0)
 603                goto bad;
 604        len += hdrlen;
 605        ip->tot_len = htons(len);
 606        ip->check = 0;
 607
 608        memmove(icp + hdrlen, cp, len - hdrlen);
 609
 610        cp = icp;
 611        memcpy(cp, ip, 20);
 612        cp += 20;
 613
 614        if (ip->ihl > 5) {
 615          memcpy(cp, cs->cs_ipopt, (ip->ihl - 5) * 4);
 616          cp += (ip->ihl - 5) * 4;
 617        }
 618
 619        put_unaligned(ip_fast_csum(icp, ip->ihl),
 620                      &((struct iphdr *)icp)->check);
 621
 622        memcpy(cp, thp, 20);
 623        cp += 20;
 624
 625        if (thp->doff > 5) {
 626          memcpy(cp, cs->cs_tcpopt, ((thp->doff) - 5) * 4);
 627          cp += ((thp->doff) - 5) * 4;
 628        }
 629
 630        return len;
 631bad:
 632        comp->sls_i_error++;
 633        return slhc_toss( comp );
 634}
 635
 636
 637int
 638slhc_remember(struct slcompress *comp, unsigned char *icp, int isize)
 639{
 640        register struct cstate *cs;
 641        unsigned ihl;
 642
 643        unsigned char index;
 644
 645        if(isize < 20) {
 646                /* The packet is shorter than a legal IP header */
 647                comp->sls_i_runt++;
 648                return slhc_toss( comp );
 649        }
 650        /* Peek at the IP header's IHL field to find its length */
 651        ihl = icp[0] & 0xf;
 652        if(ihl < 20 / 4){
 653                /* The IP header length field is too small */
 654                comp->sls_i_runt++;
 655                return slhc_toss( comp );
 656        }
 657        index = icp[9];
 658        icp[9] = IPPROTO_TCP;
 659
 660        if (ip_fast_csum(icp, ihl)) {
 661                /* Bad IP header checksum; discard */
 662                comp->sls_i_badcheck++;
 663                return slhc_toss( comp );
 664        }
 665        if(index > comp->rslot_limit) {
 666                comp->sls_i_error++;
 667                return slhc_toss(comp);
 668        }
 669
 670        /* Update local state */
 671        cs = &comp->rstate[comp->recv_current = index];
 672        comp->flags &=~ SLF_TOSS;
 673        memcpy(&cs->cs_ip,icp,20);
 674        memcpy(&cs->cs_tcp,icp + ihl*4,20);
 675        if (ihl > 5)
 676          memcpy(cs->cs_ipopt, icp + sizeof(struct iphdr), (ihl - 5) * 4);
 677        if (cs->cs_tcp.doff > 5)
 678          memcpy(cs->cs_tcpopt, icp + ihl*4 + sizeof(struct tcphdr), (cs->cs_tcp.doff - 5) * 4);
 679        cs->cs_hsize = ihl*2 + cs->cs_tcp.doff*2;
 680        cs->initialized = true;
 681        /* Put headers back on packet
 682         * Neither header checksum is recalculated
 683         */
 684        comp->sls_i_uncompressed++;
 685        return isize;
 686}
 687
 688int
 689slhc_toss(struct slcompress *comp)
 690{
 691        if ( comp == NULLSLCOMPR )
 692                return 0;
 693
 694        comp->flags |= SLF_TOSS;
 695        return 0;
 696}
 697
 698#else /* CONFIG_INET */
 699
 700int
 701slhc_toss(struct slcompress *comp)
 702{
 703  printk(KERN_DEBUG "Called IP function on non IP-system: slhc_toss");
 704  return -EINVAL;
 705}
 706int
 707slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize)
 708{
 709  printk(KERN_DEBUG "Called IP function on non IP-system: slhc_uncompress");
 710  return -EINVAL;
 711}
 712int
 713slhc_compress(struct slcompress *comp, unsigned char *icp, int isize,
 714        unsigned char *ocp, unsigned char **cpp, int compress_cid)
 715{
 716  printk(KERN_DEBUG "Called IP function on non IP-system: slhc_compress");
 717  return -EINVAL;
 718}
 719
 720int
 721slhc_remember(struct slcompress *comp, unsigned char *icp, int isize)
 722{
 723  printk(KERN_DEBUG "Called IP function on non IP-system: slhc_remember");
 724  return -EINVAL;
 725}
 726
 727void
 728slhc_free(struct slcompress *comp)
 729{
 730  printk(KERN_DEBUG "Called IP function on non IP-system: slhc_free");
 731}
 732struct slcompress *
 733slhc_init(int rslots, int tslots)
 734{
 735  printk(KERN_DEBUG "Called IP function on non IP-system: slhc_init");
 736  return NULL;
 737}
 738
 739#endif /* CONFIG_INET */
 740
 741/* VJ header compression */
 742EXPORT_SYMBOL(slhc_init);
 743EXPORT_SYMBOL(slhc_free);
 744EXPORT_SYMBOL(slhc_remember);
 745EXPORT_SYMBOL(slhc_compress);
 746EXPORT_SYMBOL(slhc_uncompress);
 747EXPORT_SYMBOL(slhc_toss);
 748
 749MODULE_LICENSE("Dual BSD/GPL");
 750