![Tejun Heo](/assets/img/avatar_default.png)
percpu.h is included by sched.h and module.h and thus ends up being included when building most .c files. percpu.h includes slab.h which in turn includes gfp.h making everything defined by the two files universally available and complicating inclusion dependencies. percpu.h -> slab.h dependency is about to be removed. Prepare for this change by updating users of gfp and slab facilities include those headers directly instead of assuming availability. As this conversion needs to touch large number of source files, the following script is used as the basis of conversion. http://userweb.kernel.org/~tj/misc/slabh-sweep.py The script does the followings. * Scan files for gfp and slab usages and update includes such that only the necessary includes are there. ie. if only gfp is used, gfp.h, if slab is used, slab.h. * When the script inserts a new include, it looks at the include blocks and try to put the new include such that its order conforms to its surrounding. It's put in the include block which contains core kernel includes, in the same order that the rest are ordered - alphabetical, Christmas tree, rev-Xmas-tree or at the end if there doesn't seem to be any matching order. * If the script can't find a place to put a new include (mostly because the file doesn't have fitting include block), it prints out an error message indicating which .h file needs to be added to the file. The conversion was done in the following steps. 1. The initial automatic conversion of all .c files updated slightly over 4000 files, deleting around 700 includes and adding ~480 gfp.h and ~3000 slab.h inclusions. The script emitted errors for ~400 files. 2. Each error was manually checked. Some didn't need the inclusion, some needed manual addition while adding it to implementation .h or embedding .c file was more appropriate for others. This step added inclusions to around 150 files. 3. The script was run again and the output was compared to the edits from #2 to make sure no file was left behind. 4. Several build tests were done and a couple of problems were fixed. e.g. lib/decompress_*.c used malloc/free() wrappers around slab APIs requiring slab.h to be added manually. 5. The script was run on all .h files but without automatically editing them as sprinkling gfp.h and slab.h inclusions around .h files could easily lead to inclusion dependency hell. Most gfp.h inclusion directives were ignored as stuff from gfp.h was usually wildly available and often used in preprocessor macros. Each slab.h inclusion directive was examined and added manually as necessary. 6. percpu.h was updated not to include slab.h. 7. Build test were done on the following configurations and failures were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my distributed build env didn't work with gcov compiles) and a few more options had to be turned off depending on archs to make things build (like ipr on powerpc/64 which failed due to missing writeq). * x86 and x86_64 UP and SMP allmodconfig and a custom test config. * powerpc and powerpc64 SMP allmodconfig * sparc and sparc64 SMP allmodconfig * ia64 SMP allmodconfig * s390 SMP allmodconfig * alpha SMP allmodconfig * um on x86_64 SMP allmodconfig 8. percpu.h modifications were reverted so that it could be applied as a separate patch and serve as bisection point. Given the fact that I had only a couple of failures from tests on step 6, I'm fairly confident about the coverage of this conversion patch. If there is a breakage, it's likely to be something in one of the arch headers which should be easily discoverable easily on most builds of the specific arch. Signed-off-by: Tejun Heo <tj@kernel.org> Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
751 lines
19 KiB
C
751 lines
19 KiB
C
/*
|
|
* Routines to compress and uncompress 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 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
|
|
* - Initial distribution.
|
|
*
|
|
*
|
|
* modified for KA9Q Internet Software Package by
|
|
* Katie Stevens (dkstevens@ucdavis.edu)
|
|
* University of California, Davis
|
|
* Computing Services
|
|
* - 01-31-90 initial adaptation (from 1.19)
|
|
* PPP.05 02-15-90 [ks]
|
|
* PPP.08 05-02-90 [ks] use PPP protocol field to signal compression
|
|
* PPP.15 09-90 [ks] improve mbuf handling
|
|
* PPP.16 11-02 [karn] substantially rewritten to use NOS facilities
|
|
*
|
|
* - Feb 1991 Bill_Simpson@um.cc.umich.edu
|
|
* variable number of conversation slots
|
|
* allow zero or one slots
|
|
* separate routines
|
|
* status display
|
|
* - Jul 1994 Dmitry Gorodchanin
|
|
* Fixes for memory leaks.
|
|
* - Oct 1994 Dmitry Gorodchanin
|
|
* Modularization.
|
|
* - Jan 1995 Bjorn Ekwall
|
|
* Use ip_fast_csum from ip.h
|
|
* - July 1995 Christos A. Polyzols
|
|
* Spotted bug in tcp option checking
|
|
*
|
|
*
|
|
* This module is a difficult issue. It's clearly inet code but it's also clearly
|
|
* driver code belonging close to PPP and SLIP
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/types.h>
|
|
#include <linux/string.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/kernel.h>
|
|
#include <net/slhc_vj.h>
|
|
|
|
#ifdef CONFIG_INET
|
|
/* Entire module is for IP only */
|
|
#include <linux/mm.h>
|
|
#include <linux/socket.h>
|
|
#include <linux/sockios.h>
|
|
#include <linux/termios.h>
|
|
#include <linux/in.h>
|
|
#include <linux/fcntl.h>
|
|
#include <linux/inet.h>
|
|
#include <linux/netdevice.h>
|
|
#include <net/ip.h>
|
|
#include <net/protocol.h>
|
|
#include <net/icmp.h>
|
|
#include <net/tcp.h>
|
|
#include <linux/skbuff.h>
|
|
#include <net/sock.h>
|
|
#include <linux/timer.h>
|
|
#include <asm/system.h>
|
|
#include <asm/uaccess.h>
|
|
#include <net/checksum.h>
|
|
#include <asm/unaligned.h>
|
|
|
|
static unsigned char *encode(unsigned char *cp, unsigned short n);
|
|
static long decode(unsigned char **cpp);
|
|
static unsigned char * put16(unsigned char *cp, unsigned short x);
|
|
static unsigned short pull16(unsigned char **cpp);
|
|
|
|
/* Initialize compression data structure
|
|
* slots must be in range 0 to 255 (zero meaning no compression)
|
|
*/
|
|
struct slcompress *
|
|
slhc_init(int rslots, int tslots)
|
|
{
|
|
register short i;
|
|
register struct cstate *ts;
|
|
struct slcompress *comp;
|
|
|
|
comp = kzalloc(sizeof(struct slcompress), GFP_KERNEL);
|
|
if (! comp)
|
|
goto out_fail;
|
|
|
|
if ( rslots > 0 && rslots < 256 ) {
|
|
size_t rsize = rslots * sizeof(struct cstate);
|
|
comp->rstate = kzalloc(rsize, GFP_KERNEL);
|
|
if (! comp->rstate)
|
|
goto out_free;
|
|
comp->rslot_limit = rslots - 1;
|
|
}
|
|
|
|
if ( tslots > 0 && tslots < 256 ) {
|
|
size_t tsize = tslots * sizeof(struct cstate);
|
|
comp->tstate = kzalloc(tsize, GFP_KERNEL);
|
|
if (! comp->tstate)
|
|
goto out_free2;
|
|
comp->tslot_limit = tslots - 1;
|
|
}
|
|
|
|
comp->xmit_oldest = 0;
|
|
comp->xmit_current = 255;
|
|
comp->recv_current = 255;
|
|
/*
|
|
* don't accept any packets with implicit index until we get
|
|
* one with an explicit index. Otherwise the uncompress code
|
|
* will try to use connection 255, which is almost certainly
|
|
* out of range
|
|
*/
|
|
comp->flags |= SLF_TOSS;
|
|
|
|
if ( tslots > 0 ) {
|
|
ts = comp->tstate;
|
|
for(i = comp->tslot_limit; i > 0; --i){
|
|
ts[i].cs_this = i;
|
|
ts[i].next = &(ts[i - 1]);
|
|
}
|
|
ts[0].next = &(ts[comp->tslot_limit]);
|
|
ts[0].cs_this = 0;
|
|
}
|
|
return comp;
|
|
|
|
out_free2:
|
|
kfree(comp->rstate);
|
|
out_free:
|
|
kfree(comp);
|
|
out_fail:
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* Free a compression data structure */
|
|
void
|
|
slhc_free(struct slcompress *comp)
|
|
{
|
|
if ( comp == NULLSLCOMPR )
|
|
return;
|
|
|
|
if ( comp->tstate != NULLSLSTATE )
|
|
kfree( comp->tstate );
|
|
|
|
if ( comp->rstate != NULLSLSTATE )
|
|
kfree( comp->rstate );
|
|
|
|
kfree( comp );
|
|
}
|
|
|
|
|
|
/* Put a short in host order into a char array in network order */
|
|
static inline unsigned char *
|
|
put16(unsigned char *cp, unsigned short x)
|
|
{
|
|
*cp++ = x >> 8;
|
|
*cp++ = x;
|
|
|
|
return cp;
|
|
}
|
|
|
|
|
|
/* Encode a number */
|
|
static unsigned char *
|
|
encode(unsigned char *cp, unsigned short n)
|
|
{
|
|
if(n >= 256 || n == 0){
|
|
*cp++ = 0;
|
|
cp = put16(cp,n);
|
|
} else {
|
|
*cp++ = n;
|
|
}
|
|
return cp;
|
|
}
|
|
|
|
/* Pull a 16-bit integer in host order from buffer in network byte order */
|
|
static unsigned short
|
|
pull16(unsigned char **cpp)
|
|
{
|
|
short rval;
|
|
|
|
rval = *(*cpp)++;
|
|
rval <<= 8;
|
|
rval |= *(*cpp)++;
|
|
return rval;
|
|
}
|
|
|
|
/* Decode a number */
|
|
static long
|
|
decode(unsigned char **cpp)
|
|
{
|
|
register int x;
|
|
|
|
x = *(*cpp)++;
|
|
if(x == 0){
|
|
return pull16(cpp) & 0xffff; /* pull16 returns -1 on error */
|
|
} else {
|
|
return x & 0xff; /* -1 if PULLCHAR returned error */
|
|
}
|
|
}
|
|
|
|
/*
|
|
* icp and isize are the original packet.
|
|
* ocp is a place to put a copy if necessary.
|
|
* cpp is initially a pointer to icp. If the copy is used,
|
|
* change it to ocp.
|
|
*/
|
|
|
|
int
|
|
slhc_compress(struct slcompress *comp, unsigned char *icp, int isize,
|
|
unsigned char *ocp, unsigned char **cpp, int compress_cid)
|
|
{
|
|
register struct cstate *ocs = &(comp->tstate[comp->xmit_oldest]);
|
|
register struct cstate *lcs = ocs;
|
|
register struct cstate *cs = lcs->next;
|
|
register unsigned long deltaS, deltaA;
|
|
register short changes = 0;
|
|
int hlen;
|
|
unsigned char new_seq[16];
|
|
register unsigned char *cp = new_seq;
|
|
struct iphdr *ip;
|
|
struct tcphdr *th, *oth;
|
|
__sum16 csum;
|
|
|
|
|
|
/*
|
|
* Don't play with runt packets.
|
|
*/
|
|
|
|
if(isize<sizeof(struct iphdr))
|
|
return isize;
|
|
|
|
ip = (struct iphdr *) icp;
|
|
|
|
/* Bail if this packet isn't TCP, or is an IP fragment */
|
|
if (ip->protocol != IPPROTO_TCP || (ntohs(ip->frag_off) & 0x3fff)) {
|
|
/* Send as regular IP */
|
|
if(ip->protocol != IPPROTO_TCP)
|
|
comp->sls_o_nontcp++;
|
|
else
|
|
comp->sls_o_tcp++;
|
|
return isize;
|
|
}
|
|
/* Extract TCP header */
|
|
|
|
th = (struct tcphdr *)(((unsigned char *)ip) + ip->ihl*4);
|
|
hlen = ip->ihl*4 + th->doff*4;
|
|
|
|
/* Bail if the TCP packet isn't `compressible' (i.e., ACK isn't set or
|
|
* some other control bit is set). Also uncompressible if
|
|
* it's a runt.
|
|
*/
|
|
if(hlen > isize || th->syn || th->fin || th->rst ||
|
|
! (th->ack)){
|
|
/* TCP connection stuff; send as regular IP */
|
|
comp->sls_o_tcp++;
|
|
return isize;
|
|
}
|
|
/*
|
|
* 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.
|
|
*
|
|
* States are kept in a circularly linked list with
|
|
* xmit_oldest 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.
|
|
*/
|
|
for ( ; ; ) {
|
|
if( ip->saddr == cs->cs_ip.saddr
|
|
&& ip->daddr == cs->cs_ip.daddr
|
|
&& th->source == cs->cs_tcp.source
|
|
&& th->dest == cs->cs_tcp.dest)
|
|
goto found;
|
|
|
|
/* if current equal oldest, at end of list */
|
|
if ( cs == ocs )
|
|
break;
|
|
lcs = cs;
|
|
cs = cs->next;
|
|
comp->sls_o_searches++;
|
|
};
|
|
/*
|
|
* 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
|
|
* xmit_oldest to update the lru linkage.
|
|
*/
|
|
comp->sls_o_misses++;
|
|
comp->xmit_oldest = lcs->cs_this;
|
|
goto uncompressed;
|
|
|
|
found:
|
|
/*
|
|
* Found it -- move to the front on the connection list.
|
|
*/
|
|
if(lcs == ocs) {
|
|
/* found at most recently used */
|
|
} else if (cs == ocs) {
|
|
/* found at least recently used */
|
|
comp->xmit_oldest = lcs->cs_this;
|
|
} else {
|
|
/* more than 2 elements */
|
|
lcs->next = cs->next;
|
|
cs->next = ocs->next;
|
|
ocs->next = cs;
|
|
}
|
|
|
|
/*
|
|
* Make sure that only what we expect to change changed.
|
|
* Check the following:
|
|
* IP protocol version, header length & type of service.
|
|
* The "Don't fragment" bit.
|
|
* The time-to-live field.
|
|
* The TCP header length.
|
|
* IP options, if any.
|
|
* TCP options, if any.
|
|
* If any of these things are different between the previous &
|
|
* current datagram, we send the current datagram `uncompressed'.
|
|
*/
|
|
oth = &cs->cs_tcp;
|
|
|
|
if(ip->version != cs->cs_ip.version || ip->ihl != cs->cs_ip.ihl
|
|
|| ip->tos != cs->cs_ip.tos
|
|
|| (ip->frag_off & htons(0x4000)) != (cs->cs_ip.frag_off & htons(0x4000))
|
|
|| ip->ttl != cs->cs_ip.ttl
|
|
|| th->doff != cs->cs_tcp.doff
|
|
|| (ip->ihl > 5 && memcmp(ip+1,cs->cs_ipopt,((ip->ihl)-5)*4) != 0)
|
|
|| (th->doff > 5 && memcmp(th+1,cs->cs_tcpopt,((th->doff)-5)*4) != 0)){
|
|
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->urg){
|
|
deltaS = ntohs(th->urg_ptr);
|
|
cp = encode(cp,deltaS);
|
|
changes |= NEW_U;
|
|
} else if(th->urg_ptr != oth->urg_ptr){
|
|
/* 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 = ntohs(th->window) - ntohs(oth->window)) != 0){
|
|
cp = encode(cp,deltaS);
|
|
changes |= NEW_W;
|
|
}
|
|
if((deltaA = ntohl(th->ack_seq) - ntohl(oth->ack_seq)) != 0L){
|
|
if(deltaA > 0x0000ffff)
|
|
goto uncompressed;
|
|
cp = encode(cp,deltaA);
|
|
changes |= NEW_A;
|
|
}
|
|
if((deltaS = ntohl(th->seq) - ntohl(oth->seq)) != 0L){
|
|
if(deltaS > 0x0000ffff)
|
|
goto uncompressed;
|
|
cp = encode(cp,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->tot_len != cs->cs_ip.tot_len &&
|
|
ntohs(cs->cs_ip.tot_len) == hlen)
|
|
break;
|
|
goto uncompressed;
|
|
break;
|
|
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.tot_len) - hlen){
|
|
/* special case for echoed terminal traffic */
|
|
changes = SPECIAL_I;
|
|
cp = new_seq;
|
|
}
|
|
break;
|
|
case NEW_S:
|
|
if(deltaS == ntohs(cs->cs_ip.tot_len) - hlen){
|
|
/* special case for data xfer */
|
|
changes = SPECIAL_D;
|
|
cp = new_seq;
|
|
}
|
|
break;
|
|
}
|
|
deltaS = ntohs(ip->id) - ntohs(cs->cs_ip.id);
|
|
if(deltaS != 1){
|
|
cp = encode(cp,deltaS);
|
|
changes |= NEW_I;
|
|
}
|
|
if(th->psh)
|
|
changes |= TCP_PUSH_BIT;
|
|
/* Grab the cksum before we overwrite it below. Then update our
|
|
* state with this packet's header.
|
|
*/
|
|
csum = th->check;
|
|
memcpy(&cs->cs_ip,ip,20);
|
|
memcpy(&cs->cs_tcp,th,20);
|
|
/* 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.
|
|
*/
|
|
deltaS = cp - new_seq;
|
|
if(compress_cid == 0 || comp->xmit_current != cs->cs_this){
|
|
cp = ocp;
|
|
*cpp = ocp;
|
|
*cp++ = changes | NEW_C;
|
|
*cp++ = cs->cs_this;
|
|
comp->xmit_current = cs->cs_this;
|
|
} else {
|
|
cp = ocp;
|
|
*cpp = ocp;
|
|
*cp++ = changes;
|
|
}
|
|
*(__sum16 *)cp = csum;
|
|
cp += 2;
|
|
/* deltaS is now the size of the change section of the compressed header */
|
|
memcpy(cp,new_seq,deltaS); /* Write list of deltas */
|
|
memcpy(cp+deltaS,icp+hlen,isize-hlen);
|
|
comp->sls_o_compressed++;
|
|
ocp[0] |= SL_TYPE_COMPRESSED_TCP;
|
|
return isize - hlen + deltaS + (cp - ocp);
|
|
|
|
/* Update connection state cs & send uncompressed packet (i.e.,
|
|
* a regular ip/tcp packet but with the 'conversation id' we hope
|
|
* to use on future compressed packets in the protocol field).
|
|
*/
|
|
uncompressed:
|
|
memcpy(&cs->cs_ip,ip,20);
|
|
memcpy(&cs->cs_tcp,th,20);
|
|
if (ip->ihl > 5)
|
|
memcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4);
|
|
if (th->doff > 5)
|
|
memcpy(cs->cs_tcpopt, th+1, ((th->doff) - 5) * 4);
|
|
comp->xmit_current = cs->cs_this;
|
|
comp->sls_o_uncompressed++;
|
|
memcpy(ocp, icp, isize);
|
|
*cpp = ocp;
|
|
ocp[9] = cs->cs_this;
|
|
ocp[0] |= SL_TYPE_UNCOMPRESSED_TCP;
|
|
return isize;
|
|
}
|
|
|
|
|
|
int
|
|
slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize)
|
|
{
|
|
register int changes;
|
|
long x;
|
|
register struct tcphdr *thp;
|
|
register struct iphdr *ip;
|
|
register struct cstate *cs;
|
|
int len, hdrlen;
|
|
unsigned char *cp = icp;
|
|
|
|
/* We've got a compressed packet; read the change byte */
|
|
comp->sls_i_compressed++;
|
|
if(isize < 3){
|
|
comp->sls_i_error++;
|
|
return 0;
|
|
}
|
|
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.
|
|
*/
|
|
x = *cp++; /* Read conn index */
|
|
if(x < 0 || x > comp->rslot_limit)
|
|
goto bad;
|
|
|
|
comp->flags &=~ SLF_TOSS;
|
|
comp->recv_current = x;
|
|
} 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 & SLF_TOSS){
|
|
comp->sls_i_tossed++;
|
|
return 0;
|
|
}
|
|
}
|
|
cs = &comp->rstate[comp->recv_current];
|
|
thp = &cs->cs_tcp;
|
|
ip = &cs->cs_ip;
|
|
|
|
thp->check = *(__sum16 *)cp;
|
|
cp += 2;
|
|
|
|
thp->psh = (changes & TCP_PUSH_BIT) ? 1 : 0;
|
|
/*
|
|
* we can use the same number for the length of the saved header and
|
|
* the current one, because the packet wouldn't have been sent
|
|
* as compressed unless the options were the same as the previous one
|
|
*/
|
|
|
|
hdrlen = ip->ihl * 4 + thp->doff * 4;
|
|
|
|
switch(changes & SPECIALS_MASK){
|
|
case SPECIAL_I: /* Echoed terminal traffic */
|
|
{
|
|
register short i;
|
|
i = ntohs(ip->tot_len) - hdrlen;
|
|
thp->ack_seq = htonl( ntohl(thp->ack_seq) + i);
|
|
thp->seq = htonl( ntohl(thp->seq) + i);
|
|
}
|
|
break;
|
|
|
|
case SPECIAL_D: /* Unidirectional data */
|
|
thp->seq = htonl( ntohl(thp->seq) +
|
|
ntohs(ip->tot_len) - hdrlen);
|
|
break;
|
|
|
|
default:
|
|
if(changes & NEW_U){
|
|
thp->urg = 1;
|
|
if((x = decode(&cp)) == -1) {
|
|
goto bad;
|
|
}
|
|
thp->urg_ptr = htons(x);
|
|
} else
|
|
thp->urg = 0;
|
|
if(changes & NEW_W){
|
|
if((x = decode(&cp)) == -1) {
|
|
goto bad;
|
|
}
|
|
thp->window = htons( ntohs(thp->window) + x);
|
|
}
|
|
if(changes & NEW_A){
|
|
if((x = decode(&cp)) == -1) {
|
|
goto bad;
|
|
}
|
|
thp->ack_seq = htonl( ntohl(thp->ack_seq) + x);
|
|
}
|
|
if(changes & NEW_S){
|
|
if((x = decode(&cp)) == -1) {
|
|
goto bad;
|
|
}
|
|
thp->seq = htonl( ntohl(thp->seq) + x);
|
|
}
|
|
break;
|
|
}
|
|
if(changes & NEW_I){
|
|
if((x = decode(&cp)) == -1) {
|
|
goto bad;
|
|
}
|
|
ip->id = htons (ntohs (ip->id) + x);
|
|
} else
|
|
ip->id = htons (ntohs (ip->id) + 1);
|
|
|
|
/*
|
|
* At this point, cp points to the first byte of data in the
|
|
* packet. Put the reconstructed TCP and IP headers back on the
|
|
* packet. Recalculate IP checksum (but not TCP checksum).
|
|
*/
|
|
|
|
len = isize - (cp - icp);
|
|
if (len < 0)
|
|
goto bad;
|
|
len += hdrlen;
|
|
ip->tot_len = htons(len);
|
|
ip->check = 0;
|
|
|
|
memmove(icp + hdrlen, cp, len - hdrlen);
|
|
|
|
cp = icp;
|
|
memcpy(cp, ip, 20);
|
|
cp += 20;
|
|
|
|
if (ip->ihl > 5) {
|
|
memcpy(cp, cs->cs_ipopt, (ip->ihl - 5) * 4);
|
|
cp += (ip->ihl - 5) * 4;
|
|
}
|
|
|
|
put_unaligned(ip_fast_csum(icp, ip->ihl),
|
|
&((struct iphdr *)icp)->check);
|
|
|
|
memcpy(cp, thp, 20);
|
|
cp += 20;
|
|
|
|
if (thp->doff > 5) {
|
|
memcpy(cp, cs->cs_tcpopt, ((thp->doff) - 5) * 4);
|
|
cp += ((thp->doff) - 5) * 4;
|
|
}
|
|
|
|
return len;
|
|
bad:
|
|
comp->sls_i_error++;
|
|
return slhc_toss( comp );
|
|
}
|
|
|
|
|
|
int
|
|
slhc_remember(struct slcompress *comp, unsigned char *icp, int isize)
|
|
{
|
|
register struct cstate *cs;
|
|
unsigned ihl;
|
|
|
|
unsigned char index;
|
|
|
|
if(isize < 20) {
|
|
/* The packet is shorter than a legal IP header */
|
|
comp->sls_i_runt++;
|
|
return slhc_toss( comp );
|
|
}
|
|
/* Peek at the IP header's IHL field to find its length */
|
|
ihl = icp[0] & 0xf;
|
|
if(ihl < 20 / 4){
|
|
/* The IP header length field is too small */
|
|
comp->sls_i_runt++;
|
|
return slhc_toss( comp );
|
|
}
|
|
index = icp[9];
|
|
icp[9] = IPPROTO_TCP;
|
|
|
|
if (ip_fast_csum(icp, ihl)) {
|
|
/* Bad IP header checksum; discard */
|
|
comp->sls_i_badcheck++;
|
|
return slhc_toss( comp );
|
|
}
|
|
if(index > comp->rslot_limit) {
|
|
comp->sls_i_error++;
|
|
return slhc_toss(comp);
|
|
}
|
|
|
|
/* Update local state */
|
|
cs = &comp->rstate[comp->recv_current = index];
|
|
comp->flags &=~ SLF_TOSS;
|
|
memcpy(&cs->cs_ip,icp,20);
|
|
memcpy(&cs->cs_tcp,icp + ihl*4,20);
|
|
if (ihl > 5)
|
|
memcpy(cs->cs_ipopt, icp + sizeof(struct iphdr), (ihl - 5) * 4);
|
|
if (cs->cs_tcp.doff > 5)
|
|
memcpy(cs->cs_tcpopt, icp + ihl*4 + sizeof(struct tcphdr), (cs->cs_tcp.doff - 5) * 4);
|
|
cs->cs_hsize = ihl*2 + cs->cs_tcp.doff*2;
|
|
/* Put headers back on packet
|
|
* Neither header checksum is recalculated
|
|
*/
|
|
comp->sls_i_uncompressed++;
|
|
return isize;
|
|
}
|
|
|
|
int
|
|
slhc_toss(struct slcompress *comp)
|
|
{
|
|
if ( comp == NULLSLCOMPR )
|
|
return 0;
|
|
|
|
comp->flags |= SLF_TOSS;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* VJ header compression */
|
|
EXPORT_SYMBOL(slhc_init);
|
|
EXPORT_SYMBOL(slhc_free);
|
|
EXPORT_SYMBOL(slhc_remember);
|
|
EXPORT_SYMBOL(slhc_compress);
|
|
EXPORT_SYMBOL(slhc_uncompress);
|
|
EXPORT_SYMBOL(slhc_toss);
|
|
|
|
#else /* CONFIG_INET */
|
|
|
|
|
|
int
|
|
slhc_toss(struct slcompress *comp)
|
|
{
|
|
printk(KERN_DEBUG "Called IP function on non IP-system: slhc_toss");
|
|
return -EINVAL;
|
|
}
|
|
int
|
|
slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize)
|
|
{
|
|
printk(KERN_DEBUG "Called IP function on non IP-system: slhc_uncompress");
|
|
return -EINVAL;
|
|
}
|
|
int
|
|
slhc_compress(struct slcompress *comp, unsigned char *icp, int isize,
|
|
unsigned char *ocp, unsigned char **cpp, int compress_cid)
|
|
{
|
|
printk(KERN_DEBUG "Called IP function on non IP-system: slhc_compress");
|
|
return -EINVAL;
|
|
}
|
|
|
|
int
|
|
slhc_remember(struct slcompress *comp, unsigned char *icp, int isize)
|
|
{
|
|
printk(KERN_DEBUG "Called IP function on non IP-system: slhc_remember");
|
|
return -EINVAL;
|
|
}
|
|
|
|
void
|
|
slhc_free(struct slcompress *comp)
|
|
{
|
|
printk(KERN_DEBUG "Called IP function on non IP-system: slhc_free");
|
|
return;
|
|
}
|
|
struct slcompress *
|
|
slhc_init(int rslots, int tslots)
|
|
{
|
|
printk(KERN_DEBUG "Called IP function on non IP-system: slhc_init");
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL(slhc_init);
|
|
EXPORT_SYMBOL(slhc_free);
|
|
EXPORT_SYMBOL(slhc_remember);
|
|
EXPORT_SYMBOL(slhc_compress);
|
|
EXPORT_SYMBOL(slhc_uncompress);
|
|
EXPORT_SYMBOL(slhc_toss);
|
|
|
|
#endif /* CONFIG_INET */
|
|
MODULE_LICENSE("Dual BSD/GPL");
|