/* sl_compress.c - TCP/IP header compression routines *//* Copyright 1990-2000 Wind River Systems, Inc. */#include "copyright_wrs.h"/*- * Copyright (c) 1989, 1993, 1994 *	The Regents of the University of California.  All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software *    must display the following acknowledgement: *	This product includes software developed by the University of *	California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * *	@(#)slcompress.c	8.2 (Berkeley) 4/16/94 *//* * Routines to compress and uncompess tcp packets (for transmission * over low speed serial lines. * * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: *	- Initial distribution. * * static char rcsid[] = * "$Header: slcompress.c,v 1.19 89/12/31 08:52:59 van Exp $"; *//*modification history--------------------01f,11mar00,ham  fixed compilation warnings.01e,01aug96,vin  merged with bsd4.4. moved to netinet made it universal for 		 PPP as well as CSLIP. 01d,16jun95,dzb  header file consolidation.  removed BCOPY.01c,27jan95,dab  fixes to DECODE macros.01b,13jan95,dzb  prepended "ppp_" due to CSLIP name space conflict.01a,21dec94,dab  VxWorks port - first WRS version.	   +dzb  added: path for ppp header files, WRS copyright.*/#include <vxWorks.h>#include <sys/types.h>#include <net/mbuf.h>#include <net/socketvar.h>#include <netinet/in.h>#include <netinet/in_systm.h>#include <netinet/ip.h>#include <netinet/tcp.h>#include <netinet/sl_compress.h>/********************************************************************************* sl_compress_init - initialize compressed TCP/IP header stack** This routine initializes a TCP/IP compression structure.  Each* structure contains an array of connections characterized by the* most recently reconstructed TCP/IP header.** RETURNS: N/A** NOMANUAL*/voidsl_compress_init(comp)	struct slcompress *comp;{	register u_int i;	register struct cstate *tstate = comp->tstate;	bzero((char *)comp, sizeof(*comp));	for (i = MAX_STATES - 1; i > 0; --i) {		tstate[i].cs_id = i;		tstate[i].cs_next = &tstate[i - 1];	}	tstate[0].cs_next = &tstate[MAX_STATES - 1];	tstate[0].cs_id = 0;	comp->last_cs = &tstate[0];	comp->last_recv = 255;	comp->last_xmit = 255;	comp->flags = SLF_TOSS;}/********************************************************************************* sl_compress_tcp - compress the TCP/IP header in the given mbuf chain** RETURNS: The converted protocol version of the given mbuf chain.** NOMANUAL*/u_intsl_compress_tcp(m, ip, comp, compress_cid)	struct mbuf *m;	register struct ip *ip;	struct slcompress *comp;	int compress_cid;{	register struct cstate *cs = comp->last_cs->cs_next;	register u_int hlen = ip->ip_hl;	register struct tcphdr *oth;	register struct tcphdr *th;	register u_int deltaS, deltaA;	register u_int changes = 0;	u_char new_seq[16];	register u_char *cp = new_seq;	/*	 * 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).  (We assume that the caller has already made sure the	 * packet is IP proto TCP).	 */	if ((ip->ip_off & htons(0x3fff)) || m->m_len < 40)		return (TYPE_IP);	th = (struct tcphdr *)&((int *)ip)[hlen];	if ((th->th_flags & (TH_SYN|TH_FIN|TH_RST|TH_ACK)) != TH_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(sls_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 ||	    *(int *)th != ((int *)&cs->cs_ip)[cs->cs_ip.ip_hl]) {		/*		 * 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(sls_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			    && *(int *)th == ((int *)&cs->cs_ip)[cs->cs_ip.ip_hl])				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(sls_misses)		comp->last_cs = lcs;		hlen += th->th_off;		hlen <<= 2;		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;		}	}	/*	 * 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'.	 */	oth = (struct tcphdr *)&((int *)&cs->cs_ip)[hlen];	deltaS = hlen;	hlen += th->th_off;	hlen <<= 2;	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] ||	    th->th_off != oth->th_off ||	    (deltaS > 5 &&	     BCMP(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2)) ||	    (th->th_off > 5 &&	     BCMP(th + 1, oth + 1, (th->th_off - 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 & TH_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)))) {		ENCODE(deltaS);		changes |= NEW_W;	}	if ((deltaA = ntohl(th->th_ack) - ntohl(oth->th_ack))) {		if (deltaA > 0xffff)			goto uncompressed;		ENCODE(deltaA);		changes |= NEW_A;	}	if ((deltaS = ntohl(th->th_seq) - ntohl(oth->th_seq))) {		if (deltaS > 0xffff)			goto uncompressed;		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 = ntohs(ip->ip_id) - ntohs(cs->cs_ip.ip_id);	if (deltaS != 1) {		ENCODEZ(deltaS);		changes |= NEW_I;	}	if (th->th_flags & TH_PUSH)		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 = cp - new_seq;	cp = (u_char *)ip;	if (compress_cid == 0 || comp->last_xmit != cs->cs_id) {		comp->last_xmit = cs->cs_id;		hlen -= deltaS + 4;		cp += hlen;		*cp++ = changes | NEW_C;		*cp++ = cs->cs_id;	} else {		hlen -= deltaS + 3;		cp += hlen;		*cp++ = changes;	}	m->m_len -= hlen;	m->m_data += hlen;	*cp++ = deltaA >> 8;	*cp++ = deltaA;	BCOPY(new_seq, cp, deltaS);	INCR(sls_compressed)	return (TYPE_COMPRESSED_TCP);	/*	 * Update connection state cs & send uncompressed packet ('uncompressed'	 * means 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);}/********************************************************************************* sl_uncompress_tcp - uncompress the TCP/IP header in the given buffer.** RETURNS: The length of the uncompressed TCP/IP header, 0 if ERROR.** NOMANUAL*/intsl_uncompress_tcp(bufp, len, type, comp)	u_char **bufp;	int len;	u_int type;	struct slcompress *comp;{	register u_char *cp;	register u_int hlen, changes;	register struct tcphdr *th;	register struct cstate *cs;	register struct ip *ip;	switch (type) {	case TYPE_UNCOMPRESSED_TCP:		ip = (struct ip *) *bufp;		if (ip->ip_p >= MAX_STATES)			goto bad;		cs = &comp->rstate[comp->last_recv = ip->ip_p];		comp->flags &=~ SLF_TOSS;		ip->ip_p = IPPROTO_TCP;		hlen = ip->ip_hl;		hlen += ((struct tcphdr *)&((int *)ip)[hlen])->th_off;		hlen <<= 2;		BCOPY(ip, &cs->cs_ip, hlen);		cs->cs_ip.ip_sum = 0;		cs->cs_hlen = hlen;		INCR(sls_uncompressedin)		return (len);	default:		goto bad;	case TYPE_COMPRESSED_TCP:		break;	}	/* We've got a compressed packet. */	INCR(sls_compressedin)	cp = *bufp;	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_STATES)			goto bad;		comp->flags &=~ SLF_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 & SLF_TOSS) {			INCR(sls_tossed)			return (0);		}	}	cs = &comp->rstate[comp->last_recv];	hlen = cs->cs_ip.ip_hl << 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 |= TH_PUSH;	else		th->th_flags &=~ TH_PUSH;	switch (changes & SPECIALS_MASK) {	case SPECIAL_I:		{		register u_int i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;		th->th_ack = htonl(ntohl(th->th_ack) + i);		th->th_seq = htonl(ntohl(th->th_seq) + i);		}		break;	case SPECIAL_D:		th->th_seq = htonl(ntohl(th->th_seq) + ntohs(cs->cs_ip.ip_len)				   - cs->cs_hlen);		break;	default:		if (changes & NEW_U) {			th->th_flags |= TH_URG;			DECODEU(th->th_urp)		} else			th->th_flags &=~ TH_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 = htons(ntohs(cs->cs_ip.ip_id) + 1);	/*	 * At this point, cp points to the first byte of data in the	 * packet.  If we're not aligned on a 4-byte boundary, copy the	 * data down so the ip & tcp headers will be aligned.  Then back up	 * cp by the tcp/ip header length to make room for the reconstructed	 * header (we assume the packet we were handed has enough space to	 * prepend 128 bytes of header).  Adjust the length to account for	 * the new header & fill in the IP total length.	 */	len -= (cp - *bufp);	if (len < 0)		/* we must have dropped some characters (crc should detect		 * this but the old slip framing won't) */		goto bad;	if ((int)cp & 3) {		if (len > 0)			(void) ovbcopy(cp, (caddr_t)((int)cp &~ 3), len);		cp = (u_char *)((int)cp &~ 3);	}	cp -= cs->cs_hlen;	len += cs->cs_hlen;	cs->cs_ip.ip_len = htons(len);	BCOPY(&cs->cs_ip, cp, cs->cs_hlen);	*bufp = cp;	/* recompute the ip header checksum */	{		register u_short *bp = (u_short *)cp;		for (changes = 0; hlen > 0; hlen -= 2)			changes += *bp++;		changes = (changes & 0xffff) + (changes >> 16);		changes = (changes & 0xffff) + (changes >> 16);		((struct ip *)cp)->ip_sum = ~ changes;	}	return (len);bad:	comp->flags |= SLF_TOSS;	INCR(sls_errorin)	return (0);}