]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Routines to compress and uncompress tcp packets (for transmission | |
3 | * over low speed serial lines). | |
4 | * | |
5 | * Copyright (c) 1989 Regents of the University of California. | |
6 | * All rights reserved. | |
7 | * | |
8 | * Redistribution and use in source and binary forms are permitted | |
9 | * provided that the above copyright notice and this paragraph are | |
10 | * duplicated in all such forms and that any documentation, | |
11 | * advertising materials, and other materials related to such | |
12 | * distribution and use acknowledge that the software was developed | |
13 | * by the University of California, Berkeley. The name of the | |
14 | * University may not be used to endorse or promote products derived | |
15 | * from this software without specific prior written permission. | |
16 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR | |
17 | * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED | |
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | |
19 | * | |
20 | * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: | |
21 | * - Initial distribution. | |
22 | * | |
23 | * | |
24 | * modified for KA9Q Internet Software Package by | |
25 | * Katie Stevens (dkstevens@ucdavis.edu) | |
26 | * University of California, Davis | |
27 | * Computing Services | |
28 | * - 01-31-90 initial adaptation (from 1.19) | |
29 | * PPP.05 02-15-90 [ks] | |
30 | * PPP.08 05-02-90 [ks] use PPP protocol field to signal compression | |
31 | * PPP.15 09-90 [ks] improve mbuf handling | |
32 | * PPP.16 11-02 [karn] substantially rewritten to use NOS facilities | |
33 | * | |
34 | * - Feb 1991 Bill_Simpson@um.cc.umich.edu | |
35 | * variable number of conversation slots | |
36 | * allow zero or one slots | |
37 | * separate routines | |
38 | * status display | |
39 | * - Jul 1994 Dmitry Gorodchanin | |
40 | * Fixes for memory leaks. | |
41 | * - Oct 1994 Dmitry Gorodchanin | |
42 | * Modularization. | |
43 | * - Jan 1995 Bjorn Ekwall | |
44 | * Use ip_fast_csum from ip.h | |
6aa20a22 | 45 | * - July 1995 Christos A. Polyzols |
1da177e4 LT |
46 | * Spotted bug in tcp option checking |
47 | * | |
48 | * | |
49 | * This module is a difficult issue. It's clearly inet code but it's also clearly | |
50 | * driver code belonging close to PPP and SLIP | |
51 | */ | |
52 | ||
1da177e4 | 53 | #include <linux/module.h> |
5a0e3ad6 | 54 | #include <linux/slab.h> |
1da177e4 LT |
55 | #include <linux/types.h> |
56 | #include <linux/string.h> | |
57 | #include <linux/errno.h> | |
58 | #include <linux/kernel.h> | |
59 | #include <net/slhc_vj.h> | |
60 | ||
61 | #ifdef CONFIG_INET | |
62 | /* Entire module is for IP only */ | |
63 | #include <linux/mm.h> | |
64 | #include <linux/socket.h> | |
65 | #include <linux/sockios.h> | |
66 | #include <linux/termios.h> | |
67 | #include <linux/in.h> | |
68 | #include <linux/fcntl.h> | |
69 | #include <linux/inet.h> | |
70 | #include <linux/netdevice.h> | |
71 | #include <net/ip.h> | |
72 | #include <net/protocol.h> | |
73 | #include <net/icmp.h> | |
74 | #include <net/tcp.h> | |
75 | #include <linux/skbuff.h> | |
76 | #include <net/sock.h> | |
77 | #include <linux/timer.h> | |
7c0f6ba6 | 78 | #include <linux/uaccess.h> |
1da177e4 LT |
79 | #include <net/checksum.h> |
80 | #include <asm/unaligned.h> | |
81 | ||
82 | static unsigned char *encode(unsigned char *cp, unsigned short n); | |
83 | static long decode(unsigned char **cpp); | |
84 | static unsigned char * put16(unsigned char *cp, unsigned short x); | |
85 | static unsigned short pull16(unsigned char **cpp); | |
86 | ||
4ab42d78 | 87 | /* Allocate compression data structure |
1da177e4 | 88 | * slots must be in range 0 to 255 (zero meaning no compression) |
4ab42d78 | 89 | * Returns pointer to structure or ERR_PTR() on error. |
1da177e4 LT |
90 | */ |
91 | struct slcompress * | |
92 | slhc_init(int rslots, int tslots) | |
93 | { | |
94 | register short i; | |
95 | register struct cstate *ts; | |
96 | struct slcompress *comp; | |
97 | ||
4ab42d78 BH |
98 | if (rslots < 0 || rslots > 255 || tslots < 0 || tslots > 255) |
99 | return ERR_PTR(-EINVAL); | |
100 | ||
79690602 | 101 | comp = kzalloc(sizeof(struct slcompress), GFP_KERNEL); |
1da177e4 LT |
102 | if (! comp) |
103 | goto out_fail; | |
1da177e4 | 104 | |
4ab42d78 | 105 | if (rslots > 0) { |
1da177e4 | 106 | size_t rsize = rslots * sizeof(struct cstate); |
79690602 | 107 | comp->rstate = kzalloc(rsize, GFP_KERNEL); |
1da177e4 LT |
108 | if (! comp->rstate) |
109 | goto out_free; | |
1da177e4 LT |
110 | comp->rslot_limit = rslots - 1; |
111 | } | |
112 | ||
4ab42d78 | 113 | if (tslots > 0) { |
1da177e4 | 114 | size_t tsize = tslots * sizeof(struct cstate); |
79690602 | 115 | comp->tstate = kzalloc(tsize, GFP_KERNEL); |
1da177e4 LT |
116 | if (! comp->tstate) |
117 | goto out_free2; | |
1da177e4 LT |
118 | comp->tslot_limit = tslots - 1; |
119 | } | |
120 | ||
121 | comp->xmit_oldest = 0; | |
122 | comp->xmit_current = 255; | |
123 | comp->recv_current = 255; | |
124 | /* | |
125 | * don't accept any packets with implicit index until we get | |
126 | * one with an explicit index. Otherwise the uncompress code | |
127 | * will try to use connection 255, which is almost certainly | |
128 | * out of range | |
129 | */ | |
130 | comp->flags |= SLF_TOSS; | |
131 | ||
132 | if ( tslots > 0 ) { | |
133 | ts = comp->tstate; | |
134 | for(i = comp->tslot_limit; i > 0; --i){ | |
135 | ts[i].cs_this = i; | |
136 | ts[i].next = &(ts[i - 1]); | |
137 | } | |
138 | ts[0].next = &(ts[comp->tslot_limit]); | |
139 | ts[0].cs_this = 0; | |
140 | } | |
141 | return comp; | |
142 | ||
143 | out_free2: | |
79690602 | 144 | kfree(comp->rstate); |
1da177e4 | 145 | out_free: |
79690602 | 146 | kfree(comp); |
1da177e4 | 147 | out_fail: |
4ab42d78 | 148 | return ERR_PTR(-ENOMEM); |
1da177e4 LT |
149 | } |
150 | ||
151 | ||
152 | /* Free a compression data structure */ | |
153 | void | |
154 | slhc_free(struct slcompress *comp) | |
155 | { | |
156 | if ( comp == NULLSLCOMPR ) | |
157 | return; | |
158 | ||
159 | if ( comp->tstate != NULLSLSTATE ) | |
160 | kfree( comp->tstate ); | |
161 | ||
162 | if ( comp->rstate != NULLSLSTATE ) | |
163 | kfree( comp->rstate ); | |
164 | ||
165 | kfree( comp ); | |
166 | } | |
167 | ||
168 | ||
169 | /* Put a short in host order into a char array in network order */ | |
170 | static inline unsigned char * | |
171 | put16(unsigned char *cp, unsigned short x) | |
172 | { | |
173 | *cp++ = x >> 8; | |
174 | *cp++ = x; | |
175 | ||
176 | return cp; | |
177 | } | |
178 | ||
179 | ||
180 | /* Encode a number */ | |
3c582b30 | 181 | static unsigned char * |
1da177e4 LT |
182 | encode(unsigned char *cp, unsigned short n) |
183 | { | |
184 | if(n >= 256 || n == 0){ | |
185 | *cp++ = 0; | |
186 | cp = put16(cp,n); | |
187 | } else { | |
188 | *cp++ = n; | |
189 | } | |
190 | return cp; | |
191 | } | |
192 | ||
193 | /* Pull a 16-bit integer in host order from buffer in network byte order */ | |
194 | static unsigned short | |
195 | pull16(unsigned char **cpp) | |
196 | { | |
197 | short rval; | |
198 | ||
199 | rval = *(*cpp)++; | |
200 | rval <<= 8; | |
201 | rval |= *(*cpp)++; | |
202 | return rval; | |
203 | } | |
204 | ||
205 | /* Decode a number */ | |
3c582b30 | 206 | static long |
1da177e4 LT |
207 | decode(unsigned char **cpp) |
208 | { | |
209 | register int x; | |
210 | ||
211 | x = *(*cpp)++; | |
212 | if(x == 0){ | |
213 | return pull16(cpp) & 0xffff; /* pull16 returns -1 on error */ | |
214 | } else { | |
215 | return x & 0xff; /* -1 if PULLCHAR returned error */ | |
216 | } | |
217 | } | |
218 | ||
219 | /* | |
220 | * icp and isize are the original packet. | |
221 | * ocp is a place to put a copy if necessary. | |
222 | * cpp is initially a pointer to icp. If the copy is used, | |
223 | * change it to ocp. | |
224 | */ | |
225 | ||
226 | int | |
227 | slhc_compress(struct slcompress *comp, unsigned char *icp, int isize, | |
228 | unsigned char *ocp, unsigned char **cpp, int compress_cid) | |
229 | { | |
230 | register struct cstate *ocs = &(comp->tstate[comp->xmit_oldest]); | |
231 | register struct cstate *lcs = ocs; | |
232 | register struct cstate *cs = lcs->next; | |
233 | register unsigned long deltaS, deltaA; | |
234 | register short changes = 0; | |
235 | int hlen; | |
236 | unsigned char new_seq[16]; | |
237 | register unsigned char *cp = new_seq; | |
238 | struct iphdr *ip; | |
239 | struct tcphdr *th, *oth; | |
7cd61888 | 240 | __sum16 csum; |
1da177e4 LT |
241 | |
242 | ||
243 | /* | |
244 | * Don't play with runt packets. | |
245 | */ | |
6aa20a22 | 246 | |
1da177e4 LT |
247 | if(isize<sizeof(struct iphdr)) |
248 | return isize; | |
6aa20a22 | 249 | |
1da177e4 LT |
250 | ip = (struct iphdr *) icp; |
251 | ||
252 | /* Bail if this packet isn't TCP, or is an IP fragment */ | |
253 | if (ip->protocol != IPPROTO_TCP || (ntohs(ip->frag_off) & 0x3fff)) { | |
254 | /* Send as regular IP */ | |
255 | if(ip->protocol != IPPROTO_TCP) | |
256 | comp->sls_o_nontcp++; | |
257 | else | |
258 | comp->sls_o_tcp++; | |
259 | return isize; | |
260 | } | |
261 | /* Extract TCP header */ | |
262 | ||
263 | th = (struct tcphdr *)(((unsigned char *)ip) + ip->ihl*4); | |
264 | hlen = ip->ihl*4 + th->doff*4; | |
265 | ||
266 | /* Bail if the TCP packet isn't `compressible' (i.e., ACK isn't set or | |
267 | * some other control bit is set). Also uncompressible if | |
268 | * it's a runt. | |
269 | */ | |
270 | if(hlen > isize || th->syn || th->fin || th->rst || | |
271 | ! (th->ack)){ | |
272 | /* TCP connection stuff; send as regular IP */ | |
273 | comp->sls_o_tcp++; | |
274 | return isize; | |
275 | } | |
276 | /* | |
277 | * Packet is compressible -- we're going to send either a | |
278 | * COMPRESSED_TCP or UNCOMPRESSED_TCP packet. Either way, | |
279 | * we need to locate (or create) the connection state. | |
280 | * | |
281 | * States are kept in a circularly linked list with | |
282 | * xmit_oldest pointing to the end of the list. The | |
283 | * list is kept in lru order by moving a state to the | |
284 | * head of the list whenever it is referenced. Since | |
285 | * the list is short and, empirically, the connection | |
286 | * we want is almost always near the front, we locate | |
287 | * states via linear search. If we don't find a state | |
288 | * for the datagram, the oldest state is (re-)used. | |
289 | */ | |
290 | for ( ; ; ) { | |
291 | if( ip->saddr == cs->cs_ip.saddr | |
292 | && ip->daddr == cs->cs_ip.daddr | |
293 | && th->source == cs->cs_tcp.source | |
294 | && th->dest == cs->cs_tcp.dest) | |
295 | goto found; | |
296 | ||
297 | /* if current equal oldest, at end of list */ | |
298 | if ( cs == ocs ) | |
299 | break; | |
300 | lcs = cs; | |
301 | cs = cs->next; | |
302 | comp->sls_o_searches++; | |
6403eab1 | 303 | } |
1da177e4 LT |
304 | /* |
305 | * Didn't find it -- re-use oldest cstate. Send an | |
306 | * uncompressed packet that tells the other side what | |
307 | * connection number we're using for this conversation. | |
308 | * | |
309 | * Note that since the state list is circular, the oldest | |
310 | * state points to the newest and we only need to set | |
311 | * xmit_oldest to update the lru linkage. | |
312 | */ | |
313 | comp->sls_o_misses++; | |
314 | comp->xmit_oldest = lcs->cs_this; | |
315 | goto uncompressed; | |
316 | ||
317 | found: | |
318 | /* | |
319 | * Found it -- move to the front on the connection list. | |
320 | */ | |
321 | if(lcs == ocs) { | |
322 | /* found at most recently used */ | |
323 | } else if (cs == ocs) { | |
324 | /* found at least recently used */ | |
325 | comp->xmit_oldest = lcs->cs_this; | |
326 | } else { | |
327 | /* more than 2 elements */ | |
328 | lcs->next = cs->next; | |
329 | cs->next = ocs->next; | |
330 | ocs->next = cs; | |
331 | } | |
332 | ||
333 | /* | |
334 | * Make sure that only what we expect to change changed. | |
335 | * Check the following: | |
336 | * IP protocol version, header length & type of service. | |
337 | * The "Don't fragment" bit. | |
338 | * The time-to-live field. | |
339 | * The TCP header length. | |
340 | * IP options, if any. | |
341 | * TCP options, if any. | |
342 | * If any of these things are different between the previous & | |
343 | * current datagram, we send the current datagram `uncompressed'. | |
344 | */ | |
345 | oth = &cs->cs_tcp; | |
346 | ||
347 | if(ip->version != cs->cs_ip.version || ip->ihl != cs->cs_ip.ihl | |
348 | || ip->tos != cs->cs_ip.tos | |
349 | || (ip->frag_off & htons(0x4000)) != (cs->cs_ip.frag_off & htons(0x4000)) | |
350 | || ip->ttl != cs->cs_ip.ttl | |
351 | || th->doff != cs->cs_tcp.doff | |
352 | || (ip->ihl > 5 && memcmp(ip+1,cs->cs_ipopt,((ip->ihl)-5)*4) != 0) | |
353 | || (th->doff > 5 && memcmp(th+1,cs->cs_tcpopt,((th->doff)-5)*4) != 0)){ | |
354 | goto uncompressed; | |
355 | } | |
356 | ||
357 | /* | |
358 | * Figure out which of the changing fields changed. The | |
359 | * receiver expects changes in the order: urgent, window, | |
360 | * ack, seq (the order minimizes the number of temporaries | |
361 | * needed in this section of code). | |
362 | */ | |
363 | if(th->urg){ | |
364 | deltaS = ntohs(th->urg_ptr); | |
365 | cp = encode(cp,deltaS); | |
366 | changes |= NEW_U; | |
367 | } else if(th->urg_ptr != oth->urg_ptr){ | |
368 | /* argh! URG not set but urp changed -- a sensible | |
369 | * implementation should never do this but RFC793 | |
370 | * doesn't prohibit the change so we have to deal | |
371 | * with it. */ | |
372 | goto uncompressed; | |
373 | } | |
374 | if((deltaS = ntohs(th->window) - ntohs(oth->window)) != 0){ | |
375 | cp = encode(cp,deltaS); | |
376 | changes |= NEW_W; | |
377 | } | |
378 | if((deltaA = ntohl(th->ack_seq) - ntohl(oth->ack_seq)) != 0L){ | |
379 | if(deltaA > 0x0000ffff) | |
380 | goto uncompressed; | |
381 | cp = encode(cp,deltaA); | |
382 | changes |= NEW_A; | |
383 | } | |
384 | if((deltaS = ntohl(th->seq) - ntohl(oth->seq)) != 0L){ | |
385 | if(deltaS > 0x0000ffff) | |
386 | goto uncompressed; | |
387 | cp = encode(cp,deltaS); | |
388 | changes |= NEW_S; | |
389 | } | |
390 | ||
391 | switch(changes){ | |
392 | case 0: /* Nothing changed. If this packet contains data and the | |
393 | * last one didn't, this is probably a data packet following | |
394 | * an ack (normal on an interactive connection) and we send | |
395 | * it compressed. Otherwise it's probably a retransmit, | |
396 | * retransmitted ack or window probe. Send it uncompressed | |
397 | * in case the other side missed the compressed version. | |
398 | */ | |
399 | if(ip->tot_len != cs->cs_ip.tot_len && | |
400 | ntohs(cs->cs_ip.tot_len) == hlen) | |
401 | break; | |
402 | goto uncompressed; | |
1da177e4 LT |
403 | case SPECIAL_I: |
404 | case SPECIAL_D: | |
405 | /* actual changes match one of our special case encodings -- | |
406 | * send packet uncompressed. | |
407 | */ | |
408 | goto uncompressed; | |
409 | case NEW_S|NEW_A: | |
410 | if(deltaS == deltaA && | |
411 | deltaS == ntohs(cs->cs_ip.tot_len) - hlen){ | |
412 | /* special case for echoed terminal traffic */ | |
413 | changes = SPECIAL_I; | |
414 | cp = new_seq; | |
415 | } | |
416 | break; | |
417 | case NEW_S: | |
418 | if(deltaS == ntohs(cs->cs_ip.tot_len) - hlen){ | |
419 | /* special case for data xfer */ | |
420 | changes = SPECIAL_D; | |
421 | cp = new_seq; | |
422 | } | |
423 | break; | |
424 | } | |
425 | deltaS = ntohs(ip->id) - ntohs(cs->cs_ip.id); | |
426 | if(deltaS != 1){ | |
427 | cp = encode(cp,deltaS); | |
428 | changes |= NEW_I; | |
429 | } | |
430 | if(th->psh) | |
431 | changes |= TCP_PUSH_BIT; | |
432 | /* Grab the cksum before we overwrite it below. Then update our | |
433 | * state with this packet's header. | |
434 | */ | |
7cd61888 | 435 | csum = th->check; |
1da177e4 LT |
436 | memcpy(&cs->cs_ip,ip,20); |
437 | memcpy(&cs->cs_tcp,th,20); | |
438 | /* We want to use the original packet as our compressed packet. | |
439 | * (cp - new_seq) is the number of bytes we need for compressed | |
440 | * sequence numbers. In addition we need one byte for the change | |
441 | * mask, one for the connection id and two for the tcp checksum. | |
442 | * So, (cp - new_seq) + 4 bytes of header are needed. | |
443 | */ | |
444 | deltaS = cp - new_seq; | |
445 | if(compress_cid == 0 || comp->xmit_current != cs->cs_this){ | |
446 | cp = ocp; | |
447 | *cpp = ocp; | |
448 | *cp++ = changes | NEW_C; | |
449 | *cp++ = cs->cs_this; | |
450 | comp->xmit_current = cs->cs_this; | |
451 | } else { | |
452 | cp = ocp; | |
453 | *cpp = ocp; | |
454 | *cp++ = changes; | |
455 | } | |
7cd61888 AV |
456 | *(__sum16 *)cp = csum; |
457 | cp += 2; | |
1da177e4 LT |
458 | /* deltaS is now the size of the change section of the compressed header */ |
459 | memcpy(cp,new_seq,deltaS); /* Write list of deltas */ | |
460 | memcpy(cp+deltaS,icp+hlen,isize-hlen); | |
461 | comp->sls_o_compressed++; | |
462 | ocp[0] |= SL_TYPE_COMPRESSED_TCP; | |
463 | return isize - hlen + deltaS + (cp - ocp); | |
464 | ||
465 | /* Update connection state cs & send uncompressed packet (i.e., | |
466 | * a regular ip/tcp packet but with the 'conversation id' we hope | |
467 | * to use on future compressed packets in the protocol field). | |
468 | */ | |
469 | uncompressed: | |
470 | memcpy(&cs->cs_ip,ip,20); | |
471 | memcpy(&cs->cs_tcp,th,20); | |
472 | if (ip->ihl > 5) | |
473 | memcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4); | |
474 | if (th->doff > 5) | |
475 | memcpy(cs->cs_tcpopt, th+1, ((th->doff) - 5) * 4); | |
476 | comp->xmit_current = cs->cs_this; | |
477 | comp->sls_o_uncompressed++; | |
478 | memcpy(ocp, icp, isize); | |
479 | *cpp = ocp; | |
480 | ocp[9] = cs->cs_this; | |
481 | ocp[0] |= SL_TYPE_UNCOMPRESSED_TCP; | |
482 | return isize; | |
483 | } | |
484 | ||
485 | ||
486 | int | |
487 | slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize) | |
488 | { | |
489 | register int changes; | |
490 | long x; | |
491 | register struct tcphdr *thp; | |
492 | register struct iphdr *ip; | |
493 | register struct cstate *cs; | |
494 | int len, hdrlen; | |
495 | unsigned char *cp = icp; | |
496 | ||
497 | /* We've got a compressed packet; read the change byte */ | |
498 | comp->sls_i_compressed++; | |
499 | if(isize < 3){ | |
500 | comp->sls_i_error++; | |
501 | return 0; | |
502 | } | |
503 | changes = *cp++; | |
504 | if(changes & NEW_C){ | |
505 | /* Make sure the state index is in range, then grab the state. | |
506 | * If we have a good state index, clear the 'discard' flag. | |
507 | */ | |
508 | x = *cp++; /* Read conn index */ | |
509 | if(x < 0 || x > comp->rslot_limit) | |
510 | goto bad; | |
511 | ||
512 | comp->flags &=~ SLF_TOSS; | |
513 | comp->recv_current = x; | |
514 | } else { | |
515 | /* this packet has an implicit state index. If we've | |
516 | * had a line error since the last time we got an | |
517 | * explicit state index, we have to toss the packet. */ | |
518 | if(comp->flags & SLF_TOSS){ | |
519 | comp->sls_i_tossed++; | |
520 | return 0; | |
521 | } | |
522 | } | |
523 | cs = &comp->rstate[comp->recv_current]; | |
524 | thp = &cs->cs_tcp; | |
525 | ip = &cs->cs_ip; | |
526 | ||
7cd61888 AV |
527 | thp->check = *(__sum16 *)cp; |
528 | cp += 2; | |
1da177e4 LT |
529 | |
530 | thp->psh = (changes & TCP_PUSH_BIT) ? 1 : 0; | |
531 | /* | |
532 | * we can use the same number for the length of the saved header and | |
533 | * the current one, because the packet wouldn't have been sent | |
534 | * as compressed unless the options were the same as the previous one | |
535 | */ | |
536 | ||
537 | hdrlen = ip->ihl * 4 + thp->doff * 4; | |
538 | ||
539 | switch(changes & SPECIALS_MASK){ | |
540 | case SPECIAL_I: /* Echoed terminal traffic */ | |
541 | { | |
542 | register short i; | |
543 | i = ntohs(ip->tot_len) - hdrlen; | |
544 | thp->ack_seq = htonl( ntohl(thp->ack_seq) + i); | |
545 | thp->seq = htonl( ntohl(thp->seq) + i); | |
546 | } | |
547 | break; | |
548 | ||
549 | case SPECIAL_D: /* Unidirectional data */ | |
550 | thp->seq = htonl( ntohl(thp->seq) + | |
551 | ntohs(ip->tot_len) - hdrlen); | |
552 | break; | |
553 | ||
554 | default: | |
555 | if(changes & NEW_U){ | |
556 | thp->urg = 1; | |
557 | if((x = decode(&cp)) == -1) { | |
558 | goto bad; | |
559 | } | |
560 | thp->urg_ptr = htons(x); | |
561 | } else | |
562 | thp->urg = 0; | |
563 | if(changes & NEW_W){ | |
564 | if((x = decode(&cp)) == -1) { | |
565 | goto bad; | |
566 | } | |
567 | thp->window = htons( ntohs(thp->window) + x); | |
568 | } | |
569 | if(changes & NEW_A){ | |
570 | if((x = decode(&cp)) == -1) { | |
571 | goto bad; | |
572 | } | |
573 | thp->ack_seq = htonl( ntohl(thp->ack_seq) + x); | |
574 | } | |
575 | if(changes & NEW_S){ | |
576 | if((x = decode(&cp)) == -1) { | |
577 | goto bad; | |
578 | } | |
579 | thp->seq = htonl( ntohl(thp->seq) + x); | |
580 | } | |
581 | break; | |
582 | } | |
583 | if(changes & NEW_I){ | |
584 | if((x = decode(&cp)) == -1) { | |
585 | goto bad; | |
586 | } | |
587 | ip->id = htons (ntohs (ip->id) + x); | |
588 | } else | |
589 | ip->id = htons (ntohs (ip->id) + 1); | |
590 | ||
591 | /* | |
592 | * At this point, cp points to the first byte of data in the | |
593 | * packet. Put the reconstructed TCP and IP headers back on the | |
594 | * packet. Recalculate IP checksum (but not TCP checksum). | |
595 | */ | |
596 | ||
597 | len = isize - (cp - icp); | |
598 | if (len < 0) | |
599 | goto bad; | |
600 | len += hdrlen; | |
601 | ip->tot_len = htons(len); | |
602 | ip->check = 0; | |
603 | ||
604 | memmove(icp + hdrlen, cp, len - hdrlen); | |
605 | ||
606 | cp = icp; | |
607 | memcpy(cp, ip, 20); | |
608 | cp += 20; | |
609 | ||
610 | if (ip->ihl > 5) { | |
611 | memcpy(cp, cs->cs_ipopt, (ip->ihl - 5) * 4); | |
612 | cp += (ip->ihl - 5) * 4; | |
613 | } | |
614 | ||
615 | put_unaligned(ip_fast_csum(icp, ip->ihl), | |
616 | &((struct iphdr *)icp)->check); | |
617 | ||
618 | memcpy(cp, thp, 20); | |
619 | cp += 20; | |
620 | ||
621 | if (thp->doff > 5) { | |
622 | memcpy(cp, cs->cs_tcpopt, ((thp->doff) - 5) * 4); | |
623 | cp += ((thp->doff) - 5) * 4; | |
624 | } | |
625 | ||
626 | return len; | |
627 | bad: | |
628 | comp->sls_i_error++; | |
629 | return slhc_toss( comp ); | |
630 | } | |
631 | ||
632 | ||
633 | int | |
634 | slhc_remember(struct slcompress *comp, unsigned char *icp, int isize) | |
635 | { | |
636 | register struct cstate *cs; | |
637 | unsigned ihl; | |
638 | ||
639 | unsigned char index; | |
640 | ||
641 | if(isize < 20) { | |
642 | /* The packet is shorter than a legal IP header */ | |
643 | comp->sls_i_runt++; | |
644 | return slhc_toss( comp ); | |
645 | } | |
646 | /* Peek at the IP header's IHL field to find its length */ | |
647 | ihl = icp[0] & 0xf; | |
648 | if(ihl < 20 / 4){ | |
649 | /* The IP header length field is too small */ | |
650 | comp->sls_i_runt++; | |
651 | return slhc_toss( comp ); | |
652 | } | |
653 | index = icp[9]; | |
654 | icp[9] = IPPROTO_TCP; | |
655 | ||
656 | if (ip_fast_csum(icp, ihl)) { | |
657 | /* Bad IP header checksum; discard */ | |
658 | comp->sls_i_badcheck++; | |
659 | return slhc_toss( comp ); | |
660 | } | |
661 | if(index > comp->rslot_limit) { | |
662 | comp->sls_i_error++; | |
663 | return slhc_toss(comp); | |
664 | } | |
665 | ||
666 | /* Update local state */ | |
667 | cs = &comp->rstate[comp->recv_current = index]; | |
668 | comp->flags &=~ SLF_TOSS; | |
669 | memcpy(&cs->cs_ip,icp,20); | |
670 | memcpy(&cs->cs_tcp,icp + ihl*4,20); | |
671 | if (ihl > 5) | |
672 | memcpy(cs->cs_ipopt, icp + sizeof(struct iphdr), (ihl - 5) * 4); | |
673 | if (cs->cs_tcp.doff > 5) | |
674 | memcpy(cs->cs_tcpopt, icp + ihl*4 + sizeof(struct tcphdr), (cs->cs_tcp.doff - 5) * 4); | |
675 | cs->cs_hsize = ihl*2 + cs->cs_tcp.doff*2; | |
676 | /* Put headers back on packet | |
677 | * Neither header checksum is recalculated | |
678 | */ | |
679 | comp->sls_i_uncompressed++; | |
680 | return isize; | |
681 | } | |
682 | ||
683 | int | |
684 | slhc_toss(struct slcompress *comp) | |
685 | { | |
686 | if ( comp == NULLSLCOMPR ) | |
687 | return 0; | |
688 | ||
689 | comp->flags |= SLF_TOSS; | |
690 | return 0; | |
691 | } | |
692 | ||
1da177e4 LT |
693 | #else /* CONFIG_INET */ |
694 | ||
1da177e4 LT |
695 | int |
696 | slhc_toss(struct slcompress *comp) | |
697 | { | |
698 | printk(KERN_DEBUG "Called IP function on non IP-system: slhc_toss"); | |
699 | return -EINVAL; | |
700 | } | |
701 | int | |
702 | slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize) | |
703 | { | |
704 | printk(KERN_DEBUG "Called IP function on non IP-system: slhc_uncompress"); | |
705 | return -EINVAL; | |
706 | } | |
707 | int | |
708 | slhc_compress(struct slcompress *comp, unsigned char *icp, int isize, | |
709 | unsigned char *ocp, unsigned char **cpp, int compress_cid) | |
710 | { | |
711 | printk(KERN_DEBUG "Called IP function on non IP-system: slhc_compress"); | |
712 | return -EINVAL; | |
713 | } | |
714 | ||
715 | int | |
716 | slhc_remember(struct slcompress *comp, unsigned char *icp, int isize) | |
717 | { | |
718 | printk(KERN_DEBUG "Called IP function on non IP-system: slhc_remember"); | |
719 | return -EINVAL; | |
720 | } | |
721 | ||
722 | void | |
723 | slhc_free(struct slcompress *comp) | |
724 | { | |
725 | printk(KERN_DEBUG "Called IP function on non IP-system: slhc_free"); | |
1da177e4 LT |
726 | } |
727 | struct slcompress * | |
728 | slhc_init(int rslots, int tslots) | |
729 | { | |
730 | printk(KERN_DEBUG "Called IP function on non IP-system: slhc_init"); | |
731 | return NULL; | |
732 | } | |
7f8a688e DK |
733 | |
734 | #endif /* CONFIG_INET */ | |
735 | ||
736 | /* VJ header compression */ | |
1da177e4 LT |
737 | EXPORT_SYMBOL(slhc_init); |
738 | EXPORT_SYMBOL(slhc_free); | |
739 | EXPORT_SYMBOL(slhc_remember); | |
740 | EXPORT_SYMBOL(slhc_compress); | |
741 | EXPORT_SYMBOL(slhc_uncompress); | |
742 | EXPORT_SYMBOL(slhc_toss); | |
743 | ||
1da177e4 | 744 | MODULE_LICENSE("Dual BSD/GPL"); |