Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
isdn_net.c
Go to the documentation of this file.
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 ([email protected])
6  * Copyright 1995,96 by Thinking Objects Software GmbH Wuerzburg
7  * Copyright 1995,96 by Michael Hipp ([email protected])
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  * [email protected]
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 <[email protected]>
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 is 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->tail) {
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  ndev->trans_start = jiffies;
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  ndev->trans_start = jiffies;
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 (memcmp(eth->h_dest, dev->broadcast, ETH_ALEN) == 0)
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 (memcmp(eth->h_dest, dev->dev_addr, ETH_ALEN))
1386  skb->pkt_type = PACKET_OTHERHOST;
1387  }
1388  if (ntohs(eth->h_proto) >= 1536)
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(unsigned long data)
1513 {
1514  isdn_net_local *lp = (isdn_net_local *) data;
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  init_timer(&lp->cisco_timer);
1619  lp->cisco_timer.data = (unsigned long) lp;
1620  lp->cisco_timer.function = isdn_net_ciscohdlck_slarp_send_keepalive;
1621  lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1622  add_timer(&lp->cisco_timer);
1623 }
1624 
1625 static void
1626 isdn_net_ciscohdlck_disconnected(isdn_net_local *lp)
1627 {
1628  del_timer(&lp->cisco_timer);
1629 }
1630 
1631 static void
1632 isdn_net_ciscohdlck_slarp_send_reply(isdn_net_local *lp)
1633 {
1634  struct sk_buff *skb;
1635  unsigned char *p;
1636  struct in_device *in_dev = NULL;
1637  __be32 addr = 0; /* local ipv4 address */
1638  __be32 mask = 0; /* local netmask */
1639 
1640  if ((in_dev = lp->netdev->dev->ip_ptr) != NULL) {
1641  /* take primary(first) address of interface */
1642  struct in_ifaddr *ifa = in_dev->ifa_list;
1643  if (ifa != NULL) {
1644  addr = ifa->ifa_local;
1645  mask = ifa->ifa_mask;
1646  }
1647  }
1648 
1649  skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1650  if (!skb)
1651  return;
1652 
1653  p = skb_put(skb, 4 + 14);
1654 
1655  /* cisco header */
1656  *(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1657  *(u8 *)(p + 1) = CISCO_CTRL;
1658  *(__be16 *)(p + 2) = cpu_to_be16(CISCO_TYPE_SLARP);
1659 
1660  /* slarp reply, send own ip/netmask; if values are nonsense remote
1661  * should think we are unable to provide it with an address via SLARP */
1662  *(__be32 *)(p + 4) = cpu_to_be32(CISCO_SLARP_REPLY);
1663  *(__be32 *)(p + 8) = addr; // address
1664  *(__be32 *)(p + 12) = mask; // netmask
1665  *(__be16 *)(p + 16) = cpu_to_be16(0); // unused
1666  p += 18;
1667 
1668  isdn_net_write_super(lp, skb);
1669 }
1670 
1671 static void
1672 isdn_net_ciscohdlck_slarp_in(isdn_net_local *lp, struct sk_buff *skb)
1673 {
1674  unsigned char *p;
1675  int period;
1676  u32 code;
1677  u32 my_seq;
1678  u32 your_seq;
1679  __be32 local;
1680  __be32 *addr, *mask;
1681 
1682  if (skb->len < 14)
1683  return;
1684 
1685  p = skb->data;
1686  code = be32_to_cpup((__be32 *)p);
1687  p += 4;
1688 
1689  switch (code) {
1690  case CISCO_SLARP_REQUEST:
1691  lp->cisco_yourseq = 0;
1692  isdn_net_ciscohdlck_slarp_send_reply(lp);
1693  break;
1694  case CISCO_SLARP_REPLY:
1695  addr = (__be32 *)p;
1696  mask = (__be32 *)(p + 4);
1697  if (*mask != cpu_to_be32(0xfffffffc))
1698  goto slarp_reply_out;
1699  if ((*addr & cpu_to_be32(3)) == cpu_to_be32(0) ||
1700  (*addr & cpu_to_be32(3)) == cpu_to_be32(3))
1701  goto slarp_reply_out;
1702  local = *addr ^ cpu_to_be32(3);
1703  printk(KERN_INFO "%s: got slarp reply: remote ip: %pI4, local ip: %pI4 mask: %pI4\n",
1704  lp->netdev->dev->name, addr, &local, mask);
1705  break;
1706  slarp_reply_out:
1707  printk(KERN_INFO "%s: got invalid slarp reply (%pI4/%pI4) - ignored\n",
1708  lp->netdev->dev->name, addr, mask);
1709  break;
1710  case CISCO_SLARP_KEEPALIVE:
1711  period = (int)((jiffies - lp->cisco_last_slarp_in
1712  + HZ / 2 - 1) / HZ);
1713  if (lp->cisco_debserint &&
1714  (period != lp->cisco_keepalive_period) &&
1715  lp->cisco_last_slarp_in) {
1716  printk(KERN_DEBUG "%s: Keepalive period mismatch - "
1717  "is %d but should be %d.\n",
1718  lp->netdev->dev->name, period,
1719  lp->cisco_keepalive_period);
1720  }
1721  lp->cisco_last_slarp_in = jiffies;
1722  my_seq = be32_to_cpup((__be32 *)(p + 0));
1723  your_seq = be32_to_cpup((__be32 *)(p + 4));
1724  p += 10;
1725  lp->cisco_yourseq = my_seq;
1726  lp->cisco_mineseen = your_seq;
1727  break;
1728  }
1729 }
1730 
1731 static void
1732 isdn_net_ciscohdlck_receive(isdn_net_local *lp, struct sk_buff *skb)
1733 {
1734  unsigned char *p;
1735  u8 addr;
1736  u8 ctrl;
1737  u16 type;
1738 
1739  if (skb->len < 4)
1740  goto out_free;
1741 
1742  p = skb->data;
1743  addr = *(u8 *)(p + 0);
1744  ctrl = *(u8 *)(p + 1);
1745  type = be16_to_cpup((__be16 *)(p + 2));
1746  p += 4;
1747  skb_pull(skb, 4);
1748 
1749  if (addr != CISCO_ADDR_UNICAST && addr != CISCO_ADDR_BROADCAST) {
1750  printk(KERN_WARNING "%s: Unknown Cisco addr 0x%02x\n",
1751  lp->netdev->dev->name, addr);
1752  goto out_free;
1753  }
1754  if (ctrl != CISCO_CTRL) {
1755  printk(KERN_WARNING "%s: Unknown Cisco ctrl 0x%02x\n",
1756  lp->netdev->dev->name, ctrl);
1757  goto out_free;
1758  }
1759 
1760  switch (type) {
1761  case CISCO_TYPE_SLARP:
1762  isdn_net_ciscohdlck_slarp_in(lp, skb);
1763  goto out_free;
1764  case CISCO_TYPE_CDP:
1765  if (lp->cisco_debserint)
1766  printk(KERN_DEBUG "%s: Received CDP packet. use "
1767  "\"no cdp enable\" on cisco.\n",
1768  lp->netdev->dev->name);
1769  goto out_free;
1770  default:
1771  /* no special cisco protocol */
1772  skb->protocol = htons(type);
1773  netif_rx(skb);
1774  return;
1775  }
1776 
1777 out_free:
1778  kfree_skb(skb);
1779 }
1780 
1781 /*
1782  * Got a packet from ISDN-Channel.
1783  */
1784 static void
1785 isdn_net_receive(struct net_device *ndev, struct sk_buff *skb)
1786 {
1787  isdn_net_local *lp = netdev_priv(ndev);
1788  isdn_net_local *olp = lp; /* original 'lp' */
1789 #ifdef CONFIG_ISDN_X25
1790  struct concap_proto *cprot = lp->netdev->cprot;
1791 #endif
1792  lp->transcount += skb->len;
1793 
1794  lp->stats.rx_packets++;
1795  lp->stats.rx_bytes += skb->len;
1796  if (lp->master) {
1797  /* Bundling: If device is a slave-device, deliver to master, also
1798  * handle master's statistics and hangup-timeout
1799  */
1800  ndev = lp->master;
1801  lp = netdev_priv(ndev);
1802  lp->stats.rx_packets++;
1803  lp->stats.rx_bytes += skb->len;
1804  }
1805  skb->dev = ndev;
1806  skb->pkt_type = PACKET_HOST;
1807  skb_reset_mac_header(skb);
1808 #ifdef ISDN_DEBUG_NET_DUMP
1809  isdn_dumppkt("R:", skb->data, skb->len, 40);
1810 #endif
1811  switch (lp->p_encap) {
1812  case ISDN_NET_ENCAP_ETHER:
1813  /* Ethernet over ISDN */
1814  olp->huptimer = 0;
1815  lp->huptimer = 0;
1816  skb->protocol = isdn_net_type_trans(skb, ndev);
1817  break;
1818  case ISDN_NET_ENCAP_UIHDLC:
1819  /* HDLC with UI-frame (for ispa with -h1 option) */
1820  olp->huptimer = 0;
1821  lp->huptimer = 0;
1822  skb_pull(skb, 2);
1823  /* Fall through */
1824  case ISDN_NET_ENCAP_RAWIP:
1825  /* RAW-IP without MAC-Header */
1826  olp->huptimer = 0;
1827  lp->huptimer = 0;
1828  skb->protocol = htons(ETH_P_IP);
1829  break;
1830  case ISDN_NET_ENCAP_CISCOHDLCK:
1831  isdn_net_ciscohdlck_receive(lp, skb);
1832  return;
1833  case ISDN_NET_ENCAP_CISCOHDLC:
1834  /* CISCO-HDLC IP with type field and fake I-frame-header */
1835  skb_pull(skb, 2);
1836  /* Fall through */
1837  case ISDN_NET_ENCAP_IPTYP:
1838  /* IP with type field */
1839  olp->huptimer = 0;
1840  lp->huptimer = 0;
1841  skb->protocol = *(__be16 *)&(skb->data[0]);
1842  skb_pull(skb, 2);
1843  if (*(unsigned short *) skb->data == 0xFFFF)
1844  skb->protocol = htons(ETH_P_802_3);
1845  break;
1846 #ifdef CONFIG_ISDN_PPP
1847  case ISDN_NET_ENCAP_SYNCPPP:
1848  /* huptimer is done in isdn_ppp_push_higher */
1849  isdn_ppp_receive(lp->netdev, olp, skb);
1850  return;
1851 #endif
1852 
1853  default:
1854 #ifdef CONFIG_ISDN_X25
1855  /* try if there are generic sync_device receiver routines */
1856  if (cprot) if (cprot->pops)
1857  if (cprot->pops->data_ind) {
1858  cprot->pops->data_ind(cprot, skb);
1859  return;
1860  };
1861 #endif /* CONFIG_ISDN_X25 */
1862  printk(KERN_WARNING "%s: unknown encapsulation, dropping\n",
1863  lp->netdev->dev->name);
1864  kfree_skb(skb);
1865  return;
1866  }
1867 
1868  netif_rx(skb);
1869  return;
1870 }
1871 
1872 /*
1873  * A packet arrived via ISDN. Search interface-chain for a corresponding
1874  * interface. If found, deliver packet to receiver-function and return 1,
1875  * else return 0.
1876  */
1877 int
1878 isdn_net_rcv_skb(int idx, struct sk_buff *skb)
1879 {
1880  isdn_net_dev *p = dev->rx_netdev[idx];
1881 
1882  if (p) {
1883  isdn_net_local *lp = p->local;
1884  if ((lp->flags & ISDN_NET_CONNECTED) &&
1885  (!lp->dialstate)) {
1886  isdn_net_receive(p->dev, skb);
1887  return 1;
1888  }
1889  }
1890  return 0;
1891 }
1892 
1893 /*
1894  * build an header
1895  * depends on encaps that is being used.
1896  */
1897 
1898 static int isdn_net_header(struct sk_buff *skb, struct net_device *dev,
1899  unsigned short type,
1900  const void *daddr, const void *saddr, unsigned plen)
1901 {
1902  isdn_net_local *lp = netdev_priv(dev);
1903  unsigned char *p;
1904  int len = 0;
1905 
1906  switch (lp->p_encap) {
1907  case ISDN_NET_ENCAP_ETHER:
1908  len = eth_header(skb, dev, type, daddr, saddr, plen);
1909  break;
1910 #ifdef CONFIG_ISDN_PPP
1911  case ISDN_NET_ENCAP_SYNCPPP:
1912  /* stick on a fake header to keep fragmentation code happy. */
1913  len = IPPP_MAX_HEADER;
1914  skb_push(skb, len);
1915  break;
1916 #endif
1917  case ISDN_NET_ENCAP_RAWIP:
1918  printk(KERN_WARNING "isdn_net_header called with RAW_IP!\n");
1919  len = 0;
1920  break;
1921  case ISDN_NET_ENCAP_IPTYP:
1922  /* ethernet type field */
1923  *((__be16 *)skb_push(skb, 2)) = htons(type);
1924  len = 2;
1925  break;
1926  case ISDN_NET_ENCAP_UIHDLC:
1927  /* HDLC with UI-Frames (for ispa with -h1 option) */
1928  *((__be16 *)skb_push(skb, 2)) = htons(0x0103);
1929  len = 2;
1930  break;
1931  case ISDN_NET_ENCAP_CISCOHDLC:
1932  case ISDN_NET_ENCAP_CISCOHDLCK:
1933  p = skb_push(skb, 4);
1934  *(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1935  *(u8 *)(p + 1) = CISCO_CTRL;
1936  *(__be16 *)(p + 2) = cpu_to_be16(type);
1937  p += 4;
1938  len = 4;
1939  break;
1940 #ifdef CONFIG_ISDN_X25
1941  default:
1942  /* try if there are generic concap protocol routines */
1943  if (lp->netdev->cprot) {
1944  printk(KERN_WARNING "isdn_net_header called with concap_proto!\n");
1945  len = 0;
1946  break;
1947  }
1948  break;
1949 #endif /* CONFIG_ISDN_X25 */
1950  }
1951  return len;
1952 }
1953 
1954 /* We don't need to send arp, because we have point-to-point connections. */
1955 static int
1956 isdn_net_rebuild_header(struct sk_buff *skb)
1957 {
1958  struct net_device *dev = skb->dev;
1959  isdn_net_local *lp = netdev_priv(dev);
1960  int ret = 0;
1961 
1962  if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1963  struct ethhdr *eth = (struct ethhdr *) skb->data;
1964 
1965  /*
1966  * Only ARP/IP is currently supported
1967  */
1968 
1969  if (eth->h_proto != htons(ETH_P_IP)) {
1970  printk(KERN_WARNING
1971  "isdn_net: %s don't know how to resolve type %d addresses?\n",
1972  dev->name, (int) eth->h_proto);
1973  memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
1974  return 0;
1975  }
1976  /*
1977  * Try to get ARP to resolve the header.
1978  */
1979 #ifdef CONFIG_INET
1980  ret = arp_find(eth->h_dest, skb);
1981 #endif
1982  }
1983  return ret;
1984 }
1985 
1986 static int isdn_header_cache(const struct neighbour *neigh, struct hh_cache *hh,
1987  __be16 type)
1988 {
1989  const struct net_device *dev = neigh->dev;
1990  isdn_net_local *lp = netdev_priv(dev);
1991 
1992  if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
1993  return eth_header_cache(neigh, hh, type);
1994  return -1;
1995 }
1996 
1997 static void isdn_header_cache_update(struct hh_cache *hh,
1998  const struct net_device *dev,
1999  const unsigned char *haddr)
2000 {
2001  isdn_net_local *lp = netdev_priv(dev);
2002  if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
2003  eth_header_cache_update(hh, dev, haddr);
2004 }
2005 
2006 static const struct header_ops isdn_header_ops = {
2007  .create = isdn_net_header,
2008  .rebuild = isdn_net_rebuild_header,
2009  .cache = isdn_header_cache,
2010  .cache_update = isdn_header_cache_update,
2011 };
2012 
2013 /*
2014  * Interface-setup. (just after registering a new interface)
2015  */
2016 static int
2017 isdn_net_init(struct net_device *ndev)
2018 {
2019  ushort max_hlhdr_len = 0;
2020  int drvidx;
2021 
2022  /*
2023  * up till binding we ask the protocol layer to reserve as much
2024  * as we might need for HL layer
2025  */
2026 
2027  for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++)
2028  if (dev->drv[drvidx])
2029  if (max_hlhdr_len < dev->drv[drvidx]->interface->hl_hdrlen)
2030  max_hlhdr_len = dev->drv[drvidx]->interface->hl_hdrlen;
2031 
2032  ndev->hard_header_len = ETH_HLEN + max_hlhdr_len;
2033  return 0;
2034 }
2035 
2036 static void
2037 isdn_net_swapbind(int drvidx)
2038 {
2039  isdn_net_dev *p;
2040 
2041 #ifdef ISDN_DEBUG_NET_ICALL
2042  printk(KERN_DEBUG "n_fi: swapping ch of %d\n", drvidx);
2043 #endif
2044  p = dev->netdev;
2045  while (p) {
2046  if (p->local->pre_device == drvidx)
2047  switch (p->local->pre_channel) {
2048  case 0:
2049  p->local->pre_channel = 1;
2050  break;
2051  case 1:
2052  p->local->pre_channel = 0;
2053  break;
2054  }
2055  p = (isdn_net_dev *) p->next;
2056  }
2057 }
2058 
2059 static void
2060 isdn_net_swap_usage(int i1, int i2)
2061 {
2062  int u1 = dev->usage[i1] & ISDN_USAGE_EXCLUSIVE;
2063  int u2 = dev->usage[i2] & ISDN_USAGE_EXCLUSIVE;
2064 
2065 #ifdef ISDN_DEBUG_NET_ICALL
2066  printk(KERN_DEBUG "n_fi: usage of %d and %d\n", i1, i2);
2067 #endif
2068  dev->usage[i1] &= ~ISDN_USAGE_EXCLUSIVE;
2069  dev->usage[i1] |= u2;
2070  dev->usage[i2] &= ~ISDN_USAGE_EXCLUSIVE;
2071  dev->usage[i2] |= u1;
2072  isdn_info_update();
2073 }
2074 
2075 /*
2076  * An incoming call-request has arrived.
2077  * Search the interface-chain for an appropriate interface.
2078  * If found, connect the interface to the ISDN-channel and initiate
2079  * D- and B-Channel-setup. If secure-flag is set, accept only
2080  * configured phone-numbers. If callback-flag is set, initiate
2081  * callback-dialing.
2082  *
2083  * Return-Value: 0 = No appropriate interface for this call.
2084  * 1 = Call accepted
2085  * 2 = Reject call, wait cbdelay, then call back
2086  * 3 = Reject call
2087  * 4 = Wait cbdelay, then call back
2088  * 5 = No appropriate interface for this call,
2089  * would eventually match if CID was longer.
2090  */
2091 
2092 int
2093 isdn_net_find_icall(int di, int ch, int idx, setup_parm *setup)
2094 {
2095  char *eaz;
2096  int si1;
2097  int si2;
2098  int ematch;
2099  int wret;
2100  int swapped;
2101  int sidx = 0;
2102  u_long flags;
2103  isdn_net_dev *p;
2104  isdn_net_phone *n;
2105  char nr[ISDN_MSNLEN];
2106  char *my_eaz;
2107 
2108  /* Search name in netdev-chain */
2109  if (!setup->phone[0]) {
2110  nr[0] = '0';
2111  nr[1] = '\0';
2112  printk(KERN_INFO "isdn_net: Incoming call without OAD, assuming '0'\n");
2113  } else
2114  strlcpy(nr, setup->phone, ISDN_MSNLEN);
2115  si1 = (int) setup->si1;
2116  si2 = (int) setup->si2;
2117  if (!setup->eazmsn[0]) {
2118  printk(KERN_WARNING "isdn_net: Incoming call without CPN, assuming '0'\n");
2119  eaz = "0";
2120  } else
2121  eaz = setup->eazmsn;
2122  if (dev->net_verbose > 1)
2123  printk(KERN_INFO "isdn_net: call from %s,%d,%d -> %s\n", nr, si1, si2, eaz);
2124  /* Accept DATA and VOICE calls at this stage
2125  * local eaz is checked later for allowed call types
2126  */
2127  if ((si1 != 7) && (si1 != 1)) {
2128  if (dev->net_verbose > 1)
2129  printk(KERN_INFO "isdn_net: Service-Indicator not 1 or 7, ignored\n");
2130  return 0;
2131  }
2132  n = (isdn_net_phone *) 0;
2133  p = dev->netdev;
2134  ematch = wret = swapped = 0;
2135 #ifdef ISDN_DEBUG_NET_ICALL
2136  printk(KERN_DEBUG "n_fi: di=%d ch=%d idx=%d usg=%d\n", di, ch, idx,
2137  dev->usage[idx]);
2138 #endif
2139  while (p) {
2140  int matchret;
2141  isdn_net_local *lp = p->local;
2142 
2143  /* If last check has triggered as binding-swap, revert it */
2144  switch (swapped) {
2145  case 2:
2146  isdn_net_swap_usage(idx, sidx);
2147  /* fall through */
2148  case 1:
2149  isdn_net_swapbind(di);
2150  break;
2151  }
2152  swapped = 0;
2153  /* check acceptable call types for DOV */
2154  my_eaz = isdn_map_eaz2msn(lp->msn, di);
2155  if (si1 == 1) { /* it's a DOV call, check if we allow it */
2156  if (*my_eaz == 'v' || *my_eaz == 'V' ||
2157  *my_eaz == 'b' || *my_eaz == 'B')
2158  my_eaz++; /* skip to allow a match */
2159  else
2160  my_eaz = NULL; /* force non match */
2161  } else { /* it's a DATA call, check if we allow it */
2162  if (*my_eaz == 'b' || *my_eaz == 'B')
2163  my_eaz++; /* skip to allow a match */
2164  }
2165  if (my_eaz)
2166  matchret = isdn_msncmp(eaz, my_eaz);
2167  else
2168  matchret = 1;
2169  if (!matchret)
2170  ematch = 1;
2171 
2172  /* Remember if more numbers eventually can match */
2173  if (matchret > wret)
2174  wret = matchret;
2175 #ifdef ISDN_DEBUG_NET_ICALL
2176  printk(KERN_DEBUG "n_fi: if='%s', l.msn=%s, l.flags=%d, l.dstate=%d\n",
2177  p->dev->name, lp->msn, lp->flags, lp->dialstate);
2178 #endif
2179  if ((!matchret) && /* EAZ is matching */
2180  (((!(lp->flags & ISDN_NET_CONNECTED)) && /* but not connected */
2181  (USG_NONE(dev->usage[idx]))) || /* and ch. unused or */
2182  ((((lp->dialstate == 4) || (lp->dialstate == 12)) && /* if dialing */
2183  (!(lp->flags & ISDN_NET_CALLBACK))) /* but no callback */
2184  )))
2185  {
2186 #ifdef ISDN_DEBUG_NET_ICALL
2187  printk(KERN_DEBUG "n_fi: match1, pdev=%d pch=%d\n",
2188  lp->pre_device, lp->pre_channel);
2189 #endif
2190  if (dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) {
2191  if ((lp->pre_channel != ch) ||
2192  (lp->pre_device != di)) {
2193  /* Here we got a problem:
2194  * If using an ICN-Card, an incoming call is always signaled on
2195  * on the first channel of the card, if both channels are
2196  * down. However this channel may be bound exclusive. If the
2197  * second channel is free, this call should be accepted.
2198  * The solution is horribly but it runs, so what:
2199  * We exchange the exclusive bindings of the two channels, the
2200  * corresponding variables in the interface-structs.
2201  */
2202  if (ch == 0) {
2203  sidx = isdn_dc2minor(di, 1);
2204 #ifdef ISDN_DEBUG_NET_ICALL
2205  printk(KERN_DEBUG "n_fi: ch is 0\n");
2206 #endif
2207  if (USG_NONE(dev->usage[sidx])) {
2208  /* Second Channel is free, now see if it is bound
2209  * exclusive too. */
2210  if (dev->usage[sidx] & ISDN_USAGE_EXCLUSIVE) {
2211 #ifdef ISDN_DEBUG_NET_ICALL
2212  printk(KERN_DEBUG "n_fi: 2nd channel is down and bound\n");
2213 #endif
2214  /* Yes, swap bindings only, if the original
2215  * binding is bound to channel 1 of this driver */
2216  if ((lp->pre_device == di) &&
2217  (lp->pre_channel == 1)) {
2218  isdn_net_swapbind(di);
2219  swapped = 1;
2220  } else {
2221  /* ... else iterate next device */
2222  p = (isdn_net_dev *) p->next;
2223  continue;
2224  }
2225  } else {
2226 #ifdef ISDN_DEBUG_NET_ICALL
2227  printk(KERN_DEBUG "n_fi: 2nd channel is down and unbound\n");
2228 #endif
2229  /* No, swap always and swap excl-usage also */
2230  isdn_net_swap_usage(idx, sidx);
2231  isdn_net_swapbind(di);
2232  swapped = 2;
2233  }
2234  /* Now check for exclusive binding again */
2235 #ifdef ISDN_DEBUG_NET_ICALL
2236  printk(KERN_DEBUG "n_fi: final check\n");
2237 #endif
2238  if ((dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) &&
2239  ((lp->pre_channel != ch) ||
2240  (lp->pre_device != di))) {
2241 #ifdef ISDN_DEBUG_NET_ICALL
2242  printk(KERN_DEBUG "n_fi: final check failed\n");
2243 #endif
2244  p = (isdn_net_dev *) p->next;
2245  continue;
2246  }
2247  }
2248  } else {
2249  /* We are already on the second channel, so nothing to do */
2250 #ifdef ISDN_DEBUG_NET_ICALL
2251  printk(KERN_DEBUG "n_fi: already on 2nd channel\n");
2252 #endif
2253  }
2254  }
2255  }
2256 #ifdef ISDN_DEBUG_NET_ICALL
2257  printk(KERN_DEBUG "n_fi: match2\n");
2258 #endif
2259  n = lp->phone[0];
2260  if (lp->flags & ISDN_NET_SECURE) {
2261  while (n) {
2262  if (!isdn_msncmp(nr, n->num))
2263  break;
2264  n = (isdn_net_phone *) n->next;
2265  }
2266  }
2267  if (n || (!(lp->flags & ISDN_NET_SECURE))) {
2268 #ifdef ISDN_DEBUG_NET_ICALL
2269  printk(KERN_DEBUG "n_fi: match3\n");
2270 #endif
2271  /* matching interface found */
2272 
2273  /*
2274  * Is the state STOPPED?
2275  * If so, no dialin is allowed,
2276  * so reject actively.
2277  * */
2278  if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2279  printk(KERN_INFO "incoming call, interface %s `stopped' -> rejected\n",
2280  p->dev->name);
2281  return 3;
2282  }
2283  /*
2284  * Is the interface up?
2285  * If not, reject the call actively.
2286  */
2287  if (!isdn_net_device_started(p)) {
2288  printk(KERN_INFO "%s: incoming call, interface down -> rejected\n",
2289  p->dev->name);
2290  return 3;
2291  }
2292  /* Interface is up, now see if it's a slave. If so, see if
2293  * it's master and parent slave is online. If not, reject the call.
2294  */
2295  if (lp->master) {
2296  isdn_net_local *mlp = ISDN_MASTER_PRIV(lp);
2297  printk(KERN_DEBUG "ICALLslv: %s\n", p->dev->name);
2298  printk(KERN_DEBUG "master=%s\n", lp->master->name);
2299  if (mlp->flags & ISDN_NET_CONNECTED) {
2300  printk(KERN_DEBUG "master online\n");
2301  /* Master is online, find parent-slave (master if first slave) */
2302  while (mlp->slave) {
2303  if (ISDN_SLAVE_PRIV(mlp) == lp)
2304  break;
2305  mlp = ISDN_SLAVE_PRIV(mlp);
2306  }
2307  } else
2308  printk(KERN_DEBUG "master offline\n");
2309  /* Found parent, if it's offline iterate next device */
2310  printk(KERN_DEBUG "mlpf: %d\n", mlp->flags & ISDN_NET_CONNECTED);
2311  if (!(mlp->flags & ISDN_NET_CONNECTED)) {
2312  p = (isdn_net_dev *) p->next;
2313  continue;
2314  }
2315  }
2316  if (lp->flags & ISDN_NET_CALLBACK) {
2317  int chi;
2318  /*
2319  * Is the state MANUAL?
2320  * If so, no callback can be made,
2321  * so reject actively.
2322  * */
2323  if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2324  printk(KERN_INFO "incoming call for callback, interface %s `off' -> rejected\n",
2325  p->dev->name);
2326  return 3;
2327  }
2328  printk(KERN_DEBUG "%s: call from %s -> %s, start callback\n",
2329  p->dev->name, nr, eaz);
2330  if (lp->phone[1]) {
2331  /* Grab a free ISDN-Channel */
2332  spin_lock_irqsave(&dev->lock, flags);
2333  if ((chi =
2334  isdn_get_free_channel(
2335  ISDN_USAGE_NET,
2336  lp->l2_proto,
2337  lp->l3_proto,
2338  lp->pre_device,
2339  lp->pre_channel,
2340  lp->msn)
2341  ) < 0) {
2342 
2343  printk(KERN_WARNING "isdn_net_find_icall: No channel for %s\n",
2344  p->dev->name);
2345  spin_unlock_irqrestore(&dev->lock, flags);
2346  return 0;
2347  }
2348  /* Setup dialstate. */
2349  lp->dtimer = 0;
2350  lp->dialstate = 11;
2351  /* Connect interface with channel */
2352  isdn_net_bind_channel(lp, chi);
2353 #ifdef CONFIG_ISDN_PPP
2354  if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2355  if (isdn_ppp_bind(lp) < 0) {
2356  spin_unlock_irqrestore(&dev->lock, flags);
2357  isdn_net_unbind_channel(lp);
2358  return 0;
2359  }
2360 #endif
2361  spin_unlock_irqrestore(&dev->lock, flags);
2362  /* Initiate dialing by returning 2 or 4 */
2363  return (lp->flags & ISDN_NET_CBHUP) ? 2 : 4;
2364  } else
2365  printk(KERN_WARNING "isdn_net: %s: No phone number\n",
2366  p->dev->name);
2367  return 0;
2368  } else {
2369  printk(KERN_DEBUG "%s: call from %s -> %s accepted\n",
2370  p->dev->name, nr, eaz);
2371  /* if this interface is dialing, it does it probably on a different
2372  device, so free this device */
2373  if ((lp->dialstate == 4) || (lp->dialstate == 12)) {
2374 #ifdef CONFIG_ISDN_PPP
2375  if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2376  isdn_ppp_free(lp);
2377 #endif
2378  isdn_net_lp_disconnected(lp);
2379  isdn_free_channel(lp->isdn_device, lp->isdn_channel,
2380  ISDN_USAGE_NET);
2381  }
2382  spin_lock_irqsave(&dev->lock, flags);
2383  dev->usage[idx] &= ISDN_USAGE_EXCLUSIVE;
2384  dev->usage[idx] |= ISDN_USAGE_NET;
2385  strcpy(dev->num[idx], nr);
2386  isdn_info_update();
2387  dev->st_netdev[idx] = lp->netdev;
2388  lp->isdn_device = di;
2389  lp->isdn_channel = ch;
2390  lp->ppp_slot = -1;
2391  lp->flags |= ISDN_NET_CONNECTED;
2392  lp->dialstate = 7;
2393  lp->dtimer = 0;
2394  lp->outgoing = 0;
2395  lp->huptimer = 0;
2396  lp->hupflags |= ISDN_WAITCHARGE;
2397  lp->hupflags &= ~ISDN_HAVECHARGE;
2398 #ifdef CONFIG_ISDN_PPP
2399  if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
2400  if (isdn_ppp_bind(lp) < 0) {
2401  isdn_net_unbind_channel(lp);
2402  spin_unlock_irqrestore(&dev->lock, flags);
2403  return 0;
2404  }
2405  }
2406 #endif
2407  spin_unlock_irqrestore(&dev->lock, flags);
2408  return 1;
2409  }
2410  }
2411  }
2412  p = (isdn_net_dev *) p->next;
2413  }
2414  /* If none of configured EAZ/MSN matched and not verbose, be silent */
2415  if (!ematch || dev->net_verbose)
2416  printk(KERN_INFO "isdn_net: call from %s -> %d %s ignored\n", nr, di, eaz);
2417  return (wret == 2) ? 5 : 0;
2418 }
2419 
2420 /*
2421  * Search list of net-interfaces for an interface with given name.
2422  */
2423 isdn_net_dev *
2424 isdn_net_findif(char *name)
2425 {
2426  isdn_net_dev *p = dev->netdev;
2427 
2428  while (p) {
2429  if (!strcmp(p->dev->name, name))
2430  return p;
2431  p = (isdn_net_dev *) p->next;
2432  }
2433  return (isdn_net_dev *) NULL;
2434 }
2435 
2436 /*
2437  * Force a net-interface to dial out.
2438  * This is called from the userlevel-routine below or
2439  * from isdn_net_start_xmit().
2440  */
2441 static int
2442 isdn_net_force_dial_lp(isdn_net_local *lp)
2443 {
2444  if ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) {
2445  int chi;
2446  if (lp->phone[1]) {
2447  ulong flags;
2448 
2449  /* Grab a free ISDN-Channel */
2450  spin_lock_irqsave(&dev->lock, flags);
2451  if ((chi = isdn_get_free_channel(
2452  ISDN_USAGE_NET,
2453  lp->l2_proto,
2454  lp->l3_proto,
2455  lp->pre_device,
2456  lp->pre_channel,
2457  lp->msn)) < 0) {
2458  printk(KERN_WARNING "isdn_net_force_dial: No channel for %s\n",
2459  lp->netdev->dev->name);
2460  spin_unlock_irqrestore(&dev->lock, flags);
2461  return -EAGAIN;
2462  }
2463  lp->dialstate = 1;
2464  /* Connect interface with channel */
2465  isdn_net_bind_channel(lp, chi);
2466 #ifdef CONFIG_ISDN_PPP
2467  if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2468  if (isdn_ppp_bind(lp) < 0) {
2469  isdn_net_unbind_channel(lp);
2470  spin_unlock_irqrestore(&dev->lock, flags);
2471  return -EAGAIN;
2472  }
2473 #endif
2474  /* Initiate dialing */
2475  spin_unlock_irqrestore(&dev->lock, flags);
2476  isdn_net_dial();
2477  return 0;
2478  } else
2479  return -EINVAL;
2480  } else
2481  return -EBUSY;
2482 }
2483 
2484 /*
2485  * This is called from certain upper protocol layers (multilink ppp
2486  * and x25iface encapsulation module) that want to initiate dialing
2487  * themselves.
2488  */
2489 int
2490 isdn_net_dial_req(isdn_net_local *lp)
2491 {
2492  /* is there a better error code? */
2493  if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) return -EBUSY;
2494 
2495  return isdn_net_force_dial_lp(lp);
2496 }
2497 
2498 /*
2499  * Force a net-interface to dial out.
2500  * This is always called from within userspace (ISDN_IOCTL_NET_DIAL).
2501  */
2502 int
2503 isdn_net_force_dial(char *name)
2504 {
2505  isdn_net_dev *p = isdn_net_findif(name);
2506 
2507  if (!p)
2508  return -ENODEV;
2509  return (isdn_net_force_dial_lp(p->local));
2510 }
2511 
2512 /* The ISDN-specific entries in the device structure. */
2513 static const struct net_device_ops isdn_netdev_ops = {
2514  .ndo_init = isdn_net_init,
2515  .ndo_open = isdn_net_open,
2516  .ndo_stop = isdn_net_close,
2517  .ndo_do_ioctl = isdn_net_ioctl,
2518 
2519  .ndo_start_xmit = isdn_net_start_xmit,
2520  .ndo_get_stats = isdn_net_get_stats,
2521  .ndo_tx_timeout = isdn_net_tx_timeout,
2522 };
2523 
2524 /*
2525  * Helper for alloc_netdev()
2526  */
2527 static void _isdn_setup(struct net_device *dev)
2528 {
2529  isdn_net_local *lp = netdev_priv(dev);
2530 
2531  ether_setup(dev);
2532 
2533  /* Setup the generic properties */
2534  dev->flags = IFF_NOARP | IFF_POINTOPOINT;
2535 
2536  /* isdn prepends a header in the tx path, can't share skbs */
2537  dev->priv_flags &= ~IFF_TX_SKB_SHARING;
2538  dev->header_ops = NULL;
2539  dev->netdev_ops = &isdn_netdev_ops;
2540 
2541  /* for clients with MPPP maybe higher values better */
2542  dev->tx_queue_len = 30;
2543 
2544  lp->p_encap = ISDN_NET_ENCAP_RAWIP;
2545  lp->magic = ISDN_NET_MAGIC;
2546  lp->last = lp;
2547  lp->next = lp;
2548  lp->isdn_device = -1;
2549  lp->isdn_channel = -1;
2550  lp->pre_device = -1;
2551  lp->pre_channel = -1;
2552  lp->exclusive = -1;
2553  lp->ppp_slot = -1;
2554  lp->pppbind = -1;
2555  skb_queue_head_init(&lp->super_tx_queue);
2556  lp->l2_proto = ISDN_PROTO_L2_X75I;
2557  lp->l3_proto = ISDN_PROTO_L3_TRANS;
2558  lp->triggercps = 6000;
2559  lp->slavedelay = 10 * HZ;
2560  lp->hupflags = ISDN_INHUP; /* Do hangup even on incoming calls */
2561  lp->onhtime = 10; /* Default hangup-time for saving costs */
2562  lp->dialmax = 1;
2563  /* Hangup before Callback, manual dial */
2564  lp->flags = ISDN_NET_CBHUP | ISDN_NET_DM_MANUAL;
2565  lp->cbdelay = 25; /* Wait 5 secs before Callback */
2566  lp->dialtimeout = -1; /* Infinite Dial-Timeout */
2567  lp->dialwait = 5 * HZ; /* Wait 5 sec. after failed dial */
2568  lp->dialstarted = 0; /* Jiffies of last dial-start */
2569  lp->dialwait_timer = 0; /* Jiffies of earliest next dial-start */
2570 }
2571 
2572 /*
2573  * Allocate a new network-interface and initialize its data structures.
2574  */
2575 char *
2576 isdn_net_new(char *name, struct net_device *master)
2577 {
2578  isdn_net_dev *netdev;
2579 
2580  /* Avoid creating an existing interface */
2581  if (isdn_net_findif(name)) {
2582  printk(KERN_WARNING "isdn_net: interface %s already exists\n", name);
2583  return NULL;
2584  }
2585  if (name == NULL)
2586  return NULL;
2587  if (!(netdev = kzalloc(sizeof(isdn_net_dev), GFP_KERNEL))) {
2588  printk(KERN_WARNING "isdn_net: Could not allocate net-device\n");
2589  return NULL;
2590  }
2591  netdev->dev = alloc_netdev(sizeof(isdn_net_local), name, _isdn_setup);
2592  if (!netdev->dev) {
2593  printk(KERN_WARNING "isdn_net: Could not allocate network device\n");
2594  kfree(netdev);
2595  return NULL;
2596  }
2597  netdev->local = netdev_priv(netdev->dev);
2598 
2599  if (master) {
2600  /* Device shall be a slave */
2601  struct net_device *p = MASTER_TO_SLAVE(master);
2602  struct net_device *q = master;
2603 
2604  netdev->local->master = master;
2605  /* Put device at end of slave-chain */
2606  while (p) {
2607  q = p;
2608  p = MASTER_TO_SLAVE(p);
2609  }
2610  MASTER_TO_SLAVE(q) = netdev->dev;
2611  } else {
2612  /* Device shall be a master */
2613  /*
2614  * Watchdog timer (currently) for master only.
2615  */
2616  netdev->dev->watchdog_timeo = ISDN_NET_TX_TIMEOUT;
2617  if (register_netdev(netdev->dev) != 0) {
2618  printk(KERN_WARNING "isdn_net: Could not register net-device\n");
2619  free_netdev(netdev->dev);
2620  kfree(netdev);
2621  return NULL;
2622  }
2623  }
2624  netdev->queue = netdev->local;
2625  spin_lock_init(&netdev->queue_lock);
2626 
2627  netdev->local->netdev = netdev;
2628 
2629  INIT_WORK(&netdev->local->tqueue, isdn_net_softint);
2630  spin_lock_init(&netdev->local->xmit_lock);
2631 
2632  /* Put into to netdev-chain */
2633  netdev->next = (void *) dev->netdev;
2634  dev->netdev = netdev;
2635  return netdev->dev->name;
2636 }
2637 
2638 char *
2639 isdn_net_newslave(char *parm)
2640 {
2641  char *p = strchr(parm, ',');
2642  isdn_net_dev *n;
2643  char newname[10];
2644 
2645  if (p) {
2646  /* Slave-Name MUST not be empty */
2647  if (!strlen(p + 1))
2648  return NULL;
2649  strcpy(newname, p + 1);
2650  *p = 0;
2651  /* Master must already exist */
2652  if (!(n = isdn_net_findif(parm)))
2653  return NULL;
2654  /* Master must be a real interface, not a slave */
2655  if (n->local->master)
2656  return NULL;
2657  /* Master must not be started yet */
2658  if (isdn_net_device_started(n))
2659  return NULL;
2660  return (isdn_net_new(newname, n->dev));
2661  }
2662  return NULL;
2663 }
2664 
2665 /*
2666  * Set interface-parameters.
2667  * Always set all parameters, so the user-level application is responsible
2668  * for not overwriting existing setups. It has to get the current
2669  * setup first, if only selected parameters are to be changed.
2670  */
2671 int
2672 isdn_net_setcfg(isdn_net_ioctl_cfg *cfg)
2673 {
2674  isdn_net_dev *p = isdn_net_findif(cfg->name);
2675  ulong features;
2676  int i;
2677  int drvidx;
2678  int chidx;
2679  char drvid[25];
2680 
2681  if (p) {
2682  isdn_net_local *lp = p->local;
2683 
2684  /* See if any registered driver supports the features we want */
2685  features = ((1 << cfg->l2_proto) << ISDN_FEATURE_L2_SHIFT) |
2686  ((1 << cfg->l3_proto) << ISDN_FEATURE_L3_SHIFT);
2687  for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2688  if (dev->drv[i])
2689  if ((dev->drv[i]->interface->features & features) == features)
2690  break;
2691  if (i == ISDN_MAX_DRIVERS) {
2692  printk(KERN_WARNING "isdn_net: No driver with selected features\n");
2693  return -ENODEV;
2694  }
2695  if (lp->p_encap != cfg->p_encap) {
2696 #ifdef CONFIG_ISDN_X25
2697  struct concap_proto *cprot = p->cprot;
2698 #endif
2699  if (isdn_net_device_started(p)) {
2700  printk(KERN_WARNING "%s: cannot change encap when if is up\n",
2701  p->dev->name);
2702  return -EBUSY;
2703  }
2704 #ifdef CONFIG_ISDN_X25
2705  if (cprot && cprot->pops)
2706  cprot->pops->proto_del(cprot);
2707  p->cprot = NULL;
2708  lp->dops = NULL;
2709  /* ... , prepare for configuration of new one ... */
2710  switch (cfg->p_encap) {
2711  case ISDN_NET_ENCAP_X25IFACE:
2712  lp->dops = &isdn_concap_reliable_dl_dops;
2713  }
2714  /* ... and allocate new one ... */
2715  p->cprot = isdn_concap_new(cfg->p_encap);
2716  /* p -> cprot == NULL now if p_encap is not supported
2717  by means of the concap_proto mechanism */
2718  /* the protocol is not configured yet; this will
2719  happen later when isdn_net_reset() is called */
2720 #endif
2721  }
2722  switch (cfg->p_encap) {
2723  case ISDN_NET_ENCAP_SYNCPPP:
2724 #ifndef CONFIG_ISDN_PPP
2725  printk(KERN_WARNING "%s: SyncPPP support not configured\n",
2726  p->dev->name);
2727  return -EINVAL;
2728 #else
2729  p->dev->type = ARPHRD_PPP; /* change ARP type */
2730  p->dev->addr_len = 0;
2731 #endif
2732  break;
2733  case ISDN_NET_ENCAP_X25IFACE:
2734 #ifndef CONFIG_ISDN_X25
2735  printk(KERN_WARNING "%s: isdn-x25 support not configured\n",
2736  p->dev->name);
2737  return -EINVAL;
2738 #else
2739  p->dev->type = ARPHRD_X25; /* change ARP type */
2740  p->dev->addr_len = 0;
2741 #endif
2742  break;
2743  case ISDN_NET_ENCAP_CISCOHDLCK:
2744  break;
2745  default:
2746  if (cfg->p_encap >= 0 &&
2747  cfg->p_encap <= ISDN_NET_ENCAP_MAX_ENCAP)
2748  break;
2749  printk(KERN_WARNING
2750  "%s: encapsulation protocol %d not supported\n",
2751  p->dev->name, cfg->p_encap);
2752  return -EINVAL;
2753  }
2754  if (strlen(cfg->drvid)) {
2755  /* A bind has been requested ... */
2756  char *c,
2757  *e;
2758 
2759  if (strnlen(cfg->drvid, sizeof(cfg->drvid)) ==
2760  sizeof(cfg->drvid))
2761  return -EINVAL;
2762  drvidx = -1;
2763  chidx = -1;
2764  strcpy(drvid, cfg->drvid);
2765  if ((c = strchr(drvid, ','))) {
2766  /* The channel-number is appended to the driver-Id with a comma */
2767  chidx = (int) simple_strtoul(c + 1, &e, 10);
2768  if (e == c)
2769  chidx = -1;
2770  *c = '\0';
2771  }
2772  for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2773  /* Lookup driver-Id in array */
2774  if (!(strcmp(dev->drvid[i], drvid))) {
2775  drvidx = i;
2776  break;
2777  }
2778  if ((drvidx == -1) || (chidx == -1))
2779  /* Either driver-Id or channel-number invalid */
2780  return -ENODEV;
2781  } else {
2782  /* Parameters are valid, so get them */
2783  drvidx = lp->pre_device;
2784  chidx = lp->pre_channel;
2785  }
2786  if (cfg->exclusive > 0) {
2787  unsigned long flags;
2788 
2789  /* If binding is exclusive, try to grab the channel */
2790  spin_lock_irqsave(&dev->lock, flags);
2791  if ((i = isdn_get_free_channel(ISDN_USAGE_NET,
2792  lp->l2_proto, lp->l3_proto, drvidx,
2793  chidx, lp->msn)) < 0) {
2794  /* Grab failed, because desired channel is in use */
2795  lp->exclusive = -1;
2796  spin_unlock_irqrestore(&dev->lock, flags);
2797  return -EBUSY;
2798  }
2799  /* All went ok, so update isdninfo */
2800  dev->usage[i] = ISDN_USAGE_EXCLUSIVE;
2801  isdn_info_update();
2802  spin_unlock_irqrestore(&dev->lock, flags);
2803  lp->exclusive = i;
2804  } else {
2805  /* Non-exclusive binding or unbind. */
2806  lp->exclusive = -1;
2807  if ((lp->pre_device != -1) && (cfg->exclusive == -1)) {
2808  isdn_unexclusive_channel(lp->pre_device, lp->pre_channel);
2809  isdn_free_channel(lp->pre_device, lp->pre_channel, ISDN_USAGE_NET);
2810  drvidx = -1;
2811  chidx = -1;
2812  }
2813  }
2814  strlcpy(lp->msn, cfg->eaz, sizeof(lp->msn));
2815  lp->pre_device = drvidx;
2816  lp->pre_channel = chidx;
2817  lp->onhtime = cfg->onhtime;
2818  lp->charge = cfg->charge;
2819  lp->l2_proto = cfg->l2_proto;
2820  lp->l3_proto = cfg->l3_proto;
2821  lp->cbdelay = cfg->cbdelay;
2822  lp->dialmax = cfg->dialmax;
2823  lp->triggercps = cfg->triggercps;
2824  lp->slavedelay = cfg->slavedelay * HZ;
2825  lp->pppbind = cfg->pppbind;
2826  lp->dialtimeout = cfg->dialtimeout >= 0 ? cfg->dialtimeout * HZ : -1;
2827  lp->dialwait = cfg->dialwait * HZ;
2828  if (cfg->secure)
2829  lp->flags |= ISDN_NET_SECURE;
2830  else
2831  lp->flags &= ~ISDN_NET_SECURE;
2832  if (cfg->cbhup)
2833  lp->flags |= ISDN_NET_CBHUP;
2834  else
2835  lp->flags &= ~ISDN_NET_CBHUP;
2836  switch (cfg->callback) {
2837  case 0:
2838  lp->flags &= ~(ISDN_NET_CALLBACK | ISDN_NET_CBOUT);
2839  break;
2840  case 1:
2841  lp->flags |= ISDN_NET_CALLBACK;
2842  lp->flags &= ~ISDN_NET_CBOUT;
2843  break;
2844  case 2:
2845  lp->flags |= ISDN_NET_CBOUT;
2846  lp->flags &= ~ISDN_NET_CALLBACK;
2847  break;
2848  }
2849  lp->flags &= ~ISDN_NET_DIALMODE_MASK; /* first all bits off */
2850  if (cfg->dialmode && !(cfg->dialmode & ISDN_NET_DIALMODE_MASK)) {
2851  /* old isdnctrl version, where only 0 or 1 is given */
2852  printk(KERN_WARNING
2853  "Old isdnctrl version detected! Please update.\n");
2854  lp->flags |= ISDN_NET_DM_OFF; /* turn on `off' bit */
2855  }
2856  else {
2857  lp->flags |= cfg->dialmode; /* turn on selected bits */
2858  }
2859  if (cfg->chargehup)
2860  lp->hupflags |= ISDN_CHARGEHUP;
2861  else
2862  lp->hupflags &= ~ISDN_CHARGEHUP;
2863  if (cfg->ihup)
2864  lp->hupflags |= ISDN_INHUP;
2865  else
2866  lp->hupflags &= ~ISDN_INHUP;
2867  if (cfg->chargeint > 10) {
2868  lp->hupflags |= ISDN_CHARGEHUP | ISDN_HAVECHARGE | ISDN_MANCHARGE;
2869  lp->chargeint = cfg->chargeint * HZ;
2870  }
2871  if (cfg->p_encap != lp->p_encap) {
2872  if (cfg->p_encap == ISDN_NET_ENCAP_RAWIP) {
2873  p->dev->header_ops = NULL;
2874  p->dev->flags = IFF_NOARP | IFF_POINTOPOINT;
2875  } else {
2876  p->dev->header_ops = &isdn_header_ops;
2877  if (cfg->p_encap == ISDN_NET_ENCAP_ETHER)
2878  p->dev->flags = IFF_BROADCAST | IFF_MULTICAST;
2879  else
2880  p->dev->flags = IFF_NOARP | IFF_POINTOPOINT;
2881  }
2882  }
2883  lp->p_encap = cfg->p_encap;
2884  return 0;
2885  }
2886  return -ENODEV;
2887 }
2888 
2889 /*
2890  * Perform get-interface-parameters.ioctl
2891  */
2892 int
2893 isdn_net_getcfg(isdn_net_ioctl_cfg *cfg)
2894 {
2895  isdn_net_dev *p = isdn_net_findif(cfg->name);
2896 
2897  if (p) {
2898  isdn_net_local *lp = p->local;
2899 
2900  strcpy(cfg->eaz, lp->msn);
2901  cfg->exclusive = lp->exclusive;
2902  if (lp->pre_device >= 0) {
2903  sprintf(cfg->drvid, "%s,%d", dev->drvid[lp->pre_device],
2904  lp->pre_channel);
2905  } else
2906  cfg->drvid[0] = '\0';
2907  cfg->onhtime = lp->onhtime;
2908  cfg->charge = lp->charge;
2909  cfg->l2_proto = lp->l2_proto;
2910  cfg->l3_proto = lp->l3_proto;
2911  cfg->p_encap = lp->p_encap;
2912  cfg->secure = (lp->flags & ISDN_NET_SECURE) ? 1 : 0;
2913  cfg->callback = 0;
2914  if (lp->flags & ISDN_NET_CALLBACK)
2915  cfg->callback = 1;
2916  if (lp->flags & ISDN_NET_CBOUT)
2917  cfg->callback = 2;
2918  cfg->cbhup = (lp->flags & ISDN_NET_CBHUP) ? 1 : 0;
2919  cfg->dialmode = lp->flags & ISDN_NET_DIALMODE_MASK;
2920  cfg->chargehup = (lp->hupflags & 4) ? 1 : 0;
2921  cfg->ihup = (lp->hupflags & 8) ? 1 : 0;
2922  cfg->cbdelay = lp->cbdelay;
2923  cfg->dialmax = lp->dialmax;
2924  cfg->triggercps = lp->triggercps;
2925  cfg->slavedelay = lp->slavedelay / HZ;
2926  cfg->chargeint = (lp->hupflags & ISDN_CHARGEHUP) ?
2927  (lp->chargeint / HZ) : 0;
2928  cfg->pppbind = lp->pppbind;
2929  cfg->dialtimeout = lp->dialtimeout >= 0 ? lp->dialtimeout / HZ : -1;
2930  cfg->dialwait = lp->dialwait / HZ;
2931  if (lp->slave) {
2932  if (strlen(lp->slave->name) >= 10)
2933  strcpy(cfg->slave, "too-long");
2934  else
2935  strcpy(cfg->slave, lp->slave->name);
2936  } else
2937  cfg->slave[0] = '\0';
2938  if (lp->master) {
2939  if (strlen(lp->master->name) >= 10)
2940  strcpy(cfg->master, "too-long");
2941  else
2942  strcpy(cfg->master, lp->master->name);
2943  } else
2944  cfg->master[0] = '\0';
2945  return 0;
2946  }
2947  return -ENODEV;
2948 }
2949 
2950 /*
2951  * Add a phone-number to an interface.
2952  */
2953 int
2954 isdn_net_addphone(isdn_net_ioctl_phone *phone)
2955 {
2956  isdn_net_dev *p = isdn_net_findif(phone->name);
2957  isdn_net_phone *n;
2958 
2959  if (p) {
2960  if (!(n = kmalloc(sizeof(isdn_net_phone), GFP_KERNEL)))
2961  return -ENOMEM;
2962  strlcpy(n->num, phone->phone, sizeof(n->num));
2963  n->next = p->local->phone[phone->outgoing & 1];
2964  p->local->phone[phone->outgoing & 1] = n;
2965  return 0;
2966  }
2967  return -ENODEV;
2968 }
2969 
2970 /*
2971  * Copy a string of all phone-numbers of an interface to user space.
2972  * This might sleep and must be called with the isdn semaphore down.
2973  */
2974 int
2975 isdn_net_getphones(isdn_net_ioctl_phone *phone, char __user *phones)
2976 {
2977  isdn_net_dev *p = isdn_net_findif(phone->name);
2978  int inout = phone->outgoing & 1;
2979  int more = 0;
2980  int count = 0;
2981  isdn_net_phone *n;
2982 
2983  if (!p)
2984  return -ENODEV;
2985  inout &= 1;
2986  for (n = p->local->phone[inout]; n; n = n->next) {
2987  if (more) {
2988  put_user(' ', phones++);
2989  count++;
2990  }
2991  if (copy_to_user(phones, n->num, strlen(n->num) + 1)) {
2992  return -EFAULT;
2993  }
2994  phones += strlen(n->num);
2995  count += strlen(n->num);
2996  more = 1;
2997  }
2998  put_user(0, phones);
2999  count++;
3000  return count;
3001 }
3002 
3003 /*
3004  * Copy a string containing the peer's phone number of a connected interface
3005  * to user space.
3006  */
3007 int
3008 isdn_net_getpeer(isdn_net_ioctl_phone *phone, isdn_net_ioctl_phone __user *peer)
3009 {
3010  isdn_net_dev *p = isdn_net_findif(phone->name);
3011  int ch, dv, idx;
3012 
3013  if (!p)
3014  return -ENODEV;
3015  /*
3016  * Theoretical race: while this executes, the remote number might
3017  * become invalid (hang up) or change (new connection), resulting
3018  * in (partially) wrong number copied to user. This race
3019  * currently ignored.
3020  */
3021  ch = p->local->isdn_channel;
3022  dv = p->local->isdn_device;
3023  if (ch < 0 && dv < 0)
3024  return -ENOTCONN;
3025  idx = isdn_dc2minor(dv, ch);
3026  if (idx < 0)
3027  return -ENODEV;
3028  /* for pre-bound channels, we need this extra check */
3029  if (strncmp(dev->num[idx], "???", 3) == 0)
3030  return -ENOTCONN;
3031  strncpy(phone->phone, dev->num[idx], ISDN_MSNLEN);
3032  phone->outgoing = USG_OUTGOING(dev->usage[idx]);
3033  if (copy_to_user(peer, phone, sizeof(*peer)))
3034  return -EFAULT;
3035  return 0;
3036 }
3037 /*
3038  * Delete a phone-number from an interface.
3039  */
3040 int
3041 isdn_net_delphone(isdn_net_ioctl_phone *phone)
3042 {
3043  isdn_net_dev *p = isdn_net_findif(phone->name);
3044  int inout = phone->outgoing & 1;
3045  isdn_net_phone *n;
3046  isdn_net_phone *m;
3047 
3048  if (p) {
3049  n = p->local->phone[inout];
3050  m = NULL;
3051  while (n) {
3052  if (!strcmp(n->num, phone->phone)) {
3053  if (p->local->dial == n)
3054  p->local->dial = n->next;
3055  if (m)
3056  m->next = n->next;
3057  else
3058  p->local->phone[inout] = n->next;
3059  kfree(n);
3060  return 0;
3061  }
3062  m = n;
3063  n = (isdn_net_phone *) n->next;
3064  }
3065  return -EINVAL;
3066  }
3067  return -ENODEV;
3068 }
3069 
3070 /*
3071  * Delete all phone-numbers of an interface.
3072  */
3073 static int
3074 isdn_net_rmallphone(isdn_net_dev *p)
3075 {
3076  isdn_net_phone *n;
3077  isdn_net_phone *m;
3078  int i;
3079 
3080  for (i = 0; i < 2; i++) {
3081  n = p->local->phone[i];
3082  while (n) {
3083  m = n->next;
3084  kfree(n);
3085  n = m;
3086  }
3087  p->local->phone[i] = NULL;
3088  }
3089  p->local->dial = NULL;
3090  return 0;
3091 }
3092 
3093 /*
3094  * Force a hangup of a network-interface.
3095  */
3096 int
3097 isdn_net_force_hangup(char *name)
3098 {
3099  isdn_net_dev *p = isdn_net_findif(name);
3100  struct net_device *q;
3101 
3102  if (p) {
3103  if (p->local->isdn_device < 0)
3104  return 1;
3105  q = p->local->slave;
3106  /* If this interface has slaves, do a hangup for them also. */
3107  while (q) {
3108  isdn_net_hangup(q);
3109  q = MASTER_TO_SLAVE(q);
3110  }
3111  isdn_net_hangup(p->dev);
3112  return 0;
3113  }
3114  return -ENODEV;
3115 }
3116 
3117 /*
3118  * Helper-function for isdn_net_rm: Do the real work.
3119  */
3120 static int
3121 isdn_net_realrm(isdn_net_dev *p, isdn_net_dev *q)
3122 {
3123  u_long flags;
3124 
3125  if (isdn_net_device_started(p)) {
3126  return -EBUSY;
3127  }
3128 #ifdef CONFIG_ISDN_X25
3129  if (p->cprot && p->cprot->pops)
3130  p->cprot->pops->proto_del(p->cprot);
3131 #endif
3132  /* Free all phone-entries */
3133  isdn_net_rmallphone(p);
3134  /* If interface is bound exclusive, free channel-usage */
3135  if (p->local->exclusive != -1)
3136  isdn_unexclusive_channel(p->local->pre_device, p->local->pre_channel);
3137  if (p->local->master) {
3138  /* It's a slave-device, so update master's slave-pointer if necessary */
3139  if (((isdn_net_local *) ISDN_MASTER_PRIV(p->local))->slave ==
3140  p->dev)
3141  ((isdn_net_local *)ISDN_MASTER_PRIV(p->local))->slave =
3142  p->local->slave;
3143  } else {
3144  /* Unregister only if it's a master-device */
3145  unregister_netdev(p->dev);
3146  }
3147  /* Unlink device from chain */
3148  spin_lock_irqsave(&dev->lock, flags);
3149  if (q)
3150  q->next = p->next;
3151  else
3152  dev->netdev = p->next;
3153  if (p->local->slave) {
3154  /* If this interface has a slave, remove it also */
3155  char *slavename = p->local->slave->name;
3156  isdn_net_dev *n = dev->netdev;
3157  q = NULL;
3158  while (n) {
3159  if (!strcmp(n->dev->name, slavename)) {
3160  spin_unlock_irqrestore(&dev->lock, flags);
3161  isdn_net_realrm(n, q);
3162  spin_lock_irqsave(&dev->lock, flags);
3163  break;
3164  }
3165  q = n;
3166  n = (isdn_net_dev *)n->next;
3167  }
3168  }
3169  spin_unlock_irqrestore(&dev->lock, flags);
3170  /* If no more net-devices remain, disable auto-hangup timer */
3171  if (dev->netdev == NULL)
3172  isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0);
3173  free_netdev(p->dev);
3174  kfree(p);
3175 
3176  return 0;
3177 }
3178 
3179 /*
3180  * Remove a single network-interface.
3181  */
3182 int
3183 isdn_net_rm(char *name)
3184 {
3185  u_long flags;
3186  isdn_net_dev *p;
3187  isdn_net_dev *q;
3188 
3189  /* Search name in netdev-chain */
3190  spin_lock_irqsave(&dev->lock, flags);
3191  p = dev->netdev;
3192  q = NULL;
3193  while (p) {
3194  if (!strcmp(p->dev->name, name)) {
3195  spin_unlock_irqrestore(&dev->lock, flags);
3196  return (isdn_net_realrm(p, q));
3197  }
3198  q = p;
3199  p = (isdn_net_dev *) p->next;
3200  }
3201  spin_unlock_irqrestore(&dev->lock, flags);
3202  /* If no more net-devices remain, disable auto-hangup timer */
3203  if (dev->netdev == NULL)
3204  isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0);
3205  return -ENODEV;
3206 }
3207 
3208 /*
3209  * Remove all network-interfaces
3210  */
3211 int
3212 isdn_net_rmall(void)
3213 {
3214  u_long flags;
3215  int ret;
3216 
3217  /* Walk through netdev-chain */
3218  spin_lock_irqsave(&dev->lock, flags);
3219  while (dev->netdev) {
3220  if (!dev->netdev->local->master) {
3221  /* Remove master-devices only, slaves get removed with their master */
3222  spin_unlock_irqrestore(&dev->lock, flags);
3223  if ((ret = isdn_net_realrm(dev->netdev, NULL))) {
3224  return ret;
3225  }
3226  spin_lock_irqsave(&dev->lock, flags);
3227  }
3228  }
3229  dev->netdev = NULL;
3230  spin_unlock_irqrestore(&dev->lock, flags);
3231  return 0;
3232 }
Generated on Thu Jan 10 2013 13:42:20 for Linux Kernel by   doxygen 1.8.2