* Copyright (c) 1989 The Regents of the University of California.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 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
* @(#)slcompress.c 7.7 (Berkeley) 5/7/91
* 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.
* "$Header: slcompress.c,v 1.19 89/12/31 08:52:59 van Exp $";
#include <netinet/in_systm.h>
#define INCR(counter) ++comp->counter;
#define BCMP(p1, p2, n) bcmp((char *)(p1), (char *)(p2), (int)(n))
#define BCOPY(p1, p2, n) bcopy((char *)(p1), (char *)(p2), (int)(n))
register struct cstate
*tstate
= comp
->tstate
;
bzero((char *)comp
, sizeof(*comp
));
for (i
= MAX_STATES
- 1; i
> 0; --i
) {
tstate
[i
].cs_next
= &tstate
[i
- 1];
tstate
[0].cs_next
= &tstate
[MAX_STATES
- 1];
comp
->last_cs
= &tstate
[0];
/* 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
if ((u_short)(n) >= 256) { \
if ((u_short)(n) >= 256 || (u_short)(n) == 0) { \
(f) = htonl(ntohl(f) + ((cp[1] << 8) | cp[2])); \
(f) = htonl(ntohl(f) + (u_long)*cp++); \
(f) = htons(ntohs(f) + ((cp[1] << 8) | cp[2])); \
(f) = htons(ntohs(f) + (u_long)*cp++); \
(f) = htons((cp[1] << 8) | cp[2]); \
(f) = htons((u_long)*cp++); \
sl_compress_tcp(m
, ip
, comp
, 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;
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)
th
= (struct tcphdr
*)&((int *)ip
)[hlen
];
if ((th
->th_flags
& (TH_SYN
|TH_FIN
|TH_RST
|TH_ACK
)) != TH_ACK
)
* 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.
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
;
lcs
= cs
; cs
= cs
->cs_next
;
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
])
* 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.
* Found it -- move to the front on the connection list.
lcs
->cs_next
= cs
->cs_next
;
cs
->cs_next
= lastcs
->cs_next
;
* 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
];
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
||
BCMP(ip
+ 1, &cs
->cs_ip
+ 1, (deltaS
- 5) << 2)) ||
BCMP(th
+ 1, oth
+ 1, (th
->th_off
- 5) << 2)))
* 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
);
} 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
if (deltaS
= (u_short
)(ntohs(th
->th_win
) - ntohs(oth
->th_win
))) {
if (deltaA
= ntohl(th
->th_ack
) - ntohl(oth
->th_ack
)) {
if (deltaS
= ntohl(th
->th_seq
) - ntohl(oth
->th_seq
)) {
* 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
)
* actual changes match one of our special case encodings --
* send packet uncompressed.
deltaS
== ntohs(cs
->cs_ip
.ip_len
) - hlen
) {
/* special case for echoed terminal traffic */
if (deltaS
== ntohs(cs
->cs_ip
.ip_len
) - hlen
) {
/* special case for data xfer */
deltaS
= ntohs(ip
->ip_id
) - ntohs(cs
->cs_ip
.ip_id
);
if (th
->th_flags
& TH_PUSH
)
* 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.
if (compress_cid
== 0 || comp
->last_xmit
!= cs
->cs_id
) {
comp
->last_xmit
= cs
->cs_id
;
BCOPY(new_seq
, cp
, deltaS
);
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).
BCOPY(ip
, &cs
->cs_ip
, hlen
);
comp
->last_xmit
= cs
->cs_id
;
return (TYPE_UNCOMPRESSED_TCP
);
sl_uncompress_tcp(bufp
, len
, type
, comp
)
register u_int hlen
, changes
;
register struct tcphdr
*th
;
register struct cstate
*cs
;
case TYPE_UNCOMPRESSED_TCP
:
ip
= (struct ip
*) *bufp
;
if (ip
->ip_p
>= MAX_STATES
)
cs
= &comp
->rstate
[comp
->last_recv
= ip
->ip_p
];
comp
->flags
&=~ SLF_TOSS
;
hlen
+= ((struct tcphdr
*)&((int *)ip
)[hlen
])->th_off
;
BCOPY(ip
, &cs
->cs_ip
, hlen
);
case TYPE_COMPRESSED_TCP
:
/* We've got a compressed packet. */
/* Make sure the state index is in range, then grab the state.
* If we have a good state index, clear the 'discard' flag. */
comp
->flags
&=~ SLF_TOSS
;
/* 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
) {
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]);
if (changes
& TCP_PUSH_BIT
)
th
->th_flags
&=~ TH_PUSH
;
switch (changes
& SPECIALS_MASK
) {
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
);
th
->th_seq
= htonl(ntohl(th
->th_seq
) + ntohs(cs
->cs_ip
.ip_len
)
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.
/* we must have dropped some characters (crc should detect
* this but the old slip framing won't) */
(void) ovbcopy(cp
, (caddr_t
)((int)cp
&~ 3), len
);
cp
= (u_char
*)((int)cp
&~ 3);
cs
->cs_ip
.ip_len
= htons(len
);
BCOPY(&cs
->cs_ip
, cp
, cs
->cs_hlen
);
/* recompute the ip header checksum */
register u_short
*bp
= (u_short
*)cp
;
for (changes
= 0; hlen
> 0; hlen
-= 2)
changes
= (changes
& 0xffff) + (changes
>> 16);
changes
= (changes
& 0xffff) + (changes
>> 16);
((struct ip
*)cp
)->ip_sum
= ~ changes
;