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