ref: ad26dc48a6dc05da02f96e5f1e7b82de58ff5b2c
dir: /sys/src/cmd/ip/ppp/compress.c/
#include <u.h>
#include <libc.h>
#include <ip.h>
#include <auth.h>
#include "ppp.h"
typedef struct Iphdr Iphdr;
struct Iphdr
{
uchar vihl; /* Version and header length */
uchar tos; /* Type of service */
uchar length[2]; /* packet length */
uchar id[2]; /* Identification */
uchar frag[2]; /* Fragment information */
uchar ttl; /* Time to live */
uchar proto; /* Protocol */
uchar cksum[2]; /* Header checksum */
ulong src; /* Ip source (uchar ordering unimportant) */
ulong dst; /* Ip destination (uchar ordering unimportant) */
};
typedef struct Tcphdr Tcphdr;
struct Tcphdr
{
ulong ports; /* defined as a ulong to make comparisons easier */
uchar seq[4];
uchar ack[4];
uchar flag[2];
uchar win[2];
uchar cksum[2];
uchar urg[2];
};
typedef struct Ilhdr Ilhdr;
struct Ilhdr
{
uchar sum[2]; /* Checksum including header */
uchar len[2]; /* Packet length */
uchar type; /* Packet type */
uchar spec; /* Special */
uchar src[2]; /* Src port */
uchar dst[2]; /* Dst port */
uchar id[4]; /* Sequence id */
uchar ack[4]; /* Acked sequence */
};
enum
{
URG = 0x20, /* Data marked urgent */
ACK = 0x10, /* Aknowledge is valid */
PSH = 0x08, /* Whole data pipe is pushed */
RST = 0x04, /* Reset connection */
SYN = 0x02, /* Pkt. is synchronise */
FIN = 0x01, /* Start close down */
IP_DF = 0x4000, /* Don't fragment */
IP_TCPPROTO = 6,
IP_ILPROTO = 40,
IL_IPHDR = 20,
};
typedef struct Hdr Hdr;
struct Hdr
{
uchar buf[128];
Iphdr *ip;
Tcphdr *tcp;
int len;
};
typedef struct Tcpc Tcpc;
struct Tcpc
{
uchar lastrecv;
uchar lastxmit;
uchar basexmit;
uchar err;
uchar compressid;
Hdr t[MAX_STATES];
Hdr r[MAX_STATES];
};
enum
{ /* flag bits for what changed in a packet */
NEW_U=(1<<0), /* tcp only */
NEW_W=(1<<1), /* tcp only */
NEW_A=(1<<2), /* il tcp */
NEW_S=(1<<3), /* tcp only */
NEW_P=(1<<4), /* tcp only */
NEW_I=(1<<5), /* il tcp */
NEW_C=(1<<6), /* il tcp */
NEW_T=(1<<7), /* il only */
TCP_PUSH_BIT = 0x10,
};
/* reserved, special-case values of above for tcp */
#define SPECIAL_I (NEW_S|NEW_W|NEW_U) /* echoed interactive traffic */
#define SPECIAL_D (NEW_S|NEW_A|NEW_W|NEW_U) /* unidirectional data */
#define SPECIALS_MASK (NEW_S|NEW_A|NEW_W|NEW_U)
int
encode(void *p, ulong n)
{
uchar *cp;
cp = p;
if(n >= 256 || n == 0) {
*cp++ = 0;
cp[0] = n >> 8;
cp[1] = n;
return 3;
}
*cp = n;
return 1;
}
#define DECODEL(f) { \
if (*cp == 0) {\
hnputl(f, nhgetl(f) + ((cp[1] << 8) | cp[2])); \
cp += 3; \
} else { \
hnputl(f, nhgetl(f) + (ulong)*cp++); \
} \
}
#define DECODES(f) { \
if (*cp == 0) {\
hnputs(f, nhgets(f) + ((cp[1] << 8) | cp[2])); \
cp += 3; \
} else { \
hnputs(f, nhgets(f) + (ulong)*cp++); \
} \
}
Block*
tcpcompress(Tcpc *comp, Block *b, int *protop)
{
Iphdr *ip; /* current packet */
Tcphdr *tcp; /* current pkt */
ulong iplen, tcplen, hlen; /* header length in uchars */
ulong deltaS, deltaA; /* general purpose temporaries */
ulong changes; /* change mask */
uchar new_seq[16]; /* changes from last to current */
uchar *cp;
Hdr *h; /* last packet */
int i, j;
/*
* Bail if this is not a compressible TCP/IP packet
*/
ip = (Iphdr*)b->rptr;
iplen = (ip->vihl & 0xf) << 2;
tcp = (Tcphdr*)(b->rptr + iplen);
tcplen = (tcp->flag[0] & 0xf0) >> 2;
hlen = iplen + tcplen;
if((tcp->flag[1] & (SYN|FIN|RST|ACK)) != ACK){
*protop = Pip;
return b; /* connection control */
}
/*
* Packet is compressible, look for a connection
*/
changes = 0;
cp = new_seq;
j = comp->lastxmit;
h = &comp->t[j];
if(ip->src != h->ip->src || ip->dst != h->ip->dst
|| tcp->ports != h->tcp->ports) {
for(i = 0; i < MAX_STATES; ++i) {
j = (comp->basexmit + i) % MAX_STATES;
h = &comp->t[j];
if(ip->src == h->ip->src && ip->dst == h->ip->dst
&& tcp->ports == h->tcp->ports)
goto found;
}
/* no connection, reuse the oldest */
if(i == MAX_STATES) {
j = comp->basexmit;
j = (j + MAX_STATES - 1) % MAX_STATES;
comp->basexmit = j;
h = &comp->t[j];
goto rescue;
}
}
found:
/*
* Make sure that only what we expect to change changed.
*/
if(ip->vihl != h->ip->vihl || ip->tos != h->ip->tos ||
ip->ttl != h->ip->ttl || ip->proto != h->ip->proto)
goto rescue; /* headers changed */
if(iplen != sizeof(Iphdr) && memcmp(ip+1, h->ip+1, iplen - sizeof(Iphdr)))
goto rescue; /* ip options changed */
if(tcplen != sizeof(Tcphdr) && memcmp(tcp+1, h->tcp+1, tcplen - sizeof(Tcphdr)))
goto rescue; /* tcp options changed */
if(tcp->flag[1] & URG) {
cp += encode(cp, nhgets(tcp->urg));
changes |= NEW_U;
} else if(memcmp(tcp->urg, h->tcp->urg, sizeof(tcp->urg)) != 0)
goto rescue;
if(deltaS = nhgets(tcp->win) - nhgets(h->tcp->win)) {
cp += encode(cp, deltaS);
changes |= NEW_W;
}
if(deltaA = nhgetl(tcp->ack) - nhgetl(h->tcp->ack)) {
if(deltaA > 0xffff)
goto rescue;
cp += encode(cp, deltaA);
changes |= NEW_A;
}
if(deltaS = nhgetl(tcp->seq) - nhgetl(h->tcp->seq)) {
if (deltaS > 0xffff)
goto rescue;
cp += encode(cp, deltaS);
changes |= NEW_S;
}
/*
* Look for the special-case encodings.
*/
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(nhgets(ip->length) == nhgets(h->ip->length) ||
nhgets(h->ip->length) != hlen)
goto rescue;
break;
case SPECIAL_I:
case SPECIAL_D:
/*
* Actual changes match one of our special case encodings --
* send packet uncompressed.
*/
goto rescue;
case NEW_S | NEW_A:
if (deltaS == deltaA &&
deltaS == nhgets(h->ip->length) - hlen) {
/* special case for echoed terminal traffic */
changes = SPECIAL_I;
cp = new_seq;
}
break;
case NEW_S:
if (deltaS == nhgets(h->ip->length) - hlen) {
/* special case for data xfer */
changes = SPECIAL_D;
cp = new_seq;
}
break;
}
deltaS = nhgets(ip->id) - nhgets(h->ip->id);
if(deltaS != 1) {
cp += encode(cp, deltaS);
changes |= NEW_I;
}
if (tcp->flag[1] & PSH)
changes |= TCP_PUSH_BIT;
/*
* Grab the cksum before we overwrite it below. Then update our
* state with this packet's header.
*/
deltaA = nhgets(tcp->cksum);
memmove(h->buf, b->rptr, hlen);
h->len = hlen;
h->tcp = (Tcphdr*)(h->buf + iplen);
/*
* We want to use the original packet as our compressed packet. (cp -
* new_seq) is the number of uchars we need for compressed sequence
* numbers. In addition we need one uchar for the change mask, one
* for the connection id and two for the tcp checksum. So, (cp -
* new_seq) + 4 uchars of header are needed. hlen is how many uchars
* of the original packet to toss so subtract the two to get the new
* packet size. The temporaries are gross -egs.
*/
deltaS = cp - new_seq;
cp = b->rptr;
if(comp->lastxmit != j || comp->compressid == 0) {
comp->lastxmit = j;
hlen -= deltaS + 4;
cp += hlen;
*cp++ = (changes | NEW_C);
*cp++ = j;
} else {
hlen -= deltaS + 3;
cp += hlen;
*cp++ = changes;
}
b->rptr += hlen;
hnputs(cp, deltaA);
cp += 2;
memmove(cp, new_seq, deltaS);
*protop = Pvjctcp;
return b;
rescue:
/*
* Update connection state & send uncompressed packet
*/
memmove(h->buf, b->rptr, hlen);
h->tcp = (Tcphdr*)(h->buf + iplen);
h->len = hlen;
ip->proto = j;
comp->lastxmit = j;
*protop = Pvjutcp;
return b;
}
Block*
tcpuncompress(Tcpc *comp, Block *b, int type)
{
uchar *cp, changes;
int i;
int iplen, len;
Iphdr *ip;
Tcphdr *tcp;
Hdr *h;
if(type == Pvjutcp) {
/*
* Locate the saved state for this connection. If the state
* index is legal, clear the 'discard' flag.
*/
ip = (Iphdr*)b->rptr;
if(ip->proto >= MAX_STATES)
goto rescue;
iplen = (ip->vihl & 0xf) << 2;
tcp = (Tcphdr*)(b->rptr + iplen);
comp->lastrecv = ip->proto;
len = iplen + ((tcp->flag[0] & 0xf0) >> 2);
comp->err = 0;
/*
* Restore the IP protocol field then save a copy of this
* packet header. The checksum is zeroed in the copy so we
* don't have to zero it each time we process a compressed
* packet.
*/
ip->proto = IP_TCPPROTO;
h = &comp->r[comp->lastrecv];
memmove(h->buf, b->rptr, len);
h->tcp = (Tcphdr*)(h->buf + iplen);
h->len = len;
h->ip->cksum[0] = h->ip->cksum[1] = 0;
return b;
}
cp = b->rptr;
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 rescue;
comp->err = 0;
comp->lastrecv = *cp++;
} else {
/*
* This packet has no 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->err != 0){
freeb(b);
return nil;
}
}
/*
* Find the state then fill in the TCP checksum and PUSH bit.
*/
h = &comp->r[comp->lastrecv];
ip = h->ip;
tcp = h->tcp;
len = h->len;
memmove(tcp->cksum, cp, sizeof tcp->cksum);
cp += 2;
if(changes & TCP_PUSH_BIT)
tcp->flag[1] |= PSH;
else
tcp->flag[1] &= ~PSH;
/*
* Fix up the state's ack, seq, urg and win fields based on the
* changemask.
*/
switch (changes & SPECIALS_MASK) {
case SPECIAL_I:
i = nhgets(ip->length) - len;
hnputl(tcp->ack, nhgetl(tcp->ack) + i);
hnputl(tcp->seq, nhgetl(tcp->seq) + i);
break;
case SPECIAL_D:
hnputl(tcp->seq, nhgetl(tcp->seq) + nhgets(ip->length) - len);
break;
default:
if(changes & NEW_U) {
tcp->flag[1] |= URG;
if(*cp == 0){
hnputs(tcp->urg, nhgets(cp+1));
cp += 3;
}else
hnputs(tcp->urg, *cp++);
} else
tcp->flag[1] &= ~URG;
if(changes & NEW_W)
DECODES(tcp->win)
if(changes & NEW_A)
DECODEL(tcp->ack)
if(changes & NEW_S)
DECODEL(tcp->seq)
break;
}
/* Update the IP ID */
if(changes & NEW_I)
DECODES(ip->id)
else
hnputs(ip->id, nhgets(ip->id) + 1);
/*
* At this point, cp points to the first uchar of data in the packet.
* 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
* up to 128 uchars of header.
*/
b->rptr = cp;
if(b->rptr - b->base < len){
b = padb(b, len);
b = pullup(b, blen(b));
} else
b->rptr -= len;
hnputs(ip->length, BLEN(b));
memmove(b->rptr, ip, len);
/* recompute the ip header checksum */
ip = (Iphdr*)b->rptr;
ip->cksum[0] = ip->cksum[1] = 0;
hnputs(ip->cksum, ipcsum(b->rptr));
return b;
rescue:
netlog("ppp: vj: Bad Packet!\n");
comp->err = 1;
freeb(b);
return nil;
}
Tcpc*
compress_init(Tcpc *c)
{
int i;
Hdr *h;
if(c == nil)
c = malloc(sizeof(Tcpc));
memset(c, 0, sizeof(*c));
for(i = 0; i < MAX_STATES; i++){
h = &c->t[i];
h->ip = (Iphdr*)h->buf;
h->tcp = (Tcphdr*)(h->buf + 20);
h->len = 40;
h = &c->r[i];
h->ip = (Iphdr*)h->buf;
h->tcp = (Tcphdr*)(h->buf + 20);
h->len = 40;
}
return c;
}
Block*
compress(Tcpc *tcp, Block *b, int *protop)
{
Iphdr *ip;
/*
* Bail if this is not a compressible IP packet
*/
ip = (Iphdr*)b->rptr;
if((nhgets(ip->frag) & 0x3fff) != 0){
*protop = Pip;
return b;
}
switch(ip->proto) {
case IP_TCPPROTO:
return tcpcompress(tcp, b, protop);
default:
*protop = Pip;
return b;
}
}
int
compress_negotiate(Tcpc *tcp, uchar *data)
{
if(data[0] != MAX_STATES - 1)
return -1;
tcp->compressid = data[1];
return 0;
}
/* called by ppp when there was a bad frame received */
void
compress_error(Tcpc *tcp)
{
tcp->err = 1;
}