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 register short i; 95 register 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 ( 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 */ 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 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; 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 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++; 303 } 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; 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 */ 435 csum = th->check; 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 } 456 *(__sum16 *)cp = csum; 457 cp += 2; 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 527 thp->check = *(__sum16 *)cp; 528 cp += 2; 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 693 #else /* CONFIG_INET */ 694 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"); 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 } 733 734 #endif /* CONFIG_INET */ 735 736 /* VJ header compression */ 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 744 MODULE_LICENSE("Dual BSD/GPL"); 745