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 45 * - July 1995 Christos A. Polyzols 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 53 #include <linux/module.h> 54 #include <linux/slab.h> 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> 78 #include <linux/uaccess.h> 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 87 /* Allocate compression data structure 88 * slots must be in range 0 to 255 (zero meaning no compression) 89 * Returns pointer to structure or ERR_PTR() on error. 90 */ 91 struct slcompress * 92 slhc_init(int rslots, int tslots) 93 { 94 short i; 95 struct cstate *ts; 96 struct slcompress *comp; 97 98 if (rslots < 0 || rslots > 255 || tslots < 0 || tslots > 255) 99 return ERR_PTR(-EINVAL); 100 101 comp = kzalloc(sizeof(struct slcompress), GFP_KERNEL); 102 if (! comp) 103 goto out_fail; 104 105 if (rslots > 0) { 106 size_t rsize = rslots * sizeof(struct cstate); 107 comp->rstate = kzalloc(rsize, GFP_KERNEL); 108 if (! comp->rstate) 109 goto out_free; 110 comp->rslot_limit = rslots - 1; 111 } 112 113 if (tslots > 0) { 114 size_t tsize = tslots * sizeof(struct cstate); 115 comp->tstate = kzalloc(tsize, GFP_KERNEL); 116 if (! comp->tstate) 117 goto out_free2; 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: 144 kfree(comp->rstate); 145 out_free: 146 kfree(comp); 147 out_fail: 148 return ERR_PTR(-ENOMEM); 149 } 150 151 152 /* Free a compression data structure */ 153 void 154 slhc_free(struct slcompress *comp) 155 { 156 if ( IS_ERR_OR_NULL(comp) ) 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 */ 181 static unsigned char * 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 */ 206 static long 207 decode(unsigned char **cpp) 208 { 209 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 struct cstate *ocs = &(comp->tstate[comp->xmit_oldest]); 231 struct cstate *lcs = ocs; 232 struct cstate *cs = lcs->next; 233 unsigned long deltaS, deltaA; 234 short changes = 0; 235 int nlen, hlen; 236 unsigned char new_seq[16]; 237 unsigned char *cp = new_seq; 238 struct iphdr *ip; 239 struct tcphdr *th, *oth; 240 __sum16 csum; 241 242 243 /* 244 * Don't play with runt packets. 245 */ 246 247 if(isize<sizeof(struct iphdr)) 248 return isize; 249 250 ip = (struct iphdr *) icp; 251 if (ip->version != 4 || ip->ihl < 5) 252 return isize; 253 254 /* Bail if this packet isn't TCP, or is an IP fragment */ 255 if (ip->protocol != IPPROTO_TCP || (ntohs(ip->frag_off) & 0x3fff)) { 256 /* Send as regular IP */ 257 if(ip->protocol != IPPROTO_TCP) 258 comp->sls_o_nontcp++; 259 else 260 comp->sls_o_tcp++; 261 return isize; 262 } 263 nlen = ip->ihl * 4; 264 if (isize < nlen + sizeof(*th)) 265 return isize; 266 267 th = (struct tcphdr *)(icp + nlen); 268 if (th->doff < sizeof(struct tcphdr) / 4) 269 return isize; 270 hlen = nlen + th->doff * 4; 271 272 /* Bail if the TCP packet isn't `compressible' (i.e., ACK isn't set or 273 * some other control bit is set). Also uncompressible if 274 * it's a runt. 275 */ 276 if(hlen > isize || th->syn || th->fin || th->rst || 277 ! (th->ack)){ 278 /* TCP connection stuff; send as regular IP */ 279 comp->sls_o_tcp++; 280 return isize; 281 } 282 /* 283 * Packet is compressible -- we're going to send either a 284 * COMPRESSED_TCP or UNCOMPRESSED_TCP packet. Either way, 285 * we need to locate (or create) the connection state. 286 * 287 * States are kept in a circularly linked list with 288 * xmit_oldest pointing to the end of the list. The 289 * list is kept in lru order by moving a state to the 290 * head of the list whenever it is referenced. Since 291 * the list is short and, empirically, the connection 292 * we want is almost always near the front, we locate 293 * states via linear search. If we don't find a state 294 * for the datagram, the oldest state is (re-)used. 295 */ 296 for ( ; ; ) { 297 if( ip->saddr == cs->cs_ip.saddr 298 && ip->daddr == cs->cs_ip.daddr 299 && th->source == cs->cs_tcp.source 300 && th->dest == cs->cs_tcp.dest) 301 goto found; 302 303 /* if current equal oldest, at end of list */ 304 if ( cs == ocs ) 305 break; 306 lcs = cs; 307 cs = cs->next; 308 comp->sls_o_searches++; 309 } 310 /* 311 * Didn't find it -- re-use oldest cstate. Send an 312 * uncompressed packet that tells the other side what 313 * connection number we're using for this conversation. 314 * 315 * Note that since the state list is circular, the oldest 316 * state points to the newest and we only need to set 317 * xmit_oldest to update the lru linkage. 318 */ 319 comp->sls_o_misses++; 320 comp->xmit_oldest = lcs->cs_this; 321 goto uncompressed; 322 323 found: 324 /* 325 * Found it -- move to the front on the connection list. 326 */ 327 if(lcs == ocs) { 328 /* found at most recently used */ 329 } else if (cs == ocs) { 330 /* found at least recently used */ 331 comp->xmit_oldest = lcs->cs_this; 332 } else { 333 /* more than 2 elements */ 334 lcs->next = cs->next; 335 cs->next = ocs->next; 336 ocs->next = cs; 337 } 338 339 /* 340 * Make sure that only what we expect to change changed. 341 * Check the following: 342 * IP protocol version, header length & type of service. 343 * The "Don't fragment" bit. 344 * The time-to-live field. 345 * The TCP header length. 346 * IP options, if any. 347 * TCP options, if any. 348 * If any of these things are different between the previous & 349 * current datagram, we send the current datagram `uncompressed'. 350 */ 351 oth = &cs->cs_tcp; 352 353 if(ip->version != cs->cs_ip.version || ip->ihl != cs->cs_ip.ihl 354 || ip->tos != cs->cs_ip.tos 355 || (ip->frag_off & htons(0x4000)) != (cs->cs_ip.frag_off & htons(0x4000)) 356 || ip->ttl != cs->cs_ip.ttl 357 || th->doff != cs->cs_tcp.doff 358 || (ip->ihl > 5 && memcmp(ip+1,cs->cs_ipopt,((ip->ihl)-5)*4) != 0) 359 || (th->doff > 5 && memcmp(th+1,cs->cs_tcpopt,((th->doff)-5)*4) != 0)){ 360 goto uncompressed; 361 } 362 363 /* 364 * Figure out which of the changing fields changed. The 365 * receiver expects changes in the order: urgent, window, 366 * ack, seq (the order minimizes the number of temporaries 367 * needed in this section of code). 368 */ 369 if(th->urg){ 370 deltaS = ntohs(th->urg_ptr); 371 cp = encode(cp,deltaS); 372 changes |= NEW_U; 373 } else if(th->urg_ptr != oth->urg_ptr){ 374 /* argh! URG not set but urp changed -- a sensible 375 * implementation should never do this but RFC793 376 * doesn't prohibit the change so we have to deal 377 * with it. */ 378 goto uncompressed; 379 } 380 if((deltaS = ntohs(th->window) - ntohs(oth->window)) != 0){ 381 cp = encode(cp,deltaS); 382 changes |= NEW_W; 383 } 384 if((deltaA = ntohl(th->ack_seq) - ntohl(oth->ack_seq)) != 0L){ 385 if(deltaA > 0x0000ffff) 386 goto uncompressed; 387 cp = encode(cp,deltaA); 388 changes |= NEW_A; 389 } 390 if((deltaS = ntohl(th->seq) - ntohl(oth->seq)) != 0L){ 391 if(deltaS > 0x0000ffff) 392 goto uncompressed; 393 cp = encode(cp,deltaS); 394 changes |= NEW_S; 395 } 396 397 switch(changes){ 398 case 0: /* Nothing changed. If this packet contains data and the 399 * last one didn't, this is probably a data packet following 400 * an ack (normal on an interactive connection) and we send 401 * it compressed. Otherwise it's probably a retransmit, 402 * retransmitted ack or window probe. Send it uncompressed 403 * in case the other side missed the compressed version. 404 */ 405 if(ip->tot_len != cs->cs_ip.tot_len && 406 ntohs(cs->cs_ip.tot_len) == hlen) 407 break; 408 goto uncompressed; 409 case SPECIAL_I: 410 case SPECIAL_D: 411 /* actual changes match one of our special case encodings -- 412 * send packet uncompressed. 413 */ 414 goto uncompressed; 415 case NEW_S|NEW_A: 416 if(deltaS == deltaA && 417 deltaS == ntohs(cs->cs_ip.tot_len) - hlen){ 418 /* special case for echoed terminal traffic */ 419 changes = SPECIAL_I; 420 cp = new_seq; 421 } 422 break; 423 case NEW_S: 424 if(deltaS == ntohs(cs->cs_ip.tot_len) - hlen){ 425 /* special case for data xfer */ 426 changes = SPECIAL_D; 427 cp = new_seq; 428 } 429 break; 430 } 431 deltaS = ntohs(ip->id) - ntohs(cs->cs_ip.id); 432 if(deltaS != 1){ 433 cp = encode(cp,deltaS); 434 changes |= NEW_I; 435 } 436 if(th->psh) 437 changes |= TCP_PUSH_BIT; 438 /* Grab the cksum before we overwrite it below. Then update our 439 * state with this packet's header. 440 */ 441 csum = th->check; 442 memcpy(&cs->cs_ip,ip,20); 443 memcpy(&cs->cs_tcp,th,20); 444 /* We want to use the original packet as our compressed packet. 445 * (cp - new_seq) is the number of bytes we need for compressed 446 * sequence numbers. In addition we need one byte for the change 447 * mask, one for the connection id and two for the tcp checksum. 448 * So, (cp - new_seq) + 4 bytes of header are needed. 449 */ 450 deltaS = cp - new_seq; 451 if(compress_cid == 0 || comp->xmit_current != cs->cs_this){ 452 cp = ocp; 453 *cpp = ocp; 454 *cp++ = changes | NEW_C; 455 *cp++ = cs->cs_this; 456 comp->xmit_current = cs->cs_this; 457 } else { 458 cp = ocp; 459 *cpp = ocp; 460 *cp++ = changes; 461 } 462 *(__sum16 *)cp = csum; 463 cp += 2; 464 /* deltaS is now the size of the change section of the compressed header */ 465 memcpy(cp,new_seq,deltaS); /* Write list of deltas */ 466 memcpy(cp+deltaS,icp+hlen,isize-hlen); 467 comp->sls_o_compressed++; 468 ocp[0] |= SL_TYPE_COMPRESSED_TCP; 469 return isize - hlen + deltaS + (cp - ocp); 470 471 /* Update connection state cs & send uncompressed packet (i.e., 472 * a regular ip/tcp packet but with the 'conversation id' we hope 473 * to use on future compressed packets in the protocol field). 474 */ 475 uncompressed: 476 memcpy(&cs->cs_ip,ip,20); 477 memcpy(&cs->cs_tcp,th,20); 478 if (ip->ihl > 5) 479 memcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4); 480 if (th->doff > 5) 481 memcpy(cs->cs_tcpopt, th+1, ((th->doff) - 5) * 4); 482 comp->xmit_current = cs->cs_this; 483 comp->sls_o_uncompressed++; 484 memcpy(ocp, icp, isize); 485 *cpp = ocp; 486 ocp[9] = cs->cs_this; 487 ocp[0] |= SL_TYPE_UNCOMPRESSED_TCP; 488 return isize; 489 } 490 491 492 int 493 slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize) 494 { 495 int changes; 496 long x; 497 struct tcphdr *thp; 498 struct iphdr *ip; 499 struct cstate *cs; 500 int len, hdrlen; 501 unsigned char *cp = icp; 502 503 /* We've got a compressed packet; read the change byte */ 504 comp->sls_i_compressed++; 505 if(isize < 3){ 506 comp->sls_i_error++; 507 return 0; 508 } 509 changes = *cp++; 510 if(changes & NEW_C){ 511 /* Make sure the state index is in range, then grab the state. 512 * If we have a good state index, clear the 'discard' flag. 513 */ 514 x = *cp++; /* Read conn index */ 515 if(x < 0 || x > comp->rslot_limit) 516 goto bad; 517 518 /* Check if the cstate is initialized */ 519 if (!comp->rstate[x].initialized) 520 goto bad; 521 522 comp->flags &=~ SLF_TOSS; 523 comp->recv_current = x; 524 } else { 525 /* this packet has an implicit state index. If we've 526 * had a line error since the last time we got an 527 * explicit state index, we have to toss the packet. */ 528 if(comp->flags & SLF_TOSS){ 529 comp->sls_i_tossed++; 530 return 0; 531 } 532 } 533 cs = &comp->rstate[comp->recv_current]; 534 thp = &cs->cs_tcp; 535 ip = &cs->cs_ip; 536 537 thp->check = *(__sum16 *)cp; 538 cp += 2; 539 540 thp->psh = (changes & TCP_PUSH_BIT) ? 1 : 0; 541 /* 542 * we can use the same number for the length of the saved header and 543 * the current one, because the packet wouldn't have been sent 544 * as compressed unless the options were the same as the previous one 545 */ 546 547 hdrlen = ip->ihl * 4 + thp->doff * 4; 548 549 switch(changes & SPECIALS_MASK){ 550 case SPECIAL_I: /* Echoed terminal traffic */ 551 { 552 short i; 553 i = ntohs(ip->tot_len) - hdrlen; 554 thp->ack_seq = htonl( ntohl(thp->ack_seq) + i); 555 thp->seq = htonl( ntohl(thp->seq) + i); 556 } 557 break; 558 559 case SPECIAL_D: /* Unidirectional data */ 560 thp->seq = htonl( ntohl(thp->seq) + 561 ntohs(ip->tot_len) - hdrlen); 562 break; 563 564 default: 565 if(changes & NEW_U){ 566 thp->urg = 1; 567 if((x = decode(&cp)) == -1) { 568 goto bad; 569 } 570 thp->urg_ptr = htons(x); 571 } else 572 thp->urg = 0; 573 if(changes & NEW_W){ 574 if((x = decode(&cp)) == -1) { 575 goto bad; 576 } 577 thp->window = htons( ntohs(thp->window) + x); 578 } 579 if(changes & NEW_A){ 580 if((x = decode(&cp)) == -1) { 581 goto bad; 582 } 583 thp->ack_seq = htonl( ntohl(thp->ack_seq) + x); 584 } 585 if(changes & NEW_S){ 586 if((x = decode(&cp)) == -1) { 587 goto bad; 588 } 589 thp->seq = htonl( ntohl(thp->seq) + x); 590 } 591 break; 592 } 593 if(changes & NEW_I){ 594 if((x = decode(&cp)) == -1) { 595 goto bad; 596 } 597 ip->id = htons (ntohs (ip->id) + x); 598 } else 599 ip->id = htons (ntohs (ip->id) + 1); 600 601 /* 602 * At this point, cp points to the first byte of data in the 603 * packet. Put the reconstructed TCP and IP headers back on the 604 * packet. Recalculate IP checksum (but not TCP checksum). 605 */ 606 607 len = isize - (cp - icp); 608 if (len < 0) 609 goto bad; 610 len += hdrlen; 611 ip->tot_len = htons(len); 612 ip->check = 0; 613 614 memmove(icp + hdrlen, cp, len - hdrlen); 615 616 cp = icp; 617 memcpy(cp, ip, 20); 618 cp += 20; 619 620 if (ip->ihl > 5) { 621 memcpy(cp, cs->cs_ipopt, (ip->ihl - 5) * 4); 622 cp += (ip->ihl - 5) * 4; 623 } 624 625 put_unaligned(ip_fast_csum(icp, ip->ihl), 626 &((struct iphdr *)icp)->check); 627 628 memcpy(cp, thp, 20); 629 cp += 20; 630 631 if (thp->doff > 5) { 632 memcpy(cp, cs->cs_tcpopt, ((thp->doff) - 5) * 4); 633 cp += ((thp->doff) - 5) * 4; 634 } 635 636 return len; 637 bad: 638 comp->sls_i_error++; 639 return slhc_toss( comp ); 640 } 641 642 643 int 644 slhc_remember(struct slcompress *comp, unsigned char *icp, int isize) 645 { 646 struct cstate *cs; 647 unsigned ihl; 648 649 unsigned char index; 650 651 if(isize < 20) { 652 /* The packet is shorter than a legal IP header */ 653 comp->sls_i_runt++; 654 return slhc_toss( comp ); 655 } 656 /* Peek at the IP header's IHL field to find its length */ 657 ihl = icp[0] & 0xf; 658 if(ihl < 20 / 4){ 659 /* The IP header length field is too small */ 660 comp->sls_i_runt++; 661 return slhc_toss( comp ); 662 } 663 index = icp[9]; 664 icp[9] = IPPROTO_TCP; 665 666 if (ip_fast_csum(icp, ihl)) { 667 /* Bad IP header checksum; discard */ 668 comp->sls_i_badcheck++; 669 return slhc_toss( comp ); 670 } 671 if(index > comp->rslot_limit) { 672 comp->sls_i_error++; 673 return slhc_toss(comp); 674 } 675 676 /* Update local state */ 677 cs = &comp->rstate[comp->recv_current = index]; 678 comp->flags &=~ SLF_TOSS; 679 memcpy(&cs->cs_ip,icp,20); 680 memcpy(&cs->cs_tcp,icp + ihl*4,20); 681 if (ihl > 5) 682 memcpy(cs->cs_ipopt, icp + sizeof(struct iphdr), (ihl - 5) * 4); 683 if (cs->cs_tcp.doff > 5) 684 memcpy(cs->cs_tcpopt, icp + ihl*4 + sizeof(struct tcphdr), (cs->cs_tcp.doff - 5) * 4); 685 cs->cs_hsize = ihl*2 + cs->cs_tcp.doff*2; 686 cs->initialized = true; 687 /* Put headers back on packet 688 * Neither header checksum is recalculated 689 */ 690 comp->sls_i_uncompressed++; 691 return isize; 692 } 693 694 int 695 slhc_toss(struct slcompress *comp) 696 { 697 if ( comp == NULLSLCOMPR ) 698 return 0; 699 700 comp->flags |= SLF_TOSS; 701 return 0; 702 } 703 704 #else /* CONFIG_INET */ 705 706 int 707 slhc_toss(struct slcompress *comp) 708 { 709 printk(KERN_DEBUG "Called IP function on non IP-system: slhc_toss"); 710 return -EINVAL; 711 } 712 int 713 slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize) 714 { 715 printk(KERN_DEBUG "Called IP function on non IP-system: slhc_uncompress"); 716 return -EINVAL; 717 } 718 int 719 slhc_compress(struct slcompress *comp, unsigned char *icp, int isize, 720 unsigned char *ocp, unsigned char **cpp, int compress_cid) 721 { 722 printk(KERN_DEBUG "Called IP function on non IP-system: slhc_compress"); 723 return -EINVAL; 724 } 725 726 int 727 slhc_remember(struct slcompress *comp, unsigned char *icp, int isize) 728 { 729 printk(KERN_DEBUG "Called IP function on non IP-system: slhc_remember"); 730 return -EINVAL; 731 } 732 733 void 734 slhc_free(struct slcompress *comp) 735 { 736 printk(KERN_DEBUG "Called IP function on non IP-system: slhc_free"); 737 } 738 struct slcompress * 739 slhc_init(int rslots, int tslots) 740 { 741 printk(KERN_DEBUG "Called IP function on non IP-system: slhc_init"); 742 return NULL; 743 } 744 745 #endif /* CONFIG_INET */ 746 747 /* VJ header compression */ 748 EXPORT_SYMBOL(slhc_init); 749 EXPORT_SYMBOL(slhc_free); 750 EXPORT_SYMBOL(slhc_remember); 751 EXPORT_SYMBOL(slhc_compress); 752 EXPORT_SYMBOL(slhc_uncompress); 753 EXPORT_SYMBOL(slhc_toss); 754 755 MODULE_LICENSE("Dual BSD/GPL"); 756