drivers/isdn/i4l/isdn_net.c

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