1/* $Id: isdn_ppp.c,v 1.1.1.1 2007/08/03 18:52:36 Exp $ 2 * 3 * Linux ISDN subsystem, functions for synchronous PPP (linklevel). 4 * 5 * Copyright 1995,96 by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de) 6 * 7 * This software may be used and distributed according to the terms 8 * of the GNU General Public License, incorporated herein by reference. 9 * 10 */ 11 12#include <linux/isdn.h> 13#include <linux/poll.h> 14#include <linux/ppp-comp.h> 15#ifdef CONFIG_IPPP_FILTER 16#include <linux/filter.h> 17#endif 18 19#include "isdn_common.h" 20#include "isdn_ppp.h" 21#include "isdn_net.h" 22 23#ifndef PPP_IPX 24#define PPP_IPX 0x002b 25#endif 26 27/* Prototypes */ 28static int isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot); 29static int isdn_ppp_closewait(int slot); 30static void isdn_ppp_push_higher(isdn_net_dev * net_dev, isdn_net_local * lp, 31 struct sk_buff *skb, int proto); 32static int isdn_ppp_if_get_unit(char *namebuf); 33static int isdn_ppp_set_compressor(struct ippp_struct *is,struct isdn_ppp_comp_data *); 34static struct sk_buff *isdn_ppp_decompress(struct sk_buff *, 35 struct ippp_struct *,struct ippp_struct *,int *proto); 36static void isdn_ppp_receive_ccp(isdn_net_dev * net_dev, isdn_net_local * lp, 37 struct sk_buff *skb,int proto); 38static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in,int *proto, 39 struct ippp_struct *is,struct ippp_struct *master,int type); 40static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, 41 struct sk_buff *skb); 42 43/* New CCP stuff */ 44static void isdn_ppp_ccp_kickup(struct ippp_struct *is); 45static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto, 46 unsigned char code, unsigned char id, 47 unsigned char *data, int len); 48static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is); 49static void isdn_ppp_ccp_reset_free(struct ippp_struct *is); 50static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is, 51 unsigned char id); 52static void isdn_ppp_ccp_timer_callback(unsigned long closure); 53static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is, 54 unsigned char id); 55static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is, 56 struct isdn_ppp_resetparams *rp); 57static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is, 58 unsigned char id); 59 60 61 62#ifdef CONFIG_ISDN_MPP 63static ippp_bundle * isdn_ppp_bundle_arr = NULL; 64 65static int isdn_ppp_mp_bundle_array_init(void); 66static int isdn_ppp_mp_init( isdn_net_local * lp, ippp_bundle * add_to ); 67static void isdn_ppp_mp_receive(isdn_net_dev * net_dev, isdn_net_local * lp, 68 struct sk_buff *skb); 69static void isdn_ppp_mp_cleanup( isdn_net_local * lp ); 70 71static int isdn_ppp_bundle(struct ippp_struct *, int unit); 72#endif /* CONFIG_ISDN_MPP */ 73 74char *isdn_ppp_revision = "$Revision: 1.1.1.1 $"; 75 76static struct ippp_struct *ippp_table[ISDN_MAX_CHANNELS]; 77 78static struct isdn_ppp_compressor *ipc_head = NULL; 79 80/* 81 * frame log (debug) 82 */ 83static void 84isdn_ppp_frame_log(char *info, char *data, int len, int maxlen,int unit,int slot) 85{ 86 int cnt, 87 j, 88 i; 89 char buf[80]; 90 91 if (len < maxlen) 92 maxlen = len; 93 94 for (i = 0, cnt = 0; cnt < maxlen; i++) { 95 for (j = 0; j < 16 && cnt < maxlen; j++, cnt++) 96 sprintf(buf + j * 3, "%02x ", (unsigned char) data[cnt]); 97 printk(KERN_DEBUG "[%d/%d].%s[%d]: %s\n",unit,slot, info, i, buf); 98 } 99} 100 101/* 102 * unbind isdn_net_local <=> ippp-device 103 * note: it can happen, that we hangup/free the master before the slaves 104 * in this case we bind another lp to the master device 105 */ 106int 107isdn_ppp_free(isdn_net_local * lp) 108{ 109 struct ippp_struct *is; 110 111 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) { 112 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n", 113 __FUNCTION__, lp->ppp_slot); 114 return 0; 115 } 116 117#ifdef CONFIG_ISDN_MPP 118 spin_lock(&lp->netdev->pb->lock); 119#endif 120 isdn_net_rm_from_bundle(lp); 121#ifdef CONFIG_ISDN_MPP 122 if (lp->netdev->pb->ref_ct == 1) /* last link in queue? */ 123 isdn_ppp_mp_cleanup(lp); 124 125 lp->netdev->pb->ref_ct--; 126 spin_unlock(&lp->netdev->pb->lock); 127#endif /* CONFIG_ISDN_MPP */ 128 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) { 129 printk(KERN_ERR "%s: ppp_slot(%d) now invalid\n", 130 __FUNCTION__, lp->ppp_slot); 131 return 0; 132 } 133 is = ippp_table[lp->ppp_slot]; 134 if ((is->state & IPPP_CONNECT)) 135 isdn_ppp_closewait(lp->ppp_slot); /* force wakeup on ippp device */ 136 else if (is->state & IPPP_ASSIGNED) 137 is->state = IPPP_OPEN; /* fallback to 'OPEN but not ASSIGNED' state */ 138 139 if (is->debug & 0x1) 140 printk(KERN_DEBUG "isdn_ppp_free %d %lx %lx\n", lp->ppp_slot, (long) lp, (long) is->lp); 141 142 is->lp = NULL; /* link is down .. set lp to NULL */ 143 lp->ppp_slot = -1; /* is this OK ?? */ 144 145 return 0; 146} 147 148/* 149 * bind isdn_net_local <=> ippp-device 150 * 151 * This function is allways called with holding dev->lock so 152 * no additional lock is needed 153 */ 154int 155isdn_ppp_bind(isdn_net_local * lp) 156{ 157 int i; 158 int unit = 0; 159 struct ippp_struct *is; 160 int retval; 161 162 if (lp->pppbind < 0) { /* device bounded to ippp device ? */ 163 isdn_net_dev *net_dev = dev->netdev; 164 char exclusive[ISDN_MAX_CHANNELS]; /* exclusive flags */ 165 memset(exclusive, 0, ISDN_MAX_CHANNELS); 166 while (net_dev) { /* step through net devices to find exclusive minors */ 167 isdn_net_local *lp = net_dev->local; 168 if (lp->pppbind >= 0) 169 exclusive[lp->pppbind] = 1; 170 net_dev = net_dev->next; 171 } 172 /* 173 * search a free device / slot 174 */ 175 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 176 if (ippp_table[i]->state == IPPP_OPEN && !exclusive[ippp_table[i]->minor]) { /* OPEN, but not connected! */ 177 break; 178 } 179 } 180 } else { 181 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 182 if (ippp_table[i]->minor == lp->pppbind && 183 (ippp_table[i]->state & IPPP_OPEN) == IPPP_OPEN) 184 break; 185 } 186 } 187 188 if (i >= ISDN_MAX_CHANNELS) { 189 printk(KERN_WARNING "isdn_ppp_bind: Can't find a (free) connection to the ipppd daemon.\n"); 190 retval = -1; 191 goto out; 192 } 193 unit = isdn_ppp_if_get_unit(lp->name); /* get unit number from interface name .. ugly! */ 194 if (unit < 0) { 195 printk(KERN_ERR "isdn_ppp_bind: illegal interface name %s.\n", lp->name); 196 retval = -1; 197 goto out; 198 } 199 200 lp->ppp_slot = i; 201 is = ippp_table[i]; 202 is->lp = lp; 203 is->unit = unit; 204 is->state = IPPP_OPEN | IPPP_ASSIGNED; /* assigned to a netdevice but not connected */ 205#ifdef CONFIG_ISDN_MPP 206 retval = isdn_ppp_mp_init(lp, NULL); 207 if (retval < 0) 208 goto out; 209#endif /* CONFIG_ISDN_MPP */ 210 211 retval = lp->ppp_slot; 212 213 out: 214 return retval; 215} 216 217/* 218 * kick the ipppd on the device 219 * (wakes up daemon after B-channel connect) 220 */ 221 222void 223isdn_ppp_wakeup_daemon(isdn_net_local * lp) 224{ 225 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) { 226 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n", 227 __FUNCTION__, lp->ppp_slot); 228 return; 229 } 230 ippp_table[lp->ppp_slot]->state = IPPP_OPEN | IPPP_CONNECT | IPPP_NOBLOCK; 231 wake_up_interruptible(&ippp_table[lp->ppp_slot]->wq); 232} 233 234/* 235 * there was a hangup on the netdevice 236 * force wakeup of the ippp device 237 * go into 'device waits for release' state 238 */ 239static int 240isdn_ppp_closewait(int slot) 241{ 242 struct ippp_struct *is; 243 244 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 245 printk(KERN_ERR "%s: slot(%d) out of range\n", 246 __FUNCTION__, slot); 247 return 0; 248 } 249 is = ippp_table[slot]; 250 if (is->state) 251 wake_up_interruptible(&is->wq); 252 is->state = IPPP_CLOSEWAIT; 253 return 1; 254} 255 256/* 257 * isdn_ppp_find_slot / isdn_ppp_free_slot 258 */ 259 260static int 261isdn_ppp_get_slot(void) 262{ 263 int i; 264 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 265 if (!ippp_table[i]->state) 266 return i; 267 } 268 return -1; 269} 270 271/* 272 * isdn_ppp_open 273 */ 274 275int 276isdn_ppp_open(int min, struct file *file) 277{ 278 int slot; 279 struct ippp_struct *is; 280 281 if (min < 0 || min >= ISDN_MAX_CHANNELS) 282 return -ENODEV; 283 284 slot = isdn_ppp_get_slot(); 285 if (slot < 0) { 286 return -EBUSY; 287 } 288 is = file->private_data = ippp_table[slot]; 289 290 printk(KERN_DEBUG "ippp, open, slot: %d, minor: %d, state: %04x\n", 291 slot, min, is->state); 292 293 /* compression stuff */ 294 is->link_compressor = is->compressor = NULL; 295 is->link_decompressor = is->decompressor = NULL; 296 is->link_comp_stat = is->comp_stat = NULL; 297 is->link_decomp_stat = is->decomp_stat = NULL; 298 is->compflags = 0; 299 300 is->reset = isdn_ppp_ccp_reset_alloc(is); 301 302 is->lp = NULL; 303 is->mp_seqno = 0; /* MP sequence number */ 304 is->pppcfg = 0; /* ppp configuration */ 305 is->mpppcfg = 0; /* mppp configuration */ 306 is->last_link_seqno = -1; /* MP: maybe set to Bundle-MIN, when joining a bundle ?? */ 307 is->unit = -1; /* set, when we have our interface */ 308 is->mru = 1524; /* MRU, default 1524 */ 309 is->maxcid = 16; /* VJ: maxcid */ 310 is->tk = current; 311 init_waitqueue_head(&is->wq); 312 is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */ 313 is->last = is->rq; 314 is->minor = min; 315#ifdef CONFIG_ISDN_PPP_VJ 316 /* 317 * VJ header compression init 318 */ 319 is->slcomp = slhc_init(16, 16); /* not necessary for 2. link in bundle */ 320#endif 321#ifdef CONFIG_IPPP_FILTER 322 is->pass_filter = NULL; 323 is->active_filter = NULL; 324#endif 325 is->state = IPPP_OPEN; 326 327 return 0; 328} 329 330/* 331 * release ippp device 332 */ 333void 334isdn_ppp_release(int min, struct file *file) 335{ 336 int i; 337 struct ippp_struct *is; 338 339 if (min < 0 || min >= ISDN_MAX_CHANNELS) 340 return; 341 is = file->private_data; 342 343 if (!is) { 344 printk(KERN_ERR "%s: no file->private_data\n", __FUNCTION__); 345 return; 346 } 347 if (is->debug & 0x1) 348 printk(KERN_DEBUG "ippp: release, minor: %d %lx\n", min, (long) is->lp); 349 350 if (is->lp) { /* a lp address says: this link is still up */ 351 isdn_net_dev *p = is->lp->netdev; 352 353 if (!p) { 354 printk(KERN_ERR "%s: no lp->netdev\n", __FUNCTION__); 355 return; 356 } 357 is->state &= ~IPPP_CONNECT; /* -> effect: no call of wakeup */ 358 /* 359 * isdn_net_hangup() calls isdn_ppp_free() 360 * isdn_ppp_free() sets is->lp to NULL and lp->ppp_slot to -1 361 * removing the IPPP_CONNECT flag omits calling of isdn_ppp_wakeup_daemon() 362 */ 363 isdn_net_hangup(&p->dev); 364 } 365 for (i = 0; i < NUM_RCV_BUFFS; i++) { 366 kfree(is->rq[i].buf); 367 is->rq[i].buf = NULL; 368 } 369 is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */ 370 is->last = is->rq; 371 372#ifdef CONFIG_ISDN_PPP_VJ 373/* TODO: if this was the previous master: link the slcomp to the new master */ 374 slhc_free(is->slcomp); 375 is->slcomp = NULL; 376#endif 377#ifdef CONFIG_IPPP_FILTER 378 kfree(is->pass_filter); 379 is->pass_filter = NULL; 380 kfree(is->active_filter); 381 is->active_filter = NULL; 382#endif 383 384/* TODO: if this was the previous master: link the stuff to the new master */ 385 if(is->comp_stat) 386 is->compressor->free(is->comp_stat); 387 if(is->link_comp_stat) 388 is->link_compressor->free(is->link_comp_stat); 389 if(is->link_decomp_stat) 390 is->link_decompressor->free(is->link_decomp_stat); 391 if(is->decomp_stat) 392 is->decompressor->free(is->decomp_stat); 393 is->compressor = is->link_compressor = NULL; 394 is->decompressor = is->link_decompressor = NULL; 395 is->comp_stat = is->link_comp_stat = NULL; 396 is->decomp_stat = is->link_decomp_stat = NULL; 397 398 /* Clean up if necessary */ 399 if(is->reset) 400 isdn_ppp_ccp_reset_free(is); 401 402 /* this slot is ready for new connections */ 403 is->state = 0; 404} 405 406/* 407 * get_arg .. ioctl helper 408 */ 409static int 410get_arg(void __user *b, void *val, int len) 411{ 412 if (len <= 0) 413 len = sizeof(void *); 414 if (copy_from_user(val, b, len)) 415 return -EFAULT; 416 return 0; 417} 418 419/* 420 * set arg .. ioctl helper 421 */ 422static int 423set_arg(void __user *b, void *val,int len) 424{ 425 if(len <= 0) 426 len = sizeof(void *); 427 if (copy_to_user(b, val, len)) 428 return -EFAULT; 429 return 0; 430} 431 432static int get_filter(void __user *arg, struct sock_filter **p) 433{ 434 struct sock_fprog uprog; 435 struct sock_filter *code = NULL; 436 int len, err; 437 438 if (copy_from_user(&uprog, arg, sizeof(uprog))) 439 return -EFAULT; 440 441 if (!uprog.len) { 442 *p = NULL; 443 return 0; 444 } 445 446 /* uprog.len is unsigned short, so no overflow here */ 447 len = uprog.len * sizeof(struct sock_filter); 448 code = kmalloc(len, GFP_KERNEL); 449 if (code == NULL) 450 return -ENOMEM; 451 452 if (copy_from_user(code, uprog.filter, len)) { 453 kfree(code); 454 return -EFAULT; 455 } 456 457 err = sk_chk_filter(code, uprog.len); 458 if (err) { 459 kfree(code); 460 return err; 461 } 462 463 *p = code; 464 return uprog.len; 465} 466 467/* 468 * ippp device ioctl 469 */ 470int 471isdn_ppp_ioctl(int min, struct file *file, unsigned int cmd, unsigned long arg) 472{ 473 unsigned long val; 474 int r,i,j; 475 struct ippp_struct *is; 476 isdn_net_local *lp; 477 struct isdn_ppp_comp_data data; 478 void __user *argp = (void __user *)arg; 479 480 is = (struct ippp_struct *) file->private_data; 481 lp = is->lp; 482 483 if (is->debug & 0x1) 484 printk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x state: %x\n", min, cmd, is->state); 485 486 if (!(is->state & IPPP_OPEN)) 487 return -EINVAL; 488 489 switch (cmd) { 490 case PPPIOCBUNDLE: 491#ifdef CONFIG_ISDN_MPP 492 if (!(is->state & IPPP_CONNECT)) 493 return -EINVAL; 494 if ((r = get_arg(argp, &val, sizeof(val) ))) 495 return r; 496 printk(KERN_DEBUG "iPPP-bundle: minor: %d, slave unit: %d, master unit: %d\n", 497 (int) min, (int) is->unit, (int) val); 498 return isdn_ppp_bundle(is, val); 499#else 500 return -1; 501#endif 502 break; 503 case PPPIOCGUNIT: /* get ppp/isdn unit number */ 504 if ((r = set_arg(argp, &is->unit, sizeof(is->unit) ))) 505 return r; 506 break; 507 case PPPIOCGIFNAME: 508 if(!lp) 509 return -EINVAL; 510 if ((r = set_arg(argp, lp->name, strlen(lp->name)))) 511 return r; 512 break; 513 case PPPIOCGMPFLAGS: /* get configuration flags */ 514 if ((r = set_arg(argp, &is->mpppcfg, sizeof(is->mpppcfg) ))) 515 return r; 516 break; 517 case PPPIOCSMPFLAGS: /* set configuration flags */ 518 if ((r = get_arg(argp, &val, sizeof(val) ))) 519 return r; 520 is->mpppcfg = val; 521 break; 522 case PPPIOCGFLAGS: /* get configuration flags */ 523 if ((r = set_arg(argp, &is->pppcfg,sizeof(is->pppcfg) ))) 524 return r; 525 break; 526 case PPPIOCSFLAGS: /* set configuration flags */ 527 if ((r = get_arg(argp, &val, sizeof(val) ))) { 528 return r; 529 } 530 if (val & SC_ENABLE_IP && !(is->pppcfg & SC_ENABLE_IP) && (is->state & IPPP_CONNECT)) { 531 if (lp) { 532 /* OK .. we are ready to send buffers */ 533 is->pppcfg = val; /* isdn_ppp_xmit test for SC_ENABLE_IP !!! */ 534 netif_wake_queue(&lp->netdev->dev); 535 break; 536 } 537 } 538 is->pppcfg = val; 539 break; 540 case PPPIOCGIDLE: /* get idle time information */ 541 if (lp) { 542 struct ppp_idle pidle; 543 pidle.xmit_idle = pidle.recv_idle = lp->huptimer; 544 if ((r = set_arg(argp, &pidle,sizeof(struct ppp_idle)))) 545 return r; 546 } 547 break; 548 case PPPIOCSMRU: /* set receive unit size for PPP */ 549 if ((r = get_arg(argp, &val, sizeof(val) ))) 550 return r; 551 is->mru = val; 552 break; 553 case PPPIOCSMPMRU: 554 break; 555 case PPPIOCSMPMTU: 556 break; 557 case PPPIOCSMAXCID: /* set the maximum compression slot id */ 558 if ((r = get_arg(argp, &val, sizeof(val) ))) 559 return r; 560 val++; 561 if (is->maxcid != val) { 562#ifdef CONFIG_ISDN_PPP_VJ 563 struct slcompress *sltmp; 564#endif 565 if (is->debug & 0x1) 566 printk(KERN_DEBUG "ippp, ioctl: changed MAXCID to %ld\n", val); 567 is->maxcid = val; 568#ifdef CONFIG_ISDN_PPP_VJ 569 sltmp = slhc_init(16, val); 570 if (!sltmp) { 571 printk(KERN_ERR "ippp, can't realloc slhc struct\n"); 572 return -ENOMEM; 573 } 574 if (is->slcomp) 575 slhc_free(is->slcomp); 576 is->slcomp = sltmp; 577#endif 578 } 579 break; 580 case PPPIOCGDEBUG: 581 if ((r = set_arg(argp, &is->debug, sizeof(is->debug) ))) 582 return r; 583 break; 584 case PPPIOCSDEBUG: 585 if ((r = get_arg(argp, &val, sizeof(val) ))) 586 return r; 587 is->debug = val; 588 break; 589 case PPPIOCGCOMPRESSORS: 590 { 591 unsigned long protos[8] = {0,}; 592 struct isdn_ppp_compressor *ipc = ipc_head; 593 while(ipc) { 594 j = ipc->num / (sizeof(long)*8); 595 i = ipc->num % (sizeof(long)*8); 596 if(j < 8) 597 protos[j] |= (0x1<<i); 598 ipc = ipc->next; 599 } 600 if ((r = set_arg(argp,protos,8*sizeof(long) ))) 601 return r; 602 } 603 break; 604 case PPPIOCSCOMPRESSOR: 605 if ((r = get_arg(argp, &data, sizeof(struct isdn_ppp_comp_data)))) 606 return r; 607 return isdn_ppp_set_compressor(is, &data); 608 case PPPIOCGCALLINFO: 609 { 610 struct pppcallinfo pci; 611 memset((char *) &pci,0,sizeof(struct pppcallinfo)); 612 if(lp) 613 { 614 strncpy(pci.local_num,lp->msn,63); 615 if(lp->dial) { 616 strncpy(pci.remote_num,lp->dial->num,63); 617 } 618 pci.charge_units = lp->charge; 619 if(lp->outgoing) 620 pci.calltype = CALLTYPE_OUTGOING; 621 else 622 pci.calltype = CALLTYPE_INCOMING; 623 if(lp->flags & ISDN_NET_CALLBACK) 624 pci.calltype |= CALLTYPE_CALLBACK; 625 } 626 return set_arg(argp,&pci,sizeof(struct pppcallinfo)); 627 } 628#ifdef CONFIG_IPPP_FILTER 629 case PPPIOCSPASS: 630 { 631 struct sock_filter *code; 632 int len = get_filter(argp, &code); 633 if (len < 0) 634 return len; 635 kfree(is->pass_filter); 636 is->pass_filter = code; 637 is->pass_len = len; 638 break; 639 } 640 case PPPIOCSACTIVE: 641 { 642 struct sock_filter *code; 643 int len = get_filter(argp, &code); 644 if (len < 0) 645 return len; 646 kfree(is->active_filter); 647 is->active_filter = code; 648 is->active_len = len; 649 break; 650 } 651#endif /* CONFIG_IPPP_FILTER */ 652 default: 653 break; 654 } 655 return 0; 656} 657 658unsigned int 659isdn_ppp_poll(struct file *file, poll_table * wait) 660{ 661 u_int mask; 662 struct ippp_buf_queue *bf, *bl; 663 u_long flags; 664 struct ippp_struct *is; 665 666 is = file->private_data; 667 668 if (is->debug & 0x2) 669 printk(KERN_DEBUG "isdn_ppp_poll: minor: %d\n", 670 iminor(file->f_path.dentry->d_inode)); 671 672 /* just registers wait_queue hook. This doesn't really wait. */ 673 poll_wait(file, &is->wq, wait); 674 675 if (!(is->state & IPPP_OPEN)) { 676 if(is->state == IPPP_CLOSEWAIT) 677 return POLLHUP; 678 printk(KERN_DEBUG "isdn_ppp: device not open\n"); 679 return POLLERR; 680 } 681 /* we're always ready to send .. */ 682 mask = POLLOUT | POLLWRNORM; 683 684 spin_lock_irqsave(&is->buflock, flags); 685 bl = is->last; 686 bf = is->first; 687 /* 688 * if IPPP_NOBLOCK is set we return even if we have nothing to read 689 */ 690 if (bf->next != bl || (is->state & IPPP_NOBLOCK)) { 691 is->state &= ~IPPP_NOBLOCK; 692 mask |= POLLIN | POLLRDNORM; 693 } 694 spin_unlock_irqrestore(&is->buflock, flags); 695 return mask; 696} 697 698/* 699 * fill up isdn_ppp_read() queue .. 700 */ 701 702static int 703isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot) 704{ 705 struct ippp_buf_queue *bf, *bl; 706 u_long flags; 707 u_char *nbuf; 708 struct ippp_struct *is; 709 710 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 711 printk(KERN_WARNING "ippp: illegal slot(%d).\n", slot); 712 return 0; 713 } 714 is = ippp_table[slot]; 715 716 if (!(is->state & IPPP_CONNECT)) { 717 printk(KERN_DEBUG "ippp: device not activated.\n"); 718 return 0; 719 } 720 nbuf = kmalloc(len + 4, GFP_ATOMIC); 721 if (!nbuf) { 722 printk(KERN_WARNING "ippp: Can't alloc buf\n"); 723 return 0; 724 } 725 nbuf[0] = PPP_ALLSTATIONS; 726 nbuf[1] = PPP_UI; 727 nbuf[2] = proto >> 8; 728 nbuf[3] = proto & 0xff; 729 memcpy(nbuf + 4, buf, len); 730 731 spin_lock_irqsave(&is->buflock, flags); 732 bf = is->first; 733 bl = is->last; 734 735 if (bf == bl) { 736 printk(KERN_WARNING "ippp: Queue is full; discarding first buffer\n"); 737 bf = bf->next; 738 kfree(bf->buf); 739 is->first = bf; 740 } 741 bl->buf = (char *) nbuf; 742 bl->len = len + 4; 743 744 is->last = bl->next; 745 spin_unlock_irqrestore(&is->buflock, flags); 746 wake_up_interruptible(&is->wq); 747 return len; 748} 749 750/* 751 * read() .. non-blocking: ipppd calls it only after select() 752 * reports, that there is data 753 */ 754 755int 756isdn_ppp_read(int min, struct file *file, char __user *buf, int count) 757{ 758 struct ippp_struct *is; 759 struct ippp_buf_queue *b; 760 u_long flags; 761 u_char *save_buf; 762 763 is = file->private_data; 764 765 if (!(is->state & IPPP_OPEN)) 766 return 0; 767 768 if (!access_ok(VERIFY_WRITE, buf, count)) 769 return -EFAULT; 770 771 spin_lock_irqsave(&is->buflock, flags); 772 b = is->first->next; 773 save_buf = b->buf; 774 if (!save_buf) { 775 spin_unlock_irqrestore(&is->buflock, flags); 776 return -EAGAIN; 777 } 778 if (b->len < count) 779 count = b->len; 780 b->buf = NULL; 781 is->first = b; 782 783 spin_unlock_irqrestore(&is->buflock, flags); 784 if (copy_to_user(buf, save_buf, count)) 785 count = -EFAULT; 786 kfree(save_buf); 787 788 return count; 789} 790 791/* 792 * ipppd wanna write a packet to the card .. non-blocking 793 */ 794 795int 796isdn_ppp_write(int min, struct file *file, const char __user *buf, int count) 797{ 798 isdn_net_local *lp; 799 struct ippp_struct *is; 800 int proto; 801 unsigned char protobuf[4]; 802 803 is = file->private_data; 804 805 if (!(is->state & IPPP_CONNECT)) 806 return 0; 807 808 lp = is->lp; 809 810 /* -> push it directly to the lowlevel interface */ 811 812 if (!lp) 813 printk(KERN_DEBUG "isdn_ppp_write: lp == NULL\n"); 814 else { 815 /* 816 * Don't reset huptimer for 817 * LCP packets. (Echo requests). 818 */ 819 if (copy_from_user(protobuf, buf, 4)) 820 return -EFAULT; 821 proto = PPP_PROTOCOL(protobuf); 822 if (proto != PPP_LCP) 823 lp->huptimer = 0; 824 825 if (lp->isdn_device < 0 || lp->isdn_channel < 0) 826 return 0; 827 828 if ((dev->drv[lp->isdn_device]->flags & DRV_FLAG_RUNNING) && 829 lp->dialstate == 0 && 830 (lp->flags & ISDN_NET_CONNECTED)) { 831 unsigned short hl; 832 struct sk_buff *skb; 833 /* 834 * we need to reserve enought space in front of 835 * sk_buff. old call to dev_alloc_skb only reserved 836 * 16 bytes, now we are looking what the driver want 837 */ 838 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen; 839 skb = alloc_skb(hl+count, GFP_ATOMIC); 840 if (!skb) { 841 printk(KERN_WARNING "isdn_ppp_write: out of memory!\n"); 842 return count; 843 } 844 skb_reserve(skb, hl); 845 if (copy_from_user(skb_put(skb, count), buf, count)) 846 { 847 kfree_skb(skb); 848 return -EFAULT; 849 } 850 if (is->debug & 0x40) { 851 printk(KERN_DEBUG "ppp xmit: len %d\n", (int) skb->len); 852 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32,is->unit,lp->ppp_slot); 853 } 854 855 isdn_ppp_send_ccp(lp->netdev,lp,skb); /* keeps CCP/compression states in sync */ 856 857 isdn_net_write_super(lp, skb); 858 } 859 } 860 return count; 861} 862 863/* 864 * init memory, structures etc. 865 */ 866 867int 868isdn_ppp_init(void) 869{ 870 int i, 871 j; 872 873#ifdef CONFIG_ISDN_MPP 874 if( isdn_ppp_mp_bundle_array_init() < 0 ) 875 return -ENOMEM; 876#endif /* CONFIG_ISDN_MPP */ 877 878 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 879 if (!(ippp_table[i] = kzalloc(sizeof(struct ippp_struct), GFP_KERNEL))) { 880 printk(KERN_WARNING "isdn_ppp_init: Could not alloc ippp_table\n"); 881 for (j = 0; j < i; j++) 882 kfree(ippp_table[j]); 883 return -1; 884 } 885 spin_lock_init(&ippp_table[i]->buflock); 886 ippp_table[i]->state = 0; 887 ippp_table[i]->first = ippp_table[i]->rq + NUM_RCV_BUFFS - 1; 888 ippp_table[i]->last = ippp_table[i]->rq; 889 890 for (j = 0; j < NUM_RCV_BUFFS; j++) { 891 ippp_table[i]->rq[j].buf = NULL; 892 ippp_table[i]->rq[j].last = ippp_table[i]->rq + 893 (NUM_RCV_BUFFS + j - 1) % NUM_RCV_BUFFS; 894 ippp_table[i]->rq[j].next = ippp_table[i]->rq + (j + 1) % NUM_RCV_BUFFS; 895 } 896 } 897 return 0; 898} 899 900void 901isdn_ppp_cleanup(void) 902{ 903 int i; 904 905 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 906 kfree(ippp_table[i]); 907 908#ifdef CONFIG_ISDN_MPP 909 kfree(isdn_ppp_bundle_arr); 910#endif /* CONFIG_ISDN_MPP */ 911 912} 913 914/* 915 * check for address/control field and skip if allowed 916 * retval != 0 -> discard packet silently 917 */ 918static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb) 919{ 920 if (skb->len < 1) 921 return -1; 922 923 if (skb->data[0] == 0xff) { 924 if (skb->len < 2) 925 return -1; 926 927 if (skb->data[1] != 0x03) 928 return -1; 929 930 // skip address/control (AC) field 931 skb_pull(skb, 2); 932 } else { 933 if (is->pppcfg & SC_REJ_COMP_AC) 934 // if AC compression was not negotiated, but used, discard packet 935 return -1; 936 } 937 return 0; 938} 939 940/* 941 * get the PPP protocol header and pull skb 942 * retval < 0 -> discard packet silently 943 */ 944static int isdn_ppp_strip_proto(struct sk_buff *skb) 945{ 946 int proto; 947 948 if (skb->len < 1) 949 return -1; 950 951 if (skb->data[0] & 0x1) { 952 // protocol field is compressed 953 proto = skb->data[0]; 954 skb_pull(skb, 1); 955 } else { 956 if (skb->len < 2) 957 return -1; 958 proto = ((int) skb->data[0] << 8) + skb->data[1]; 959 skb_pull(skb, 2); 960 } 961 return proto; 962} 963 964 965/* 966 * handler for incoming packets on a syncPPP interface 967 */ 968void isdn_ppp_receive(isdn_net_dev * net_dev, isdn_net_local * lp, struct sk_buff *skb) 969{ 970 struct ippp_struct *is; 971 int slot; 972 int proto; 973 974 BUG_ON(net_dev->local->master); // we're called with the master device always 975 976 slot = lp->ppp_slot; 977 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 978 printk(KERN_ERR "isdn_ppp_receive: lp->ppp_slot(%d)\n", 979 lp->ppp_slot); 980 kfree_skb(skb); 981 return; 982 } 983 is = ippp_table[slot]; 984 985 if (is->debug & 0x4) { 986 printk(KERN_DEBUG "ippp_receive: is:%08lx lp:%08lx slot:%d unit:%d len:%d\n", 987 (long)is,(long)lp,lp->ppp_slot,is->unit,(int) skb->len); 988 isdn_ppp_frame_log("receive", skb->data, skb->len, 32,is->unit,lp->ppp_slot); 989 } 990 991 if (isdn_ppp_skip_ac(is, skb) < 0) { 992 kfree_skb(skb); 993 return; 994 } 995 proto = isdn_ppp_strip_proto(skb); 996 if (proto < 0) { 997 kfree_skb(skb); 998 return; 999 } 1000 1001#ifdef CONFIG_ISDN_MPP 1002 if (is->compflags & SC_LINK_DECOMP_ON) { 1003 skb = isdn_ppp_decompress(skb, is, NULL, &proto); 1004 if (!skb) // decompression error 1005 return; 1006 } 1007 1008 if (!(is->mpppcfg & SC_REJ_MP_PROT)) { // we agreed to receive MPPP 1009 if (proto == PPP_MP) { 1010 isdn_ppp_mp_receive(net_dev, lp, skb); 1011 return; 1012 } 1013 } 1014#endif 1015 isdn_ppp_push_higher(net_dev, lp, skb, proto); 1016} 1017 1018/* 1019 * we receive a reassembled frame, MPPP has been taken care of before. 1020 * address/control and protocol have been stripped from the skb 1021 * note: net_dev has to be master net_dev 1022 */ 1023static void 1024isdn_ppp_push_higher(isdn_net_dev * net_dev, isdn_net_local * lp, struct sk_buff *skb, int proto) 1025{ 1026 struct net_device *dev = &net_dev->dev; 1027 struct ippp_struct *is, *mis; 1028 isdn_net_local *mlp = NULL; 1029 int slot; 1030 1031 slot = lp->ppp_slot; 1032 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 1033 printk(KERN_ERR "isdn_ppp_push_higher: lp->ppp_slot(%d)\n", 1034 lp->ppp_slot); 1035 goto drop_packet; 1036 } 1037 is = ippp_table[slot]; 1038 1039 if (lp->master) { 1040 mlp = (isdn_net_local *) lp->master->priv; 1041 slot = mlp->ppp_slot; 1042 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 1043 printk(KERN_ERR "isdn_ppp_push_higher: master->ppp_slot(%d)\n", 1044 lp->ppp_slot); 1045 goto drop_packet; 1046 } 1047 } 1048 mis = ippp_table[slot]; 1049 1050 if (is->debug & 0x10) { 1051 printk(KERN_DEBUG "push, skb %d %04x\n", (int) skb->len, proto); 1052 isdn_ppp_frame_log("rpush", skb->data, skb->len, 32,is->unit,lp->ppp_slot); 1053 } 1054 if (mis->compflags & SC_DECOMP_ON) { 1055 skb = isdn_ppp_decompress(skb, is, mis, &proto); 1056 if (!skb) // decompression error 1057 return; 1058 } 1059 switch (proto) { 1060 case PPP_IPX: /* untested */ 1061 if (is->debug & 0x20) 1062 printk(KERN_DEBUG "isdn_ppp: IPX\n"); 1063 skb->protocol = htons(ETH_P_IPX); 1064 break; 1065 case PPP_IP: 1066 if (is->debug & 0x20) 1067 printk(KERN_DEBUG "isdn_ppp: IP\n"); 1068 skb->protocol = htons(ETH_P_IP); 1069 break; 1070 case PPP_COMP: 1071 case PPP_COMPFRAG: 1072 printk(KERN_INFO "isdn_ppp: unexpected compressed frame dropped\n"); 1073 goto drop_packet; 1074#ifdef CONFIG_ISDN_PPP_VJ 1075 case PPP_VJC_UNCOMP: 1076 if (is->debug & 0x20) 1077 printk(KERN_DEBUG "isdn_ppp: VJC_UNCOMP\n"); 1078 if (net_dev->local->ppp_slot < 0) { 1079 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n", 1080 __FUNCTION__, net_dev->local->ppp_slot); 1081 goto drop_packet; 1082 } 1083 if (slhc_remember(ippp_table[net_dev->local->ppp_slot]->slcomp, skb->data, skb->len) <= 0) { 1084 printk(KERN_WARNING "isdn_ppp: received illegal VJC_UNCOMP frame!\n"); 1085 goto drop_packet; 1086 } 1087 skb->protocol = htons(ETH_P_IP); 1088 break; 1089 case PPP_VJC_COMP: 1090 if (is->debug & 0x20) 1091 printk(KERN_DEBUG "isdn_ppp: VJC_COMP\n"); 1092 { 1093 struct sk_buff *skb_old = skb; 1094 int pkt_len; 1095 skb = dev_alloc_skb(skb_old->len + 128); 1096 1097 if (!skb) { 1098 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name); 1099 skb = skb_old; 1100 goto drop_packet; 1101 } 1102 skb_put(skb, skb_old->len + 128); 1103 skb_copy_from_linear_data(skb_old, skb->data, 1104 skb_old->len); 1105 if (net_dev->local->ppp_slot < 0) { 1106 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n", 1107 __FUNCTION__, net_dev->local->ppp_slot); 1108 goto drop_packet; 1109 } 1110 pkt_len = slhc_uncompress(ippp_table[net_dev->local->ppp_slot]->slcomp, 1111 skb->data, skb_old->len); 1112 kfree_skb(skb_old); 1113 if (pkt_len < 0) 1114 goto drop_packet; 1115 1116 skb_trim(skb, pkt_len); 1117 skb->protocol = htons(ETH_P_IP); 1118 } 1119 break; 1120#endif 1121 case PPP_CCP: 1122 case PPP_CCPFRAG: 1123 isdn_ppp_receive_ccp(net_dev,lp,skb,proto); 1124 /* Dont pop up ResetReq/Ack stuff to the daemon any 1125 longer - the job is done already */ 1126 if(skb->data[0] == CCP_RESETREQ || 1127 skb->data[0] == CCP_RESETACK) 1128 break; 1129 /* fall through */ 1130 default: 1131 isdn_ppp_fill_rq(skb->data, skb->len, proto, lp->ppp_slot); /* push data to pppd device */ 1132 kfree_skb(skb); 1133 return; 1134 } 1135 1136#ifdef CONFIG_IPPP_FILTER 1137 /* check if the packet passes the pass and active filters 1138 * the filter instructions are constructed assuming 1139 * a four-byte PPP header on each packet (which is still present) */ 1140 skb_push(skb, 4); 1141 1142 { 1143 u_int16_t *p = (u_int16_t *) skb->data; 1144 1145 *p = 0; /* indicate inbound */ 1146 } 1147 1148 if (is->pass_filter 1149 && sk_run_filter(skb, is->pass_filter, is->pass_len) == 0) { 1150 if (is->debug & 0x2) 1151 printk(KERN_DEBUG "IPPP: inbound frame filtered.\n"); 1152 kfree_skb(skb); 1153 return; 1154 } 1155 if (!(is->active_filter 1156 && sk_run_filter(skb, is->active_filter, 1157 is->active_len) == 0)) { 1158 if (is->debug & 0x2) 1159 printk(KERN_DEBUG "IPPP: link-active filter: reseting huptimer.\n"); 1160 lp->huptimer = 0; 1161 if (mlp) 1162 mlp->huptimer = 0; 1163 } 1164 skb_pull(skb, 4); 1165#else /* CONFIG_IPPP_FILTER */ 1166 lp->huptimer = 0; 1167 if (mlp) 1168 mlp->huptimer = 0; 1169#endif /* CONFIG_IPPP_FILTER */ 1170 skb->dev = dev; 1171 skb_reset_mac_header(skb); 1172 netif_rx(skb); 1173 /* net_dev->local->stats.rx_packets++; done in isdn_net.c */ 1174 return; 1175 1176 drop_packet: 1177 net_dev->local->stats.rx_dropped++; 1178 kfree_skb(skb); 1179} 1180 1181/* 1182 * isdn_ppp_skb_push .. 1183 * checks whether we have enough space at the beginning of the skb 1184 * and allocs a new SKB if necessary 1185 */ 1186static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p,int len) 1187{ 1188 struct sk_buff *skb = *skb_p; 1189 1190 if(skb_headroom(skb) < len) { 1191 struct sk_buff *nskb = skb_realloc_headroom(skb, len); 1192 1193 if (!nskb) { 1194 printk(KERN_ERR "isdn_ppp_skb_push: can't realloc headroom!\n"); 1195 dev_kfree_skb(skb); 1196 return NULL; 1197 } 1198 printk(KERN_DEBUG "isdn_ppp_skb_push:under %d %d\n",skb_headroom(skb),len); 1199 dev_kfree_skb(skb); 1200 *skb_p = nskb; 1201 return skb_push(nskb, len); 1202 } 1203 return skb_push(skb,len); 1204} 1205 1206/* 1207 * send ppp frame .. we expect a PIDCOMPressable proto -- 1208 * (here: currently always PPP_IP,PPP_VJC_COMP,PPP_VJC_UNCOMP) 1209 * 1210 * VJ compression may change skb pointer!!! .. requeue with old 1211 * skb isn't allowed!! 1212 */ 1213 1214int 1215isdn_ppp_xmit(struct sk_buff *skb, struct net_device *netdev) 1216{ 1217 isdn_net_local *lp,*mlp; 1218 isdn_net_dev *nd; 1219 unsigned int proto = PPP_IP; /* 0x21 */ 1220 struct ippp_struct *ipt,*ipts; 1221 int slot, retval = 0; 1222 1223 mlp = (isdn_net_local *) (netdev->priv); 1224 nd = mlp->netdev; /* get master lp */ 1225 1226 slot = mlp->ppp_slot; 1227 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 1228 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n", 1229 mlp->ppp_slot); 1230 kfree_skb(skb); 1231 goto out; 1232 } 1233 ipts = ippp_table[slot]; 1234 1235 if (!(ipts->pppcfg & SC_ENABLE_IP)) { /* PPP connected ? */ 1236 if (ipts->debug & 0x1) 1237 printk(KERN_INFO "%s: IP frame delayed.\n", netdev->name); 1238 retval = 1; 1239 goto out; 1240 } 1241 1242 switch (ntohs(skb->protocol)) { 1243 case ETH_P_IP: 1244 proto = PPP_IP; 1245 break; 1246 case ETH_P_IPX: 1247 proto = PPP_IPX; /* untested */ 1248 break; 1249 default: 1250 printk(KERN_ERR "isdn_ppp: skipped unsupported protocol: %#x.\n", 1251 skb->protocol); 1252 dev_kfree_skb(skb); 1253 goto out; 1254 } 1255 1256 lp = isdn_net_get_locked_lp(nd); 1257 if (!lp) { 1258 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", netdev->name); 1259 retval = 1; 1260 goto out; 1261 } 1262 /* we have our lp locked from now on */ 1263 1264 slot = lp->ppp_slot; 1265 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 1266 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n", 1267 lp->ppp_slot); 1268 kfree_skb(skb); 1269 goto unlock; 1270 } 1271 ipt = ippp_table[slot]; 1272 1273 /* 1274 * after this line .. requeueing in the device queue is no longer allowed!!! 1275 */ 1276 1277 /* Pull off the fake header we stuck on earlier to keep 1278 * the fragmentation code happy. 1279 */ 1280 skb_pull(skb,IPPP_MAX_HEADER); 1281 1282#ifdef CONFIG_IPPP_FILTER 1283 /* check if we should pass this packet 1284 * the filter instructions are constructed assuming 1285 * a four-byte PPP header on each packet */ 1286 *skb_push(skb, 4) = 1; /* indicate outbound */ 1287 1288 { 1289 u_int16_t *p = (u_int16_t *) skb->data; 1290 1291 p++; 1292 *p = htons(proto); 1293 } 1294 1295 if (ipt->pass_filter 1296 && sk_run_filter(skb, ipt->pass_filter, ipt->pass_len) == 0) { 1297 if (ipt->debug & 0x4) 1298 printk(KERN_DEBUG "IPPP: outbound frame filtered.\n"); 1299 kfree_skb(skb); 1300 goto unlock; 1301 } 1302 if (!(ipt->active_filter 1303 && sk_run_filter(skb, ipt->active_filter, 1304 ipt->active_len) == 0)) { 1305 if (ipt->debug & 0x4) 1306 printk(KERN_DEBUG "IPPP: link-active filter: reseting huptimer.\n"); 1307 lp->huptimer = 0; 1308 } 1309 skb_pull(skb, 4); 1310#else /* CONFIG_IPPP_FILTER */ 1311 lp->huptimer = 0; 1312#endif /* CONFIG_IPPP_FILTER */ 1313 1314 if (ipt->debug & 0x4) 1315 printk(KERN_DEBUG "xmit skb, len %d\n", (int) skb->len); 1316 if (ipts->debug & 0x40) 1317 isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32,ipts->unit,lp->ppp_slot); 1318 1319#ifdef CONFIG_ISDN_PPP_VJ 1320 if (proto == PPP_IP && ipts->pppcfg & SC_COMP_TCP) { /* ipts here? probably yes, but check this again */ 1321 struct sk_buff *new_skb; 1322 unsigned short hl; 1323 /* 1324 * we need to reserve enought space in front of 1325 * sk_buff. old call to dev_alloc_skb only reserved 1326 * 16 bytes, now we are looking what the driver want. 1327 */ 1328 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen + IPPP_MAX_HEADER; 1329 /* 1330 * Note: hl might still be insufficient because the method 1331 * above does not account for a possibible MPPP slave channel 1332 * which had larger HL header space requirements than the 1333 * master. 1334 */ 1335 new_skb = alloc_skb(hl+skb->len, GFP_ATOMIC); 1336 if (new_skb) { 1337 u_char *buf; 1338 int pktlen; 1339 1340 skb_reserve(new_skb, hl); 1341 new_skb->dev = skb->dev; 1342 skb_put(new_skb, skb->len); 1343 buf = skb->data; 1344 1345 pktlen = slhc_compress(ipts->slcomp, skb->data, skb->len, new_skb->data, 1346 &buf, !(ipts->pppcfg & SC_NO_TCP_CCID)); 1347 1348 if (buf != skb->data) { 1349 if (new_skb->data != buf) 1350 printk(KERN_ERR "isdn_ppp: FATAL error after slhc_compress!!\n"); 1351 dev_kfree_skb(skb); 1352 skb = new_skb; 1353 } else { 1354 dev_kfree_skb(new_skb); 1355 } 1356 1357 skb_trim(skb, pktlen); 1358 if (skb->data[0] & SL_TYPE_COMPRESSED_TCP) { /* cslip? style -> PPP */ 1359 proto = PPP_VJC_COMP; 1360 skb->data[0] ^= SL_TYPE_COMPRESSED_TCP; 1361 } else { 1362 if (skb->data[0] >= SL_TYPE_UNCOMPRESSED_TCP) 1363 proto = PPP_VJC_UNCOMP; 1364 skb->data[0] = (skb->data[0] & 0x0f) | 0x40; 1365 } 1366 } 1367 } 1368#endif 1369 1370 /* 1371 * normal (single link) or bundle compression 1372 */ 1373 if(ipts->compflags & SC_COMP_ON) { 1374 /* We send compressed only if both down- und upstream 1375 compression is negotiated, that means, CCP is up */ 1376 if(ipts->compflags & SC_DECOMP_ON) { 1377 skb = isdn_ppp_compress(skb,&proto,ipt,ipts,0); 1378 } else { 1379 printk(KERN_DEBUG "isdn_ppp: CCP not yet up - sending as-is\n"); 1380 } 1381 } 1382 1383 if (ipt->debug & 0x24) 1384 printk(KERN_DEBUG "xmit2 skb, len %d, proto %04x\n", (int) skb->len, proto); 1385 1386#ifdef CONFIG_ISDN_MPP 1387 if (ipt->mpppcfg & SC_MP_PROT) { 1388 /* we get mp_seqno from static isdn_net_local */ 1389 long mp_seqno = ipts->mp_seqno; 1390 ipts->mp_seqno++; 1391 if (ipt->mpppcfg & SC_OUT_SHORT_SEQ) { 1392 unsigned char *data = isdn_ppp_skb_push(&skb, 3); 1393 if(!data) 1394 goto unlock; 1395 mp_seqno &= 0xfff; 1396 data[0] = MP_BEGIN_FRAG | MP_END_FRAG | ((mp_seqno >> 8) & 0xf); /* (B)egin & (E)ndbit .. */ 1397 data[1] = mp_seqno & 0xff; 1398 data[2] = proto; /* PID compression */ 1399 } else { 1400 unsigned char *data = isdn_ppp_skb_push(&skb, 5); 1401 if(!data) 1402 goto unlock; 1403 data[0] = MP_BEGIN_FRAG | MP_END_FRAG; /* (B)egin & (E)ndbit .. */ 1404 data[1] = (mp_seqno >> 16) & 0xff; /* sequence number: 24bit */ 1405 data[2] = (mp_seqno >> 8) & 0xff; 1406 data[3] = (mp_seqno >> 0) & 0xff; 1407 data[4] = proto; /* PID compression */ 1408 } 1409 proto = PPP_MP; /* MP Protocol, 0x003d */ 1410 } 1411#endif 1412 1413 /* 1414 * 'link in bundle' compression ... 1415 */ 1416 if(ipt->compflags & SC_LINK_COMP_ON) 1417 skb = isdn_ppp_compress(skb,&proto,ipt,ipts,1); 1418 1419 if( (ipt->pppcfg & SC_COMP_PROT) && (proto <= 0xff) ) { 1420 unsigned char *data = isdn_ppp_skb_push(&skb,1); 1421 if(!data) 1422 goto unlock; 1423 data[0] = proto & 0xff; 1424 } 1425 else { 1426 unsigned char *data = isdn_ppp_skb_push(&skb,2); 1427 if(!data) 1428 goto unlock; 1429 data[0] = (proto >> 8) & 0xff; 1430 data[1] = proto & 0xff; 1431 } 1432 if(!(ipt->pppcfg & SC_COMP_AC)) { 1433 unsigned char *data = isdn_ppp_skb_push(&skb,2); 1434 if(!data) 1435 goto unlock; 1436 data[0] = 0xff; /* All Stations */ 1437 data[1] = 0x03; /* Unnumbered information */ 1438 } 1439 1440 /* tx-stats are now updated via BSENT-callback */ 1441 1442 if (ipts->debug & 0x40) { 1443 printk(KERN_DEBUG "skb xmit: len: %d\n", (int) skb->len); 1444 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32,ipt->unit,lp->ppp_slot); 1445 } 1446 1447 isdn_net_writebuf_skb(lp, skb); 1448 1449 unlock: 1450 spin_unlock_bh(&lp->xmit_lock); 1451 out: 1452 return retval; 1453} 1454 1455#ifdef CONFIG_IPPP_FILTER 1456/* 1457 * check if this packet may trigger auto-dial. 1458 */ 1459 1460int isdn_ppp_autodial_filter(struct sk_buff *skb, isdn_net_local *lp) 1461{ 1462 struct ippp_struct *is = ippp_table[lp->ppp_slot]; 1463 u_int16_t proto; 1464 int drop = 0; 1465 1466 switch (ntohs(skb->protocol)) { 1467 case ETH_P_IP: 1468 proto = PPP_IP; 1469 break; 1470 case ETH_P_IPX: 1471 proto = PPP_IPX; 1472 break; 1473 default: 1474 printk(KERN_ERR "isdn_ppp_autodial_filter: unsupported protocol 0x%x.\n", 1475 skb->protocol); 1476 return 1; 1477 } 1478 1479 /* the filter instructions are constructed assuming 1480 * a four-byte PPP header on each packet. we have to 1481 * temporarily remove part of the fake header stuck on 1482 * earlier. 1483 */ 1484 *skb_pull(skb, IPPP_MAX_HEADER - 4) = 1; /* indicate outbound */ 1485 1486 { 1487 u_int16_t *p = (u_int16_t *) skb->data; 1488 1489 p++; 1490 *p = htons(proto); 1491 } 1492 1493 drop |= is->pass_filter 1494 && sk_run_filter(skb, is->pass_filter, is->pass_len) == 0; 1495 drop |= is->active_filter 1496 && sk_run_filter(skb, is->active_filter, is->active_len) == 0; 1497 1498 skb_push(skb, IPPP_MAX_HEADER - 4); 1499 return drop; 1500} 1501#endif 1502#ifdef CONFIG_ISDN_MPP 1503 1504/* this is _not_ rfc1990 header, but something we convert both short and long 1505 * headers to for convinience's sake: 1506 * byte 0 is flags as in rfc1990 1507 * bytes 1...4 is 24-bit seqence number converted to host byte order 1508 */ 1509#define MP_HEADER_LEN 5 1510 1511#define MP_LONGSEQ_MASK 0x00ffffff 1512#define MP_SHORTSEQ_MASK 0x00000fff 1513#define MP_LONGSEQ_MAX MP_LONGSEQ_MASK 1514#define MP_SHORTSEQ_MAX MP_SHORTSEQ_MASK 1515#define MP_LONGSEQ_MAXBIT ((MP_LONGSEQ_MASK+1)>>1) 1516#define MP_SHORTSEQ_MAXBIT ((MP_SHORTSEQ_MASK+1)>>1) 1517 1518/* sequence-wrap safe comparisions (for long sequence)*/ 1519#define MP_LT(a,b) ((a-b)&MP_LONGSEQ_MAXBIT) 1520#define MP_LE(a,b) !((b-a)&MP_LONGSEQ_MAXBIT) 1521#define MP_GT(a,b) ((b-a)&MP_LONGSEQ_MAXBIT) 1522#define MP_GE(a,b) !((a-b)&MP_LONGSEQ_MAXBIT) 1523 1524#define MP_SEQ(f) ((*(u32*)(f->data+1))) 1525#define MP_FLAGS(f) (f->data[0]) 1526 1527static int isdn_ppp_mp_bundle_array_init(void) 1528{ 1529 int i; 1530 int sz = ISDN_MAX_CHANNELS*sizeof(ippp_bundle); 1531 if( (isdn_ppp_bundle_arr = kzalloc(sz, GFP_KERNEL)) == NULL ) 1532 return -ENOMEM; 1533 for( i = 0; i < ISDN_MAX_CHANNELS; i++ ) 1534 spin_lock_init(&isdn_ppp_bundle_arr[i].lock); 1535 return 0; 1536} 1537 1538static ippp_bundle * isdn_ppp_mp_bundle_alloc(void) 1539{ 1540 int i; 1541 for( i = 0; i < ISDN_MAX_CHANNELS; i++ ) 1542 if (isdn_ppp_bundle_arr[i].ref_ct <= 0) 1543 return (isdn_ppp_bundle_arr + i); 1544 return NULL; 1545} 1546 1547static int isdn_ppp_mp_init( isdn_net_local * lp, ippp_bundle * add_to ) 1548{ 1549 struct ippp_struct * is; 1550 1551 if (lp->ppp_slot < 0) { 1552 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n", 1553 __FUNCTION__, lp->ppp_slot); 1554 return(-EINVAL); 1555 } 1556 1557 is = ippp_table[lp->ppp_slot]; 1558 if (add_to) { 1559 if( lp->netdev->pb ) 1560 lp->netdev->pb->ref_ct--; 1561 lp->netdev->pb = add_to; 1562 } else { /* first link in a bundle */ 1563 is->mp_seqno = 0; 1564 if ((lp->netdev->pb = isdn_ppp_mp_bundle_alloc()) == NULL) 1565 return -ENOMEM; 1566 lp->next = lp->last = lp; /* nobody else in a queue */ 1567 lp->netdev->pb->frags = NULL; 1568 lp->netdev->pb->frames = 0; 1569 lp->netdev->pb->seq = UINT_MAX; 1570 } 1571 lp->netdev->pb->ref_ct++; 1572 1573 is->last_link_seqno = 0; 1574 return 0; 1575} 1576 1577static u32 isdn_ppp_mp_get_seq( int short_seq, 1578 struct sk_buff * skb, u32 last_seq ); 1579static struct sk_buff * isdn_ppp_mp_discard( ippp_bundle * mp, 1580 struct sk_buff * from, struct sk_buff * to ); 1581static void isdn_ppp_mp_reassembly( isdn_net_dev * net_dev, isdn_net_local * lp, 1582 struct sk_buff * from, struct sk_buff * to ); 1583static void isdn_ppp_mp_free_skb( ippp_bundle * mp, struct sk_buff * skb ); 1584static void isdn_ppp_mp_print_recv_pkt( int slot, struct sk_buff * skb ); 1585 1586static void isdn_ppp_mp_receive(isdn_net_dev * net_dev, isdn_net_local * lp, 1587 struct sk_buff *skb) 1588{ 1589 struct ippp_struct *is; 1590 isdn_net_local * lpq; 1591 ippp_bundle * mp; 1592 isdn_mppp_stats * stats; 1593 struct sk_buff * newfrag, * frag, * start, *nextf; 1594 u32 newseq, minseq, thisseq; 1595 unsigned long flags; 1596 int slot; 1597 1598 spin_lock_irqsave(&net_dev->pb->lock, flags); 1599 mp = net_dev->pb; 1600 stats = &mp->stats; 1601 slot = lp->ppp_slot; 1602 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 1603 printk(KERN_ERR "%s: lp->ppp_slot(%d)\n", 1604 __FUNCTION__, lp->ppp_slot); 1605 stats->frame_drops++; 1606 dev_kfree_skb(skb); 1607 spin_unlock_irqrestore(&mp->lock, flags); 1608 return; 1609 } 1610 is = ippp_table[slot]; 1611 if( ++mp->frames > stats->max_queue_len ) 1612 stats->max_queue_len = mp->frames; 1613 1614 if (is->debug & 0x8) 1615 isdn_ppp_mp_print_recv_pkt(lp->ppp_slot, skb); 1616 1617 newseq = isdn_ppp_mp_get_seq(is->mpppcfg & SC_IN_SHORT_SEQ, 1618 skb, is->last_link_seqno); 1619 1620 1621 /* if this packet seq # is less than last already processed one, 1622 * toss it right away, but check for sequence start case first 1623 */ 1624 if( mp->seq > MP_LONGSEQ_MAX && (newseq & MP_LONGSEQ_MAXBIT) ) { 1625 mp->seq = newseq; /* the first packet: required for 1626 * rfc1990 non-compliant clients -- 1627 * prevents constant packet toss */ 1628 } else if( MP_LT(newseq, mp->seq) ) { 1629 stats->frame_drops++; 1630 isdn_ppp_mp_free_skb(mp, skb); 1631 spin_unlock_irqrestore(&mp->lock, flags); 1632 return; 1633 } 1634 1635 /* find the minimum received sequence number over all links */ 1636 is->last_link_seqno = minseq = newseq; 1637 for (lpq = net_dev->queue;;) { 1638 slot = lpq->ppp_slot; 1639 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 1640 printk(KERN_ERR "%s: lpq->ppp_slot(%d)\n", 1641 __FUNCTION__, lpq->ppp_slot); 1642 } else { 1643 u32 lls = ippp_table[slot]->last_link_seqno; 1644 if (MP_LT(lls, minseq)) 1645 minseq = lls; 1646 } 1647 if ((lpq = lpq->next) == net_dev->queue) 1648 break; 1649 } 1650 if (MP_LT(minseq, mp->seq)) 1651 minseq = mp->seq; /* can't go beyond already processed 1652 * packets */ 1653 newfrag = skb; 1654 1655 /* if this new fragment is before the first one, then enqueue it now. */ 1656 if ((frag = mp->frags) == NULL || MP_LT(newseq, MP_SEQ(frag))) { 1657 newfrag->next = frag; 1658 mp->frags = frag = newfrag; 1659 newfrag = NULL; 1660 } 1661 1662 start = MP_FLAGS(frag) & MP_BEGIN_FRAG && 1663 MP_SEQ(frag) == mp->seq ? frag : NULL; 1664 1665 /* 1666 * main fragment traversing loop 1667 * 1668 * try to accomplish several tasks: 1669 * - insert new fragment into the proper sequence slot (once that's done 1670 * newfrag will be set to NULL) 1671 * - reassemble any complete fragment sequence (non-null 'start' 1672 * indicates there is a continguous sequence present) 1673 * - discard any incomplete sequences that are below minseq -- due 1674 * to the fact that sender always increment sequence number, if there 1675 * is an incomplete sequence below minseq, no new fragments would 1676 * come to complete such sequence and it should be discarded 1677 * 1678 * loop completes when we accomplished the following tasks: 1679 * - new fragment is inserted in the proper sequence ('newfrag' is 1680 * set to NULL) 1681 * - we hit a gap in the sequence, so no reassembly/processing is 1682 * possible ('start' would be set to NULL) 1683 * 1684 * algorithm for this code is derived from code in the book 1685 * 'PPP Design And Debugging' by James Carlson (Addison-Wesley) 1686 */ 1687 while (start != NULL || newfrag != NULL) { 1688 1689 thisseq = MP_SEQ(frag); 1690 nextf = frag->next; 1691 1692 /* drop any duplicate fragments */ 1693 if (newfrag != NULL && thisseq == newseq) { 1694 isdn_ppp_mp_free_skb(mp, newfrag); 1695 newfrag = NULL; 1696 } 1697 1698 /* insert new fragment before next element if possible. */ 1699 if (newfrag != NULL && (nextf == NULL || 1700 MP_LT(newseq, MP_SEQ(nextf)))) { 1701 newfrag->next = nextf; 1702 frag->next = nextf = newfrag; 1703 newfrag = NULL; 1704 } 1705 1706 if (start != NULL) { 1707 /* check for misplaced start */ 1708 if (start != frag && (MP_FLAGS(frag) & MP_BEGIN_FRAG)) { 1709 printk(KERN_WARNING"isdn_mppp(seq %d): new " 1710 "BEGIN flag with no prior END", thisseq); 1711 stats->seqerrs++; 1712 stats->frame_drops++; 1713 start = isdn_ppp_mp_discard(mp, start,frag); 1714 nextf = frag->next; 1715 } 1716 } else if (MP_LE(thisseq, minseq)) { 1717 if (MP_FLAGS(frag) & MP_BEGIN_FRAG) 1718 start = frag; 1719 else { 1720 if (MP_FLAGS(frag) & MP_END_FRAG) 1721 stats->frame_drops++; 1722 if( mp->frags == frag ) 1723 mp->frags = nextf; 1724 isdn_ppp_mp_free_skb(mp, frag); 1725 frag = nextf; 1726 continue; 1727 } 1728 } 1729 1730 /* if start is non-null and we have end fragment, then 1731 * we have full reassembly sequence -- reassemble 1732 * and process packet now 1733 */ 1734 if (start != NULL && (MP_FLAGS(frag) & MP_END_FRAG)) { 1735 minseq = mp->seq = (thisseq+1) & MP_LONGSEQ_MASK; 1736 /* Reassemble the packet then dispatch it */ 1737 isdn_ppp_mp_reassembly(net_dev, lp, start, nextf); 1738 1739 start = NULL; 1740 frag = NULL; 1741 1742 mp->frags = nextf; 1743 } 1744 1745 /* check if need to update start pointer: if we just 1746 * reassembled the packet and sequence is contiguous 1747 * then next fragment should be the start of new reassembly 1748 * if sequence is contiguous, but we haven't reassembled yet, 1749 * keep going. 1750 * if sequence is not contiguous, either clear everyting 1751 * below low watermark and set start to the next frag or 1752 * clear start ptr. 1753 */ 1754 if (nextf != NULL && 1755 ((thisseq+1) & MP_LONGSEQ_MASK) == MP_SEQ(nextf)) { 1756 /* if we just reassembled and the next one is here, 1757 * then start another reassembly. */ 1758 1759 if (frag == NULL) { 1760 if (MP_FLAGS(nextf) & MP_BEGIN_FRAG) 1761 start = nextf; 1762 else 1763 { 1764 printk(KERN_WARNING"isdn_mppp(seq %d):" 1765 " END flag with no following " 1766 "BEGIN", thisseq); 1767 stats->seqerrs++; 1768 } 1769 } 1770 1771 } else { 1772 if ( nextf != NULL && frag != NULL && 1773 MP_LT(thisseq, minseq)) { 1774 /* we've got a break in the sequence 1775 * and we not at the end yet 1776 * and we did not just reassembled 1777 *(if we did, there wouldn't be anything before) 1778 * and we below the low watermark 1779 * discard all the frames below low watermark 1780 * and start over */ 1781 stats->frame_drops++; 1782 mp->frags = isdn_ppp_mp_discard(mp,start,nextf); 1783 } 1784 /* break in the sequence, no reassembly */ 1785 start = NULL; 1786 } 1787 1788 frag = nextf; 1789 } /* while -- main loop */ 1790 1791 if (mp->frags == NULL) 1792 mp->frags = frag; 1793 1794 /* rather straighforward way to deal with (not very) possible 1795 * queue overflow */ 1796 if (mp->frames > MP_MAX_QUEUE_LEN) { 1797 stats->overflows++; 1798 while (mp->frames > MP_MAX_QUEUE_LEN) { 1799 frag = mp->frags->next; 1800 isdn_ppp_mp_free_skb(mp, mp->frags); 1801 mp->frags = frag; 1802 } 1803 } 1804 spin_unlock_irqrestore(&mp->lock, flags); 1805} 1806 1807static void isdn_ppp_mp_cleanup( isdn_net_local * lp ) 1808{ 1809 struct sk_buff * frag = lp->netdev->pb->frags; 1810 struct sk_buff * nextfrag; 1811 while( frag ) { 1812 nextfrag = frag->next; 1813 isdn_ppp_mp_free_skb(lp->netdev->pb, frag); 1814 frag = nextfrag; 1815 } 1816 lp->netdev->pb->frags = NULL; 1817} 1818 1819static u32 isdn_ppp_mp_get_seq( int short_seq, 1820 struct sk_buff * skb, u32 last_seq ) 1821{ 1822 u32 seq; 1823 int flags = skb->data[0] & (MP_BEGIN_FRAG | MP_END_FRAG); 1824 1825 if( !short_seq ) 1826 { 1827 seq = ntohl(*(u32*)skb->data) & MP_LONGSEQ_MASK; 1828 skb_push(skb,1); 1829 } 1830 else 1831 { 1832 /* convert 12-bit short seq number to 24-bit long one 1833 */ 1834 seq = ntohs(*(u16*)skb->data) & MP_SHORTSEQ_MASK; 1835 1836 /* check for seqence wrap */ 1837 if( !(seq & MP_SHORTSEQ_MAXBIT) && 1838 (last_seq & MP_SHORTSEQ_MAXBIT) && 1839 (unsigned long)last_seq <= MP_LONGSEQ_MAX ) 1840 seq |= (last_seq + MP_SHORTSEQ_MAX+1) & 1841 (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK); 1842 else 1843 seq |= last_seq & (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK); 1844 1845 skb_push(skb, 3); /* put converted seqence back in skb */ 1846 } 1847 *(u32*)(skb->data+1) = seq; /* put seqence back in _host_ byte 1848 * order */ 1849 skb->data[0] = flags; /* restore flags */ 1850 return seq; 1851} 1852 1853struct sk_buff * isdn_ppp_mp_discard( ippp_bundle * mp, 1854 struct sk_buff * from, struct sk_buff * to ) 1855{ 1856 if( from ) 1857 while (from != to) { 1858 struct sk_buff * next = from->next; 1859 isdn_ppp_mp_free_skb(mp, from); 1860 from = next; 1861 } 1862 return from; 1863} 1864 1865void isdn_ppp_mp_reassembly( isdn_net_dev * net_dev, isdn_net_local * lp, 1866 struct sk_buff * from, struct sk_buff * to ) 1867{ 1868 ippp_bundle * mp = net_dev->pb; 1869 int proto; 1870 struct sk_buff * skb; 1871 unsigned int tot_len; 1872 1873 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) { 1874 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n", 1875 __FUNCTION__, lp->ppp_slot); 1876 return; 1877 } 1878 if( MP_FLAGS(from) == (MP_BEGIN_FRAG | MP_END_FRAG) ) { 1879 if( ippp_table[lp->ppp_slot]->debug & 0x40 ) 1880 printk(KERN_DEBUG "isdn_mppp: reassembly: frame %d, " 1881 "len %d\n", MP_SEQ(from), from->len ); 1882 skb = from; 1883 skb_pull(skb, MP_HEADER_LEN); 1884 mp->frames--; 1885 } else { 1886 struct sk_buff * frag; 1887 int n; 1888 1889 for(tot_len=n=0, frag=from; frag != to; frag=frag->next, n++) 1890 tot_len += frag->len - MP_HEADER_LEN; 1891 1892 if( ippp_table[lp->ppp_slot]->debug & 0x40 ) 1893 printk(KERN_DEBUG"isdn_mppp: reassembling frames %d " 1894 "to %d, len %d\n", MP_SEQ(from), 1895 (MP_SEQ(from)+n-1) & MP_LONGSEQ_MASK, tot_len ); 1896 if( (skb = dev_alloc_skb(tot_len)) == NULL ) { 1897 printk(KERN_ERR "isdn_mppp: cannot allocate sk buff " 1898 "of size %d\n", tot_len); 1899 isdn_ppp_mp_discard(mp, from, to); 1900 return; 1901 } 1902 1903 while( from != to ) { 1904 unsigned int len = from->len - MP_HEADER_LEN; 1905 1906 skb_copy_from_linear_data_offset(from, MP_HEADER_LEN, 1907 skb_put(skb,len), 1908 len); 1909 frag = from->next; 1910 isdn_ppp_mp_free_skb(mp, from); 1911 from = frag; 1912 } 1913 } 1914 proto = isdn_ppp_strip_proto(skb); 1915 isdn_ppp_push_higher(net_dev, lp, skb, proto); 1916} 1917 1918static void isdn_ppp_mp_free_skb(ippp_bundle * mp, struct sk_buff * skb) 1919{ 1920 dev_kfree_skb(skb); 1921 mp->frames--; 1922} 1923 1924static void isdn_ppp_mp_print_recv_pkt( int slot, struct sk_buff * skb ) 1925{ 1926 printk(KERN_DEBUG "mp_recv: %d/%d -> %02x %02x %02x %02x %02x %02x\n", 1927 slot, (int) skb->len, 1928 (int) skb->data[0], (int) skb->data[1], (int) skb->data[2], 1929 (int) skb->data[3], (int) skb->data[4], (int) skb->data[5]); 1930} 1931 1932static int 1933isdn_ppp_bundle(struct ippp_struct *is, int unit) 1934{ 1935 char ifn[IFNAMSIZ + 1]; 1936 isdn_net_dev *p; 1937 isdn_net_local *lp, *nlp; 1938 int rc; 1939 unsigned long flags; 1940 1941 sprintf(ifn, "ippp%d", unit); 1942 p = isdn_net_findif(ifn); 1943 if (!p) { 1944 printk(KERN_ERR "ippp_bundle: cannot find %s\n", ifn); 1945 return -EINVAL; 1946 } 1947 1948 spin_lock_irqsave(&p->pb->lock, flags); 1949 1950 nlp = is->lp; 1951 lp = p->queue; 1952 if( nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS || 1953 lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS ) { 1954 printk(KERN_ERR "ippp_bundle: binding to invalid slot %d\n", 1955 nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ? 1956 nlp->ppp_slot : lp->ppp_slot ); 1957 rc = -EINVAL; 1958 goto out; 1959 } 1960 1961 isdn_net_add_to_bundle(p, nlp); 1962 1963 ippp_table[nlp->ppp_slot]->unit = ippp_table[lp->ppp_slot]->unit; 1964 1965 /* maybe also SC_CCP stuff */ 1966 ippp_table[nlp->ppp_slot]->pppcfg |= ippp_table[lp->ppp_slot]->pppcfg & 1967 (SC_ENABLE_IP | SC_NO_TCP_CCID | SC_REJ_COMP_TCP); 1968 ippp_table[nlp->ppp_slot]->mpppcfg |= ippp_table[lp->ppp_slot]->mpppcfg & 1969 (SC_MP_PROT | SC_REJ_MP_PROT | SC_OUT_SHORT_SEQ | SC_IN_SHORT_SEQ); 1970 rc = isdn_ppp_mp_init(nlp, p->pb); 1971out: 1972 spin_unlock_irqrestore(&p->pb->lock, flags); 1973 return rc; 1974} 1975 1976#endif /* CONFIG_ISDN_MPP */ 1977 1978/* 1979 * network device ioctl handlers 1980 */ 1981 1982static int 1983isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev) 1984{ 1985 struct ppp_stats __user *res = ifr->ifr_data; 1986 struct ppp_stats t; 1987 isdn_net_local *lp = (isdn_net_local *) dev->priv; 1988 1989 if (!access_ok(VERIFY_WRITE, res, sizeof(struct ppp_stats))) 1990 return -EFAULT; 1991 1992 /* build a temporary stat struct and copy it to user space */ 1993 1994 memset(&t, 0, sizeof(struct ppp_stats)); 1995 if (dev->flags & IFF_UP) { 1996 t.p.ppp_ipackets = lp->stats.rx_packets; 1997 t.p.ppp_ibytes = lp->stats.rx_bytes; 1998 t.p.ppp_ierrors = lp->stats.rx_errors; 1999 t.p.ppp_opackets = lp->stats.tx_packets; 2000 t.p.ppp_obytes = lp->stats.tx_bytes; 2001 t.p.ppp_oerrors = lp->stats.tx_errors; 2002#ifdef CONFIG_ISDN_PPP_VJ 2003 if (slot >= 0 && ippp_table[slot]->slcomp) { 2004 struct slcompress *slcomp = ippp_table[slot]->slcomp; 2005 t.vj.vjs_packets = slcomp->sls_o_compressed + slcomp->sls_o_uncompressed; 2006 t.vj.vjs_compressed = slcomp->sls_o_compressed; 2007 t.vj.vjs_searches = slcomp->sls_o_searches; 2008 t.vj.vjs_misses = slcomp->sls_o_misses; 2009 t.vj.vjs_errorin = slcomp->sls_i_error; 2010 t.vj.vjs_tossed = slcomp->sls_i_tossed; 2011 t.vj.vjs_uncompressedin = slcomp->sls_i_uncompressed; 2012 t.vj.vjs_compressedin = slcomp->sls_i_compressed; 2013 } 2014#endif 2015 } 2016 if (copy_to_user(res, &t, sizeof(struct ppp_stats))) 2017 return -EFAULT; 2018 return 0; 2019} 2020 2021int 2022isdn_ppp_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 2023{ 2024 int error=0; 2025 int len; 2026 isdn_net_local *lp = (isdn_net_local *) dev->priv; 2027 2028 2029 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP) 2030 return -EINVAL; 2031 2032 switch (cmd) { 2033#define PPP_VERSION "2.3.7" 2034 case SIOCGPPPVER: 2035 len = strlen(PPP_VERSION) + 1; 2036 if (copy_to_user(ifr->ifr_data, PPP_VERSION, len)) 2037 error = -EFAULT; 2038 break; 2039 2040 case SIOCGPPPSTATS: 2041 error = isdn_ppp_dev_ioctl_stats(lp->ppp_slot, ifr, dev); 2042 break; 2043 default: 2044 error = -EINVAL; 2045 break; 2046 } 2047 return error; 2048} 2049 2050static int 2051isdn_ppp_if_get_unit(char *name) 2052{ 2053 int len, 2054 i, 2055 unit = 0, 2056 deci; 2057 2058 len = strlen(name); 2059 2060 if (strncmp("ippp", name, 4) || len > 8) 2061 return -1; 2062 2063 for (i = 0, deci = 1; i < len; i++, deci *= 10) { 2064 char a = name[len - i - 1]; 2065 if (a >= '0' && a <= '9') 2066 unit += (a - '0') * deci; 2067 else 2068 break; 2069 } 2070 if (!i || len - i != 4) 2071 unit = -1; 2072 2073 return unit; 2074} 2075 2076 2077int 2078isdn_ppp_dial_slave(char *name) 2079{ 2080#ifdef CONFIG_ISDN_MPP 2081 isdn_net_dev *ndev; 2082 isdn_net_local *lp; 2083 struct net_device *sdev; 2084 2085 if (!(ndev = isdn_net_findif(name))) 2086 return 1; 2087 lp = ndev->local; 2088 if (!(lp->flags & ISDN_NET_CONNECTED)) 2089 return 5; 2090 2091 sdev = lp->slave; 2092 while (sdev) { 2093 isdn_net_local *mlp = (isdn_net_local *) sdev->priv; 2094 if (!(mlp->flags & ISDN_NET_CONNECTED)) 2095 break; 2096 sdev = mlp->slave; 2097 } 2098 if (!sdev) 2099 return 2; 2100 2101 isdn_net_dial_req((isdn_net_local *) sdev->priv); 2102 return 0; 2103#else 2104 return -1; 2105#endif 2106} 2107 2108int 2109isdn_ppp_hangup_slave(char *name) 2110{ 2111#ifdef CONFIG_ISDN_MPP 2112 isdn_net_dev *ndev; 2113 isdn_net_local *lp; 2114 struct net_device *sdev; 2115 2116 if (!(ndev = isdn_net_findif(name))) 2117 return 1; 2118 lp = ndev->local; 2119 if (!(lp->flags & ISDN_NET_CONNECTED)) 2120 return 5; 2121 2122 sdev = lp->slave; 2123 while (sdev) { 2124 isdn_net_local *mlp = (isdn_net_local *) sdev->priv; 2125 2126 if (mlp->slave) { /* find last connected link in chain */ 2127 isdn_net_local *nlp = (isdn_net_local *) mlp->slave->priv; 2128 2129 if (!(nlp->flags & ISDN_NET_CONNECTED)) 2130 break; 2131 } else if (mlp->flags & ISDN_NET_CONNECTED) 2132 break; 2133 2134 sdev = mlp->slave; 2135 } 2136 if (!sdev) 2137 return 2; 2138 2139 isdn_net_hangup(sdev); 2140 return 0; 2141#else 2142 return -1; 2143#endif 2144} 2145 2146/* 2147 * PPP compression stuff 2148 */ 2149 2150 2151/* Push an empty CCP Data Frame up to the daemon to wake it up and let it 2152 generate a CCP Reset-Request or tear down CCP altogether */ 2153 2154static void isdn_ppp_ccp_kickup(struct ippp_struct *is) 2155{ 2156 isdn_ppp_fill_rq(NULL, 0, PPP_COMP, is->lp->ppp_slot); 2157} 2158 2159/* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary, 2160 but absolutely nontrivial. The most abstruse problem we are facing is 2161 that the generation, reception and all the handling of timeouts and 2162 resends including proper request id management should be entirely left 2163 to the (de)compressor, but indeed is not covered by the current API to 2164 the (de)compressor. The API is a prototype version from PPP where only 2165 some (de)compressors have yet been implemented and all of them are 2166 rather simple in their reset handling. Especially, their is only one 2167 outstanding ResetAck at a time with all of them and ResetReq/-Acks do 2168 not have parameters. For this very special case it was sufficient to 2169 just return an error code from the decompressor and have a single 2170 reset() entry to communicate all the necessary information between 2171 the framework and the (de)compressor. Bad enough, LZS is different 2172 (and any other compressor may be different, too). It has multiple 2173 histories (eventually) and needs to Reset each of them independently 2174 and thus uses multiple outstanding Acks and history numbers as an 2175 additional parameter to Reqs/Acks. 2176 All that makes it harder to port the reset state engine into the 2177 kernel because it is not just the same simple one as in (i)pppd but 2178 it must be able to pass additional parameters and have multiple out- 2179 standing Acks. We are trying to achieve the impossible by handling 2180 reset transactions independent by their id. The id MUST change when 2181 the data portion changes, thus any (de)compressor who uses more than 2182 one resettable state must provide and recognize individual ids for 2183 each individual reset transaction. The framework itself does _only_ 2184 differentiate them by id, because it has no other semantics like the 2185 (de)compressor might. 2186 This looks like a major redesign of the interface would be nice, 2187 but I don't have an idea how to do it better. */ 2188 2189/* Send a CCP Reset-Request or Reset-Ack directly from the kernel. This is 2190 getting that lengthy because there is no simple "send-this-frame-out" 2191 function above but every wrapper does a bit different. Hope I guess 2192 correct in this hack... */ 2193 2194static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto, 2195 unsigned char code, unsigned char id, 2196 unsigned char *data, int len) 2197{ 2198 struct sk_buff *skb; 2199 unsigned char *p; 2200 int hl; 2201 int cnt = 0; 2202 isdn_net_local *lp = is->lp; 2203 2204 /* Alloc large enough skb */ 2205 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen; 2206 skb = alloc_skb(len + hl + 16,GFP_ATOMIC); 2207 if(!skb) { 2208 printk(KERN_WARNING 2209 "ippp: CCP cannot send reset - out of memory\n"); 2210 return; 2211 } 2212 skb_reserve(skb, hl); 2213 2214 /* We may need to stuff an address and control field first */ 2215 if(!(is->pppcfg & SC_COMP_AC)) { 2216 p = skb_put(skb, 2); 2217 *p++ = 0xff; 2218 *p++ = 0x03; 2219 } 2220 2221 /* Stuff proto, code, id and length */ 2222 p = skb_put(skb, 6); 2223 *p++ = (proto >> 8); 2224 *p++ = (proto & 0xff); 2225 *p++ = code; 2226 *p++ = id; 2227 cnt = 4 + len; 2228 *p++ = (cnt >> 8); 2229 *p++ = (cnt & 0xff); 2230 2231 /* Now stuff remaining bytes */ 2232 if(len) { 2233 p = skb_put(skb, len); 2234 memcpy(p, data, len); 2235 } 2236 2237 /* skb is now ready for xmit */ 2238 printk(KERN_DEBUG "Sending CCP Frame:\n"); 2239 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit,lp->ppp_slot); 2240 2241 isdn_net_write_super(lp, skb); 2242} 2243 2244/* Allocate the reset state vector */ 2245static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is) 2246{ 2247 struct ippp_ccp_reset *r; 2248 r = kzalloc(sizeof(struct ippp_ccp_reset), GFP_KERNEL); 2249 if(!r) { 2250 printk(KERN_ERR "ippp_ccp: failed to allocate reset data" 2251 " structure - no mem\n"); 2252 return NULL; 2253 } 2254 printk(KERN_DEBUG "ippp_ccp: allocated reset data structure %p\n", r); 2255 is->reset = r; 2256 return r; 2257} 2258 2259/* Destroy the reset state vector. Kill all pending timers first. */ 2260static void isdn_ppp_ccp_reset_free(struct ippp_struct *is) 2261{ 2262 unsigned int id; 2263 2264 printk(KERN_DEBUG "ippp_ccp: freeing reset data structure %p\n", 2265 is->reset); 2266 for(id = 0; id < 256; id++) { 2267 if(is->reset->rs[id]) { 2268 isdn_ppp_ccp_reset_free_state(is, (unsigned char)id); 2269 } 2270 } 2271 kfree(is->reset); 2272 is->reset = NULL; 2273} 2274 2275/* Free a given state and clear everything up for later reallocation */ 2276static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is, 2277 unsigned char id) 2278{ 2279 struct ippp_ccp_reset_state *rs; 2280 2281 if(is->reset->rs[id]) { 2282 printk(KERN_DEBUG "ippp_ccp: freeing state for id %d\n", id); 2283 rs = is->reset->rs[id]; 2284 /* Make sure the kernel will not call back later */ 2285 if(rs->ta) 2286 del_timer(&rs->timer); 2287 is->reset->rs[id] = NULL; 2288 kfree(rs); 2289 } else { 2290 printk(KERN_WARNING "ippp_ccp: id %d is not allocated\n", id); 2291 } 2292} 2293 2294/* The timer callback function which is called when a ResetReq has timed out, 2295 aka has never been answered by a ResetAck */ 2296static void isdn_ppp_ccp_timer_callback(unsigned long closure) 2297{ 2298 struct ippp_ccp_reset_state *rs = 2299 (struct ippp_ccp_reset_state *)closure; 2300 2301 if(!rs) { 2302 printk(KERN_ERR "ippp_ccp: timer cb with zero closure.\n"); 2303 return; 2304 } 2305 if(rs->ta && rs->state == CCPResetSentReq) { 2306 /* We are correct here */ 2307 if(!rs->expra) { 2308 /* Hmm, there is no Ack really expected. We can clean 2309 up the state now, it will be reallocated if the 2310 decompressor insists on another reset */ 2311 rs->ta = 0; 2312 isdn_ppp_ccp_reset_free_state(rs->is, rs->id); 2313 return; 2314 } 2315 printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n", 2316 rs->id); 2317 /* Push it again */ 2318 isdn_ppp_ccp_xmit_reset(rs->is, PPP_CCP, CCP_RESETREQ, rs->id, 2319 rs->data, rs->dlen); 2320 /* Restart timer */ 2321 rs->timer.expires = jiffies + HZ*5; 2322 add_timer(&rs->timer); 2323 } else { 2324 printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n", 2325 rs->state); 2326 } 2327} 2328 2329/* Allocate a new reset transaction state */ 2330static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is, 2331 unsigned char id) 2332{ 2333 struct ippp_ccp_reset_state *rs; 2334 if(is->reset->rs[id]) { 2335 printk(KERN_WARNING "ippp_ccp: old state exists for id %d\n", 2336 id); 2337 return NULL; 2338 } else { 2339 rs = kzalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL); 2340 if(!rs) 2341 return NULL; 2342 rs->state = CCPResetIdle; 2343 rs->is = is; 2344 rs->id = id; 2345 init_timer(&rs->timer); 2346 rs->timer.data = (unsigned long)rs; 2347 rs->timer.function = isdn_ppp_ccp_timer_callback; 2348 is->reset->rs[id] = rs; 2349 } 2350 return rs; 2351} 2352 2353 2354/* A decompressor wants a reset with a set of parameters - do what is 2355 necessary to fulfill it */ 2356static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is, 2357 struct isdn_ppp_resetparams *rp) 2358{ 2359 struct ippp_ccp_reset_state *rs; 2360 2361 if(rp->valid) { 2362 /* The decompressor defines parameters by itself */ 2363 if(rp->rsend) { 2364 /* And he wants us to send a request */ 2365 if(!(rp->idval)) { 2366 printk(KERN_ERR "ippp_ccp: decompressor must" 2367 " specify reset id\n"); 2368 return; 2369 } 2370 if(is->reset->rs[rp->id]) { 2371 /* There is already a transaction in existence 2372 for this id. May be still waiting for a 2373 Ack or may be wrong. */ 2374 rs = is->reset->rs[rp->id]; 2375 if(rs->state == CCPResetSentReq && rs->ta) { 2376 printk(KERN_DEBUG "ippp_ccp: reset" 2377 " trans still in progress" 2378 " for id %d\n", rp->id); 2379 } else { 2380 printk(KERN_WARNING "ippp_ccp: reset" 2381 " trans in wrong state %d for" 2382 " id %d\n", rs->state, rp->id); 2383 } 2384 } else { 2385 /* Ok, this is a new transaction */ 2386 printk(KERN_DEBUG "ippp_ccp: new trans for id" 2387 " %d to be started\n", rp->id); 2388 rs = isdn_ppp_ccp_reset_alloc_state(is, rp->id); 2389 if(!rs) { 2390 printk(KERN_ERR "ippp_ccp: out of mem" 2391 " allocing ccp trans\n"); 2392 return; 2393 } 2394 rs->state = CCPResetSentReq; 2395 rs->expra = rp->expra; 2396 if(rp->dtval) { 2397 rs->dlen = rp->dlen; 2398 memcpy(rs->data, rp->data, rp->dlen); 2399 } 2400 /* HACK TODO - add link comp here */ 2401 isdn_ppp_ccp_xmit_reset(is, PPP_CCP, 2402 CCP_RESETREQ, rs->id, 2403 rs->data, rs->dlen); 2404 /* Start the timer */ 2405 rs->timer.expires = jiffies + 5*HZ; 2406 add_timer(&rs->timer); 2407 rs->ta = 1; 2408 } 2409 } else { 2410 printk(KERN_DEBUG "ippp_ccp: no reset sent\n"); 2411 } 2412 } else { 2413 /* The reset params are invalid. The decompressor does not 2414 care about them, so we just send the minimal requests 2415 and increase ids only when an Ack is received for a 2416 given id */ 2417 if(is->reset->rs[is->reset->lastid]) { 2418 /* There is already a transaction in existence 2419 for this id. May be still waiting for a 2420 Ack or may be wrong. */ 2421 rs = is->reset->rs[is->reset->lastid]; 2422 if(rs->state == CCPResetSentReq && rs->ta) { 2423 printk(KERN_DEBUG "ippp_ccp: reset" 2424 " trans still in progress" 2425 " for id %d\n", rp->id); 2426 } else { 2427 printk(KERN_WARNING "ippp_ccp: reset" 2428 " trans in wrong state %d for" 2429 " id %d\n", rs->state, rp->id); 2430 } 2431 } else { 2432 printk(KERN_DEBUG "ippp_ccp: new trans for id" 2433 " %d to be started\n", is->reset->lastid); 2434 rs = isdn_ppp_ccp_reset_alloc_state(is, 2435 is->reset->lastid); 2436 if(!rs) { 2437 printk(KERN_ERR "ippp_ccp: out of mem" 2438 " allocing ccp trans\n"); 2439 return; 2440 } 2441 rs->state = CCPResetSentReq; 2442 /* We always expect an Ack if the decompressor doesn't 2443 know better */ 2444 rs->expra = 1; 2445 rs->dlen = 0; 2446 /* HACK TODO - add link comp here */ 2447 isdn_ppp_ccp_xmit_reset(is, PPP_CCP, CCP_RESETREQ, 2448 rs->id, NULL, 0); 2449 /* Start the timer */ 2450 rs->timer.expires = jiffies + 5*HZ; 2451 add_timer(&rs->timer); 2452 rs->ta = 1; 2453 } 2454 } 2455} 2456 2457/* An Ack was received for this id. This means we stop the timer and clean 2458 up the state prior to calling the decompressors reset routine. */ 2459static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is, 2460 unsigned char id) 2461{ 2462 struct ippp_ccp_reset_state *rs = is->reset->rs[id]; 2463 2464 if(rs) { 2465 if(rs->ta && rs->state == CCPResetSentReq) { 2466 /* Great, we are correct */ 2467 if(!rs->expra) 2468 printk(KERN_DEBUG "ippp_ccp: ResetAck received" 2469 " for id %d but not expected\n", id); 2470 } else { 2471 printk(KERN_INFO "ippp_ccp: ResetAck received out of" 2472 "sync for id %d\n", id); 2473 } 2474 if(rs->ta) { 2475 rs->ta = 0; 2476 del_timer(&rs->timer); 2477 } 2478 isdn_ppp_ccp_reset_free_state(is, id); 2479 } else { 2480 printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id" 2481 " %d\n", id); 2482 } 2483 /* Make sure the simple reset stuff uses a new id next time */ 2484 is->reset->lastid++; 2485} 2486 2487/* 2488 * decompress packet 2489 * 2490 * if master = 0, we're trying to uncompress an per-link compressed packet, 2491 * as opposed to an compressed reconstructed-from-MPPP packet. 2492 * proto is updated to protocol field of uncompressed packet. 2493 * 2494 * retval: decompressed packet, 2495 * same packet if uncompressed, 2496 * NULL if decompression error 2497 */ 2498 2499static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb,struct ippp_struct *is,struct ippp_struct *master, 2500 int *proto) 2501{ 2502 void *stat = NULL; 2503 struct isdn_ppp_compressor *ipc = NULL; 2504 struct sk_buff *skb_out; 2505 int len; 2506 struct ippp_struct *ri; 2507 struct isdn_ppp_resetparams rsparm; 2508 unsigned char rsdata[IPPP_RESET_MAXDATABYTES]; 2509 2510 if(!master) { 2511 // per-link decompression 2512 stat = is->link_decomp_stat; 2513 ipc = is->link_decompressor; 2514 ri = is; 2515 } else { 2516 stat = master->decomp_stat; 2517 ipc = master->decompressor; 2518 ri = master; 2519 } 2520 2521 if (!ipc) { 2522 // no decompressor -> we can't decompress. 2523 printk(KERN_DEBUG "ippp: no decompressor defined!\n"); 2524 return skb; 2525 } 2526 BUG_ON(!stat); // if we have a compressor, stat has been set as well 2527 2528 if((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG) ) { 2529 // compressed packets are compressed by their protocol type 2530 2531 // Set up reset params for the decompressor 2532 memset(&rsparm, 0, sizeof(rsparm)); 2533 rsparm.data = rsdata; 2534 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES; 2535 2536 skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN); 2537 if (!skb_out) { 2538 kfree_skb(skb); 2539 printk(KERN_ERR "ippp: decomp memory allocation failure\n"); 2540 return NULL; 2541 } 2542 len = ipc->decompress(stat, skb, skb_out, &rsparm); 2543 kfree_skb(skb); 2544 if (len <= 0) { 2545 switch(len) { 2546 case DECOMP_ERROR: 2547 printk(KERN_INFO "ippp: decomp wants reset %s params\n", 2548 rsparm.valid ? "with" : "without"); 2549 2550 isdn_ppp_ccp_reset_trans(ri, &rsparm); 2551 break; 2552 case DECOMP_FATALERROR: 2553 ri->pppcfg |= SC_DC_FERROR; 2554 /* Kick ipppd to recognize the error */ 2555 isdn_ppp_ccp_kickup(ri); 2556 break; 2557 } 2558 kfree_skb(skb_out); 2559 return NULL; 2560 } 2561 *proto = isdn_ppp_strip_proto(skb_out); 2562 if (*proto < 0) { 2563 kfree_skb(skb_out); 2564 return NULL; 2565 } 2566 return skb_out; 2567 } else { 2568 // uncompressed packets are fed through the decompressor to 2569 // update the decompressor state 2570 ipc->incomp(stat, skb, *proto); 2571 return skb; 2572 } 2573} 2574 2575/* 2576 * compress a frame 2577 * type=0: normal/bundle compression 2578 * =1: link compression 2579 * returns original skb if we haven't compressed the frame 2580 * and a new skb pointer if we've done it 2581 */ 2582static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in,int *proto, 2583 struct ippp_struct *is,struct ippp_struct *master,int type) 2584{ 2585 int ret; 2586 int new_proto; 2587 struct isdn_ppp_compressor *compressor; 2588 void *stat; 2589 struct sk_buff *skb_out; 2590 2591 /* we do not compress control protocols */ 2592 if(*proto < 0 || *proto > 0x3fff) { 2593 return skb_in; 2594 } 2595 2596 if(type) { /* type=1 => Link compression */ 2597 return skb_in; 2598 } 2599 else { 2600 if(!master) { 2601 compressor = is->compressor; 2602 stat = is->comp_stat; 2603 } 2604 else { 2605 compressor = master->compressor; 2606 stat = master->comp_stat; 2607 } 2608 new_proto = PPP_COMP; 2609 } 2610 2611 if(!compressor) { 2612 printk(KERN_ERR "isdn_ppp: No compressor set!\n"); 2613 return skb_in; 2614 } 2615 if(!stat) { 2616 printk(KERN_ERR "isdn_ppp: Compressor not initialized?\n"); 2617 return skb_in; 2618 } 2619 2620 /* Allow for at least 150 % expansion (for now) */ 2621 skb_out = alloc_skb(skb_in->len + skb_in->len/2 + 32 + 2622 skb_headroom(skb_in), GFP_ATOMIC); 2623 if(!skb_out) 2624 return skb_in; 2625 skb_reserve(skb_out, skb_headroom(skb_in)); 2626 2627 ret = (compressor->compress)(stat,skb_in,skb_out,*proto); 2628 if(!ret) { 2629 dev_kfree_skb(skb_out); 2630 return skb_in; 2631 } 2632 2633 dev_kfree_skb(skb_in); 2634 *proto = new_proto; 2635 return skb_out; 2636} 2637 2638/* 2639 * we received a CCP frame .. 2640 * not a clean solution, but we MUST handle a few cases in the kernel 2641 */ 2642static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, 2643 struct sk_buff *skb,int proto) 2644{ 2645 struct ippp_struct *is; 2646 struct ippp_struct *mis; 2647 int len; 2648 struct isdn_ppp_resetparams rsparm; 2649 unsigned char rsdata[IPPP_RESET_MAXDATABYTES]; 2650 2651 printk(KERN_DEBUG "Received CCP frame from peer slot(%d)\n", 2652 lp->ppp_slot); 2653 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) { 2654 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n", 2655 __FUNCTION__, lp->ppp_slot); 2656 return; 2657 } 2658 is = ippp_table[lp->ppp_slot]; 2659 isdn_ppp_frame_log("ccp-rcv", skb->data, skb->len, 32, is->unit,lp->ppp_slot); 2660 2661 if(lp->master) { 2662 int slot = ((isdn_net_local *) (lp->master->priv))->ppp_slot; 2663 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 2664 printk(KERN_ERR "%s: slot(%d) out of range\n", 2665 __FUNCTION__, slot); 2666 return; 2667 } 2668 mis = ippp_table[slot]; 2669 } else 2670 mis = is; 2671 2672 switch(skb->data[0]) { 2673 case CCP_CONFREQ: 2674 if(is->debug & 0x10) 2675 printk(KERN_DEBUG "Disable compression here!\n"); 2676 if(proto == PPP_CCP) 2677 mis->compflags &= ~SC_COMP_ON; 2678 else 2679 is->compflags &= ~SC_LINK_COMP_ON; 2680 break; 2681 case CCP_TERMREQ: 2682 case CCP_TERMACK: 2683 if(is->debug & 0x10) 2684 printk(KERN_DEBUG "Disable (de)compression here!\n"); 2685 if(proto == PPP_CCP) 2686 mis->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON); 2687 else 2688 is->compflags &= ~(SC_LINK_DECOMP_ON|SC_LINK_COMP_ON); 2689 break; 2690 case CCP_CONFACK: 2691 /* if we RECEIVE an ackowledge we enable the decompressor */ 2692 if(is->debug & 0x10) 2693 printk(KERN_DEBUG "Enable decompression here!\n"); 2694 if(proto == PPP_CCP) { 2695 if (!mis->decompressor) 2696 break; 2697 mis->compflags |= SC_DECOMP_ON; 2698 } else { 2699 if (!is->decompressor) 2700 break; 2701 is->compflags |= SC_LINK_DECOMP_ON; 2702 } 2703 break; 2704 2705 case CCP_RESETACK: 2706 printk(KERN_DEBUG "Received ResetAck from peer\n"); 2707 len = (skb->data[2] << 8) | skb->data[3]; 2708 len -= 4; 2709 2710 if(proto == PPP_CCP) { 2711 /* If a reset Ack was outstanding for this id, then 2712 clean up the state engine */ 2713 isdn_ppp_ccp_reset_ack_rcvd(mis, skb->data[1]); 2714 if(mis->decompressor && mis->decomp_stat) 2715 mis->decompressor-> 2716 reset(mis->decomp_stat, 2717 skb->data[0], 2718 skb->data[1], 2719 len ? &skb->data[4] : NULL, 2720 len, NULL); 2721 /* TODO: This is not easy to decide here */ 2722 mis->compflags &= ~SC_DECOMP_DISCARD; 2723 } 2724 else { 2725 isdn_ppp_ccp_reset_ack_rcvd(is, skb->data[1]); 2726 if(is->link_decompressor && is->link_decomp_stat) 2727 is->link_decompressor-> 2728 reset(is->link_decomp_stat, 2729 skb->data[0], 2730 skb->data[1], 2731 len ? &skb->data[4] : NULL, 2732 len, NULL); 2733 /* TODO: neither here */ 2734 is->compflags &= ~SC_LINK_DECOMP_DISCARD; 2735 } 2736 break; 2737 2738 case CCP_RESETREQ: 2739 printk(KERN_DEBUG "Received ResetReq from peer\n"); 2740 /* Receiving a ResetReq means we must reset our compressor */ 2741 /* Set up reset params for the reset entry */ 2742 memset(&rsparm, 0, sizeof(rsparm)); 2743 rsparm.data = rsdata; 2744 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES; 2745 /* Isolate data length */ 2746 len = (skb->data[2] << 8) | skb->data[3]; 2747 len -= 4; 2748 if(proto == PPP_CCP) { 2749 if(mis->compressor && mis->comp_stat) 2750 mis->compressor-> 2751 reset(mis->comp_stat, 2752 skb->data[0], 2753 skb->data[1], 2754 len ? &skb->data[4] : NULL, 2755 len, &rsparm); 2756 } 2757 else { 2758 if(is->link_compressor && is->link_comp_stat) 2759 is->link_compressor-> 2760 reset(is->link_comp_stat, 2761 skb->data[0], 2762 skb->data[1], 2763 len ? &skb->data[4] : NULL, 2764 len, &rsparm); 2765 } 2766 /* Ack the Req as specified by rsparm */ 2767 if(rsparm.valid) { 2768 /* Compressor reset handler decided how to answer */ 2769 if(rsparm.rsend) { 2770 /* We should send a Frame */ 2771 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK, 2772 rsparm.idval ? rsparm.id 2773 : skb->data[1], 2774 rsparm.dtval ? 2775 rsparm.data : NULL, 2776 rsparm.dtval ? 2777 rsparm.dlen : 0); 2778 } else { 2779 printk(KERN_DEBUG "ResetAck suppressed\n"); 2780 } 2781 } else { 2782 /* We answer with a straight reflected Ack */ 2783 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK, 2784 skb->data[1], 2785 len ? &skb->data[4] : NULL, 2786 len); 2787 } 2788 break; 2789 } 2790} 2791 2792 2793/* 2794 * Daemon sends a CCP frame ... 2795 */ 2796 2797/* TODO: Clean this up with new Reset semantics */ 2798 2799/* I believe the CCP handling as-is is done wrong. Compressed frames 2800 * should only be sent/received after CCP reaches UP state, which means 2801 * both sides have sent CONF_ACK. Currently, we handle both directions 2802 * independently, which means we may accept compressed frames too early 2803 * (supposedly not a problem), but may also mean we send compressed frames 2804 * too early, which may turn out to be a problem. 2805 * This part of state machine should actually be handled by (i)pppd, but 2806 * that's too big of a change now. --kai 2807 */ 2808 2809/* Actually, we might turn this into an advantage: deal with the RFC in 2810 * the old tradition of beeing generous on what we accept, but beeing 2811 * strict on what we send. Thus we should just 2812 * - accept compressed frames as soon as decompression is negotiated 2813 * - send compressed frames only when decomp *and* comp are negotiated 2814 * - drop rx compressed frames if we cannot decomp (instead of pushing them 2815 * up to ipppd) 2816 * and I tried to modify this file according to that. --abp 2817 */ 2818 2819static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb) 2820{ 2821 struct ippp_struct *mis,*is; 2822 int proto, slot = lp->ppp_slot; 2823 unsigned char *data; 2824 2825 if(!skb || skb->len < 3) 2826 return; 2827 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 2828 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n", 2829 __FUNCTION__, slot); 2830 return; 2831 } 2832 is = ippp_table[slot]; 2833 /* Daemon may send with or without address and control field comp */ 2834 data = skb->data; 2835 if(!(is->pppcfg & SC_COMP_AC) && data[0] == 0xff && data[1] == 0x03) { 2836 data += 2; 2837 if(skb->len < 5) 2838 return; 2839 } 2840 2841 proto = ((int)data[0]<<8)+data[1]; 2842 if(proto != PPP_CCP && proto != PPP_CCPFRAG) 2843 return; 2844 2845 printk(KERN_DEBUG "Received CCP frame from daemon:\n"); 2846 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit,lp->ppp_slot); 2847 2848 if (lp->master) { 2849 slot = ((isdn_net_local *) (lp->master->priv))->ppp_slot; 2850 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) { 2851 printk(KERN_ERR "%s: slot(%d) out of range\n", 2852 __FUNCTION__, slot); 2853 return; 2854 } 2855 mis = ippp_table[slot]; 2856 } else 2857 mis = is; 2858 if (mis != is) 2859 printk(KERN_DEBUG "isdn_ppp: Ouch! Master CCP sends on slave slot!\n"); 2860 2861 switch(data[2]) { 2862 case CCP_CONFREQ: 2863 if(is->debug & 0x10) 2864 printk(KERN_DEBUG "Disable decompression here!\n"); 2865 if(proto == PPP_CCP) 2866 is->compflags &= ~SC_DECOMP_ON; 2867 else 2868 is->compflags &= ~SC_LINK_DECOMP_ON; 2869 break; 2870 case CCP_TERMREQ: 2871 case CCP_TERMACK: 2872 if(is->debug & 0x10) 2873 printk(KERN_DEBUG "Disable (de)compression here!\n"); 2874 if(proto == PPP_CCP) 2875 is->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON); 2876 else 2877 is->compflags &= ~(SC_LINK_DECOMP_ON|SC_LINK_COMP_ON); 2878 break; 2879 case CCP_CONFACK: 2880 /* if we SEND an ackowledge we can/must enable the compressor */ 2881 if(is->debug & 0x10) 2882 printk(KERN_DEBUG "Enable compression here!\n"); 2883 if(proto == PPP_CCP) { 2884 if (!is->compressor) 2885 break; 2886 is->compflags |= SC_COMP_ON; 2887 } else { 2888 if (!is->compressor) 2889 break; 2890 is->compflags |= SC_LINK_COMP_ON; 2891 } 2892 break; 2893 case CCP_RESETACK: 2894 /* If we send a ACK we should reset our compressor */ 2895 if(is->debug & 0x10) 2896 printk(KERN_DEBUG "Reset decompression state here!\n"); 2897 printk(KERN_DEBUG "ResetAck from daemon passed by\n"); 2898 if(proto == PPP_CCP) { 2899 /* link to master? */ 2900 if(is->compressor && is->comp_stat) 2901 is->compressor->reset(is->comp_stat, 0, 0, 2902 NULL, 0, NULL); 2903 is->compflags &= ~SC_COMP_DISCARD; 2904 } 2905 else { 2906 if(is->link_compressor && is->link_comp_stat) 2907 is->link_compressor->reset(is->link_comp_stat, 2908 0, 0, NULL, 0, NULL); 2909 is->compflags &= ~SC_LINK_COMP_DISCARD; 2910 } 2911 break; 2912 case CCP_RESETREQ: 2913 /* Just let it pass by */ 2914 printk(KERN_DEBUG "ResetReq from daemon passed by\n"); 2915 break; 2916 } 2917} 2918 2919int isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc) 2920{ 2921 ipc->next = ipc_head; 2922 ipc->prev = NULL; 2923 if(ipc_head) { 2924 ipc_head->prev = ipc; 2925 } 2926 ipc_head = ipc; 2927 return 0; 2928} 2929 2930int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc) 2931{ 2932 if(ipc->prev) 2933 ipc->prev->next = ipc->next; 2934 else 2935 ipc_head = ipc->next; 2936 if(ipc->next) 2937 ipc->next->prev = ipc->prev; 2938 ipc->prev = ipc->next = NULL; 2939 return 0; 2940} 2941 2942static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *data) 2943{ 2944 struct isdn_ppp_compressor *ipc = ipc_head; 2945 int ret; 2946 void *stat; 2947 int num = data->num; 2948 2949 if(is->debug & 0x10) 2950 printk(KERN_DEBUG "[%d] Set %s type %d\n",is->unit, 2951 (data->flags&IPPP_COMP_FLAG_XMIT)?"compressor":"decompressor",num); 2952 2953 /* If is has no valid reset state vector, we cannot allocate a 2954 decompressor. The decompressor would cause reset transactions 2955 sooner or later, and they need that vector. */ 2956 2957 if(!(data->flags & IPPP_COMP_FLAG_XMIT) && !is->reset) { 2958 printk(KERN_ERR "ippp_ccp: no reset data structure - can't" 2959 " allow decompression.\n"); 2960 return -ENOMEM; 2961 } 2962 2963 while(ipc) { 2964 if(ipc->num == num) { 2965 stat = ipc->alloc(data); 2966 if(stat) { 2967 ret = ipc->init(stat,data,is->unit,0); 2968 if(!ret) { 2969 printk(KERN_ERR "Can't init (de)compression!\n"); 2970 ipc->free(stat); 2971 stat = NULL; 2972 break; 2973 } 2974 } 2975 else { 2976 printk(KERN_ERR "Can't alloc (de)compression!\n"); 2977 break; 2978 } 2979 2980 if(data->flags & IPPP_COMP_FLAG_XMIT) { 2981 if(data->flags & IPPP_COMP_FLAG_LINK) { 2982 if(is->link_comp_stat) 2983 is->link_compressor->free(is->link_comp_stat); 2984 is->link_comp_stat = stat; 2985 is->link_compressor = ipc; 2986 } 2987 else { 2988 if(is->comp_stat) 2989 is->compressor->free(is->comp_stat); 2990 is->comp_stat = stat; 2991 is->compressor = ipc; 2992 } 2993 } 2994 else { 2995 if(data->flags & IPPP_COMP_FLAG_LINK) { 2996 if(is->link_decomp_stat) 2997 is->link_decompressor->free(is->link_decomp_stat); 2998 is->link_decomp_stat = stat; 2999 is->link_decompressor = ipc; 3000 } 3001 else { 3002 if(is->decomp_stat) 3003 is->decompressor->free(is->decomp_stat); 3004 is->decomp_stat = stat; 3005 is->decompressor = ipc; 3006 } 3007 } 3008 return 0; 3009 } 3010 ipc = ipc->next; 3011 } 3012 return -EINVAL; 3013} 3014