/* * 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 <string.h>#include "ppp.h"#include "vj.h"#include "pppdebug.h"#if VJ_SUPPORT > 0#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)#endifvoid 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)