1/* $Id: isdn_net.c,v 1.1.1.1 2007/08/03 18:52:36 Exp $ 2 * 3 * Linux ISDN subsystem, network interfaces and related functions (linklevel). 4 * 5 * Copyright 1994-1998 by Fritz Elfert (fritz@isdn4linux.de) 6 * Copyright 1995,96 by Thinking Objects Software GmbH Wuerzburg 7 * Copyright 1995,96 by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de) 8 * 9 * This software may be used and distributed according to the terms 10 * of the GNU General Public License, incorporated herein by reference. 11 * 12 * Data Over Voice (DOV) support added - Guy Ellis 23-Mar-02 13 * guy@traverse.com.au 14 * Outgoing calls - looks for a 'V' in first char of dialed number 15 * Incoming calls - checks first character of eaz as follows: 16 * Numeric - accept DATA only - original functionality 17 * 'V' - accept VOICE (DOV) only 18 * 'B' - accept BOTH DATA and DOV types 19 * 20 * Jan 2001: fix CISCO HDLC Bjoern A. Zeeb <i4l@zabbadoz.net> 21 * for info on the protocol, see 22 * http://i4l.zabbadoz.net/i4l/cisco-hdlc.txt 23 */ 24 25#include <linux/isdn.h> 26#include <net/arp.h> 27#include <net/dst.h> 28#include <net/pkt_sched.h> 29#include <linux/inetdevice.h> 30#include "isdn_common.h" 31#include "isdn_net.h" 32#ifdef CONFIG_ISDN_PPP 33#include "isdn_ppp.h" 34#endif 35#ifdef CONFIG_ISDN_X25 36#include <linux/concap.h> 37#include "isdn_concap.h" 38#endif 39 40 41/* 42 * Outline of new tbusy handling: 43 * 44 * Old method, roughly spoken, consisted of setting tbusy when entering 45 * isdn_net_start_xmit() and at several other locations and clearing 46 * it from isdn_net_start_xmit() thread when sending was successful. 47 * 48 * With 2.3.x multithreaded network core, to prevent problems, tbusy should 49 * only be set by the isdn_net_start_xmit() thread and only when a tx-busy 50 * condition is detected. Other threads (in particular isdn_net_stat_callb()) 51 * are only allowed to clear tbusy. 52 * 53 * -HE 54 */ 55 56/* 57 * About SOFTNET: 58 * Most of the changes were pretty obvious and basically done by HE already. 59 * 60 * One problem of the isdn net device code is that is uses struct net_device 61 * for masters and slaves. However, only master interface are registered to 62 * the network layer, and therefore, it only makes sense to call netif_* 63 * functions on them. 64 * 65 * --KG 66 */ 67 68/* 69 * Find out if the netdevice has been ifup-ed yet. 70 * For slaves, look at the corresponding master. 71 */ 72static __inline__ int isdn_net_device_started(isdn_net_dev *n) 73{ 74 isdn_net_local *lp = n->local; 75 struct net_device *dev; 76 77 if (lp->master) 78 dev = lp->master; 79 else 80 dev = &n->dev; 81 return netif_running(dev); 82} 83 84/* 85 * wake up the network -> net_device queue. 86 * For slaves, wake the corresponding master interface. 87 */ 88static __inline__ void isdn_net_device_wake_queue(isdn_net_local *lp) 89{ 90 if (lp->master) 91 netif_wake_queue(lp->master); 92 else 93 netif_wake_queue(&lp->netdev->dev); 94} 95 96/* 97 * stop the network -> net_device queue. 98 * For slaves, stop the corresponding master interface. 99 */ 100static __inline__ void isdn_net_device_stop_queue(isdn_net_local *lp) 101{ 102 if (lp->master) 103 netif_stop_queue(lp->master); 104 else 105 netif_stop_queue(&lp->netdev->dev); 106} 107 108/* 109 * find out if the net_device which this lp belongs to (lp can be 110 * master or slave) is busy. It's busy iff all (master and slave) 111 * queues are busy 112 */ 113static __inline__ int isdn_net_device_busy(isdn_net_local *lp) 114{ 115 isdn_net_local *nlp; 116 isdn_net_dev *nd; 117 unsigned long flags; 118 119 if (!isdn_net_lp_busy(lp)) 120 return 0; 121 122 if (lp->master) 123 nd = ((isdn_net_local *) lp->master->priv)->netdev; 124 else 125 nd = lp->netdev; 126 127 spin_lock_irqsave(&nd->queue_lock, flags); 128 nlp = lp->next; 129 while (nlp != lp) { 130 if (!isdn_net_lp_busy(nlp)) { 131 spin_unlock_irqrestore(&nd->queue_lock, flags); 132 return 0; 133 } 134 nlp = nlp->next; 135 } 136 spin_unlock_irqrestore(&nd->queue_lock, flags); 137 return 1; 138} 139 140static __inline__ void isdn_net_inc_frame_cnt(isdn_net_local *lp) 141{ 142 atomic_inc(&lp->frame_cnt); 143 if (isdn_net_device_busy(lp)) 144 isdn_net_device_stop_queue(lp); 145} 146 147static __inline__ void isdn_net_dec_frame_cnt(isdn_net_local *lp) 148{ 149 atomic_dec(&lp->frame_cnt); 150 151 if (!(isdn_net_device_busy(lp))) { 152 if (!skb_queue_empty(&lp->super_tx_queue)) { 153 schedule_work(&lp->tqueue); 154 } else { 155 isdn_net_device_wake_queue(lp); 156 } 157 } 158} 159 160static __inline__ void isdn_net_zero_frame_cnt(isdn_net_local *lp) 161{ 162 atomic_set(&lp->frame_cnt, 0); 163} 164 165/* For 2.2.x we leave the transmitter busy timeout at 2 secs, just 166 * to be safe. 167 * For 2.3.x we push it up to 20 secs, because call establishment 168 * (in particular callback) may take such a long time, and we 169 * don't want confusing messages in the log. However, there is a slight 170 * possibility that this large timeout will break other things like MPPP, 171 * which might rely on the tx timeout. If so, we'll find out this way... 172 */ 173 174#define ISDN_NET_TX_TIMEOUT (20*HZ) 175 176/* Prototypes */ 177 178static int isdn_net_force_dial_lp(isdn_net_local *); 179static int isdn_net_start_xmit(struct sk_buff *, struct net_device *); 180 181static void isdn_net_ciscohdlck_connected(isdn_net_local *lp); 182static void isdn_net_ciscohdlck_disconnected(isdn_net_local *lp); 183 184char *isdn_net_revision = "$Revision: 1.1.1.1 $"; 185 186 /* 187 * Code for raw-networking over ISDN 188 */ 189 190static void 191isdn_net_unreachable(struct net_device *dev, struct sk_buff *skb, char *reason) 192{ 193 if(skb) { 194 195 u_short proto = ntohs(skb->protocol); 196 197 printk(KERN_DEBUG "isdn_net: %s: %s, signalling dst_link_failure %s\n", 198 dev->name, 199 (reason != NULL) ? reason : "unknown", 200 (proto != ETH_P_IP) ? "Protocol != ETH_P_IP" : ""); 201 202 dst_link_failure(skb); 203 } 204 else { /* dial not triggered by rawIP packet */ 205 printk(KERN_DEBUG "isdn_net: %s: %s\n", 206 dev->name, 207 (reason != NULL) ? reason : "reason unknown"); 208 } 209} 210 211static void 212isdn_net_reset(struct net_device *dev) 213{ 214#ifdef CONFIG_ISDN_X25 215 struct concap_device_ops * dops = 216 ( (isdn_net_local *) dev->priv ) -> dops; 217 struct concap_proto * cprot = 218 ( (isdn_net_local *) dev->priv ) -> netdev -> cprot; 219#endif 220#ifdef CONFIG_ISDN_X25 221 if( cprot && cprot -> pops && dops ) 222 cprot -> pops -> restart ( cprot, dev, dops ); 223#endif 224} 225 226/* Open/initialize the board. */ 227static int 228isdn_net_open(struct net_device *dev) 229{ 230 int i; 231 struct net_device *p; 232 struct in_device *in_dev; 233 234 /* moved here from isdn_net_reset, because only the master has an 235 interface associated which is supposed to be started. BTW: 236 we need to call netif_start_queue, not netif_wake_queue here */ 237 netif_start_queue(dev); 238 239 isdn_net_reset(dev); 240 /* Fill in the MAC-level header (not needed, but for compatibility... */ 241 for (i = 0; i < ETH_ALEN - sizeof(u32); i++) 242 dev->dev_addr[i] = 0xfc; 243 if ((in_dev = dev->ip_ptr) != NULL) { 244 /* 245 * Any address will do - we take the first 246 */ 247 struct in_ifaddr *ifa = in_dev->ifa_list; 248 if (ifa != NULL) 249 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4); 250 } 251 252 /* If this interface has slaves, start them also */ 253 254 if ((p = (((isdn_net_local *) dev->priv)->slave))) { 255 while (p) { 256 isdn_net_reset(p); 257 p = (((isdn_net_local *) p->priv)->slave); 258 } 259 } 260 isdn_lock_drivers(); 261 return 0; 262} 263 264/* 265 * Assign an ISDN-channel to a net-interface 266 */ 267static void 268isdn_net_bind_channel(isdn_net_local * lp, int idx) 269{ 270 lp->flags |= ISDN_NET_CONNECTED; 271 lp->isdn_device = dev->drvmap[idx]; 272 lp->isdn_channel = dev->chanmap[idx]; 273 dev->rx_netdev[idx] = lp->netdev; 274 dev->st_netdev[idx] = lp->netdev; 275} 276 277/* 278 * unbind a net-interface (resets interface after an error) 279 */ 280static void 281isdn_net_unbind_channel(isdn_net_local * lp) 282{ 283 skb_queue_purge(&lp->super_tx_queue); 284 285 if (!lp->master) { /* reset only master device */ 286 /* Moral equivalent of dev_purge_queues(): 287 BEWARE! This chunk of code cannot be called from hardware 288 interrupt handler. I hope it is true. --ANK 289 */ 290 qdisc_reset(lp->netdev->dev.qdisc); 291 } 292 lp->dialstate = 0; 293 dev->rx_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL; 294 dev->st_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL; 295 isdn_free_channel(lp->isdn_device, lp->isdn_channel, ISDN_USAGE_NET); 296 lp->flags &= ~ISDN_NET_CONNECTED; 297 lp->isdn_device = -1; 298 lp->isdn_channel = -1; 299} 300 301/* 302 * Perform auto-hangup and cps-calculation for net-interfaces. 303 * 304 * auto-hangup: 305 * Increment idle-counter (this counter is reset on any incoming or 306 * outgoing packet), if counter exceeds configured limit either do a 307 * hangup immediately or - if configured - wait until just before the next 308 * charge-info. 309 * 310 * cps-calculation (needed for dynamic channel-bundling): 311 * Since this function is called every second, simply reset the 312 * byte-counter of the interface after copying it to the cps-variable. 313 */ 314static unsigned long last_jiffies = -HZ; 315 316void 317isdn_net_autohup(void) 318{ 319 isdn_net_dev *p = dev->netdev; 320 int anymore; 321 322 anymore = 0; 323 while (p) { 324 isdn_net_local *l = p->local; 325 if (jiffies == last_jiffies) 326 l->cps = l->transcount; 327 else 328 l->cps = (l->transcount * HZ) / (jiffies - last_jiffies); 329 l->transcount = 0; 330 if (dev->net_verbose > 3) 331 printk(KERN_DEBUG "%s: %d bogocps\n", l->name, l->cps); 332 if ((l->flags & ISDN_NET_CONNECTED) && (!l->dialstate)) { 333 anymore = 1; 334 l->huptimer++; 335 /* 336 * if there is some dialmode where timeout-hangup 337 * should _not_ be done, check for that here 338 */ 339 if ((l->onhtime) && 340 (l->huptimer > l->onhtime)) 341 { 342 if (l->hupflags & ISDN_MANCHARGE && 343 l->hupflags & ISDN_CHARGEHUP) { 344 while (time_after(jiffies, l->chargetime + l->chargeint)) 345 l->chargetime += l->chargeint; 346 if (time_after(jiffies, l->chargetime + l->chargeint - 2 * HZ)) 347 if (l->outgoing || l->hupflags & ISDN_INHUP) 348 isdn_net_hangup(&p->dev); 349 } else if (l->outgoing) { 350 if (l->hupflags & ISDN_CHARGEHUP) { 351 if (l->hupflags & ISDN_WAITCHARGE) { 352 printk(KERN_DEBUG "isdn_net: Hupflags of %s are %X\n", 353 l->name, l->hupflags); 354 isdn_net_hangup(&p->dev); 355 } else if (time_after(jiffies, l->chargetime + l->chargeint)) { 356 printk(KERN_DEBUG 357 "isdn_net: %s: chtime = %lu, chint = %d\n", 358 l->name, l->chargetime, l->chargeint); 359 isdn_net_hangup(&p->dev); 360 } 361 } else 362 isdn_net_hangup(&p->dev); 363 } else if (l->hupflags & ISDN_INHUP) 364 isdn_net_hangup(&p->dev); 365 } 366 367 if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*l) == ISDN_NET_DM_OFF)) { 368 isdn_net_hangup(&p->dev); 369 break; 370 } 371 } 372 p = (isdn_net_dev *) p->next; 373 } 374 last_jiffies = jiffies; 375 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, anymore); 376} 377 378static void isdn_net_lp_disconnected(isdn_net_local *lp) 379{ 380 isdn_net_rm_from_bundle(lp); 381} 382 383/* 384 * Handle status-messages from ISDN-interfacecard. 385 * This function is called from within the main-status-dispatcher 386 * isdn_status_callback, which itself is called from the low-level driver. 387 * Return: 1 = Event handled, 0 = not for us or unknown Event. 388 */ 389int 390isdn_net_stat_callback(int idx, isdn_ctrl *c) 391{ 392 isdn_net_dev *p = dev->st_netdev[idx]; 393 int cmd = c->command; 394 395 if (p) { 396 isdn_net_local *lp = p->local; 397#ifdef CONFIG_ISDN_X25 398 struct concap_proto *cprot = lp->netdev->cprot; 399 struct concap_proto_ops *pops = cprot ? cprot->pops : NULL; 400#endif 401 switch (cmd) { 402 case ISDN_STAT_BSENT: 403 /* A packet has successfully been sent out */ 404 if ((lp->flags & ISDN_NET_CONNECTED) && 405 (!lp->dialstate)) { 406 isdn_net_dec_frame_cnt(lp); 407 lp->stats.tx_packets++; 408 lp->stats.tx_bytes += c->parm.length; 409 } 410 return 1; 411 case ISDN_STAT_DCONN: 412 /* D-Channel is up */ 413 switch (lp->dialstate) { 414 case 4: 415 case 7: 416 case 8: 417 lp->dialstate++; 418 return 1; 419 case 12: 420 lp->dialstate = 5; 421 return 1; 422 } 423 break; 424 case ISDN_STAT_DHUP: 425 /* Either D-Channel-hangup or error during dialout */ 426#ifdef CONFIG_ISDN_X25 427 /* If we are not connencted then dialing had 428 failed. If there are generic encap protocol 429 receiver routines signal the closure of 430 the link*/ 431 432 if( !(lp->flags & ISDN_NET_CONNECTED) 433 && pops && pops -> disconn_ind ) 434 pops -> disconn_ind(cprot); 435#endif /* CONFIG_ISDN_X25 */ 436 if ((!lp->dialstate) && (lp->flags & ISDN_NET_CONNECTED)) { 437 if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK) 438 isdn_net_ciscohdlck_disconnected(lp); 439#ifdef CONFIG_ISDN_PPP 440 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) 441 isdn_ppp_free(lp); 442#endif 443 isdn_net_lp_disconnected(lp); 444 isdn_all_eaz(lp->isdn_device, lp->isdn_channel); 445 printk(KERN_INFO "%s: remote hangup\n", lp->name); 446 printk(KERN_INFO "%s: Chargesum is %d\n", lp->name, 447 lp->charge); 448 isdn_net_unbind_channel(lp); 449 return 1; 450 } 451 break; 452#ifdef CONFIG_ISDN_X25 453 case ISDN_STAT_BHUP: 454 /* B-Channel-hangup */ 455 /* try if there are generic encap protocol 456 receiver routines and signal the closure of 457 the link */ 458 if( pops && pops -> disconn_ind ){ 459 pops -> disconn_ind(cprot); 460 return 1; 461 } 462 break; 463#endif /* CONFIG_ISDN_X25 */ 464 case ISDN_STAT_BCONN: 465 /* B-Channel is up */ 466 isdn_net_zero_frame_cnt(lp); 467 switch (lp->dialstate) { 468 case 5: 469 case 6: 470 case 7: 471 case 8: 472 case 9: 473 case 10: 474 case 12: 475 if (lp->dialstate <= 6) { 476 dev->usage[idx] |= ISDN_USAGE_OUTGOING; 477 isdn_info_update(); 478 } else 479 dev->rx_netdev[idx] = p; 480 lp->dialstate = 0; 481 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 1); 482 if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK) 483 isdn_net_ciscohdlck_connected(lp); 484 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP) { 485 if (lp->master) { /* is lp a slave? */ 486 isdn_net_dev *nd = ((isdn_net_local *)lp->master->priv)->netdev; 487 isdn_net_add_to_bundle(nd, lp); 488 } 489 } 490 printk(KERN_INFO "isdn_net: %s connected\n", lp->name); 491 /* If first Chargeinfo comes before B-Channel connect, 492 * we correct the timestamp here. 493 */ 494 lp->chargetime = jiffies; 495 496 /* reset dial-timeout */ 497 lp->dialstarted = 0; 498 lp->dialwait_timer = 0; 499 500#ifdef CONFIG_ISDN_PPP 501 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) 502 isdn_ppp_wakeup_daemon(lp); 503#endif 504#ifdef CONFIG_ISDN_X25 505 /* try if there are generic concap receiver routines */ 506 if( pops ) 507 if( pops->connect_ind) 508 pops->connect_ind(cprot); 509#endif /* CONFIG_ISDN_X25 */ 510 /* ppp needs to do negotiations first */ 511 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP) 512 isdn_net_device_wake_queue(lp); 513 return 1; 514 } 515 break; 516 case ISDN_STAT_NODCH: 517 /* No D-Channel avail. */ 518 if (lp->dialstate == 4) { 519 lp->dialstate--; 520 return 1; 521 } 522 break; 523 case ISDN_STAT_CINF: 524 /* Charge-info from TelCo. Calculate interval between 525 * charge-infos and set timestamp for last info for 526 * usage by isdn_net_autohup() 527 */ 528 lp->charge++; 529 if (lp->hupflags & ISDN_HAVECHARGE) { 530 lp->hupflags &= ~ISDN_WAITCHARGE; 531 lp->chargeint = jiffies - lp->chargetime - (2 * HZ); 532 } 533 if (lp->hupflags & ISDN_WAITCHARGE) 534 lp->hupflags |= ISDN_HAVECHARGE; 535 lp->chargetime = jiffies; 536 printk(KERN_DEBUG "isdn_net: Got CINF chargetime of %s now %lu\n", 537 lp->name, lp->chargetime); 538 return 1; 539 } 540 } 541 return 0; 542} 543 544/* 545 * Perform dialout for net-interfaces and timeout-handling for 546 * D-Channel-up and B-Channel-up Messages. 547 * This function is initially called from within isdn_net_start_xmit() or 548 * or isdn_net_find_icall() after initializing the dialstate for an 549 * interface. If further calls are needed, the function schedules itself 550 * for a timer-callback via isdn_timer_function(). 551 * The dialstate is also affected by incoming status-messages from 552 * the ISDN-Channel which are handled in isdn_net_stat_callback() above. 553 */ 554void 555isdn_net_dial(void) 556{ 557 isdn_net_dev *p = dev->netdev; 558 int anymore = 0; 559 int i; 560 isdn_ctrl cmd; 561 u_char *phone_number; 562 563 while (p) { 564 isdn_net_local *lp = p->local; 565 566#ifdef ISDN_DEBUG_NET_DIAL 567 if (lp->dialstate) 568 printk(KERN_DEBUG "%s: dialstate=%d\n", lp->name, lp->dialstate); 569#endif 570 switch (lp->dialstate) { 571 case 0: 572 /* Nothing to do for this interface */ 573 break; 574 case 1: 575 /* Initiate dialout. Set phone-number-pointer to first number 576 * of interface. 577 */ 578 lp->dial = lp->phone[1]; 579 if (!lp->dial) { 580 printk(KERN_WARNING "%s: phone number deleted?\n", 581 lp->name); 582 isdn_net_hangup(&p->dev); 583 break; 584 } 585 anymore = 1; 586 587 if(lp->dialtimeout > 0) 588 if(lp->dialstarted == 0 || time_after(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait)) { 589 lp->dialstarted = jiffies; 590 lp->dialwait_timer = 0; 591 } 592 593 lp->dialstate++; 594 /* Fall through */ 595 case 2: 596 /* Prepare dialing. Clear EAZ, then set EAZ. */ 597 cmd.driver = lp->isdn_device; 598 cmd.arg = lp->isdn_channel; 599 cmd.command = ISDN_CMD_CLREAZ; 600 isdn_command(&cmd); 601 sprintf(cmd.parm.num, "%s", isdn_map_eaz2msn(lp->msn, cmd.driver)); 602 cmd.command = ISDN_CMD_SETEAZ; 603 isdn_command(&cmd); 604 lp->dialretry = 0; 605 anymore = 1; 606 lp->dialstate++; 607 /* Fall through */ 608 case 3: 609 /* Setup interface, dial current phone-number, switch to next number. 610 * If list of phone-numbers is exhausted, increment 611 * retry-counter. 612 */ 613 if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF)) { 614 char *s; 615 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 616 s = "dial suppressed: isdn system stopped"; 617 else 618 s = "dial suppressed: dialmode `off'"; 619 isdn_net_unreachable(&p->dev, NULL, s); 620 isdn_net_hangup(&p->dev); 621 break; 622 } 623 cmd.driver = lp->isdn_device; 624 cmd.command = ISDN_CMD_SETL2; 625 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8); 626 isdn_command(&cmd); 627 cmd.driver = lp->isdn_device; 628 cmd.command = ISDN_CMD_SETL3; 629 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8); 630 isdn_command(&cmd); 631 cmd.driver = lp->isdn_device; 632 cmd.arg = lp->isdn_channel; 633 if (!lp->dial) { 634 printk(KERN_WARNING "%s: phone number deleted?\n", 635 lp->name); 636 isdn_net_hangup(&p->dev); 637 break; 638 } 639 if (!strncmp(lp->dial->num, "LEASED", strlen("LEASED"))) { 640 lp->dialstate = 4; 641 printk(KERN_INFO "%s: Open leased line ...\n", lp->name); 642 } else { 643 if(lp->dialtimeout > 0) 644 if (time_after(jiffies, lp->dialstarted + lp->dialtimeout)) { 645 lp->dialwait_timer = jiffies + lp->dialwait; 646 lp->dialstarted = 0; 647 isdn_net_unreachable(&p->dev, NULL, "dial: timed out"); 648 isdn_net_hangup(&p->dev); 649 break; 650 } 651 652 cmd.driver = lp->isdn_device; 653 cmd.command = ISDN_CMD_DIAL; 654 cmd.parm.setup.si2 = 0; 655 656 /* check for DOV */ 657 phone_number = lp->dial->num; 658 if ((*phone_number == 'v') || 659 (*phone_number == 'V')) { /* DOV call */ 660 cmd.parm.setup.si1 = 1; 661 } else { /* DATA call */ 662 cmd.parm.setup.si1 = 7; 663 } 664 665 strcpy(cmd.parm.setup.phone, phone_number); 666 /* 667 * Switch to next number or back to start if at end of list. 668 */ 669 if (!(lp->dial = (isdn_net_phone *) lp->dial->next)) { 670 lp->dial = lp->phone[1]; 671 lp->dialretry++; 672 673 if (lp->dialretry > lp->dialmax) { 674 if (lp->dialtimeout == 0) { 675 lp->dialwait_timer = jiffies + lp->dialwait; 676 lp->dialstarted = 0; 677 isdn_net_unreachable(&p->dev, NULL, "dial: tried all numbers dialmax times"); 678 } 679 isdn_net_hangup(&p->dev); 680 break; 681 } 682 } 683 sprintf(cmd.parm.setup.eazmsn, "%s", 684 isdn_map_eaz2msn(lp->msn, cmd.driver)); 685 i = isdn_dc2minor(lp->isdn_device, lp->isdn_channel); 686 if (i >= 0) { 687 strcpy(dev->num[i], cmd.parm.setup.phone); 688 dev->usage[i] |= ISDN_USAGE_OUTGOING; 689 isdn_info_update(); 690 } 691 printk(KERN_INFO "%s: dialing %d %s... %s\n", lp->name, 692 lp->dialretry, cmd.parm.setup.phone, 693 (cmd.parm.setup.si1 == 1) ? "DOV" : ""); 694 lp->dtimer = 0; 695#ifdef ISDN_DEBUG_NET_DIAL 696 printk(KERN_DEBUG "dial: d=%d c=%d\n", lp->isdn_device, 697 lp->isdn_channel); 698#endif 699 isdn_command(&cmd); 700 } 701 lp->huptimer = 0; 702 lp->outgoing = 1; 703 if (lp->chargeint) { 704 lp->hupflags |= ISDN_HAVECHARGE; 705 lp->hupflags &= ~ISDN_WAITCHARGE; 706 } else { 707 lp->hupflags |= ISDN_WAITCHARGE; 708 lp->hupflags &= ~ISDN_HAVECHARGE; 709 } 710 anymore = 1; 711 lp->dialstate = 712 (lp->cbdelay && 713 (lp->flags & ISDN_NET_CBOUT)) ? 12 : 4; 714 break; 715 case 4: 716 /* Wait for D-Channel-connect. 717 * If timeout, switch back to state 3. 718 * Dialmax-handling moved to state 3. 719 */ 720 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10) 721 lp->dialstate = 3; 722 anymore = 1; 723 break; 724 case 5: 725 /* Got D-Channel-Connect, send B-Channel-request */ 726 cmd.driver = lp->isdn_device; 727 cmd.arg = lp->isdn_channel; 728 cmd.command = ISDN_CMD_ACCEPTB; 729 anymore = 1; 730 lp->dtimer = 0; 731 lp->dialstate++; 732 isdn_command(&cmd); 733 break; 734 case 6: 735 /* Wait for B- or D-Channel-connect. If timeout, 736 * switch back to state 3. 737 */ 738#ifdef ISDN_DEBUG_NET_DIAL 739 printk(KERN_DEBUG "dialtimer2: %d\n", lp->dtimer); 740#endif 741 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10) 742 lp->dialstate = 3; 743 anymore = 1; 744 break; 745 case 7: 746 /* Got incoming Call, setup L2 and L3 protocols, 747 * then wait for D-Channel-connect 748 */ 749#ifdef ISDN_DEBUG_NET_DIAL 750 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer); 751#endif 752 cmd.driver = lp->isdn_device; 753 cmd.command = ISDN_CMD_SETL2; 754 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8); 755 isdn_command(&cmd); 756 cmd.driver = lp->isdn_device; 757 cmd.command = ISDN_CMD_SETL3; 758 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8); 759 isdn_command(&cmd); 760 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT15) 761 isdn_net_hangup(&p->dev); 762 else { 763 anymore = 1; 764 lp->dialstate++; 765 } 766 break; 767 case 9: 768 /* Got incoming D-Channel-Connect, send B-Channel-request */ 769 cmd.driver = lp->isdn_device; 770 cmd.arg = lp->isdn_channel; 771 cmd.command = ISDN_CMD_ACCEPTB; 772 isdn_command(&cmd); 773 anymore = 1; 774 lp->dtimer = 0; 775 lp->dialstate++; 776 break; 777 case 8: 778 case 10: 779 /* Wait for B- or D-channel-connect */ 780#ifdef ISDN_DEBUG_NET_DIAL 781 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer); 782#endif 783 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10) 784 isdn_net_hangup(&p->dev); 785 else 786 anymore = 1; 787 break; 788 case 11: 789 /* Callback Delay */ 790 if (lp->dtimer++ > lp->cbdelay) 791 lp->dialstate = 1; 792 anymore = 1; 793 break; 794 case 12: 795 /* Remote does callback. Hangup after cbdelay, then wait for incoming 796 * call (in state 4). 797 */ 798 if (lp->dtimer++ > lp->cbdelay) 799 { 800 printk(KERN_INFO "%s: hangup waiting for callback ...\n", lp->name); 801 lp->dtimer = 0; 802 lp->dialstate = 4; 803 cmd.driver = lp->isdn_device; 804 cmd.command = ISDN_CMD_HANGUP; 805 cmd.arg = lp->isdn_channel; 806 isdn_command(&cmd); 807 isdn_all_eaz(lp->isdn_device, lp->isdn_channel); 808 } 809 anymore = 1; 810 break; 811 default: 812 printk(KERN_WARNING "isdn_net: Illegal dialstate %d for device %s\n", 813 lp->dialstate, lp->name); 814 } 815 p = (isdn_net_dev *) p->next; 816 } 817 isdn_timer_ctrl(ISDN_TIMER_NETDIAL, anymore); 818} 819 820/* 821 * Perform hangup for a net-interface. 822 */ 823void 824isdn_net_hangup(struct net_device *d) 825{ 826 isdn_net_local *lp = (isdn_net_local *) d->priv; 827 isdn_ctrl cmd; 828#ifdef CONFIG_ISDN_X25 829 struct concap_proto *cprot = lp->netdev->cprot; 830 struct concap_proto_ops *pops = cprot ? cprot->pops : NULL; 831#endif 832 833 if (lp->flags & ISDN_NET_CONNECTED) { 834 if (lp->slave != NULL) { 835 isdn_net_local *slp = (isdn_net_local *)lp->slave->priv; 836 if (slp->flags & ISDN_NET_CONNECTED) { 837 printk(KERN_INFO 838 "isdn_net: hang up slave %s before %s\n", 839 slp->name, lp->name); 840 isdn_net_hangup(lp->slave); 841 } 842 } 843 printk(KERN_INFO "isdn_net: local hangup %s\n", lp->name); 844#ifdef CONFIG_ISDN_PPP 845 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) 846 isdn_ppp_free(lp); 847#endif 848 isdn_net_lp_disconnected(lp); 849#ifdef CONFIG_ISDN_X25 850 /* try if there are generic encap protocol 851 receiver routines and signal the closure of 852 the link */ 853 if( pops && pops -> disconn_ind ) 854 pops -> disconn_ind(cprot); 855#endif /* CONFIG_ISDN_X25 */ 856 857 cmd.driver = lp->isdn_device; 858 cmd.command = ISDN_CMD_HANGUP; 859 cmd.arg = lp->isdn_channel; 860 isdn_command(&cmd); 861 printk(KERN_INFO "%s: Chargesum is %d\n", lp->name, lp->charge); 862 isdn_all_eaz(lp->isdn_device, lp->isdn_channel); 863 } 864 isdn_net_unbind_channel(lp); 865} 866 867typedef struct { 868 unsigned short source; 869 unsigned short dest; 870} ip_ports; 871 872static void 873isdn_net_log_skb(struct sk_buff * skb, isdn_net_local * lp) 874{ 875 /* hopefully, this was set correctly */ 876 const u_char *p = skb_network_header(skb); 877 unsigned short proto = ntohs(skb->protocol); 878 int data_ofs; 879 ip_ports *ipp; 880 char addinfo[100]; 881 882 addinfo[0] = '\0'; 883 /* This check stolen from 2.1.72 dev_queue_xmit_nit() */ 884 if (p < skb->data || skb->network_header >= skb->tail) { 885 /* fall back to old isdn_net_log_packet method() */ 886 char * buf = skb->data; 887 888 printk(KERN_DEBUG "isdn_net: protocol %04x is buggy, dev %s\n", skb->protocol, lp->name); 889 p = buf; 890 proto = ETH_P_IP; 891 switch (lp->p_encap) { 892 case ISDN_NET_ENCAP_IPTYP: 893 proto = ntohs(*(unsigned short *) &buf[0]); 894 p = &buf[2]; 895 break; 896 case ISDN_NET_ENCAP_ETHER: 897 proto = ntohs(*(unsigned short *) &buf[12]); 898 p = &buf[14]; 899 break; 900 case ISDN_NET_ENCAP_CISCOHDLC: 901 proto = ntohs(*(unsigned short *) &buf[2]); 902 p = &buf[4]; 903 break; 904#ifdef CONFIG_ISDN_PPP 905 case ISDN_NET_ENCAP_SYNCPPP: 906 proto = ntohs(skb->protocol); 907 p = &buf[IPPP_MAX_HEADER]; 908 break; 909#endif 910 } 911 } 912 data_ofs = ((p[0] & 15) * 4); 913 switch (proto) { 914 case ETH_P_IP: 915 switch (p[9]) { 916 case 1: 917 strcpy(addinfo, " ICMP"); 918 break; 919 case 2: 920 strcpy(addinfo, " IGMP"); 921 break; 922 case 4: 923 strcpy(addinfo, " IPIP"); 924 break; 925 case 6: 926 ipp = (ip_ports *) (&p[data_ofs]); 927 sprintf(addinfo, " TCP, port: %d -> %d", ntohs(ipp->source), 928 ntohs(ipp->dest)); 929 break; 930 case 8: 931 strcpy(addinfo, " EGP"); 932 break; 933 case 12: 934 strcpy(addinfo, " PUP"); 935 break; 936 case 17: 937 ipp = (ip_ports *) (&p[data_ofs]); 938 sprintf(addinfo, " UDP, port: %d -> %d", ntohs(ipp->source), 939 ntohs(ipp->dest)); 940 break; 941 case 22: 942 strcpy(addinfo, " IDP"); 943 break; 944 } 945 printk(KERN_INFO 946 "OPEN: %d.%d.%d.%d -> %d.%d.%d.%d%s\n", 947 948 p[12], p[13], p[14], p[15], 949 p[16], p[17], p[18], p[19], 950 addinfo); 951 break; 952 case ETH_P_ARP: 953 printk(KERN_INFO 954 "OPEN: ARP %d.%d.%d.%d -> *.*.*.* ?%d.%d.%d.%d\n", 955 p[14], p[15], p[16], p[17], 956 p[24], p[25], p[26], p[27]); 957 break; 958 } 959} 960 961/* 962 * this function is used to send supervisory data, i.e. data which was 963 * not received from the network layer, but e.g. frames from ipppd, CCP 964 * reset frames etc. 965 */ 966void isdn_net_write_super(isdn_net_local *lp, struct sk_buff *skb) 967{ 968 if (in_irq()) { 969 // we can't grab the lock from irq context, 970 // so we just queue the packet 971 skb_queue_tail(&lp->super_tx_queue, skb); 972 schedule_work(&lp->tqueue); 973 return; 974 } 975 976 spin_lock_bh(&lp->xmit_lock); 977 if (!isdn_net_lp_busy(lp)) { 978 isdn_net_writebuf_skb(lp, skb); 979 } else { 980 skb_queue_tail(&lp->super_tx_queue, skb); 981 } 982 spin_unlock_bh(&lp->xmit_lock); 983} 984 985/* 986 * called from tq_immediate 987 */ 988static void isdn_net_softint(struct work_struct *work) 989{ 990 isdn_net_local *lp = container_of(work, isdn_net_local, tqueue); 991 struct sk_buff *skb; 992 993 spin_lock_bh(&lp->xmit_lock); 994 while (!isdn_net_lp_busy(lp)) { 995 skb = skb_dequeue(&lp->super_tx_queue); 996 if (!skb) 997 break; 998 isdn_net_writebuf_skb(lp, skb); 999 } 1000 spin_unlock_bh(&lp->xmit_lock); 1001} 1002 1003/* 1004 * all frames sent from the (net) LL to a HL driver should go via this function 1005 * it's serialized by the caller holding the lp->xmit_lock spinlock 1006 */ 1007void isdn_net_writebuf_skb(isdn_net_local *lp, struct sk_buff *skb) 1008{ 1009 int ret; 1010 int len = skb->len; /* save len */ 1011 1012 /* before obtaining the lock the caller should have checked that 1013 the lp isn't busy */ 1014 if (isdn_net_lp_busy(lp)) { 1015 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__); 1016 goto error; 1017 } 1018 1019 if (!(lp->flags & ISDN_NET_CONNECTED)) { 1020 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__); 1021 goto error; 1022 } 1023 ret = isdn_writebuf_skb_stub(lp->isdn_device, lp->isdn_channel, 1, skb); 1024 if (ret != len) { 1025 /* we should never get here */ 1026 printk(KERN_WARNING "%s: HL driver queue full\n", lp->name); 1027 goto error; 1028 } 1029 1030 lp->transcount += len; 1031 isdn_net_inc_frame_cnt(lp); 1032 return; 1033 1034 error: 1035 dev_kfree_skb(skb); 1036 lp->stats.tx_errors++; 1037 1038} 1039 1040 1041/* 1042 * Helper function for isdn_net_start_xmit. 1043 * When called, the connection is already established. 1044 * Based on cps-calculation, check if device is overloaded. 1045 * If so, and if a slave exists, trigger dialing for it. 1046 * If any slave is online, deliver packets using a simple round robin 1047 * scheme. 1048 * 1049 * Return: 0 on success, !0 on failure. 1050 */ 1051 1052static int 1053isdn_net_xmit(struct net_device *ndev, struct sk_buff *skb) 1054{ 1055 isdn_net_dev *nd; 1056 isdn_net_local *slp; 1057 isdn_net_local *lp = (isdn_net_local *) ndev->priv; 1058 int retv = 0; 1059 1060 if (((isdn_net_local *) (ndev->priv))->master) { 1061 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__); 1062 dev_kfree_skb(skb); 1063 return 0; 1064 } 1065 1066 /* For the other encaps the header has already been built */ 1067#ifdef CONFIG_ISDN_PPP 1068 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) { 1069 return isdn_ppp_xmit(skb, ndev); 1070 } 1071#endif 1072 nd = ((isdn_net_local *) ndev->priv)->netdev; 1073 lp = isdn_net_get_locked_lp(nd); 1074 if (!lp) { 1075 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", ndev->name); 1076 return 1; 1077 } 1078 /* we have our lp locked from now on */ 1079 1080 /* Reset hangup-timeout */ 1081 lp->huptimer = 0; 1082 isdn_net_writebuf_skb(lp, skb); 1083 spin_unlock_bh(&lp->xmit_lock); 1084 1085 /* the following stuff is here for backwards compatibility. 1086 * in future, start-up and hangup of slaves (based on current load) 1087 * should move to userspace and get based on an overall cps 1088 * calculation 1089 */ 1090 if (lp->cps > lp->triggercps) { 1091 if (lp->slave) { 1092 if (!lp->sqfull) { 1093 /* First time overload: set timestamp only */ 1094 lp->sqfull = 1; 1095 lp->sqfull_stamp = jiffies; 1096 } else { 1097 /* subsequent overload: if slavedelay exceeded, start dialing */ 1098 if (time_after(jiffies, lp->sqfull_stamp + lp->slavedelay)) { 1099 slp = lp->slave->priv; 1100 if (!(slp->flags & ISDN_NET_CONNECTED)) { 1101 isdn_net_force_dial_lp((isdn_net_local *) lp->slave->priv); 1102 } 1103 } 1104 } 1105 } 1106 } else { 1107 if (lp->sqfull && time_after(jiffies, lp->sqfull_stamp + lp->slavedelay + (10 * HZ))) { 1108 lp->sqfull = 0; 1109 } 1110 /* this is a hack to allow auto-hangup for slaves on moderate loads */ 1111 nd->queue = nd->local; 1112 } 1113 1114 return retv; 1115 1116} 1117 1118static void 1119isdn_net_adjust_hdr(struct sk_buff *skb, struct net_device *dev) 1120{ 1121 isdn_net_local *lp = (isdn_net_local *) dev->priv; 1122 if (!skb) 1123 return; 1124 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) { 1125 const int pullsize = skb_network_offset(skb) - ETH_HLEN; 1126 if (pullsize > 0) { 1127 printk(KERN_DEBUG "isdn_net: Pull junk %d\n", pullsize); 1128 skb_pull(skb, pullsize); 1129 } 1130 } 1131} 1132 1133 1134static void isdn_net_tx_timeout(struct net_device * ndev) 1135{ 1136 isdn_net_local *lp = (isdn_net_local *) ndev->priv; 1137 1138 printk(KERN_WARNING "isdn_tx_timeout dev %s dialstate %d\n", ndev->name, lp->dialstate); 1139 if (!lp->dialstate){ 1140 lp->stats.tx_errors++; 1141 /* 1142 * There is a certain probability that this currently 1143 * works at all because if we always wake up the interface, 1144 * then upper layer will try to send the next packet 1145 * immediately. And then, the old clean_up logic in the 1146 * driver will hopefully continue to work as it used to do. 1147 * 1148 * This is rather primitive right know, we better should 1149 * clean internal queues here, in particular for multilink and 1150 * ppp, and reset HL driver's channel, too. --HE 1151 * 1152 * actually, this may not matter at all, because ISDN hardware 1153 * should not see transmitter hangs at all IMO 1154 * changed KERN_DEBUG to KERN_WARNING to find out if this is 1155 * ever called --KG 1156 */ 1157 } 1158 ndev->trans_start = jiffies; 1159 netif_wake_queue(ndev); 1160} 1161 1162/* 1163 * Try sending a packet. 1164 * If this interface isn't connected to a ISDN-Channel, find a free channel, 1165 * and start dialing. 1166 */ 1167static int 1168isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev) 1169{ 1170 isdn_net_local *lp = (isdn_net_local *) ndev->priv; 1171#ifdef CONFIG_ISDN_X25 1172 struct concap_proto * cprot = lp -> netdev -> cprot; 1173/* At this point hard_start_xmit() passes control to the encapsulation 1174 protocol (if present). 1175 For X.25 auto-dialing is completly bypassed because: 1176 - It does not conform with the semantics of a reliable datalink 1177 service as needed by X.25 PLP. 1178 - I don't want that the interface starts dialing when the network layer 1179 sends a message which requests to disconnect the lapb link (or if it 1180 sends any other message not resulting in data transmission). 1181 Instead, dialing will be initiated by the encapsulation protocol entity 1182 when a dl_establish request is received from the upper layer. 1183*/ 1184 if (cprot && cprot -> pops) { 1185 int ret = cprot -> pops -> encap_and_xmit ( cprot , skb); 1186 1187 if (ret) 1188 netif_stop_queue(ndev); 1189 return ret; 1190 } else 1191#endif 1192 /* auto-dialing xmit function */ 1193 { 1194#ifdef ISDN_DEBUG_NET_DUMP 1195 u_char *buf; 1196#endif 1197 isdn_net_adjust_hdr(skb, ndev); 1198#ifdef ISDN_DEBUG_NET_DUMP 1199 buf = skb->data; 1200 isdn_dumppkt("S:", buf, skb->len, 40); 1201#endif 1202 1203 if (!(lp->flags & ISDN_NET_CONNECTED)) { 1204 int chi; 1205 /* only do autodial if allowed by config */ 1206 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) { 1207 isdn_net_unreachable(ndev, skb, "dial rejected: interface not in dialmode `auto'"); 1208 dev_kfree_skb(skb); 1209 return 0; 1210 } 1211 if (lp->phone[1]) { 1212 ulong flags; 1213 1214 if(lp->dialwait_timer <= 0) 1215 if(lp->dialstarted > 0 && lp->dialtimeout > 0 && time_before(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait)) 1216 lp->dialwait_timer = lp->dialstarted + lp->dialtimeout + lp->dialwait; 1217 1218 if(lp->dialwait_timer > 0) { 1219 if(time_before(jiffies, lp->dialwait_timer)) { 1220 isdn_net_unreachable(ndev, skb, "dial rejected: retry-time not reached"); 1221 dev_kfree_skb(skb); 1222 return 0; 1223 } else 1224 lp->dialwait_timer = 0; 1225 } 1226 /* Grab a free ISDN-Channel */ 1227 spin_lock_irqsave(&dev->lock, flags); 1228 if (((chi = 1229 isdn_get_free_channel( 1230 ISDN_USAGE_NET, 1231 lp->l2_proto, 1232 lp->l3_proto, 1233 lp->pre_device, 1234 lp->pre_channel, 1235 lp->msn) 1236 ) < 0) && 1237 ((chi = 1238 isdn_get_free_channel( 1239 ISDN_USAGE_NET, 1240 lp->l2_proto, 1241 lp->l3_proto, 1242 lp->pre_device, 1243 lp->pre_channel^1, 1244 lp->msn) 1245 ) < 0)) { 1246 spin_unlock_irqrestore(&dev->lock, flags); 1247 isdn_net_unreachable(ndev, skb, 1248 "No channel"); 1249 dev_kfree_skb(skb); 1250 return 0; 1251 } 1252 /* Log packet, which triggered dialing */ 1253 if (dev->net_verbose) 1254 isdn_net_log_skb(skb, lp); 1255 lp->dialstate = 1; 1256 /* Connect interface with channel */ 1257 isdn_net_bind_channel(lp, chi); 1258#ifdef CONFIG_ISDN_PPP 1259 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) { 1260 /* no 'first_skb' handling for syncPPP */ 1261 if (isdn_ppp_bind(lp) < 0) { 1262 dev_kfree_skb(skb); 1263 isdn_net_unbind_channel(lp); 1264 spin_unlock_irqrestore(&dev->lock, flags); 1265 return 0; /* STN (skb to nirvana) ;) */ 1266 } 1267#ifdef CONFIG_IPPP_FILTER 1268 if (isdn_ppp_autodial_filter(skb, lp)) { 1269 isdn_ppp_free(lp); 1270 isdn_net_unbind_channel(lp); 1271 spin_unlock_irqrestore(&dev->lock, flags); 1272 isdn_net_unreachable(ndev, skb, "dial rejected: packet filtered"); 1273 dev_kfree_skb(skb); 1274 return 0; 1275 } 1276#endif 1277 spin_unlock_irqrestore(&dev->lock, flags); 1278 isdn_net_dial(); /* Initiate dialing */ 1279 netif_stop_queue(ndev); 1280 return 1; /* let upper layer requeue skb packet */ 1281 } 1282#endif 1283 /* Initiate dialing */ 1284 spin_unlock_irqrestore(&dev->lock, flags); 1285 isdn_net_dial(); 1286 isdn_net_device_stop_queue(lp); 1287 return 1; 1288 } else { 1289 isdn_net_unreachable(ndev, skb, 1290 "No phone number"); 1291 dev_kfree_skb(skb); 1292 return 0; 1293 } 1294 } else { 1295 /* Device is connected to an ISDN channel */ 1296 ndev->trans_start = jiffies; 1297 if (!lp->dialstate) { 1298 /* ISDN connection is established, try sending */ 1299 int ret; 1300 ret = (isdn_net_xmit(ndev, skb)); 1301 if(ret) netif_stop_queue(ndev); 1302 return ret; 1303 } else 1304 netif_stop_queue(ndev); 1305 } 1306 } 1307 return 1; 1308} 1309 1310/* 1311 * Shutdown a net-interface. 1312 */ 1313static int 1314isdn_net_close(struct net_device *dev) 1315{ 1316 struct net_device *p; 1317#ifdef CONFIG_ISDN_X25 1318 struct concap_proto * cprot = 1319 ( (isdn_net_local *) dev->priv ) -> netdev -> cprot; 1320 /* printk(KERN_DEBUG "isdn_net_close %s\n" , dev-> name ); */ 1321#endif 1322 1323#ifdef CONFIG_ISDN_X25 1324 if( cprot && cprot -> pops ) cprot -> pops -> close( cprot ); 1325#endif 1326 netif_stop_queue(dev); 1327 if ((p = (((isdn_net_local *) dev->priv)->slave))) { 1328 /* If this interface has slaves, stop them also */ 1329 while (p) { 1330#ifdef CONFIG_ISDN_X25 1331 cprot = ( (isdn_net_local *) p->priv ) 1332 -> netdev -> cprot; 1333 if( cprot && cprot -> pops ) 1334 cprot -> pops -> close( cprot ); 1335#endif 1336 isdn_net_hangup(p); 1337 p = (((isdn_net_local *) p->priv)->slave); 1338 } 1339 } 1340 isdn_net_hangup(dev); 1341 isdn_unlock_drivers(); 1342 return 0; 1343} 1344 1345/* 1346 * Get statistics 1347 */ 1348static struct net_device_stats * 1349isdn_net_get_stats(struct net_device *dev) 1350{ 1351 isdn_net_local *lp = (isdn_net_local *) dev->priv; 1352 return &lp->stats; 1353} 1354 1355/* This is simply a copy from std. eth.c EXCEPT we pull ETH_HLEN 1356 * instead of dev->hard_header_len off. This is done because the 1357 * lowlevel-driver has already pulled off its stuff when we get 1358 * here and this routine only gets called with p_encap == ETHER. 1359 * Determine the packet's protocol ID. The rule here is that we 1360 * assume 802.3 if the type field is short enough to be a length. 1361 * This is normal practice and works for any 'now in use' protocol. 1362 */ 1363 1364static unsigned short 1365isdn_net_type_trans(struct sk_buff *skb, struct net_device *dev) 1366{ 1367 struct ethhdr *eth; 1368 unsigned char *rawp; 1369 1370 skb_reset_mac_header(skb); 1371 skb_pull(skb, ETH_HLEN); 1372 eth = eth_hdr(skb); 1373 1374 if (*eth->h_dest & 1) { 1375 if (memcmp(eth->h_dest, dev->broadcast, ETH_ALEN) == 0) 1376 skb->pkt_type = PACKET_BROADCAST; 1377 else 1378 skb->pkt_type = PACKET_MULTICAST; 1379 } 1380 /* 1381 * This ALLMULTI check should be redundant by 1.4 1382 * so don't forget to remove it. 1383 */ 1384 1385 else if (dev->flags & (IFF_PROMISC /*| IFF_ALLMULTI*/)) { 1386 if (memcmp(eth->h_dest, dev->dev_addr, ETH_ALEN)) 1387 skb->pkt_type = PACKET_OTHERHOST; 1388 } 1389 if (ntohs(eth->h_proto) >= 1536) 1390 return eth->h_proto; 1391 1392 rawp = skb->data; 1393 1394 /* 1395 * This is a magic hack to spot IPX packets. Older Novell breaks 1396 * the protocol design and runs IPX over 802.3 without an 802.2 LLC 1397 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This 1398 * won't work for fault tolerant netware but does for the rest. 1399 */ 1400 if (*(unsigned short *) rawp == 0xFFFF) 1401 return htons(ETH_P_802_3); 1402 /* 1403 * Real 802.2 LLC 1404 */ 1405 return htons(ETH_P_802_2); 1406} 1407 1408 1409/* 1410 * CISCO HDLC keepalive specific stuff 1411 */ 1412static struct sk_buff* 1413isdn_net_ciscohdlck_alloc_skb(isdn_net_local *lp, int len) 1414{ 1415 unsigned short hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen; 1416 struct sk_buff *skb; 1417 1418 skb = alloc_skb(hl + len, GFP_ATOMIC); 1419 if (skb) 1420 skb_reserve(skb, hl); 1421 else 1422 printk("isdn out of mem at %s:%d!\n", __FILE__, __LINE__); 1423 return skb; 1424} 1425 1426/* cisco hdlck device private ioctls */ 1427static int 1428isdn_ciscohdlck_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 1429{ 1430 isdn_net_local *lp = (isdn_net_local *) dev->priv; 1431 unsigned long len = 0; 1432 unsigned long expires = 0; 1433 int tmp = 0; 1434 int period = lp->cisco_keepalive_period; 1435 s8 debserint = lp->cisco_debserint; 1436 int rc = 0; 1437 1438 if (lp->p_encap != ISDN_NET_ENCAP_CISCOHDLCK) 1439 return -EINVAL; 1440 1441 switch (cmd) { 1442 /* get/set keepalive period */ 1443 case SIOCGKEEPPERIOD: 1444 len = (unsigned long)sizeof(lp->cisco_keepalive_period); 1445 if (copy_to_user(ifr->ifr_data, 1446 &lp->cisco_keepalive_period, len)) 1447 rc = -EFAULT; 1448 break; 1449 case SIOCSKEEPPERIOD: 1450 tmp = lp->cisco_keepalive_period; 1451 len = (unsigned long)sizeof(lp->cisco_keepalive_period); 1452 if (copy_from_user(&period, ifr->ifr_data, len)) 1453 rc = -EFAULT; 1454 if ((period > 0) && (period <= 32767)) 1455 lp->cisco_keepalive_period = period; 1456 else 1457 rc = -EINVAL; 1458 if (!rc && (tmp != lp->cisco_keepalive_period)) { 1459 expires = (unsigned long)(jiffies + 1460 lp->cisco_keepalive_period * HZ); 1461 mod_timer(&lp->cisco_timer, expires); 1462 printk(KERN_INFO "%s: Keepalive period set " 1463 "to %d seconds.\n", 1464 lp->name, lp->cisco_keepalive_period); 1465 } 1466 break; 1467 1468 /* get/set debugging */ 1469 case SIOCGDEBSERINT: 1470 len = (unsigned long)sizeof(lp->cisco_debserint); 1471 if (copy_to_user(ifr->ifr_data, 1472 &lp->cisco_debserint, len)) 1473 rc = -EFAULT; 1474 break; 1475 case SIOCSDEBSERINT: 1476 len = (unsigned long)sizeof(lp->cisco_debserint); 1477 if (copy_from_user(&debserint, 1478 ifr->ifr_data, len)) 1479 rc = -EFAULT; 1480 if ((debserint >= 0) && (debserint <= 64)) 1481 lp->cisco_debserint = debserint; 1482 else 1483 rc = -EINVAL; 1484 break; 1485 1486 default: 1487 rc = -EINVAL; 1488 break; 1489 } 1490 return (rc); 1491} 1492 1493/* called via cisco_timer.function */ 1494static void 1495isdn_net_ciscohdlck_slarp_send_keepalive(unsigned long data) 1496{ 1497 isdn_net_local *lp = (isdn_net_local *) data; 1498 struct sk_buff *skb; 1499 unsigned char *p; 1500 unsigned long last_cisco_myseq = lp->cisco_myseq; 1501 int myseq_diff = 0; 1502 1503 if (!(lp->flags & ISDN_NET_CONNECTED) || lp->dialstate) { 1504 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__); 1505 return; 1506 } 1507 lp->cisco_myseq++; 1508 1509 myseq_diff = (lp->cisco_myseq - lp->cisco_mineseen); 1510 if ((lp->cisco_line_state) && ((myseq_diff >= 3)||(myseq_diff <= -3))) { 1511 /* line up -> down */ 1512 lp->cisco_line_state = 0; 1513 printk (KERN_WARNING 1514 "UPDOWN: Line protocol on Interface %s," 1515 " changed state to down\n", lp->name); 1516 /* should stop routing higher-level data accross */ 1517 } else if ((!lp->cisco_line_state) && 1518 (myseq_diff >= 0) && (myseq_diff <= 2)) { 1519 /* line down -> up */ 1520 lp->cisco_line_state = 1; 1521 printk (KERN_WARNING 1522 "UPDOWN: Line protocol on Interface %s," 1523 " changed state to up\n", lp->name); 1524 /* restart routing higher-level data accross */ 1525 } 1526 1527 if (lp->cisco_debserint) 1528 printk (KERN_DEBUG "%s: HDLC " 1529 "myseq %lu, mineseen %lu%c, yourseen %lu, %s\n", 1530 lp->name, last_cisco_myseq, lp->cisco_mineseen, 1531 ((last_cisco_myseq == lp->cisco_mineseen) ? '*' : 040), 1532 lp->cisco_yourseq, 1533 ((lp->cisco_line_state) ? "line up" : "line down")); 1534 1535 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14); 1536 if (!skb) 1537 return; 1538 1539 p = skb_put(skb, 4 + 14); 1540 1541 /* cisco header */ 1542 p += put_u8 (p, CISCO_ADDR_UNICAST); 1543 p += put_u8 (p, CISCO_CTRL); 1544 p += put_u16(p, CISCO_TYPE_SLARP); 1545 1546 /* slarp keepalive */ 1547 p += put_u32(p, CISCO_SLARP_KEEPALIVE); 1548 p += put_u32(p, lp->cisco_myseq); 1549 p += put_u32(p, lp->cisco_yourseq); 1550 p += put_u16(p, 0xffff); // reliablity, always 0xffff 1551 1552 isdn_net_write_super(lp, skb); 1553 1554 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ; 1555 1556 add_timer(&lp->cisco_timer); 1557} 1558 1559static void 1560isdn_net_ciscohdlck_slarp_send_request(isdn_net_local *lp) 1561{ 1562 struct sk_buff *skb; 1563 unsigned char *p; 1564 1565 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14); 1566 if (!skb) 1567 return; 1568 1569 p = skb_put(skb, 4 + 14); 1570 1571 /* cisco header */ 1572 p += put_u8 (p, CISCO_ADDR_UNICAST); 1573 p += put_u8 (p, CISCO_CTRL); 1574 p += put_u16(p, CISCO_TYPE_SLARP); 1575 1576 /* slarp request */ 1577 p += put_u32(p, CISCO_SLARP_REQUEST); 1578 p += put_u32(p, 0); // address 1579 p += put_u32(p, 0); // netmask 1580 p += put_u16(p, 0); // unused 1581 1582 isdn_net_write_super(lp, skb); 1583} 1584 1585static void 1586isdn_net_ciscohdlck_connected(isdn_net_local *lp) 1587{ 1588 lp->cisco_myseq = 0; 1589 lp->cisco_mineseen = 0; 1590 lp->cisco_yourseq = 0; 1591 lp->cisco_keepalive_period = ISDN_TIMER_KEEPINT; 1592 lp->cisco_last_slarp_in = 0; 1593 lp->cisco_line_state = 0; 1594 lp->cisco_debserint = 0; 1595 1596 /* send slarp request because interface/seq.no.s reset */ 1597 isdn_net_ciscohdlck_slarp_send_request(lp); 1598 1599 init_timer(&lp->cisco_timer); 1600 lp->cisco_timer.data = (unsigned long) lp; 1601 lp->cisco_timer.function = isdn_net_ciscohdlck_slarp_send_keepalive; 1602 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ; 1603 add_timer(&lp->cisco_timer); 1604} 1605 1606static void 1607isdn_net_ciscohdlck_disconnected(isdn_net_local *lp) 1608{ 1609 del_timer(&lp->cisco_timer); 1610} 1611 1612static void 1613isdn_net_ciscohdlck_slarp_send_reply(isdn_net_local *lp) 1614{ 1615 struct sk_buff *skb; 1616 unsigned char *p; 1617 struct in_device *in_dev = NULL; 1618 __be32 addr = 0; /* local ipv4 address */ 1619 __be32 mask = 0; /* local netmask */ 1620 1621 if ((in_dev = lp->netdev->dev.ip_ptr) != NULL) { 1622 /* take primary(first) address of interface */ 1623 struct in_ifaddr *ifa = in_dev->ifa_list; 1624 if (ifa != NULL) { 1625 addr = ifa->ifa_local; 1626 mask = ifa->ifa_mask; 1627 } 1628 } 1629 1630 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14); 1631 if (!skb) 1632 return; 1633 1634 p = skb_put(skb, 4 + 14); 1635 1636 /* cisco header */ 1637 p += put_u8 (p, CISCO_ADDR_UNICAST); 1638 p += put_u8 (p, CISCO_CTRL); 1639 p += put_u16(p, CISCO_TYPE_SLARP); 1640 1641 /* slarp reply, send own ip/netmask; if values are nonsense remote 1642 * should think we are unable to provide it with an address via SLARP */ 1643 p += put_u32(p, CISCO_SLARP_REPLY); 1644 p += put_u32(p, addr); // address 1645 p += put_u32(p, mask); // netmask 1646 p += put_u16(p, 0); // unused 1647 1648 isdn_net_write_super(lp, skb); 1649} 1650 1651static void 1652isdn_net_ciscohdlck_slarp_in(isdn_net_local *lp, struct sk_buff *skb) 1653{ 1654 unsigned char *p; 1655 int period; 1656 u32 code; 1657 u32 my_seq, addr; 1658 u32 your_seq, mask; 1659 u32 local; 1660 u16 unused; 1661 1662 if (skb->len < 14) 1663 return; 1664 1665 p = skb->data; 1666 p += get_u32(p, &code); 1667 1668 switch (code) { 1669 case CISCO_SLARP_REQUEST: 1670 lp->cisco_yourseq = 0; 1671 isdn_net_ciscohdlck_slarp_send_reply(lp); 1672 break; 1673 case CISCO_SLARP_REPLY: 1674 addr = ntohl(*(u32 *)p); 1675 mask = ntohl(*(u32 *)(p+4)); 1676 if (mask != 0xfffffffc) 1677 goto slarp_reply_out; 1678 if ((addr & 3) == 0 || (addr & 3) == 3) 1679 goto slarp_reply_out; 1680 local = addr ^ 3; 1681 printk(KERN_INFO "%s: got slarp reply: " 1682 "remote ip: %d.%d.%d.%d, " 1683 "local ip: %d.%d.%d.%d " 1684 "mask: %d.%d.%d.%d\n", 1685 lp->name, 1686 HIPQUAD(addr), 1687 HIPQUAD(local), 1688 HIPQUAD(mask)); 1689 break; 1690 slarp_reply_out: 1691 printk(KERN_INFO "%s: got invalid slarp " 1692 "reply (%d.%d.%d.%d/%d.%d.%d.%d) " 1693 "- ignored\n", lp->name, 1694 HIPQUAD(addr), HIPQUAD(mask)); 1695 break; 1696 case CISCO_SLARP_KEEPALIVE: 1697 period = (int)((jiffies - lp->cisco_last_slarp_in 1698 + HZ/2 - 1) / HZ); 1699 if (lp->cisco_debserint && 1700 (period != lp->cisco_keepalive_period) && 1701 lp->cisco_last_slarp_in) { 1702 printk(KERN_DEBUG "%s: Keepalive period mismatch - " 1703 "is %d but should be %d.\n", 1704 lp->name, period, lp->cisco_keepalive_period); 1705 } 1706 lp->cisco_last_slarp_in = jiffies; 1707 p += get_u32(p, &my_seq); 1708 p += get_u32(p, &your_seq); 1709 p += get_u16(p, &unused); 1710 lp->cisco_yourseq = my_seq; 1711 lp->cisco_mineseen = your_seq; 1712 break; 1713 } 1714} 1715 1716static void 1717isdn_net_ciscohdlck_receive(isdn_net_local *lp, struct sk_buff *skb) 1718{ 1719 unsigned char *p; 1720 u8 addr; 1721 u8 ctrl; 1722 u16 type; 1723 1724 if (skb->len < 4) 1725 goto out_free; 1726 1727 p = skb->data; 1728 p += get_u8 (p, &addr); 1729 p += get_u8 (p, &ctrl); 1730 p += get_u16(p, &type); 1731 skb_pull(skb, 4); 1732 1733 if (addr != CISCO_ADDR_UNICAST && addr != CISCO_ADDR_BROADCAST) { 1734 printk(KERN_WARNING "%s: Unknown Cisco addr 0x%02x\n", 1735 lp->name, addr); 1736 goto out_free; 1737 } 1738 if (ctrl != CISCO_CTRL) { 1739 printk(KERN_WARNING "%s: Unknown Cisco ctrl 0x%02x\n", 1740 lp->name, ctrl); 1741 goto out_free; 1742 } 1743 1744 switch (type) { 1745 case CISCO_TYPE_SLARP: 1746 isdn_net_ciscohdlck_slarp_in(lp, skb); 1747 goto out_free; 1748 case CISCO_TYPE_CDP: 1749 if (lp->cisco_debserint) 1750 printk(KERN_DEBUG "%s: Received CDP packet. use " 1751 "\"no cdp enable\" on cisco.\n", lp->name); 1752 goto out_free; 1753 default: 1754 /* no special cisco protocol */ 1755 skb->protocol = htons(type); 1756 netif_rx(skb); 1757 return; 1758 } 1759 1760 out_free: 1761 kfree_skb(skb); 1762} 1763 1764/* 1765 * Got a packet from ISDN-Channel. 1766 */ 1767static void 1768isdn_net_receive(struct net_device *ndev, struct sk_buff *skb) 1769{ 1770 isdn_net_local *lp = (isdn_net_local *) ndev->priv; 1771 isdn_net_local *olp = lp; /* original 'lp' */ 1772#ifdef CONFIG_ISDN_X25 1773 struct concap_proto *cprot = lp -> netdev -> cprot; 1774#endif 1775 lp->transcount += skb->len; 1776 1777 lp->stats.rx_packets++; 1778 lp->stats.rx_bytes += skb->len; 1779 if (lp->master) { 1780 /* Bundling: If device is a slave-device, deliver to master, also 1781 * handle master's statistics and hangup-timeout 1782 */ 1783 ndev = lp->master; 1784 lp = (isdn_net_local *) ndev->priv; 1785 lp->stats.rx_packets++; 1786 lp->stats.rx_bytes += skb->len; 1787 } 1788 skb->dev = ndev; 1789 skb->pkt_type = PACKET_HOST; 1790 skb_reset_mac_header(skb); 1791#ifdef ISDN_DEBUG_NET_DUMP 1792 isdn_dumppkt("R:", skb->data, skb->len, 40); 1793#endif 1794 switch (lp->p_encap) { 1795 case ISDN_NET_ENCAP_ETHER: 1796 /* Ethernet over ISDN */ 1797 olp->huptimer = 0; 1798 lp->huptimer = 0; 1799 skb->protocol = isdn_net_type_trans(skb, ndev); 1800 break; 1801 case ISDN_NET_ENCAP_UIHDLC: 1802 /* HDLC with UI-frame (for ispa with -h1 option) */ 1803 olp->huptimer = 0; 1804 lp->huptimer = 0; 1805 skb_pull(skb, 2); 1806 /* Fall through */ 1807 case ISDN_NET_ENCAP_RAWIP: 1808 /* RAW-IP without MAC-Header */ 1809 olp->huptimer = 0; 1810 lp->huptimer = 0; 1811 skb->protocol = htons(ETH_P_IP); 1812 break; 1813 case ISDN_NET_ENCAP_CISCOHDLCK: 1814 isdn_net_ciscohdlck_receive(lp, skb); 1815 return; 1816 case ISDN_NET_ENCAP_CISCOHDLC: 1817 /* CISCO-HDLC IP with type field and fake I-frame-header */ 1818 skb_pull(skb, 2); 1819 /* Fall through */ 1820 case ISDN_NET_ENCAP_IPTYP: 1821 /* IP with type field */ 1822 olp->huptimer = 0; 1823 lp->huptimer = 0; 1824 skb->protocol = *(unsigned short *) &(skb->data[0]); 1825 skb_pull(skb, 2); 1826 if (*(unsigned short *) skb->data == 0xFFFF) 1827 skb->protocol = htons(ETH_P_802_3); 1828 break; 1829#ifdef CONFIG_ISDN_PPP 1830 case ISDN_NET_ENCAP_SYNCPPP: 1831 /* huptimer is done in isdn_ppp_push_higher */ 1832 isdn_ppp_receive(lp->netdev, olp, skb); 1833 return; 1834#endif 1835 1836 default: 1837#ifdef CONFIG_ISDN_X25 1838 /* try if there are generic sync_device receiver routines */ 1839 if(cprot) if(cprot -> pops) 1840 if( cprot -> pops -> data_ind){ 1841 cprot -> pops -> data_ind(cprot,skb); 1842 return; 1843 }; 1844#endif /* CONFIG_ISDN_X25 */ 1845 printk(KERN_WARNING "%s: unknown encapsulation, dropping\n", 1846 lp->name); 1847 kfree_skb(skb); 1848 return; 1849 } 1850 1851 netif_rx(skb); 1852 return; 1853} 1854 1855/* 1856 * A packet arrived via ISDN. Search interface-chain for a corresponding 1857 * interface. If found, deliver packet to receiver-function and return 1, 1858 * else return 0. 1859 */ 1860int 1861isdn_net_rcv_skb(int idx, struct sk_buff *skb) 1862{ 1863 isdn_net_dev *p = dev->rx_netdev[idx]; 1864 1865 if (p) { 1866 isdn_net_local *lp = p->local; 1867 if ((lp->flags & ISDN_NET_CONNECTED) && 1868 (!lp->dialstate)) { 1869 isdn_net_receive(&p->dev, skb); 1870 return 1; 1871 } 1872 } 1873 return 0; 1874} 1875 1876static int 1877my_eth_header(struct sk_buff *skb, struct net_device *dev, unsigned short type, 1878 void *daddr, void *saddr, unsigned len) 1879{ 1880 struct ethhdr *eth = (struct ethhdr *) skb_push(skb, ETH_HLEN); 1881 1882 /* 1883 * Set the protocol type. For a packet of type ETH_P_802_3 we 1884 * put the length here instead. It is up to the 802.2 layer to 1885 * carry protocol information. 1886 */ 1887 1888 if (type != ETH_P_802_3) 1889 eth->h_proto = htons(type); 1890 else 1891 eth->h_proto = htons(len); 1892 1893 /* 1894 * Set the source hardware address. 1895 */ 1896 if (saddr) 1897 memcpy(eth->h_source, saddr, dev->addr_len); 1898 else 1899 memcpy(eth->h_source, dev->dev_addr, dev->addr_len); 1900 1901 /* 1902 * Anyway, the loopback-device should never use this function... 1903 */ 1904 1905 if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) { 1906 memset(eth->h_dest, 0, dev->addr_len); 1907 return ETH_HLEN /*(dev->hard_header_len)*/; 1908 } 1909 if (daddr) { 1910 memcpy(eth->h_dest, daddr, dev->addr_len); 1911 return ETH_HLEN /*dev->hard_header_len*/; 1912 } 1913 return -ETH_HLEN /*dev->hard_header_len*/; 1914} 1915 1916/* 1917 * build an header 1918 * depends on encaps that is being used. 1919 */ 1920 1921static int 1922isdn_net_header(struct sk_buff *skb, struct net_device *dev, unsigned short type, 1923 void *daddr, void *saddr, unsigned plen) 1924{ 1925 isdn_net_local *lp = dev->priv; 1926 unsigned char *p; 1927 ushort len = 0; 1928 1929 switch (lp->p_encap) { 1930 case ISDN_NET_ENCAP_ETHER: 1931 len = my_eth_header(skb, dev, type, daddr, saddr, plen); 1932 break; 1933#ifdef CONFIG_ISDN_PPP 1934 case ISDN_NET_ENCAP_SYNCPPP: 1935 /* stick on a fake header to keep fragmentation code happy. */ 1936 len = IPPP_MAX_HEADER; 1937 skb_push(skb,len); 1938 break; 1939#endif 1940 case ISDN_NET_ENCAP_RAWIP: 1941 printk(KERN_WARNING "isdn_net_header called with RAW_IP!\n"); 1942 len = 0; 1943 break; 1944 case ISDN_NET_ENCAP_IPTYP: 1945 /* ethernet type field */ 1946 *((ushort *) skb_push(skb, 2)) = htons(type); 1947 len = 2; 1948 break; 1949 case ISDN_NET_ENCAP_UIHDLC: 1950 /* HDLC with UI-Frames (for ispa with -h1 option) */ 1951 *((ushort *) skb_push(skb, 2)) = htons(0x0103); 1952 len = 2; 1953 break; 1954 case ISDN_NET_ENCAP_CISCOHDLC: 1955 case ISDN_NET_ENCAP_CISCOHDLCK: 1956 p = skb_push(skb, 4); 1957 p += put_u8 (p, CISCO_ADDR_UNICAST); 1958 p += put_u8 (p, CISCO_CTRL); 1959 p += put_u16(p, type); 1960 len = 4; 1961 break; 1962#ifdef CONFIG_ISDN_X25 1963 default: 1964 /* try if there are generic concap protocol routines */ 1965 if( lp-> netdev -> cprot ){ 1966 printk(KERN_WARNING "isdn_net_header called with concap_proto!\n"); 1967 len = 0; 1968 break; 1969 } 1970 break; 1971#endif /* CONFIG_ISDN_X25 */ 1972 } 1973 return len; 1974} 1975 1976/* We don't need to send arp, because we have point-to-point connections. */ 1977static int 1978isdn_net_rebuild_header(struct sk_buff *skb) 1979{ 1980 struct net_device *dev = skb->dev; 1981 isdn_net_local *lp = dev->priv; 1982 int ret = 0; 1983 1984 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) { 1985 struct ethhdr *eth = (struct ethhdr *) skb->data; 1986 1987 /* 1988 * Only ARP/IP is currently supported 1989 */ 1990 1991 if (eth->h_proto != htons(ETH_P_IP)) { 1992 printk(KERN_WARNING 1993 "isdn_net: %s don't know how to resolve type %d addresses?\n", 1994 dev->name, (int) eth->h_proto); 1995 memcpy(eth->h_source, dev->dev_addr, dev->addr_len); 1996 return 0; 1997 } 1998 /* 1999 * Try to get ARP to resolve the header. 2000 */ 2001#ifdef CONFIG_INET 2002 ret = arp_find(eth->h_dest, skb); 2003#endif 2004 } 2005 return ret; 2006} 2007 2008/* 2009 * Interface-setup. (just after registering a new interface) 2010 */ 2011static int 2012isdn_net_init(struct net_device *ndev) 2013{ 2014 ushort max_hlhdr_len = 0; 2015 isdn_net_local *lp = (isdn_net_local *) ndev->priv; 2016 int drvidx, i; 2017 2018 ether_setup(ndev); 2019 lp->org_hhc = ndev->hard_header_cache; 2020 lp->org_hcu = ndev->header_cache_update; 2021 2022 /* Setup the generic properties */ 2023 2024 ndev->hard_header = NULL; 2025 ndev->hard_header_cache = NULL; 2026 ndev->header_cache_update = NULL; 2027 ndev->mtu = 1500; 2028 ndev->flags = IFF_NOARP|IFF_POINTOPOINT; 2029 ndev->type = ARPHRD_ETHER; 2030 ndev->addr_len = ETH_ALEN; 2031 2032 /* for clients with MPPP maybe higher values better */ 2033 ndev->tx_queue_len = 30; 2034 2035 for (i = 0; i < ETH_ALEN; i++) 2036 ndev->broadcast[i] = 0xff; 2037 2038 /* The ISDN-specific entries in the device structure. */ 2039 ndev->open = &isdn_net_open; 2040 ndev->hard_start_xmit = &isdn_net_start_xmit; 2041 2042 /* 2043 * up till binding we ask the protocol layer to reserve as much 2044 * as we might need for HL layer 2045 */ 2046 2047 for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++) 2048 if (dev->drv[drvidx]) 2049 if (max_hlhdr_len < dev->drv[drvidx]->interface->hl_hdrlen) 2050 max_hlhdr_len = dev->drv[drvidx]->interface->hl_hdrlen; 2051 2052 ndev->hard_header_len = ETH_HLEN + max_hlhdr_len; 2053 ndev->stop = &isdn_net_close; 2054 ndev->get_stats = &isdn_net_get_stats; 2055 ndev->rebuild_header = &isdn_net_rebuild_header; 2056 ndev->do_ioctl = NULL; 2057 return 0; 2058} 2059 2060static void 2061isdn_net_swapbind(int drvidx) 2062{ 2063 isdn_net_dev *p; 2064 2065#ifdef ISDN_DEBUG_NET_ICALL 2066 printk(KERN_DEBUG "n_fi: swapping ch of %d\n", drvidx); 2067#endif 2068 p = dev->netdev; 2069 while (p) { 2070 if (p->local->pre_device == drvidx) 2071 switch (p->local->pre_channel) { 2072 case 0: 2073 p->local->pre_channel = 1; 2074 break; 2075 case 1: 2076 p->local->pre_channel = 0; 2077 break; 2078 } 2079 p = (isdn_net_dev *) p->next; 2080 } 2081} 2082 2083static void 2084isdn_net_swap_usage(int i1, int i2) 2085{ 2086 int u1 = dev->usage[i1] & ISDN_USAGE_EXCLUSIVE; 2087 int u2 = dev->usage[i2] & ISDN_USAGE_EXCLUSIVE; 2088 2089#ifdef ISDN_DEBUG_NET_ICALL 2090 printk(KERN_DEBUG "n_fi: usage of %d and %d\n", i1, i2); 2091#endif 2092 dev->usage[i1] &= ~ISDN_USAGE_EXCLUSIVE; 2093 dev->usage[i1] |= u2; 2094 dev->usage[i2] &= ~ISDN_USAGE_EXCLUSIVE; 2095 dev->usage[i2] |= u1; 2096 isdn_info_update(); 2097} 2098 2099/* 2100 * An incoming call-request has arrived. 2101 * Search the interface-chain for an appropriate interface. 2102 * If found, connect the interface to the ISDN-channel and initiate 2103 * D- and B-Channel-setup. If secure-flag is set, accept only 2104 * configured phone-numbers. If callback-flag is set, initiate 2105 * callback-dialing. 2106 * 2107 * Return-Value: 0 = No appropriate interface for this call. 2108 * 1 = Call accepted 2109 * 2 = Reject call, wait cbdelay, then call back 2110 * 3 = Reject call 2111 * 4 = Wait cbdelay, then call back 2112 * 5 = No appropriate interface for this call, 2113 * would eventually match if CID was longer. 2114 */ 2115 2116int 2117isdn_net_find_icall(int di, int ch, int idx, setup_parm *setup) 2118{ 2119 char *eaz; 2120 int si1; 2121 int si2; 2122 int ematch; 2123 int wret; 2124 int swapped; 2125 int sidx = 0; 2126 u_long flags; 2127 isdn_net_dev *p; 2128 isdn_net_phone *n; 2129 char nr[32]; 2130 char *my_eaz; 2131 2132 /* Search name in netdev-chain */ 2133 if (!setup->phone[0]) { 2134 nr[0] = '0'; 2135 nr[1] = '\0'; 2136 printk(KERN_INFO "isdn_net: Incoming call without OAD, assuming '0'\n"); 2137 } else 2138 strcpy(nr, setup->phone); 2139 si1 = (int) setup->si1; 2140 si2 = (int) setup->si2; 2141 if (!setup->eazmsn[0]) { 2142 printk(KERN_WARNING "isdn_net: Incoming call without CPN, assuming '0'\n"); 2143 eaz = "0"; 2144 } else 2145 eaz = setup->eazmsn; 2146 if (dev->net_verbose > 1) 2147 printk(KERN_INFO "isdn_net: call from %s,%d,%d -> %s\n", nr, si1, si2, eaz); 2148 /* Accept DATA and VOICE calls at this stage 2149 * local eaz is checked later for allowed call types 2150 */ 2151 if ((si1 != 7) && (si1 != 1)) { 2152 if (dev->net_verbose > 1) 2153 printk(KERN_INFO "isdn_net: Service-Indicator not 1 or 7, ignored\n"); 2154 return 0; 2155 } 2156 n = (isdn_net_phone *) 0; 2157 p = dev->netdev; 2158 ematch = wret = swapped = 0; 2159#ifdef ISDN_DEBUG_NET_ICALL 2160 printk(KERN_DEBUG "n_fi: di=%d ch=%d idx=%d usg=%d\n", di, ch, idx, 2161 dev->usage[idx]); 2162#endif 2163 while (p) { 2164 int matchret; 2165 isdn_net_local *lp = p->local; 2166 2167 /* If last check has triggered as binding-swap, revert it */ 2168 switch (swapped) { 2169 case 2: 2170 isdn_net_swap_usage(idx, sidx); 2171 /* fall through */ 2172 case 1: 2173 isdn_net_swapbind(di); 2174 break; 2175 } 2176 swapped = 0; 2177 /* check acceptable call types for DOV */ 2178 my_eaz = isdn_map_eaz2msn(lp->msn, di); 2179 if (si1 == 1) { /* it's a DOV call, check if we allow it */ 2180 if (*my_eaz == 'v' || *my_eaz == 'V' || 2181 *my_eaz == 'b' || *my_eaz == 'B') 2182 my_eaz++; /* skip to allow a match */ 2183 else 2184 my_eaz = NULL; /* force non match */ 2185 } else { /* it's a DATA call, check if we allow it */ 2186 if (*my_eaz == 'b' || *my_eaz == 'B') 2187 my_eaz++; /* skip to allow a match */ 2188 } 2189 if (my_eaz) 2190 matchret = isdn_msncmp(eaz, my_eaz); 2191 else 2192 matchret = 1; 2193 if (!matchret) 2194 ematch = 1; 2195 2196 /* Remember if more numbers eventually can match */ 2197 if (matchret > wret) 2198 wret = matchret; 2199#ifdef ISDN_DEBUG_NET_ICALL 2200 printk(KERN_DEBUG "n_fi: if='%s', l.msn=%s, l.flags=%d, l.dstate=%d\n", 2201 lp->name, lp->msn, lp->flags, lp->dialstate); 2202#endif 2203 if ((!matchret) && /* EAZ is matching */ 2204 (((!(lp->flags & ISDN_NET_CONNECTED)) && /* but not connected */ 2205 (USG_NONE(dev->usage[idx]))) || /* and ch. unused or */ 2206 ((((lp->dialstate == 4) || (lp->dialstate == 12)) && /* if dialing */ 2207 (!(lp->flags & ISDN_NET_CALLBACK))) /* but no callback */ 2208 ))) 2209 { 2210#ifdef ISDN_DEBUG_NET_ICALL 2211 printk(KERN_DEBUG "n_fi: match1, pdev=%d pch=%d\n", 2212 lp->pre_device, lp->pre_channel); 2213#endif 2214 if (dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) { 2215 if ((lp->pre_channel != ch) || 2216 (lp->pre_device != di)) { 2217 /* Here we got a problem: 2218 * If using an ICN-Card, an incoming call is always signaled on 2219 * on the first channel of the card, if both channels are 2220 * down. However this channel may be bound exclusive. If the 2221 * second channel is free, this call should be accepted. 2222 * The solution is horribly but it runs, so what: 2223 * We exchange the exclusive bindings of the two channels, the 2224 * corresponding variables in the interface-structs. 2225 */ 2226 if (ch == 0) { 2227 sidx = isdn_dc2minor(di, 1); 2228#ifdef ISDN_DEBUG_NET_ICALL 2229 printk(KERN_DEBUG "n_fi: ch is 0\n"); 2230#endif 2231 if (USG_NONE(dev->usage[sidx])) { 2232 /* Second Channel is free, now see if it is bound 2233 * exclusive too. */ 2234 if (dev->usage[sidx] & ISDN_USAGE_EXCLUSIVE) { 2235#ifdef ISDN_DEBUG_NET_ICALL 2236 printk(KERN_DEBUG "n_fi: 2nd channel is down and bound\n"); 2237#endif 2238 /* Yes, swap bindings only, if the original 2239 * binding is bound to channel 1 of this driver */ 2240 if ((lp->pre_device == di) && 2241 (lp->pre_channel == 1)) { 2242 isdn_net_swapbind(di); 2243 swapped = 1; 2244 } else { 2245 /* ... else iterate next device */ 2246 p = (isdn_net_dev *) p->next; 2247 continue; 2248 } 2249 } else { 2250#ifdef ISDN_DEBUG_NET_ICALL 2251 printk(KERN_DEBUG "n_fi: 2nd channel is down and unbound\n"); 2252#endif 2253 /* No, swap always and swap excl-usage also */ 2254 isdn_net_swap_usage(idx, sidx); 2255 isdn_net_swapbind(di); 2256 swapped = 2; 2257 } 2258 /* Now check for exclusive binding again */ 2259#ifdef ISDN_DEBUG_NET_ICALL 2260 printk(KERN_DEBUG "n_fi: final check\n"); 2261#endif 2262 if ((dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) && 2263 ((lp->pre_channel != ch) || 2264 (lp->pre_device != di))) { 2265#ifdef ISDN_DEBUG_NET_ICALL 2266 printk(KERN_DEBUG "n_fi: final check failed\n"); 2267#endif 2268 p = (isdn_net_dev *) p->next; 2269 continue; 2270 } 2271 } 2272 } else { 2273 /* We are already on the second channel, so nothing to do */ 2274#ifdef ISDN_DEBUG_NET_ICALL 2275 printk(KERN_DEBUG "n_fi: already on 2nd channel\n"); 2276#endif 2277 } 2278 } 2279 } 2280#ifdef ISDN_DEBUG_NET_ICALL 2281 printk(KERN_DEBUG "n_fi: match2\n"); 2282#endif 2283 n = lp->phone[0]; 2284 if (lp->flags & ISDN_NET_SECURE) { 2285 while (n) { 2286 if (!isdn_msncmp(nr, n->num)) 2287 break; 2288 n = (isdn_net_phone *) n->next; 2289 } 2290 } 2291 if (n || (!(lp->flags & ISDN_NET_SECURE))) { 2292#ifdef ISDN_DEBUG_NET_ICALL 2293 printk(KERN_DEBUG "n_fi: match3\n"); 2294#endif 2295 /* matching interface found */ 2296 2297 /* 2298 * Is the state STOPPED? 2299 * If so, no dialin is allowed, 2300 * so reject actively. 2301 * */ 2302 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) { 2303 printk(KERN_INFO "incoming call, interface %s `stopped' -> rejected\n", 2304 lp->name); 2305 return 3; 2306 } 2307 /* 2308 * Is the interface up? 2309 * If not, reject the call actively. 2310 */ 2311 if (!isdn_net_device_started(p)) { 2312 printk(KERN_INFO "%s: incoming call, interface down -> rejected\n", 2313 lp->name); 2314 return 3; 2315 } 2316 /* Interface is up, now see if it's a slave. If so, see if 2317 * it's master and parent slave is online. If not, reject the call. 2318 */ 2319 if (lp->master) { 2320 isdn_net_local *mlp = (isdn_net_local *) lp->master->priv; 2321 printk(KERN_DEBUG "ICALLslv: %s\n", lp->name); 2322 printk(KERN_DEBUG "master=%s\n", mlp->name); 2323 if (mlp->flags & ISDN_NET_CONNECTED) { 2324 printk(KERN_DEBUG "master online\n"); 2325 /* Master is online, find parent-slave (master if first slave) */ 2326 while (mlp->slave) { 2327 if ((isdn_net_local *) mlp->slave->priv == lp) 2328 break; 2329 mlp = (isdn_net_local *) mlp->slave->priv; 2330 } 2331 } else 2332 printk(KERN_DEBUG "master offline\n"); 2333 /* Found parent, if it's offline iterate next device */ 2334 printk(KERN_DEBUG "mlpf: %d\n", mlp->flags & ISDN_NET_CONNECTED); 2335 if (!(mlp->flags & ISDN_NET_CONNECTED)) { 2336 p = (isdn_net_dev *) p->next; 2337 continue; 2338 } 2339 } 2340 if (lp->flags & ISDN_NET_CALLBACK) { 2341 int chi; 2342 /* 2343 * Is the state MANUAL? 2344 * If so, no callback can be made, 2345 * so reject actively. 2346 * */ 2347 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) { 2348 printk(KERN_INFO "incoming call for callback, interface %s `off' -> rejected\n", 2349 lp->name); 2350 return 3; 2351 } 2352 printk(KERN_DEBUG "%s: call from %s -> %s, start callback\n", 2353 lp->name, nr, eaz); 2354 if (lp->phone[1]) { 2355 /* Grab a free ISDN-Channel */ 2356 spin_lock_irqsave(&dev->lock, flags); 2357 if ((chi = 2358 isdn_get_free_channel( 2359 ISDN_USAGE_NET, 2360 lp->l2_proto, 2361 lp->l3_proto, 2362 lp->pre_device, 2363 lp->pre_channel, 2364 lp->msn) 2365 ) < 0) { 2366 2367 printk(KERN_WARNING "isdn_net_find_icall: No channel for %s\n", lp->name); 2368 spin_unlock_irqrestore(&dev->lock, flags); 2369 return 0; 2370 } 2371 /* Setup dialstate. */ 2372 lp->dtimer = 0; 2373 lp->dialstate = 11; 2374 /* Connect interface with channel */ 2375 isdn_net_bind_channel(lp, chi); 2376#ifdef CONFIG_ISDN_PPP 2377 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) 2378 if (isdn_ppp_bind(lp) < 0) { 2379 spin_unlock_irqrestore(&dev->lock, flags); 2380 isdn_net_unbind_channel(lp); 2381 return 0; 2382 } 2383#endif 2384 spin_unlock_irqrestore(&dev->lock, flags); 2385 /* Initiate dialing by returning 2 or 4 */ 2386 return (lp->flags & ISDN_NET_CBHUP) ? 2 : 4; 2387 } else 2388 printk(KERN_WARNING "isdn_net: %s: No phone number\n", lp->name); 2389 return 0; 2390 } else { 2391 printk(KERN_DEBUG "%s: call from %s -> %s accepted\n", lp->name, nr, 2392 eaz); 2393 /* if this interface is dialing, it does it probably on a different 2394 device, so free this device */ 2395 if ((lp->dialstate == 4) || (lp->dialstate == 12)) { 2396#ifdef CONFIG_ISDN_PPP 2397 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) 2398 isdn_ppp_free(lp); 2399#endif 2400 isdn_net_lp_disconnected(lp); 2401 isdn_free_channel(lp->isdn_device, lp->isdn_channel, 2402 ISDN_USAGE_NET); 2403 } 2404 spin_lock_irqsave(&dev->lock, flags); 2405 dev->usage[idx] &= ISDN_USAGE_EXCLUSIVE; 2406 dev->usage[idx] |= ISDN_USAGE_NET; 2407 strcpy(dev->num[idx], nr); 2408 isdn_info_update(); 2409 dev->st_netdev[idx] = lp->netdev; 2410 lp->isdn_device = di; 2411 lp->isdn_channel = ch; 2412 lp->ppp_slot = -1; 2413 lp->flags |= ISDN_NET_CONNECTED; 2414 lp->dialstate = 7; 2415 lp->dtimer = 0; 2416 lp->outgoing = 0; 2417 lp->huptimer = 0; 2418 lp->hupflags |= ISDN_WAITCHARGE; 2419 lp->hupflags &= ~ISDN_HAVECHARGE; 2420#ifdef CONFIG_ISDN_PPP 2421 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) { 2422 if (isdn_ppp_bind(lp) < 0) { 2423 isdn_net_unbind_channel(lp); 2424 spin_unlock_irqrestore(&dev->lock, flags); 2425 return 0; 2426 } 2427 } 2428#endif 2429 spin_unlock_irqrestore(&dev->lock, flags); 2430 return 1; 2431 } 2432 } 2433 } 2434 p = (isdn_net_dev *) p->next; 2435 } 2436 /* If none of configured EAZ/MSN matched and not verbose, be silent */ 2437 if (!ematch || dev->net_verbose) 2438 printk(KERN_INFO "isdn_net: call from %s -> %d %s ignored\n", nr, di, eaz); 2439 return (wret == 2)?5:0; 2440} 2441 2442/* 2443 * Search list of net-interfaces for an interface with given name. 2444 */ 2445isdn_net_dev * 2446isdn_net_findif(char *name) 2447{ 2448 isdn_net_dev *p = dev->netdev; 2449 2450 while (p) { 2451 if (!strcmp(p->local->name, name)) 2452 return p; 2453 p = (isdn_net_dev *) p->next; 2454 } 2455 return (isdn_net_dev *) NULL; 2456} 2457 2458/* 2459 * Force a net-interface to dial out. 2460 * This is called from the userlevel-routine below or 2461 * from isdn_net_start_xmit(). 2462 */ 2463static int 2464isdn_net_force_dial_lp(isdn_net_local * lp) 2465{ 2466 if ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) { 2467 int chi; 2468 if (lp->phone[1]) { 2469 ulong flags; 2470 2471 /* Grab a free ISDN-Channel */ 2472 spin_lock_irqsave(&dev->lock, flags); 2473 if ((chi = isdn_get_free_channel( 2474 ISDN_USAGE_NET, 2475 lp->l2_proto, 2476 lp->l3_proto, 2477 lp->pre_device, 2478 lp->pre_channel, 2479 lp->msn)) < 0) { 2480 printk(KERN_WARNING "isdn_net_force_dial: No channel for %s\n", lp->name); 2481 spin_unlock_irqrestore(&dev->lock, flags); 2482 return -EAGAIN; 2483 } 2484 lp->dialstate = 1; 2485 /* Connect interface with channel */ 2486 isdn_net_bind_channel(lp, chi); 2487#ifdef CONFIG_ISDN_PPP 2488 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) 2489 if (isdn_ppp_bind(lp) < 0) { 2490 isdn_net_unbind_channel(lp); 2491 spin_unlock_irqrestore(&dev->lock, flags); 2492 return -EAGAIN; 2493 } 2494#endif 2495 /* Initiate dialing */ 2496 spin_unlock_irqrestore(&dev->lock, flags); 2497 isdn_net_dial(); 2498 return 0; 2499 } else 2500 return -EINVAL; 2501 } else 2502 return -EBUSY; 2503} 2504 2505/* 2506 * This is called from certain upper protocol layers (multilink ppp 2507 * and x25iface encapsulation module) that want to initiate dialing 2508 * themselves. 2509 */ 2510int 2511isdn_net_dial_req(isdn_net_local * lp) 2512{ 2513 /* is there a better error code? */ 2514 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) return -EBUSY; 2515 2516 return isdn_net_force_dial_lp(lp); 2517} 2518 2519/* 2520 * Force a net-interface to dial out. 2521 * This is always called from within userspace (ISDN_IOCTL_NET_DIAL). 2522 */ 2523int 2524isdn_net_force_dial(char *name) 2525{ 2526 isdn_net_dev *p = isdn_net_findif(name); 2527 2528 if (!p) 2529 return -ENODEV; 2530 return (isdn_net_force_dial_lp(p->local)); 2531} 2532 2533/* 2534 * Allocate a new network-interface and initialize its data structures. 2535 */ 2536char * 2537isdn_net_new(char *name, struct net_device *master) 2538{ 2539 isdn_net_dev *netdev; 2540 2541 /* Avoid creating an existing interface */ 2542 if (isdn_net_findif(name)) { 2543 printk(KERN_WARNING "isdn_net: interface %s already exists\n", name); 2544 return NULL; 2545 } 2546 if (!(netdev = kzalloc(sizeof(isdn_net_dev), GFP_KERNEL))) { 2547 printk(KERN_WARNING "isdn_net: Could not allocate net-device\n"); 2548 return NULL; 2549 } 2550 if (!(netdev->local = kzalloc(sizeof(isdn_net_local), GFP_KERNEL))) { 2551 printk(KERN_WARNING "isdn_net: Could not allocate device locals\n"); 2552 kfree(netdev); 2553 return NULL; 2554 } 2555 if (name == NULL) 2556 strcpy(netdev->local->name, " "); 2557 else 2558 strcpy(netdev->local->name, name); 2559 strcpy(netdev->dev.name, netdev->local->name); 2560 netdev->dev.priv = netdev->local; 2561 netdev->dev.init = isdn_net_init; 2562 netdev->local->p_encap = ISDN_NET_ENCAP_RAWIP; 2563 if (master) { 2564 /* Device shall be a slave */ 2565 struct net_device *p = (((isdn_net_local *) master->priv)->slave); 2566 struct net_device *q = master; 2567 2568 netdev->local->master = master; 2569 /* Put device at end of slave-chain */ 2570 while (p) { 2571 q = p; 2572 p = (((isdn_net_local *) p->priv)->slave); 2573 } 2574 ((isdn_net_local *) q->priv)->slave = &(netdev->dev); 2575 } else { 2576 /* Device shall be a master */ 2577 /* 2578 * Watchdog timer (currently) for master only. 2579 */ 2580 netdev->dev.tx_timeout = isdn_net_tx_timeout; 2581 netdev->dev.watchdog_timeo = ISDN_NET_TX_TIMEOUT; 2582 if (register_netdev(&netdev->dev) != 0) { 2583 printk(KERN_WARNING "isdn_net: Could not register net-device\n"); 2584 kfree(netdev->local); 2585 kfree(netdev); 2586 return NULL; 2587 } 2588 } 2589 netdev->local->magic = ISDN_NET_MAGIC; 2590 2591 netdev->queue = netdev->local; 2592 spin_lock_init(&netdev->queue_lock); 2593 2594 netdev->local->last = netdev->local; 2595 netdev->local->netdev = netdev; 2596 netdev->local->next = netdev->local; 2597 2598 INIT_WORK(&netdev->local->tqueue, isdn_net_softint); 2599 spin_lock_init(&netdev->local->xmit_lock); 2600 2601 netdev->local->isdn_device = -1; 2602 netdev->local->isdn_channel = -1; 2603 netdev->local->pre_device = -1; 2604 netdev->local->pre_channel = -1; 2605 netdev->local->exclusive = -1; 2606 netdev->local->ppp_slot = -1; 2607 netdev->local->pppbind = -1; 2608 skb_queue_head_init(&netdev->local->super_tx_queue); 2609 netdev->local->l2_proto = ISDN_PROTO_L2_X75I; 2610 netdev->local->l3_proto = ISDN_PROTO_L3_TRANS; 2611 netdev->local->triggercps = 6000; 2612 netdev->local->slavedelay = 10 * HZ; 2613 netdev->local->hupflags = ISDN_INHUP; /* Do hangup even on incoming calls */ 2614 netdev->local->onhtime = 10; /* Default hangup-time for saving costs 2615 of those who forget configuring this */ 2616 netdev->local->dialmax = 1; 2617 netdev->local->flags = ISDN_NET_CBHUP | ISDN_NET_DM_MANUAL; /* Hangup before Callback, manual dial */ 2618 netdev->local->cbdelay = 25; /* Wait 5 secs before Callback */ 2619 netdev->local->dialtimeout = -1; /* Infinite Dial-Timeout */ 2620 netdev->local->dialwait = 5 * HZ; /* Wait 5 sec. after failed dial */ 2621 netdev->local->dialstarted = 0; /* Jiffies of last dial-start */ 2622 netdev->local->dialwait_timer = 0; /* Jiffies of earliest next dial-start */ 2623 2624 /* Put into to netdev-chain */ 2625 netdev->next = (void *) dev->netdev; 2626 dev->netdev = netdev; 2627 return netdev->dev.name; 2628} 2629 2630char * 2631isdn_net_newslave(char *parm) 2632{ 2633 char *p = strchr(parm, ','); 2634 isdn_net_dev *n; 2635 char newname[10]; 2636 2637 if (p) { 2638 /* Slave-Name MUST not be empty */ 2639 if (!strlen(p + 1)) 2640 return NULL; 2641 strcpy(newname, p + 1); 2642 *p = 0; 2643 /* Master must already exist */ 2644 if (!(n = isdn_net_findif(parm))) 2645 return NULL; 2646 /* Master must be a real interface, not a slave */ 2647 if (n->local->master) 2648 return NULL; 2649 /* Master must not be started yet */ 2650 if (isdn_net_device_started(n)) 2651 return NULL; 2652 return (isdn_net_new(newname, &(n->dev))); 2653 } 2654 return NULL; 2655} 2656 2657/* 2658 * Set interface-parameters. 2659 * Always set all parameters, so the user-level application is responsible 2660 * for not overwriting existing setups. It has to get the current 2661 * setup first, if only selected parameters are to be changed. 2662 */ 2663int 2664isdn_net_setcfg(isdn_net_ioctl_cfg * cfg) 2665{ 2666 isdn_net_dev *p = isdn_net_findif(cfg->name); 2667 ulong features; 2668 int i; 2669 int drvidx; 2670 int chidx; 2671 char drvid[25]; 2672 2673 if (p) { 2674 isdn_net_local *lp = p->local; 2675 2676 /* See if any registered driver supports the features we want */ 2677 features = ((1 << cfg->l2_proto) << ISDN_FEATURE_L2_SHIFT) | 2678 ((1 << cfg->l3_proto) << ISDN_FEATURE_L3_SHIFT); 2679 for (i = 0; i < ISDN_MAX_DRIVERS; i++) 2680 if (dev->drv[i]) 2681 if ((dev->drv[i]->interface->features & features) == features) 2682 break; 2683 if (i == ISDN_MAX_DRIVERS) { 2684 printk(KERN_WARNING "isdn_net: No driver with selected features\n"); 2685 return -ENODEV; 2686 } 2687 if (lp->p_encap != cfg->p_encap){ 2688#ifdef CONFIG_ISDN_X25 2689 struct concap_proto * cprot = p -> cprot; 2690#endif 2691 if (isdn_net_device_started(p)) { 2692 printk(KERN_WARNING "%s: cannot change encap when if is up\n", 2693 lp->name); 2694 return -EBUSY; 2695 } 2696#ifdef CONFIG_ISDN_X25 2697 if( cprot && cprot -> pops ) 2698 cprot -> pops -> proto_del ( cprot ); 2699 p -> cprot = NULL; 2700 lp -> dops = NULL; 2701 /* ... , prepare for configuration of new one ... */ 2702 switch ( cfg -> p_encap ){ 2703 case ISDN_NET_ENCAP_X25IFACE: 2704 lp -> dops = &isdn_concap_reliable_dl_dops; 2705 } 2706 /* ... and allocate new one ... */ 2707 p -> cprot = isdn_concap_new( cfg -> p_encap ); 2708 /* p -> cprot == NULL now if p_encap is not supported 2709 by means of the concap_proto mechanism */ 2710 /* the protocol is not configured yet; this will 2711 happen later when isdn_net_reset() is called */ 2712#endif 2713 } 2714 switch ( cfg->p_encap ) { 2715 case ISDN_NET_ENCAP_SYNCPPP: 2716#ifndef CONFIG_ISDN_PPP 2717 printk(KERN_WARNING "%s: SyncPPP support not configured\n", 2718 lp->name); 2719 return -EINVAL; 2720#else 2721 p->dev.type = ARPHRD_PPP; /* change ARP type */ 2722 p->dev.addr_len = 0; 2723 p->dev.do_ioctl = isdn_ppp_dev_ioctl; 2724#endif 2725 break; 2726 case ISDN_NET_ENCAP_X25IFACE: 2727#ifndef CONFIG_ISDN_X25 2728 printk(KERN_WARNING "%s: isdn-x25 support not configured\n", 2729 p->local->name); 2730 return -EINVAL; 2731#else 2732 p->dev.type = ARPHRD_X25; /* change ARP type */ 2733 p->dev.addr_len = 0; 2734#endif 2735 break; 2736 case ISDN_NET_ENCAP_CISCOHDLCK: 2737 p->dev.do_ioctl = isdn_ciscohdlck_dev_ioctl; 2738 break; 2739 default: 2740 if( cfg->p_encap >= 0 && 2741 cfg->p_encap <= ISDN_NET_ENCAP_MAX_ENCAP ) 2742 break; 2743 printk(KERN_WARNING 2744 "%s: encapsulation protocol %d not supported\n", 2745 p->local->name, cfg->p_encap); 2746 return -EINVAL; 2747 } 2748 if (strlen(cfg->drvid)) { 2749 /* A bind has been requested ... */ 2750 char *c, 2751 *e; 2752 2753 drvidx = -1; 2754 chidx = -1; 2755 strcpy(drvid, cfg->drvid); 2756 if ((c = strchr(drvid, ','))) { 2757 /* The channel-number is appended to the driver-Id with a comma */ 2758 chidx = (int) simple_strtoul(c + 1, &e, 10); 2759 if (e == c) 2760 chidx = -1; 2761 *c = '\0'; 2762 } 2763 for (i = 0; i < ISDN_MAX_DRIVERS; i++) 2764 /* Lookup driver-Id in array */ 2765 if (!(strcmp(dev->drvid[i], drvid))) { 2766 drvidx = i; 2767 break; 2768 } 2769 if ((drvidx == -1) || (chidx == -1)) 2770 /* Either driver-Id or channel-number invalid */ 2771 return -ENODEV; 2772 } else { 2773 /* Parameters are valid, so get them */ 2774 drvidx = lp->pre_device; 2775 chidx = lp->pre_channel; 2776 } 2777 if (cfg->exclusive > 0) { 2778 unsigned long flags; 2779 2780 /* If binding is exclusive, try to grab the channel */ 2781 spin_lock_irqsave(&dev->lock, flags); 2782 if ((i = isdn_get_free_channel(ISDN_USAGE_NET, 2783 lp->l2_proto, lp->l3_proto, drvidx, 2784 chidx, lp->msn)) < 0) { 2785 /* Grab failed, because desired channel is in use */ 2786 lp->exclusive = -1; 2787 spin_unlock_irqrestore(&dev->lock, flags); 2788 return -EBUSY; 2789 } 2790 /* All went ok, so update isdninfo */ 2791 dev->usage[i] = ISDN_USAGE_EXCLUSIVE; 2792 isdn_info_update(); 2793 spin_unlock_irqrestore(&dev->lock, flags); 2794 lp->exclusive = i; 2795 } else { 2796 /* Non-exclusive binding or unbind. */ 2797 lp->exclusive = -1; 2798 if ((lp->pre_device != -1) && (cfg->exclusive == -1)) { 2799 isdn_unexclusive_channel(lp->pre_device, lp->pre_channel); 2800 isdn_free_channel(lp->pre_device, lp->pre_channel, ISDN_USAGE_NET); 2801 drvidx = -1; 2802 chidx = -1; 2803 } 2804 } 2805 strcpy(lp->msn, cfg->eaz); 2806 lp->pre_device = drvidx; 2807 lp->pre_channel = chidx; 2808 lp->onhtime = cfg->onhtime; 2809 lp->charge = cfg->charge; 2810 lp->l2_proto = cfg->l2_proto; 2811 lp->l3_proto = cfg->l3_proto; 2812 lp->cbdelay = cfg->cbdelay; 2813 lp->dialmax = cfg->dialmax; 2814 lp->triggercps = cfg->triggercps; 2815 lp->slavedelay = cfg->slavedelay * HZ; 2816 lp->pppbind = cfg->pppbind; 2817 lp->dialtimeout = cfg->dialtimeout >= 0 ? cfg->dialtimeout * HZ : -1; 2818 lp->dialwait = cfg->dialwait * HZ; 2819 if (cfg->secure) 2820 lp->flags |= ISDN_NET_SECURE; 2821 else 2822 lp->flags &= ~ISDN_NET_SECURE; 2823 if (cfg->cbhup) 2824 lp->flags |= ISDN_NET_CBHUP; 2825 else 2826 lp->flags &= ~ISDN_NET_CBHUP; 2827 switch (cfg->callback) { 2828 case 0: 2829 lp->flags &= ~(ISDN_NET_CALLBACK | ISDN_NET_CBOUT); 2830 break; 2831 case 1: 2832 lp->flags |= ISDN_NET_CALLBACK; 2833 lp->flags &= ~ISDN_NET_CBOUT; 2834 break; 2835 case 2: 2836 lp->flags |= ISDN_NET_CBOUT; 2837 lp->flags &= ~ISDN_NET_CALLBACK; 2838 break; 2839 } 2840 lp->flags &= ~ISDN_NET_DIALMODE_MASK; /* first all bits off */ 2841 if (cfg->dialmode && !(cfg->dialmode & ISDN_NET_DIALMODE_MASK)) { 2842 /* old isdnctrl version, where only 0 or 1 is given */ 2843 printk(KERN_WARNING 2844 "Old isdnctrl version detected! Please update.\n"); 2845 lp->flags |= ISDN_NET_DM_OFF; /* turn on `off' bit */ 2846 } 2847 else { 2848 lp->flags |= cfg->dialmode; /* turn on selected bits */ 2849 } 2850 if (cfg->chargehup) 2851 lp->hupflags |= ISDN_CHARGEHUP; 2852 else 2853 lp->hupflags &= ~ISDN_CHARGEHUP; 2854 if (cfg->ihup) 2855 lp->hupflags |= ISDN_INHUP; 2856 else 2857 lp->hupflags &= ~ISDN_INHUP; 2858 if (cfg->chargeint > 10) { 2859 lp->hupflags |= ISDN_CHARGEHUP | ISDN_HAVECHARGE | ISDN_MANCHARGE; 2860 lp->chargeint = cfg->chargeint * HZ; 2861 } 2862 if (cfg->p_encap != lp->p_encap) { 2863 if (cfg->p_encap == ISDN_NET_ENCAP_RAWIP) { 2864 p->dev.hard_header = NULL; 2865 p->dev.hard_header_cache = NULL; 2866 p->dev.header_cache_update = NULL; 2867 p->dev.flags = IFF_NOARP|IFF_POINTOPOINT; 2868 } else { 2869 p->dev.hard_header = isdn_net_header; 2870 if (cfg->p_encap == ISDN_NET_ENCAP_ETHER) { 2871 p->dev.hard_header_cache = lp->org_hhc; 2872 p->dev.header_cache_update = lp->org_hcu; 2873 p->dev.flags = IFF_BROADCAST | IFF_MULTICAST; 2874 } else { 2875 p->dev.hard_header_cache = NULL; 2876 p->dev.header_cache_update = NULL; 2877 p->dev.flags = IFF_NOARP|IFF_POINTOPOINT; 2878 } 2879 } 2880 } 2881 lp->p_encap = cfg->p_encap; 2882 return 0; 2883 } 2884 return -ENODEV; 2885} 2886 2887/* 2888 * Perform get-interface-parameters.ioctl 2889 */ 2890int 2891isdn_net_getcfg(isdn_net_ioctl_cfg * cfg) 2892{ 2893 isdn_net_dev *p = isdn_net_findif(cfg->name); 2894 2895 if (p) { 2896 isdn_net_local *lp = p->local; 2897 2898 strcpy(cfg->eaz, lp->msn); 2899 cfg->exclusive = lp->exclusive; 2900 if (lp->pre_device >= 0) { 2901 sprintf(cfg->drvid, "%s,%d", dev->drvid[lp->pre_device], 2902 lp->pre_channel); 2903 } else 2904 cfg->drvid[0] = '\0'; 2905 cfg->onhtime = lp->onhtime; 2906 cfg->charge = lp->charge; 2907 cfg->l2_proto = lp->l2_proto; 2908 cfg->l3_proto = lp->l3_proto; 2909 cfg->p_encap = lp->p_encap; 2910 cfg->secure = (lp->flags & ISDN_NET_SECURE) ? 1 : 0; 2911 cfg->callback = 0; 2912 if (lp->flags & ISDN_NET_CALLBACK) 2913 cfg->callback = 1; 2914 if (lp->flags & ISDN_NET_CBOUT) 2915 cfg->callback = 2; 2916 cfg->cbhup = (lp->flags & ISDN_NET_CBHUP) ? 1 : 0; 2917 cfg->dialmode = lp->flags & ISDN_NET_DIALMODE_MASK; 2918 cfg->chargehup = (lp->hupflags & 4) ? 1 : 0; 2919 cfg->ihup = (lp->hupflags & 8) ? 1 : 0; 2920 cfg->cbdelay = lp->cbdelay; 2921 cfg->dialmax = lp->dialmax; 2922 cfg->triggercps = lp->triggercps; 2923 cfg->slavedelay = lp->slavedelay / HZ; 2924 cfg->chargeint = (lp->hupflags & ISDN_CHARGEHUP) ? 2925 (lp->chargeint / HZ) : 0; 2926 cfg->pppbind = lp->pppbind; 2927 cfg->dialtimeout = lp->dialtimeout >= 0 ? lp->dialtimeout / HZ : -1; 2928 cfg->dialwait = lp->dialwait / HZ; 2929 if (lp->slave) 2930 strcpy(cfg->slave, ((isdn_net_local *) lp->slave->priv)->name); 2931 else 2932 cfg->slave[0] = '\0'; 2933 if (lp->master) 2934 strcpy(cfg->master, ((isdn_net_local *) lp->master->priv)->name); 2935 else 2936 cfg->master[0] = '\0'; 2937 return 0; 2938 } 2939 return -ENODEV; 2940} 2941 2942/* 2943 * Add a phone-number to an interface. 2944 */ 2945int 2946isdn_net_addphone(isdn_net_ioctl_phone * phone) 2947{ 2948 isdn_net_dev *p = isdn_net_findif(phone->name); 2949 isdn_net_phone *n; 2950 2951 if (p) { 2952 if (!(n = kmalloc(sizeof(isdn_net_phone), GFP_KERNEL))) 2953 return -ENOMEM; 2954 strcpy(n->num, phone->phone); 2955 n->next = p->local->phone[phone->outgoing & 1]; 2956 p->local->phone[phone->outgoing & 1] = n; 2957 return 0; 2958 } 2959 return -ENODEV; 2960} 2961 2962/* 2963 * Copy a string of all phone-numbers of an interface to user space. 2964 * This might sleep and must be called with the isdn semaphore down. 2965 */ 2966int 2967isdn_net_getphones(isdn_net_ioctl_phone * phone, char __user *phones) 2968{ 2969 isdn_net_dev *p = isdn_net_findif(phone->name); 2970 int inout = phone->outgoing & 1; 2971 int more = 0; 2972 int count = 0; 2973 isdn_net_phone *n; 2974 2975 if (!p) 2976 return -ENODEV; 2977 inout &= 1; 2978 for (n = p->local->phone[inout]; n; n = n->next) { 2979 if (more) { 2980 put_user(' ', phones++); 2981 count++; 2982 } 2983 if (copy_to_user(phones, n->num, strlen(n->num) + 1)) { 2984 return -EFAULT; 2985 } 2986 phones += strlen(n->num); 2987 count += strlen(n->num); 2988 more = 1; 2989 } 2990 put_user(0, phones); 2991 count++; 2992 return count; 2993} 2994 2995/* 2996 * Copy a string containing the peer's phone number of a connected interface 2997 * to user space. 2998 */ 2999int 3000isdn_net_getpeer(isdn_net_ioctl_phone *phone, isdn_net_ioctl_phone __user *peer) 3001{ 3002 isdn_net_dev *p = isdn_net_findif(phone->name); 3003 int ch, dv, idx; 3004 3005 if (!p) return -ENODEV; 3006 /* 3007 * Theoretical race: while this executes, the remote number might 3008 * become invalid (hang up) or change (new connection), resulting 3009 * in (partially) wrong number copied to user. This race 3010 * currently ignored. 3011 */ 3012 ch = p->local->isdn_channel; 3013 dv = p->local->isdn_device; 3014 if(ch<0 && dv<0) return -ENOTCONN; 3015 idx = isdn_dc2minor(dv, ch); 3016 if (idx<0) return -ENODEV; 3017 /* for pre-bound channels, we need this extra check */ 3018 if ( strncmp(dev->num[idx],"???",3) == 0 ) return -ENOTCONN; 3019 strncpy(phone->phone,dev->num[idx],ISDN_MSNLEN); 3020 phone->outgoing=USG_OUTGOING(dev->usage[idx]); 3021 if ( copy_to_user(peer,phone,sizeof(*peer)) ) return -EFAULT; 3022 return 0; 3023} 3024/* 3025 * Delete a phone-number from an interface. 3026 */ 3027int 3028isdn_net_delphone(isdn_net_ioctl_phone * phone) 3029{ 3030 isdn_net_dev *p = isdn_net_findif(phone->name); 3031 int inout = phone->outgoing & 1; 3032 isdn_net_phone *n; 3033 isdn_net_phone *m; 3034 3035 if (p) { 3036 n = p->local->phone[inout]; 3037 m = NULL; 3038 while (n) { 3039 if (!strcmp(n->num, phone->phone)) { 3040 if (p->local->dial == n) 3041 p->local->dial = n->next; 3042 if (m) 3043 m->next = n->next; 3044 else 3045 p->local->phone[inout] = n->next; 3046 kfree(n); 3047 return 0; 3048 } 3049 m = n; 3050 n = (isdn_net_phone *) n->next; 3051 } 3052 return -EINVAL; 3053 } 3054 return -ENODEV; 3055} 3056 3057/* 3058 * Delete all phone-numbers of an interface. 3059 */ 3060static int 3061isdn_net_rmallphone(isdn_net_dev * p) 3062{ 3063 isdn_net_phone *n; 3064 isdn_net_phone *m; 3065 int i; 3066 3067 for (i = 0; i < 2; i++) { 3068 n = p->local->phone[i]; 3069 while (n) { 3070 m = n->next; 3071 kfree(n); 3072 n = m; 3073 } 3074 p->local->phone[i] = NULL; 3075 } 3076 p->local->dial = NULL; 3077 return 0; 3078} 3079 3080/* 3081 * Force a hangup of a network-interface. 3082 */ 3083int 3084isdn_net_force_hangup(char *name) 3085{ 3086 isdn_net_dev *p = isdn_net_findif(name); 3087 struct net_device *q; 3088 3089 if (p) { 3090 if (p->local->isdn_device < 0) 3091 return 1; 3092 q = p->local->slave; 3093 /* If this interface has slaves, do a hangup for them also. */ 3094 while (q) { 3095 isdn_net_hangup(q); 3096 q = (((isdn_net_local *) q->priv)->slave); 3097 } 3098 isdn_net_hangup(&p->dev); 3099 return 0; 3100 } 3101 return -ENODEV; 3102} 3103 3104/* 3105 * Helper-function for isdn_net_rm: Do the real work. 3106 */ 3107static int 3108isdn_net_realrm(isdn_net_dev * p, isdn_net_dev * q) 3109{ 3110 u_long flags; 3111 3112 if (isdn_net_device_started(p)) { 3113 return -EBUSY; 3114 } 3115#ifdef CONFIG_ISDN_X25 3116 if( p -> cprot && p -> cprot -> pops ) 3117 p -> cprot -> pops -> proto_del ( p -> cprot ); 3118#endif 3119 /* Free all phone-entries */ 3120 isdn_net_rmallphone(p); 3121 /* If interface is bound exclusive, free channel-usage */ 3122 if (p->local->exclusive != -1) 3123 isdn_unexclusive_channel(p->local->pre_device, p->local->pre_channel); 3124 if (p->local->master) { 3125 /* It's a slave-device, so update master's slave-pointer if necessary */ 3126 if (((isdn_net_local *) (p->local->master->priv))->slave == &p->dev) 3127 ((isdn_net_local *) (p->local->master->priv))->slave = p->local->slave; 3128 } else { 3129 /* Unregister only if it's a master-device */ 3130 p->dev.hard_header_cache = p->local->org_hhc; 3131 p->dev.header_cache_update = p->local->org_hcu; 3132 unregister_netdev(&p->dev); 3133 } 3134 /* Unlink device from chain */ 3135 spin_lock_irqsave(&dev->lock, flags); 3136 if (q) 3137 q->next = p->next; 3138 else 3139 dev->netdev = p->next; 3140 if (p->local->slave) { 3141 /* If this interface has a slave, remove it also */ 3142 char *slavename = ((isdn_net_local *) (p->local->slave->priv))->name; 3143 isdn_net_dev *n = dev->netdev; 3144 q = NULL; 3145 while (n) { 3146 if (!strcmp(n->local->name, slavename)) { 3147 spin_unlock_irqrestore(&dev->lock, flags); 3148 isdn_net_realrm(n, q); 3149 spin_lock_irqsave(&dev->lock, flags); 3150 break; 3151 } 3152 q = n; 3153 n = (isdn_net_dev *) n->next; 3154 } 3155 } 3156 spin_unlock_irqrestore(&dev->lock, flags); 3157 /* If no more net-devices remain, disable auto-hangup timer */ 3158 if (dev->netdev == NULL) 3159 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0); 3160 kfree(p->local); 3161 kfree(p); 3162 3163 return 0; 3164} 3165 3166/* 3167 * Remove a single network-interface. 3168 */ 3169int 3170isdn_net_rm(char *name) 3171{ 3172 u_long flags; 3173 isdn_net_dev *p; 3174 isdn_net_dev *q; 3175 3176 /* Search name in netdev-chain */ 3177 spin_lock_irqsave(&dev->lock, flags); 3178 p = dev->netdev; 3179 q = NULL; 3180 while (p) { 3181 if (!strcmp(p->local->name, name)) { 3182 spin_unlock_irqrestore(&dev->lock, flags); 3183 return (isdn_net_realrm(p, q)); 3184 } 3185 q = p; 3186 p = (isdn_net_dev *) p->next; 3187 } 3188 spin_unlock_irqrestore(&dev->lock, flags); 3189 /* If no more net-devices remain, disable auto-hangup timer */ 3190 if (dev->netdev == NULL) 3191 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0); 3192 return -ENODEV; 3193} 3194 3195/* 3196 * Remove all network-interfaces 3197 */ 3198int 3199isdn_net_rmall(void) 3200{ 3201 u_long flags; 3202 int ret; 3203 3204 /* Walk through netdev-chain */ 3205 spin_lock_irqsave(&dev->lock, flags); 3206 while (dev->netdev) { 3207 if (!dev->netdev->local->master) { 3208 /* Remove master-devices only, slaves get removed with their master */ 3209 spin_unlock_irqrestore(&dev->lock, flags); 3210 if ((ret = isdn_net_realrm(dev->netdev, NULL))) { 3211 return ret; 3212 } 3213 spin_lock_irqsave(&dev->lock, flags); 3214 } 3215 } 3216 dev->netdev = NULL; 3217 spin_unlock_irqrestore(&dev->lock, flags); 3218 return 0; 3219} 3220