1*623e24ceSblambert /* $OpenBSD: slcompress.c,v 1.12 2015/12/03 14:34:48 blambert Exp $ */
24b7ce64cSmillert /* $NetBSD: slcompress.c,v 1.17 1997/05/17 21:12:10 christos Exp $ */
3df930be7Sderaadt
4df930be7Sderaadt /*
5df930be7Sderaadt * Copyright (c) 1989, 1993, 1994
6df930be7Sderaadt * The Regents of the University of California. All rights reserved.
7df930be7Sderaadt *
8df930be7Sderaadt * Redistribution and use in source and binary forms, with or without
9df930be7Sderaadt * modification, are permitted provided that the following conditions
10df930be7Sderaadt * are met:
11df930be7Sderaadt * 1. Redistributions of source code must retain the above copyright
12df930be7Sderaadt * notice, this list of conditions and the following disclaimer.
13df930be7Sderaadt * 2. Redistributions in binary form must reproduce the above copyright
14df930be7Sderaadt * notice, this list of conditions and the following disclaimer in the
15df930be7Sderaadt * documentation and/or other materials provided with the distribution.
1629295d1cSmillert * 3. Neither the name of the University nor the names of its contributors
17df930be7Sderaadt * may be used to endorse or promote products derived from this software
18df930be7Sderaadt * without specific prior written permission.
19df930be7Sderaadt *
20df930be7Sderaadt * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21df930be7Sderaadt * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22df930be7Sderaadt * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23df930be7Sderaadt * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24df930be7Sderaadt * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25df930be7Sderaadt * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26df930be7Sderaadt * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27df930be7Sderaadt * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28df930be7Sderaadt * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29df930be7Sderaadt * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30df930be7Sderaadt * SUCH DAMAGE.
31df930be7Sderaadt *
32df930be7Sderaadt * @(#)slcompress.c 8.2 (Berkeley) 4/16/94
33df930be7Sderaadt */
34df930be7Sderaadt
35df930be7Sderaadt /*
36df930be7Sderaadt * Routines to compress and uncompess tcp packets (for transmission
37df930be7Sderaadt * over low speed serial lines.
38df930be7Sderaadt *
39df930be7Sderaadt * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989:
40df930be7Sderaadt * - Initial distribution.
41df930be7Sderaadt */
42df930be7Sderaadt
43df930be7Sderaadt #include <sys/param.h>
44df930be7Sderaadt #include <sys/mbuf.h>
45edd75aa1Sniklas #include <sys/systm.h>
46df930be7Sderaadt
47df930be7Sderaadt #include <netinet/in.h>
48df930be7Sderaadt #include <netinet/ip.h>
49df930be7Sderaadt #include <netinet/tcp.h>
50df930be7Sderaadt
51df930be7Sderaadt #include <net/slcompress.h>
52df930be7Sderaadt
53df930be7Sderaadt #ifndef SL_NO_STATS
54df930be7Sderaadt #define INCR(counter) ++comp->counter;
55df930be7Sderaadt #else
56df930be7Sderaadt #define INCR(counter)
57df930be7Sderaadt #endif
58df930be7Sderaadt
59df930be7Sderaadt #define BCMP(p1, p2, n) bcmp((char *)(p1), (char *)(p2), (int)(n))
60df930be7Sderaadt #define BCOPY(p1, p2, n) bcopy((char *)(p1), (char *)(p2), (int)(n))
614b7ce64cSmillert
62df930be7Sderaadt void
sl_compress_init(struct slcompress * comp)63*623e24ceSblambert sl_compress_init(struct slcompress *comp)
644b7ce64cSmillert {
6564aa4cc7Sitojun u_int i;
6664aa4cc7Sitojun struct cstate *tstate = comp->tstate;
674b7ce64cSmillert
684b7ce64cSmillert bzero((char *)comp, sizeof(*comp));
694b7ce64cSmillert for (i = MAX_STATES - 1; i > 0; --i) {
704b7ce64cSmillert tstate[i].cs_id = i;
714b7ce64cSmillert tstate[i].cs_next = &tstate[i - 1];
724b7ce64cSmillert }
734b7ce64cSmillert tstate[0].cs_next = &tstate[MAX_STATES - 1];
744b7ce64cSmillert tstate[0].cs_id = 0;
754b7ce64cSmillert comp->last_cs = &tstate[0];
764b7ce64cSmillert comp->last_recv = 255;
774b7ce64cSmillert comp->last_xmit = 255;
784b7ce64cSmillert comp->flags = SLF_TOSS;
794b7ce64cSmillert }
804b7ce64cSmillert
814b7ce64cSmillert
824b7ce64cSmillert /*
834b7ce64cSmillert * Like sl_compress_init, but we get to specify the maximum connection
844b7ce64cSmillert * ID to use on transmission.
854b7ce64cSmillert */
864b7ce64cSmillert void
sl_compress_setup(struct slcompress * comp,int max_state)87*623e24ceSblambert sl_compress_setup(struct slcompress *comp, int max_state)
88df930be7Sderaadt {
8964aa4cc7Sitojun u_int i;
9064aa4cc7Sitojun struct cstate *tstate = comp->tstate;
91df930be7Sderaadt
92d724e01aSderaadt if (max_state == -1) {
93df930be7Sderaadt max_state = MAX_STATES - 1;
94df930be7Sderaadt bzero((char *)comp, sizeof(*comp));
95d724e01aSderaadt } else {
96d724e01aSderaadt /* Don't reset statistics */
97d724e01aSderaadt bzero((char *)comp->tstate, sizeof(comp->tstate));
98d724e01aSderaadt bzero((char *)comp->rstate, sizeof(comp->rstate));
99d724e01aSderaadt }
100df930be7Sderaadt for (i = max_state; i > 0; --i) {
101df930be7Sderaadt tstate[i].cs_id = i;
102df930be7Sderaadt tstate[i].cs_next = &tstate[i - 1];
103df930be7Sderaadt }
104df930be7Sderaadt tstate[0].cs_next = &tstate[max_state];
105df930be7Sderaadt tstate[0].cs_id = 0;
106df930be7Sderaadt comp->last_cs = &tstate[0];
107df930be7Sderaadt comp->last_recv = 255;
108df930be7Sderaadt comp->last_xmit = 255;
109df930be7Sderaadt comp->flags = SLF_TOSS;
110df930be7Sderaadt }
111df930be7Sderaadt
112df930be7Sderaadt
113df930be7Sderaadt /* ENCODE encodes a number that is known to be non-zero. ENCODEZ
114df930be7Sderaadt * checks for zero (since zero has to be encoded in the long, 3 byte
115df930be7Sderaadt * form).
116df930be7Sderaadt */
117df930be7Sderaadt #define ENCODE(n) { \
118df930be7Sderaadt if ((u_int16_t)(n) >= 256) { \
119df930be7Sderaadt *cp++ = 0; \
120df930be7Sderaadt cp[1] = (n); \
121df930be7Sderaadt cp[0] = (n) >> 8; \
122df930be7Sderaadt cp += 2; \
123df930be7Sderaadt } else { \
124df930be7Sderaadt *cp++ = (n); \
125df930be7Sderaadt } \
126df930be7Sderaadt }
127df930be7Sderaadt #define ENCODEZ(n) { \
128df930be7Sderaadt if ((u_int16_t)(n) >= 256 || (u_int16_t)(n) == 0) { \
129df930be7Sderaadt *cp++ = 0; \
130df930be7Sderaadt cp[1] = (n); \
131df930be7Sderaadt cp[0] = (n) >> 8; \
132df930be7Sderaadt cp += 2; \
133df930be7Sderaadt } else { \
134df930be7Sderaadt *cp++ = (n); \
135df930be7Sderaadt } \
136df930be7Sderaadt }
137df930be7Sderaadt
138df930be7Sderaadt #define DECODEL(f) { \
139df930be7Sderaadt if (*cp == 0) {\
140df930be7Sderaadt (f) = htonl(ntohl(f) + ((cp[1] << 8) | cp[2])); \
141df930be7Sderaadt cp += 3; \
142df930be7Sderaadt } else { \
143df930be7Sderaadt (f) = htonl(ntohl(f) + (u_int32_t)*cp++); \
144df930be7Sderaadt } \
145df930be7Sderaadt }
146df930be7Sderaadt
147df930be7Sderaadt #define DECODES(f) { \
148df930be7Sderaadt if (*cp == 0) {\
149df930be7Sderaadt (f) = htons(ntohs(f) + ((cp[1] << 8) | cp[2])); \
150df930be7Sderaadt cp += 3; \
151df930be7Sderaadt } else { \
152df930be7Sderaadt (f) = htons(ntohs(f) + (u_int32_t)*cp++); \
153df930be7Sderaadt } \
154df930be7Sderaadt }
155df930be7Sderaadt
156df930be7Sderaadt #define DECODEU(f) { \
157df930be7Sderaadt if (*cp == 0) {\
158df930be7Sderaadt (f) = htons((cp[1] << 8) | cp[2]); \
159df930be7Sderaadt cp += 3; \
160df930be7Sderaadt } else { \
161df930be7Sderaadt (f) = htons((u_int32_t)*cp++); \
162df930be7Sderaadt } \
163df930be7Sderaadt }
164df930be7Sderaadt
165df930be7Sderaadt u_int
sl_compress_tcp(struct mbuf * m,struct ip * ip,struct slcompress * comp,int compress_cid)166*623e24ceSblambert sl_compress_tcp(struct mbuf *m, struct ip *ip, struct slcompress *comp,
167*623e24ceSblambert int compress_cid)
168df930be7Sderaadt {
16964aa4cc7Sitojun struct cstate *cs = comp->last_cs->cs_next;
17064aa4cc7Sitojun u_int hlen = ip->ip_hl;
17164aa4cc7Sitojun struct tcphdr *oth;
17264aa4cc7Sitojun struct tcphdr *th;
17364aa4cc7Sitojun u_int deltaS, deltaA;
17464aa4cc7Sitojun u_int changes = 0;
175df930be7Sderaadt u_char new_seq[16];
17664aa4cc7Sitojun u_char *cp = new_seq;
177df930be7Sderaadt
178df930be7Sderaadt /*
179df930be7Sderaadt * Bail if this is an IP fragment or if the TCP packet isn't
180df930be7Sderaadt * `compressible' (i.e., ACK isn't set or some other control bit is
181df930be7Sderaadt * set). (We assume that the caller has already made sure the
182df930be7Sderaadt * packet is IP proto TCP).
183df930be7Sderaadt */
184df930be7Sderaadt if ((ip->ip_off & htons(0x3fff)) || m->m_len < 40)
185df930be7Sderaadt return (TYPE_IP);
186df930be7Sderaadt
187df930be7Sderaadt th = (struct tcphdr *)&((int32_t *)ip)[hlen];
188df930be7Sderaadt if ((th->th_flags & (TH_SYN|TH_FIN|TH_RST|TH_ACK)) != TH_ACK)
189df930be7Sderaadt return (TYPE_IP);
190df930be7Sderaadt /*
191df930be7Sderaadt * Packet is compressible -- we're going to send either a
192df930be7Sderaadt * COMPRESSED_TCP or UNCOMPRESSED_TCP packet. Either way we need
193df930be7Sderaadt * to locate (or create) the connection state. Special case the
194df930be7Sderaadt * most recently used connection since it's most likely to be used
195df930be7Sderaadt * again & we don't have to do any reordering if it's used.
196df930be7Sderaadt */
197df930be7Sderaadt INCR(sls_packets)
198df930be7Sderaadt if (ip->ip_src.s_addr != cs->cs_ip.ip_src.s_addr ||
199df930be7Sderaadt ip->ip_dst.s_addr != cs->cs_ip.ip_dst.s_addr ||
200df930be7Sderaadt *(int32_t *)th != ((int32_t *)&cs->cs_ip)[cs->cs_ip.ip_hl]) {
201df930be7Sderaadt /*
202df930be7Sderaadt * Wasn't the first -- search for it.
203df930be7Sderaadt *
204df930be7Sderaadt * States are kept in a circularly linked list with
205df930be7Sderaadt * last_cs pointing to the end of the list. The
206df930be7Sderaadt * list is kept in lru order by moving a state to the
207df930be7Sderaadt * head of the list whenever it is referenced. Since
208df930be7Sderaadt * the list is short and, empirically, the connection
209df930be7Sderaadt * we want is almost always near the front, we locate
210df930be7Sderaadt * states via linear search. If we don't find a state
211df930be7Sderaadt * for the datagram, the oldest state is (re-)used.
212df930be7Sderaadt */
21364aa4cc7Sitojun struct cstate *lcs;
21464aa4cc7Sitojun struct cstate *lastcs = comp->last_cs;
215df930be7Sderaadt
216df930be7Sderaadt do {
217df930be7Sderaadt lcs = cs; cs = cs->cs_next;
218df930be7Sderaadt INCR(sls_searches)
219df930be7Sderaadt if (ip->ip_src.s_addr == cs->cs_ip.ip_src.s_addr
220df930be7Sderaadt && ip->ip_dst.s_addr == cs->cs_ip.ip_dst.s_addr
221df930be7Sderaadt && *(int32_t *)th ==
222df930be7Sderaadt ((int32_t *)&cs->cs_ip)[cs->cs_ip.ip_hl])
223df930be7Sderaadt goto found;
224df930be7Sderaadt } while (cs != lastcs);
225df930be7Sderaadt
226df930be7Sderaadt /*
227df930be7Sderaadt * Didn't find it -- re-use oldest cstate. Send an
228df930be7Sderaadt * uncompressed packet that tells the other side what
229df930be7Sderaadt * connection number we're using for this conversation.
230df930be7Sderaadt * Note that since the state list is circular, the oldest
231df930be7Sderaadt * state points to the newest and we only need to set
232df930be7Sderaadt * last_cs to update the lru linkage.
233df930be7Sderaadt */
234df930be7Sderaadt INCR(sls_misses)
235df930be7Sderaadt comp->last_cs = lcs;
236df930be7Sderaadt hlen += th->th_off;
237df930be7Sderaadt hlen <<= 2;
238df930be7Sderaadt goto uncompressed;
239df930be7Sderaadt
240df930be7Sderaadt found:
241df930be7Sderaadt /*
242df930be7Sderaadt * Found it -- move to the front on the connection list.
243df930be7Sderaadt */
244df930be7Sderaadt if (cs == lastcs)
245df930be7Sderaadt comp->last_cs = lcs;
246df930be7Sderaadt else {
247df930be7Sderaadt lcs->cs_next = cs->cs_next;
248df930be7Sderaadt cs->cs_next = lastcs->cs_next;
249df930be7Sderaadt lastcs->cs_next = cs;
250df930be7Sderaadt }
251df930be7Sderaadt }
252df930be7Sderaadt
253df930be7Sderaadt /*
254df930be7Sderaadt * Make sure that only what we expect to change changed. The first
255df930be7Sderaadt * line of the `if' checks the IP protocol version, header length &
256df930be7Sderaadt * type of service. The 2nd line checks the "Don't fragment" bit.
257df930be7Sderaadt * The 3rd line checks the time-to-live and protocol (the protocol
258df930be7Sderaadt * check is unnecessary but costless). The 4th line checks the TCP
259df930be7Sderaadt * header length. The 5th line checks IP options, if any. The 6th
260df930be7Sderaadt * line checks TCP options, if any. If any of these things are
261df930be7Sderaadt * different between the previous & current datagram, we send the
262df930be7Sderaadt * current datagram `uncompressed'.
263df930be7Sderaadt */
264df930be7Sderaadt oth = (struct tcphdr *)&((int32_t *)&cs->cs_ip)[hlen];
265df930be7Sderaadt deltaS = hlen;
266df930be7Sderaadt hlen += th->th_off;
267df930be7Sderaadt hlen <<= 2;
268df930be7Sderaadt
269df930be7Sderaadt if (((u_int16_t *)ip)[0] != ((u_int16_t *)&cs->cs_ip)[0] ||
270df930be7Sderaadt ((u_int16_t *)ip)[3] != ((u_int16_t *)&cs->cs_ip)[3] ||
271df930be7Sderaadt ((u_int16_t *)ip)[4] != ((u_int16_t *)&cs->cs_ip)[4] ||
272df930be7Sderaadt th->th_off != oth->th_off ||
273df930be7Sderaadt (deltaS > 5 &&
274df930be7Sderaadt BCMP(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2)) ||
275df930be7Sderaadt (th->th_off > 5 &&
276df930be7Sderaadt BCMP(th + 1, oth + 1, (th->th_off - 5) << 2)))
277df930be7Sderaadt goto uncompressed;
278df930be7Sderaadt
279df930be7Sderaadt /*
280df930be7Sderaadt * Figure out which of the changing fields changed. The
281df930be7Sderaadt * receiver expects changes in the order: urgent, window,
282df930be7Sderaadt * ack, seq (the order minimizes the number of temporaries
283df930be7Sderaadt * needed in this section of code).
284df930be7Sderaadt */
285df930be7Sderaadt if (th->th_flags & TH_URG) {
286df930be7Sderaadt deltaS = ntohs(th->th_urp);
287df930be7Sderaadt ENCODEZ(deltaS);
288df930be7Sderaadt changes |= NEW_U;
289df930be7Sderaadt } else if (th->th_urp != oth->th_urp)
290df930be7Sderaadt /* argh! URG not set but urp changed -- a sensible
291df930be7Sderaadt * implementation should never do this but RFC793
292df930be7Sderaadt * doesn't prohibit the change so we have to deal
293df930be7Sderaadt * with it. */
294df930be7Sderaadt goto uncompressed;
295df930be7Sderaadt
296edd75aa1Sniklas deltaS = (u_int16_t)(ntohs(th->th_win) - ntohs(oth->th_win));
297edd75aa1Sniklas if (deltaS) {
298df930be7Sderaadt ENCODE(deltaS);
299df930be7Sderaadt changes |= NEW_W;
300df930be7Sderaadt }
301df930be7Sderaadt
302edd75aa1Sniklas deltaA = ntohl(th->th_ack) - ntohl(oth->th_ack);
303edd75aa1Sniklas if (deltaA) {
304df930be7Sderaadt if (deltaA > 0xffff)
305df930be7Sderaadt goto uncompressed;
306df930be7Sderaadt ENCODE(deltaA);
307df930be7Sderaadt changes |= NEW_A;
308df930be7Sderaadt }
309df930be7Sderaadt
310edd75aa1Sniklas deltaS = ntohl(th->th_seq) - ntohl(oth->th_seq);
311edd75aa1Sniklas if (deltaS) {
312df930be7Sderaadt if (deltaS > 0xffff)
313df930be7Sderaadt goto uncompressed;
314df930be7Sderaadt ENCODE(deltaS);
315df930be7Sderaadt changes |= NEW_S;
316df930be7Sderaadt }
317df930be7Sderaadt
318df930be7Sderaadt switch(changes) {
319df930be7Sderaadt
320df930be7Sderaadt case 0:
321df930be7Sderaadt /*
322df930be7Sderaadt * Nothing changed. If this packet contains data and the
323df930be7Sderaadt * last one didn't, this is probably a data packet following
324df930be7Sderaadt * an ack (normal on an interactive connection) and we send
325df930be7Sderaadt * it compressed. Otherwise it's probably a retransmit,
326df930be7Sderaadt * retransmitted ack or window probe. Send it uncompressed
327df930be7Sderaadt * in case the other side missed the compressed version.
328df930be7Sderaadt */
329df930be7Sderaadt if (ip->ip_len != cs->cs_ip.ip_len &&
330df930be7Sderaadt ntohs(cs->cs_ip.ip_len) == hlen)
331df930be7Sderaadt break;
332df930be7Sderaadt
33383344e41Sjsg /* FALLTHROUGH */
334df930be7Sderaadt
335df930be7Sderaadt case SPECIAL_I:
336df930be7Sderaadt case SPECIAL_D:
337df930be7Sderaadt /*
338df930be7Sderaadt * actual changes match one of our special case encodings --
339df930be7Sderaadt * send packet uncompressed.
340df930be7Sderaadt */
341df930be7Sderaadt goto uncompressed;
342df930be7Sderaadt
343df930be7Sderaadt case NEW_S|NEW_A:
344df930be7Sderaadt if (deltaS == deltaA &&
345df930be7Sderaadt deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {
346df930be7Sderaadt /* special case for echoed terminal traffic */
347df930be7Sderaadt changes = SPECIAL_I;
348df930be7Sderaadt cp = new_seq;
349df930be7Sderaadt }
350df930be7Sderaadt break;
351df930be7Sderaadt
352df930be7Sderaadt case NEW_S:
353df930be7Sderaadt if (deltaS == ntohs(cs->cs_ip.ip_len) - hlen) {
354df930be7Sderaadt /* special case for data xfer */
355df930be7Sderaadt changes = SPECIAL_D;
356df930be7Sderaadt cp = new_seq;
357df930be7Sderaadt }
358df930be7Sderaadt break;
359df930be7Sderaadt }
360df930be7Sderaadt
361df930be7Sderaadt deltaS = ntohs(ip->ip_id) - ntohs(cs->cs_ip.ip_id);
362df930be7Sderaadt if (deltaS != 1) {
363df930be7Sderaadt ENCODEZ(deltaS);
364df930be7Sderaadt changes |= NEW_I;
365df930be7Sderaadt }
366df930be7Sderaadt if (th->th_flags & TH_PUSH)
367df930be7Sderaadt changes |= TCP_PUSH_BIT;
368df930be7Sderaadt /*
369df930be7Sderaadt * Grab the cksum before we overwrite it below. Then update our
370df930be7Sderaadt * state with this packet's header.
371df930be7Sderaadt */
372df930be7Sderaadt deltaA = ntohs(th->th_sum);
373df930be7Sderaadt BCOPY(ip, &cs->cs_ip, hlen);
374df930be7Sderaadt
375df930be7Sderaadt /*
376df930be7Sderaadt * We want to use the original packet as our compressed packet.
377df930be7Sderaadt * (cp - new_seq) is the number of bytes we need for compressed
378df930be7Sderaadt * sequence numbers. In addition we need one byte for the change
379df930be7Sderaadt * mask, one for the connection id and two for the tcp checksum.
380df930be7Sderaadt * So, (cp - new_seq) + 4 bytes of header are needed. hlen is how
381df930be7Sderaadt * many bytes of the original packet to toss so subtract the two to
382df930be7Sderaadt * get the new packet size.
383df930be7Sderaadt */
384df930be7Sderaadt deltaS = cp - new_seq;
385df930be7Sderaadt cp = (u_char *)ip;
386df930be7Sderaadt if (compress_cid == 0 || comp->last_xmit != cs->cs_id) {
387df930be7Sderaadt comp->last_xmit = cs->cs_id;
388df930be7Sderaadt hlen -= deltaS + 4;
389df930be7Sderaadt cp += hlen;
390df930be7Sderaadt *cp++ = changes | NEW_C;
391df930be7Sderaadt *cp++ = cs->cs_id;
392df930be7Sderaadt } else {
393df930be7Sderaadt hlen -= deltaS + 3;
394df930be7Sderaadt cp += hlen;
395df930be7Sderaadt *cp++ = changes;
396df930be7Sderaadt }
397df930be7Sderaadt m->m_len -= hlen;
398df930be7Sderaadt m->m_data += hlen;
399df930be7Sderaadt *cp++ = deltaA >> 8;
400df930be7Sderaadt *cp++ = deltaA;
401df930be7Sderaadt BCOPY(new_seq, cp, deltaS);
402df930be7Sderaadt INCR(sls_compressed)
403df930be7Sderaadt return (TYPE_COMPRESSED_TCP);
404df930be7Sderaadt
405df930be7Sderaadt /*
406df930be7Sderaadt * Update connection state cs & send uncompressed packet ('uncompressed'
407df930be7Sderaadt * means a regular ip/tcp packet but with the 'conversation id' we hope
408df930be7Sderaadt * to use on future compressed packets in the protocol field).
409df930be7Sderaadt */
410df930be7Sderaadt uncompressed:
411df930be7Sderaadt BCOPY(ip, &cs->cs_ip, hlen);
412df930be7Sderaadt ip->ip_p = cs->cs_id;
413df930be7Sderaadt comp->last_xmit = cs->cs_id;
414df930be7Sderaadt return (TYPE_UNCOMPRESSED_TCP);
415df930be7Sderaadt }
416df930be7Sderaadt
417df930be7Sderaadt
418df930be7Sderaadt int
sl_uncompress_tcp(u_char ** bufp,int len,u_int type,struct slcompress * comp)419*623e24ceSblambert sl_uncompress_tcp(u_char **bufp, int len, u_int type, struct slcompress *comp)
420df930be7Sderaadt {
421df930be7Sderaadt u_char *hdr, *cp;
422df930be7Sderaadt int hlen, vjlen;
423df930be7Sderaadt
424df930be7Sderaadt cp = bufp? *bufp: NULL;
425df930be7Sderaadt vjlen = sl_uncompress_tcp_core(cp, len, len, type, comp, &hdr, &hlen);
426df930be7Sderaadt if (vjlen < 0)
427df930be7Sderaadt return (0); /* error */
428df930be7Sderaadt if (vjlen == 0)
429df930be7Sderaadt return (len); /* was uncompressed already */
430df930be7Sderaadt
431df930be7Sderaadt cp += vjlen;
432df930be7Sderaadt len -= vjlen;
433df930be7Sderaadt
434df930be7Sderaadt /*
435df930be7Sderaadt * At this point, cp points to the first byte of data in the
436df930be7Sderaadt * packet. If we're not aligned on a 4-byte boundary, copy the
437df930be7Sderaadt * data down so the ip & tcp headers will be aligned. Then back up
438df930be7Sderaadt * cp by the tcp/ip header length to make room for the reconstructed
439df930be7Sderaadt * header (we assume the packet we were handed has enough space to
440df930be7Sderaadt * prepend 128 bytes of header).
441df930be7Sderaadt */
442cf3a88a1Sderaadt if ((long)cp & 3) {
443df930be7Sderaadt if (len > 0)
4448f51fbe3Sderaadt (void) memmove((caddr_t)((long)cp &~ 3), cp, len);
445cf3a88a1Sderaadt cp = (u_char *)((long)cp &~ 3);
446df930be7Sderaadt }
447df930be7Sderaadt cp -= hlen;
448df930be7Sderaadt len += hlen;
449df930be7Sderaadt BCOPY(hdr, cp, hlen);
450df930be7Sderaadt
451df930be7Sderaadt *bufp = cp;
452df930be7Sderaadt return (len);
453df930be7Sderaadt }
454df930be7Sderaadt
455df930be7Sderaadt /*
456df930be7Sderaadt * Uncompress a packet of total length total_len. The first buflen
457df930be7Sderaadt * bytes are at buf; this must include the entire (compressed or
458df930be7Sderaadt * uncompressed) TCP/IP header. This procedure returns the length
459df930be7Sderaadt * of the VJ header, with a pointer to the uncompressed IP header
460df930be7Sderaadt * in *hdrp and its length in *hlenp.
461df930be7Sderaadt */
462df930be7Sderaadt int
sl_uncompress_tcp_core(u_char * buf,int buflen,int total_len,u_int type,struct slcompress * comp,u_char ** hdrp,u_int * hlenp)463*623e24ceSblambert sl_uncompress_tcp_core(u_char *buf, int buflen, int total_len, u_int type,
464*623e24ceSblambert struct slcompress *comp, u_char **hdrp, u_int *hlenp)
465df930be7Sderaadt {
46664aa4cc7Sitojun u_char *cp;
46764aa4cc7Sitojun u_int hlen, changes;
46864aa4cc7Sitojun struct tcphdr *th;
46964aa4cc7Sitojun struct cstate *cs;
47064aa4cc7Sitojun struct ip *ip;
47164aa4cc7Sitojun u_int16_t *bp;
47264aa4cc7Sitojun u_int vjlen;
473df930be7Sderaadt
474df930be7Sderaadt switch (type) {
475df930be7Sderaadt
476df930be7Sderaadt case TYPE_UNCOMPRESSED_TCP:
477df930be7Sderaadt ip = (struct ip *) buf;
478df930be7Sderaadt if (ip->ip_p >= MAX_STATES)
479df930be7Sderaadt goto bad;
480df930be7Sderaadt cs = &comp->rstate[comp->last_recv = ip->ip_p];
481df930be7Sderaadt comp->flags &=~ SLF_TOSS;
482df930be7Sderaadt ip->ip_p = IPPROTO_TCP;
48316a6a920Sjoshd /*
48416a6a920Sjoshd * Calculate the size of the TCP/IP header and make sure that
48516a6a920Sjoshd * we don't overflow the space we have available for it.
48616a6a920Sjoshd */
48716a6a920Sjoshd hlen = ip->ip_hl << 2;
48816a6a920Sjoshd if (hlen + sizeof(struct tcphdr) > buflen)
48916a6a920Sjoshd goto bad;
49016a6a920Sjoshd hlen += ((struct tcphdr *)&((char *)ip)[hlen])->th_off << 2;
49116a6a920Sjoshd if (hlen > MAX_HDR || hlen > buflen)
49216a6a920Sjoshd goto bad;
493df930be7Sderaadt BCOPY(ip, &cs->cs_ip, hlen);
494df930be7Sderaadt cs->cs_hlen = hlen;
495df930be7Sderaadt INCR(sls_uncompressedin)
496df930be7Sderaadt *hdrp = (u_char *) &cs->cs_ip;
497df930be7Sderaadt *hlenp = hlen;
498df930be7Sderaadt return (0);
499df930be7Sderaadt
500df930be7Sderaadt default:
501df930be7Sderaadt goto bad;
502df930be7Sderaadt
503df930be7Sderaadt case TYPE_COMPRESSED_TCP:
504df930be7Sderaadt break;
505df930be7Sderaadt }
506df930be7Sderaadt /* We've got a compressed packet. */
507df930be7Sderaadt INCR(sls_compressedin)
508df930be7Sderaadt cp = buf;
509df930be7Sderaadt changes = *cp++;
510df930be7Sderaadt if (changes & NEW_C) {
511df930be7Sderaadt /* Make sure the state index is in range, then grab the state.
512df930be7Sderaadt * If we have a good state index, clear the 'discard' flag. */
513df930be7Sderaadt if (*cp >= MAX_STATES)
514df930be7Sderaadt goto bad;
515df930be7Sderaadt
516df930be7Sderaadt comp->flags &=~ SLF_TOSS;
517df930be7Sderaadt comp->last_recv = *cp++;
518df930be7Sderaadt } else {
519df930be7Sderaadt /* this packet has an implicit state index. If we've
520df930be7Sderaadt * had a line error since the last time we got an
521df930be7Sderaadt * explicit state index, we have to toss the packet. */
522df930be7Sderaadt if (comp->flags & SLF_TOSS) {
523df930be7Sderaadt INCR(sls_tossed)
524df930be7Sderaadt return (-1);
525df930be7Sderaadt }
526df930be7Sderaadt }
527df930be7Sderaadt cs = &comp->rstate[comp->last_recv];
528df930be7Sderaadt hlen = cs->cs_ip.ip_hl << 2;
529df930be7Sderaadt th = (struct tcphdr *)&((u_char *)&cs->cs_ip)[hlen];
530df930be7Sderaadt th->th_sum = htons((*cp << 8) | cp[1]);
531df930be7Sderaadt cp += 2;
532df930be7Sderaadt if (changes & TCP_PUSH_BIT)
533df930be7Sderaadt th->th_flags |= TH_PUSH;
534df930be7Sderaadt else
535df930be7Sderaadt th->th_flags &=~ TH_PUSH;
536df930be7Sderaadt
537df930be7Sderaadt switch (changes & SPECIALS_MASK) {
538df930be7Sderaadt case SPECIAL_I:
539df930be7Sderaadt {
54064aa4cc7Sitojun u_int i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;
541df930be7Sderaadt th->th_ack = htonl(ntohl(th->th_ack) + i);
542df930be7Sderaadt th->th_seq = htonl(ntohl(th->th_seq) + i);
543df930be7Sderaadt }
544df930be7Sderaadt break;
545df930be7Sderaadt
546df930be7Sderaadt case SPECIAL_D:
547df930be7Sderaadt th->th_seq = htonl(ntohl(th->th_seq) + ntohs(cs->cs_ip.ip_len)
548df930be7Sderaadt - cs->cs_hlen);
549df930be7Sderaadt break;
550df930be7Sderaadt
551df930be7Sderaadt default:
552df930be7Sderaadt if (changes & NEW_U) {
553df930be7Sderaadt th->th_flags |= TH_URG;
554df930be7Sderaadt DECODEU(th->th_urp)
555df930be7Sderaadt } else
556df930be7Sderaadt th->th_flags &=~ TH_URG;
557df930be7Sderaadt if (changes & NEW_W)
558df930be7Sderaadt DECODES(th->th_win)
559df930be7Sderaadt if (changes & NEW_A)
560df930be7Sderaadt DECODEL(th->th_ack)
561df930be7Sderaadt if (changes & NEW_S)
562df930be7Sderaadt DECODEL(th->th_seq)
563df930be7Sderaadt break;
564df930be7Sderaadt }
565df930be7Sderaadt if (changes & NEW_I) {
566df930be7Sderaadt DECODES(cs->cs_ip.ip_id)
567df930be7Sderaadt } else
568df930be7Sderaadt cs->cs_ip.ip_id = htons(ntohs(cs->cs_ip.ip_id) + 1);
569df930be7Sderaadt
570df930be7Sderaadt /*
571df930be7Sderaadt * At this point, cp points to the first byte of data in the
572df930be7Sderaadt * packet. Fill in the IP total length and update the IP
573df930be7Sderaadt * header checksum.
574df930be7Sderaadt */
575df930be7Sderaadt vjlen = cp - buf;
576df930be7Sderaadt buflen -= vjlen;
577df930be7Sderaadt if (buflen < 0)
578df930be7Sderaadt /* we must have dropped some characters (crc should detect
579df930be7Sderaadt * this but the old slip framing won't) */
580df930be7Sderaadt goto bad;
581df930be7Sderaadt
582df930be7Sderaadt total_len += cs->cs_hlen - vjlen;
583df930be7Sderaadt cs->cs_ip.ip_len = htons(total_len);
584df930be7Sderaadt
585df930be7Sderaadt /* recompute the ip header checksum */
586df930be7Sderaadt bp = (u_int16_t *) &cs->cs_ip;
587df930be7Sderaadt cs->cs_ip.ip_sum = 0;
588df930be7Sderaadt for (changes = 0; hlen > 0; hlen -= 2)
589df930be7Sderaadt changes += *bp++;
590df930be7Sderaadt changes = (changes & 0xffff) + (changes >> 16);
591df930be7Sderaadt changes = (changes & 0xffff) + (changes >> 16);
592df930be7Sderaadt cs->cs_ip.ip_sum = ~ changes;
593df930be7Sderaadt
594df930be7Sderaadt *hdrp = (u_char *) &cs->cs_ip;
595df930be7Sderaadt *hlenp = cs->cs_hlen;
596df930be7Sderaadt return vjlen;
597df930be7Sderaadt
598df930be7Sderaadt bad:
599df930be7Sderaadt comp->flags |= SLF_TOSS;
600df930be7Sderaadt INCR(sls_errorin)
601df930be7Sderaadt return (-1);
602df930be7Sderaadt }
603