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