1 /* $Id: isdn_net.c,v 1.1.2.2 2004/01/12 22:37:19 keil Exp $
3 * Linux ISDN subsystem, network interfaces and related functions (linklevel).
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)
9 * This software may be used and distributed according to the terms
10 * of the GNU General Public License, incorporated herein by reference.
12 * Data Over Voice (DOV) support added - Guy Ellis 23-Mar-02
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
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
25 #include <linux/isdn.h>
28 #include <net/pkt_sched.h>
29 #include <linux/inetdevice.h>
30 #include "isdn_common.h"
32 #ifdef CONFIG_ISDN_PPP
35 #ifdef CONFIG_ISDN_X25
36 #include <linux/concap.h>
37 #include "isdn_concap.h"
42 * Outline of new tbusy handling:
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.
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.
58 * Most of the changes were pretty obvious and basically done by HE already.
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_*
69 * Find out if the netdevice has been ifup-ed yet.
70 * For slaves, look at the corresponding master.
72 static __inline__ int isdn_net_device_started(isdn_net_dev *n)
74 isdn_net_local *lp = n->local;
75 struct net_device *dev;
81 return netif_running(dev);
85 * wake up the network -> net_device queue.
86 * For slaves, wake the corresponding master interface.
88 static __inline__ void isdn_net_device_wake_queue(isdn_net_local *lp)
91 netif_wake_queue(lp->master);
93 netif_wake_queue(&lp->netdev->dev);
97 * stop the network -> net_device queue.
98 * For slaves, stop the corresponding master interface.
100 static __inline__ void isdn_net_device_stop_queue(isdn_net_local *lp)
103 netif_stop_queue(lp->master);
105 netif_stop_queue(&lp->netdev->dev);
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)
113 static __inline__ int isdn_net_device_busy(isdn_net_local *lp)
119 if (!isdn_net_lp_busy(lp))
123 nd = ((isdn_net_local *) lp->master->priv)->netdev;
127 spin_lock_irqsave(&nd->queue_lock, flags);
130 if (!isdn_net_lp_busy(nlp)) {
131 spin_unlock_irqrestore(&nd->queue_lock, flags);
136 spin_unlock_irqrestore(&nd->queue_lock, flags);
140 static __inline__ void isdn_net_inc_frame_cnt(isdn_net_local *lp)
142 atomic_inc(&lp->frame_cnt);
143 if (isdn_net_device_busy(lp))
144 isdn_net_device_stop_queue(lp);
147 static __inline__ void isdn_net_dec_frame_cnt(isdn_net_local *lp)
149 atomic_dec(&lp->frame_cnt);
151 if (!(isdn_net_device_busy(lp))) {
152 if (!skb_queue_empty(&lp->super_tx_queue)) {
153 schedule_work(&lp->tqueue);
155 isdn_net_device_wake_queue(lp);
160 static __inline__ void isdn_net_zero_frame_cnt(isdn_net_local *lp)
162 atomic_set(&lp->frame_cnt, 0);
165 /* For 2.2.x we leave the transmitter busy timeout at 2 secs, just
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...
174 #define ISDN_NET_TX_TIMEOUT (20*HZ)
178 static int isdn_net_force_dial_lp(isdn_net_local *);
179 static int isdn_net_start_xmit(struct sk_buff *, struct net_device *);
181 static void isdn_net_ciscohdlck_connected(isdn_net_local *lp);
182 static void isdn_net_ciscohdlck_disconnected(isdn_net_local *lp);
184 char *isdn_net_revision = "$Revision: 1.1.2.2 $";
187 * Code for raw-networking over ISDN
191 isdn_net_unreachable(struct net_device *dev, struct sk_buff *skb, char *reason)
195 u_short proto = ntohs(skb->protocol);
197 printk(KERN_DEBUG "isdn_net: %s: %s, signalling dst_link_failure %s\n",
199 (reason != NULL) ? reason : "unknown",
200 (proto != ETH_P_IP) ? "Protocol != ETH_P_IP" : "");
202 dst_link_failure(skb);
204 else { /* dial not triggered by rawIP packet */
205 printk(KERN_DEBUG "isdn_net: %s: %s\n",
207 (reason != NULL) ? reason : "reason unknown");
212 isdn_net_reset(struct net_device *dev)
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;
220 #ifdef CONFIG_ISDN_X25
221 if( cprot && cprot -> pops && dops )
222 cprot -> pops -> restart ( cprot, dev, dops );
226 /* Open/initialize the board. */
228 isdn_net_open(struct net_device *dev)
231 struct net_device *p;
232 struct in_device *in_dev;
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);
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) {
245 * Any address will do - we take the first
247 struct in_ifaddr *ifa = in_dev->ifa_list;
249 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
252 /* If this interface has slaves, start them also */
254 if ((p = (((isdn_net_local *) dev->priv)->slave))) {
257 p = (((isdn_net_local *) p->priv)->slave);
265 * Assign an ISDN-channel to a net-interface
268 isdn_net_bind_channel(isdn_net_local * lp, int idx)
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;
278 * unbind a net-interface (resets interface after an error)
281 isdn_net_unbind_channel(isdn_net_local * lp)
283 skb_queue_purge(&lp->super_tx_queue);
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
290 qdisc_reset(lp->netdev->dev.qdisc);
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;
302 * Perform auto-hangup and cps-calculation for net-interfaces.
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
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.
314 static unsigned long last_jiffies = -HZ;
317 isdn_net_autohup(void)
319 isdn_net_dev *p = dev->netdev;
324 isdn_net_local *l = p->local;
325 if (jiffies == last_jiffies)
326 l->cps = l->transcount;
328 l->cps = (l->transcount * HZ) / (jiffies - last_jiffies);
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)) {
336 * if there is some dialmode where timeout-hangup
337 * should _not_ be done, check for that here
340 (l->huptimer > l->onhtime))
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)) {
357 "isdn_net: %s: chtime = %lu, chint = %d\n",
358 l->name, l->chargetime, l->chargeint);
359 isdn_net_hangup(&p->dev);
362 isdn_net_hangup(&p->dev);
363 } else if (l->hupflags & ISDN_INHUP)
364 isdn_net_hangup(&p->dev);
367 if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*l) == ISDN_NET_DM_OFF)) {
368 isdn_net_hangup(&p->dev);
372 p = (isdn_net_dev *) p->next;
374 last_jiffies = jiffies;
375 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, anymore);
378 static void isdn_net_lp_disconnected(isdn_net_local *lp)
380 isdn_net_rm_from_bundle(lp);
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.
390 isdn_net_stat_callback(int idx, isdn_ctrl *c)
392 isdn_net_dev *p = dev->st_netdev[idx];
393 int cmd = c->command;
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;
402 case ISDN_STAT_BSENT:
403 /* A packet has successfully been sent out */
404 if ((lp->flags & ISDN_NET_CONNECTED) &&
406 isdn_net_dec_frame_cnt(lp);
407 lp->stats.tx_packets++;
408 lp->stats.tx_bytes += c->parm.length;
411 case ISDN_STAT_DCONN:
412 /* D-Channel is up */
413 switch (lp->dialstate) {
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
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)
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,
448 isdn_net_unbind_channel(lp);
452 #ifdef CONFIG_ISDN_X25
454 /* B-Channel-hangup */
455 /* try if there are generic encap protocol
456 receiver routines and signal the closure of
458 if( pops && pops -> disconn_ind ){
459 pops -> disconn_ind(cprot);
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) {
475 if (lp->dialstate <= 6) {
476 dev->usage[idx] |= ISDN_USAGE_OUTGOING;
479 dev->rx_netdev[idx] = p;
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);
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.
494 lp->chargetime = jiffies;
496 /* reset dial-timeout */
498 lp->dialwait_timer = 0;
500 #ifdef CONFIG_ISDN_PPP
501 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
502 isdn_ppp_wakeup_daemon(lp);
504 #ifdef CONFIG_ISDN_X25
505 /* try if there are generic concap receiver routines */
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);
516 case ISDN_STAT_NODCH:
517 /* No D-Channel avail. */
518 if (lp->dialstate == 4) {
524 /* Charge-info from TelCo. Calculate interval between
525 * charge-infos and set timestamp for last info for
526 * usage by isdn_net_autohup()
529 if (lp->hupflags & ISDN_HAVECHARGE) {
530 lp->hupflags &= ~ISDN_WAITCHARGE;
531 lp->chargeint = jiffies - lp->chargetime - (2 * HZ);
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);
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.
557 isdn_net_dev *p = dev->netdev;
561 u_char *phone_number;
564 isdn_net_local *lp = p->local;
566 #ifdef ISDN_DEBUG_NET_DIAL
568 printk(KERN_DEBUG "%s: dialstate=%d\n", lp->name, lp->dialstate);
570 switch (lp->dialstate) {
572 /* Nothing to do for this interface */
575 /* Initiate dialout. Set phone-number-pointer to first number
578 lp->dial = lp->phone[1];
580 printk(KERN_WARNING "%s: phone number deleted?\n",
582 isdn_net_hangup(&p->dev);
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;
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;
601 sprintf(cmd.parm.num, "%s", isdn_map_eaz2msn(lp->msn, cmd.driver));
602 cmd.command = ISDN_CMD_SETEAZ;
609 /* Setup interface, dial current phone-number, switch to next number.
610 * If list of phone-numbers is exhausted, increment
613 if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF)) {
615 if (dev->global_flags & ISDN_GLOBAL_STOPPED)
616 s = "dial suppressed: isdn system stopped";
618 s = "dial suppressed: dialmode `off'";
619 isdn_net_unreachable(&p->dev, NULL, s);
620 isdn_net_hangup(&p->dev);
623 cmd.driver = lp->isdn_device;
624 cmd.command = ISDN_CMD_SETL2;
625 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
627 cmd.driver = lp->isdn_device;
628 cmd.command = ISDN_CMD_SETL3;
629 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
631 cmd.driver = lp->isdn_device;
632 cmd.arg = lp->isdn_channel;
634 printk(KERN_WARNING "%s: phone number deleted?\n",
636 isdn_net_hangup(&p->dev);
639 if (!strncmp(lp->dial->num, "LEASED", strlen("LEASED"))) {
641 printk(KERN_INFO "%s: Open leased line ...\n", lp->name);
643 if(lp->dialtimeout > 0)
644 if (time_after(jiffies, lp->dialstarted + lp->dialtimeout)) {
645 lp->dialwait_timer = jiffies + lp->dialwait;
647 isdn_net_unreachable(&p->dev, NULL, "dial: timed out");
648 isdn_net_hangup(&p->dev);
652 cmd.driver = lp->isdn_device;
653 cmd.command = ISDN_CMD_DIAL;
654 cmd.parm.setup.si2 = 0;
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;
665 strcpy(cmd.parm.setup.phone, phone_number);
667 * Switch to next number or back to start if at end of list.
669 if (!(lp->dial = (isdn_net_phone *) lp->dial->next)) {
670 lp->dial = lp->phone[1];
673 if (lp->dialretry > lp->dialmax) {
674 if (lp->dialtimeout == 0) {
675 lp->dialwait_timer = jiffies + lp->dialwait;
677 isdn_net_unreachable(&p->dev, NULL, "dial: tried all numbers dialmax times");
679 isdn_net_hangup(&p->dev);
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);
687 strcpy(dev->num[i], cmd.parm.setup.phone);
688 dev->usage[i] |= ISDN_USAGE_OUTGOING;
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" : "");
695 #ifdef ISDN_DEBUG_NET_DIAL
696 printk(KERN_DEBUG "dial: d=%d c=%d\n", lp->isdn_device,
704 lp->hupflags |= ISDN_HAVECHARGE;
705 lp->hupflags &= ~ISDN_WAITCHARGE;
707 lp->hupflags |= ISDN_WAITCHARGE;
708 lp->hupflags &= ~ISDN_HAVECHARGE;
713 (lp->flags & ISDN_NET_CBOUT)) ? 12 : 4;
716 /* Wait for D-Channel-connect.
717 * If timeout, switch back to state 3.
718 * Dialmax-handling moved to state 3.
720 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
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;
735 /* Wait for B- or D-Channel-connect. If timeout,
736 * switch back to state 3.
738 #ifdef ISDN_DEBUG_NET_DIAL
739 printk(KERN_DEBUG "dialtimer2: %d\n", lp->dtimer);
741 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
746 /* Got incoming Call, setup L2 and L3 protocols,
747 * then wait for D-Channel-connect
749 #ifdef ISDN_DEBUG_NET_DIAL
750 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
752 cmd.driver = lp->isdn_device;
753 cmd.command = ISDN_CMD_SETL2;
754 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
756 cmd.driver = lp->isdn_device;
757 cmd.command = ISDN_CMD_SETL3;
758 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
760 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT15)
761 isdn_net_hangup(&p->dev);
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;
779 /* Wait for B- or D-channel-connect */
780 #ifdef ISDN_DEBUG_NET_DIAL
781 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
783 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
784 isdn_net_hangup(&p->dev);
790 if (lp->dtimer++ > lp->cbdelay)
795 /* Remote does callback. Hangup after cbdelay, then wait for incoming
798 if (lp->dtimer++ > lp->cbdelay)
800 printk(KERN_INFO "%s: hangup waiting for callback ...\n", lp->name);
803 cmd.driver = lp->isdn_device;
804 cmd.command = ISDN_CMD_HANGUP;
805 cmd.arg = lp->isdn_channel;
807 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
812 printk(KERN_WARNING "isdn_net: Illegal dialstate %d for device %s\n",
813 lp->dialstate, lp->name);
815 p = (isdn_net_dev *) p->next;
817 isdn_timer_ctrl(ISDN_TIMER_NETDIAL, anymore);
821 * Perform hangup for a net-interface.
824 isdn_net_hangup(struct net_device *d)
826 isdn_net_local *lp = (isdn_net_local *) d->priv;
828 #ifdef CONFIG_ISDN_X25
829 struct concap_proto *cprot = lp->netdev->cprot;
830 struct concap_proto_ops *pops = cprot ? cprot->pops : NULL;
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) {
838 "isdn_net: hang up slave %s before %s\n",
839 slp->name, lp->name);
840 isdn_net_hangup(lp->slave);
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)
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
853 if( pops && pops -> disconn_ind )
854 pops -> disconn_ind(cprot);
855 #endif /* CONFIG_ISDN_X25 */
857 cmd.driver = lp->isdn_device;
858 cmd.command = ISDN_CMD_HANGUP;
859 cmd.arg = lp->isdn_channel;
861 printk(KERN_INFO "%s: Chargesum is %d\n", lp->name, lp->charge);
862 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
864 isdn_net_unbind_channel(lp);
868 unsigned short source;
873 isdn_net_log_skb(struct sk_buff * skb, isdn_net_local * lp)
875 /* hopefully, this was set correctly */
876 const u_char *p = skb_network_header(skb);
877 unsigned short proto = ntohs(skb->protocol);
883 /* This check stolen from 2.1.72 dev_queue_xmit_nit() */
884 if (p < skb->data || skb->network_header >= skb->tail) {
885 /* fall back to old isdn_net_log_packet method() */
886 char * buf = skb->data;
888 printk(KERN_DEBUG "isdn_net: protocol %04x is buggy, dev %s\n", skb->protocol, lp->name);
891 switch (lp->p_encap) {
892 case ISDN_NET_ENCAP_IPTYP:
893 proto = ntohs(*(unsigned short *) &buf[0]);
896 case ISDN_NET_ENCAP_ETHER:
897 proto = ntohs(*(unsigned short *) &buf[12]);
900 case ISDN_NET_ENCAP_CISCOHDLC:
901 proto = ntohs(*(unsigned short *) &buf[2]);
904 #ifdef CONFIG_ISDN_PPP
905 case ISDN_NET_ENCAP_SYNCPPP:
906 proto = ntohs(skb->protocol);
907 p = &buf[IPPP_MAX_HEADER];
912 data_ofs = ((p[0] & 15) * 4);
917 strcpy(addinfo, " ICMP");
920 strcpy(addinfo, " IGMP");
923 strcpy(addinfo, " IPIP");
926 ipp = (ip_ports *) (&p[data_ofs]);
927 sprintf(addinfo, " TCP, port: %d -> %d", ntohs(ipp->source),
931 strcpy(addinfo, " EGP");
934 strcpy(addinfo, " PUP");
937 ipp = (ip_ports *) (&p[data_ofs]);
938 sprintf(addinfo, " UDP, port: %d -> %d", ntohs(ipp->source),
942 strcpy(addinfo, " IDP");
946 "OPEN: %d.%d.%d.%d -> %d.%d.%d.%d%s\n",
948 p[12], p[13], p[14], p[15],
949 p[16], p[17], p[18], p[19],
954 "OPEN: ARP %d.%d.%d.%d -> *.*.*.* ?%d.%d.%d.%d\n",
955 p[14], p[15], p[16], p[17],
956 p[24], p[25], p[26], p[27]);
962 * this function is used to send supervisory data, i.e. data which was
963 * not received from the network layer, but e.g. frames from ipppd, CCP
966 void isdn_net_write_super(isdn_net_local *lp, struct sk_buff *skb)
969 // we can't grab the lock from irq context,
970 // so we just queue the packet
971 skb_queue_tail(&lp->super_tx_queue, skb);
972 schedule_work(&lp->tqueue);
976 spin_lock_bh(&lp->xmit_lock);
977 if (!isdn_net_lp_busy(lp)) {
978 isdn_net_writebuf_skb(lp, skb);
980 skb_queue_tail(&lp->super_tx_queue, skb);
982 spin_unlock_bh(&lp->xmit_lock);
986 * called from tq_immediate
988 static void isdn_net_softint(struct work_struct *work)
990 isdn_net_local *lp = container_of(work, isdn_net_local, tqueue);
993 spin_lock_bh(&lp->xmit_lock);
994 while (!isdn_net_lp_busy(lp)) {
995 skb = skb_dequeue(&lp->super_tx_queue);
998 isdn_net_writebuf_skb(lp, skb);
1000 spin_unlock_bh(&lp->xmit_lock);
1004 * all frames sent from the (net) LL to a HL driver should go via this function
1005 * it's serialized by the caller holding the lp->xmit_lock spinlock
1007 void isdn_net_writebuf_skb(isdn_net_local *lp, struct sk_buff *skb)
1010 int len = skb->len; /* save len */
1012 /* before obtaining the lock the caller should have checked that
1013 the lp isn't busy */
1014 if (isdn_net_lp_busy(lp)) {
1015 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1019 if (!(lp->flags & ISDN_NET_CONNECTED)) {
1020 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1023 ret = isdn_writebuf_skb_stub(lp->isdn_device, lp->isdn_channel, 1, skb);
1025 /* we should never get here */
1026 printk(KERN_WARNING "%s: HL driver queue full\n", lp->name);
1030 lp->transcount += len;
1031 isdn_net_inc_frame_cnt(lp);
1036 lp->stats.tx_errors++;
1042 * Helper function for isdn_net_start_xmit.
1043 * When called, the connection is already established.
1044 * Based on cps-calculation, check if device is overloaded.
1045 * If so, and if a slave exists, trigger dialing for it.
1046 * If any slave is online, deliver packets using a simple round robin
1049 * Return: 0 on success, !0 on failure.
1053 isdn_net_xmit(struct net_device *ndev, struct sk_buff *skb)
1056 isdn_net_local *slp;
1057 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1060 if (((isdn_net_local *) (ndev->priv))->master) {
1061 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1066 /* For the other encaps the header has already been built */
1067 #ifdef CONFIG_ISDN_PPP
1068 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1069 return isdn_ppp_xmit(skb, ndev);
1072 nd = ((isdn_net_local *) ndev->priv)->netdev;
1073 lp = isdn_net_get_locked_lp(nd);
1075 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", ndev->name);
1078 /* we have our lp locked from now on */
1080 /* Reset hangup-timeout */
1081 lp->huptimer = 0; // FIXME?
1082 isdn_net_writebuf_skb(lp, skb);
1083 spin_unlock_bh(&lp->xmit_lock);
1085 /* the following stuff is here for backwards compatibility.
1086 * in future, start-up and hangup of slaves (based on current load)
1087 * should move to userspace and get based on an overall cps
1090 if (lp->cps > lp->triggercps) {
1093 /* First time overload: set timestamp only */
1095 lp->sqfull_stamp = jiffies;
1097 /* subsequent overload: if slavedelay exceeded, start dialing */
1098 if (time_after(jiffies, lp->sqfull_stamp + lp->slavedelay)) {
1099 slp = lp->slave->priv;
1100 if (!(slp->flags & ISDN_NET_CONNECTED)) {
1101 isdn_net_force_dial_lp((isdn_net_local *) lp->slave->priv);
1107 if (lp->sqfull && time_after(jiffies, lp->sqfull_stamp + lp->slavedelay + (10 * HZ))) {
1110 /* this is a hack to allow auto-hangup for slaves on moderate loads */
1111 nd->queue = nd->local;
1119 isdn_net_adjust_hdr(struct sk_buff *skb, struct net_device *dev)
1121 isdn_net_local *lp = (isdn_net_local *) dev->priv;
1124 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1125 const int pullsize = skb_network_offset(skb) - ETH_HLEN;
1127 printk(KERN_DEBUG "isdn_net: Pull junk %d\n", pullsize);
1128 skb_pull(skb, pullsize);
1134 static void isdn_net_tx_timeout(struct net_device * ndev)
1136 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1138 printk(KERN_WARNING "isdn_tx_timeout dev %s dialstate %d\n", ndev->name, lp->dialstate);
1139 if (!lp->dialstate){
1140 lp->stats.tx_errors++;
1142 * There is a certain probability that this currently
1143 * works at all because if we always wake up the interface,
1144 * then upper layer will try to send the next packet
1145 * immediately. And then, the old clean_up logic in the
1146 * driver will hopefully continue to work as it used to do.
1148 * This is rather primitive right know, we better should
1149 * clean internal queues here, in particular for multilink and
1150 * ppp, and reset HL driver's channel, too. --HE
1152 * actually, this may not matter at all, because ISDN hardware
1153 * should not see transmitter hangs at all IMO
1154 * changed KERN_DEBUG to KERN_WARNING to find out if this is
1158 ndev->trans_start = jiffies;
1159 netif_wake_queue(ndev);
1163 * Try sending a packet.
1164 * If this interface isn't connected to a ISDN-Channel, find a free channel,
1165 * and start dialing.
1168 isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1170 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1171 #ifdef CONFIG_ISDN_X25
1172 struct concap_proto * cprot = lp -> netdev -> cprot;
1173 /* At this point hard_start_xmit() passes control to the encapsulation
1174 protocol (if present).
1175 For X.25 auto-dialing is completly bypassed because:
1176 - It does not conform with the semantics of a reliable datalink
1177 service as needed by X.25 PLP.
1178 - I don't want that the interface starts dialing when the network layer
1179 sends a message which requests to disconnect the lapb link (or if it
1180 sends any other message not resulting in data transmission).
1181 Instead, dialing will be initiated by the encapsulation protocol entity
1182 when a dl_establish request is received from the upper layer.
1184 if (cprot && cprot -> pops) {
1185 int ret = cprot -> pops -> encap_and_xmit ( cprot , skb);
1188 netif_stop_queue(ndev);
1192 /* auto-dialing xmit function */
1194 #ifdef ISDN_DEBUG_NET_DUMP
1197 isdn_net_adjust_hdr(skb, ndev);
1198 #ifdef ISDN_DEBUG_NET_DUMP
1200 isdn_dumppkt("S:", buf, skb->len, 40);
1203 if (!(lp->flags & ISDN_NET_CONNECTED)) {
1205 /* only do autodial if allowed by config */
1206 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) {
1207 isdn_net_unreachable(ndev, skb, "dial rejected: interface not in dialmode `auto'");
1214 if(lp->dialwait_timer <= 0)
1215 if(lp->dialstarted > 0 && lp->dialtimeout > 0 && time_before(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait))
1216 lp->dialwait_timer = lp->dialstarted + lp->dialtimeout + lp->dialwait;
1218 if(lp->dialwait_timer > 0) {
1219 if(time_before(jiffies, lp->dialwait_timer)) {
1220 isdn_net_unreachable(ndev, skb, "dial rejected: retry-time not reached");
1224 lp->dialwait_timer = 0;
1226 /* Grab a free ISDN-Channel */
1227 spin_lock_irqsave(&dev->lock, flags);
1229 isdn_get_free_channel(
1238 isdn_get_free_channel(
1246 spin_unlock_irqrestore(&dev->lock, flags);
1247 isdn_net_unreachable(ndev, skb,
1252 /* Log packet, which triggered dialing */
1253 if (dev->net_verbose)
1254 isdn_net_log_skb(skb, lp);
1256 /* Connect interface with channel */
1257 isdn_net_bind_channel(lp, chi);
1258 #ifdef CONFIG_ISDN_PPP
1259 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1260 /* no 'first_skb' handling for syncPPP */
1261 if (isdn_ppp_bind(lp) < 0) {
1263 isdn_net_unbind_channel(lp);
1264 spin_unlock_irqrestore(&dev->lock, flags);
1265 return 0; /* STN (skb to nirvana) ;) */
1267 #ifdef CONFIG_IPPP_FILTER
1268 if (isdn_ppp_autodial_filter(skb, lp)) {
1270 isdn_net_unbind_channel(lp);
1271 spin_unlock_irqrestore(&dev->lock, flags);
1272 isdn_net_unreachable(ndev, skb, "dial rejected: packet filtered");
1277 spin_unlock_irqrestore(&dev->lock, flags);
1278 isdn_net_dial(); /* Initiate dialing */
1279 netif_stop_queue(ndev);
1280 return 1; /* let upper layer requeue skb packet */
1283 /* Initiate dialing */
1284 spin_unlock_irqrestore(&dev->lock, flags);
1286 isdn_net_device_stop_queue(lp);
1289 isdn_net_unreachable(ndev, skb,
1295 /* Device is connected to an ISDN channel */
1296 ndev->trans_start = jiffies;
1297 if (!lp->dialstate) {
1298 /* ISDN connection is established, try sending */
1300 ret = (isdn_net_xmit(ndev, skb));
1301 if(ret) netif_stop_queue(ndev);
1304 netif_stop_queue(ndev);
1311 * Shutdown a net-interface.
1314 isdn_net_close(struct net_device *dev)
1316 struct net_device *p;
1317 #ifdef CONFIG_ISDN_X25
1318 struct concap_proto * cprot =
1319 ( (isdn_net_local *) dev->priv ) -> netdev -> cprot;
1320 /* printk(KERN_DEBUG "isdn_net_close %s\n" , dev-> name ); */
1323 #ifdef CONFIG_ISDN_X25
1324 if( cprot && cprot -> pops ) cprot -> pops -> close( cprot );
1326 netif_stop_queue(dev);
1327 if ((p = (((isdn_net_local *) dev->priv)->slave))) {
1328 /* If this interface has slaves, stop them also */
1330 #ifdef CONFIG_ISDN_X25
1331 cprot = ( (isdn_net_local *) p->priv )
1333 if( cprot && cprot -> pops )
1334 cprot -> pops -> close( cprot );
1337 p = (((isdn_net_local *) p->priv)->slave);
1340 isdn_net_hangup(dev);
1341 isdn_unlock_drivers();
1348 static struct net_device_stats *
1349 isdn_net_get_stats(struct net_device *dev)
1351 isdn_net_local *lp = (isdn_net_local *) dev->priv;
1355 /* This is simply a copy from std. eth.c EXCEPT we pull ETH_HLEN
1356 * instead of dev->hard_header_len off. This is done because the
1357 * lowlevel-driver has already pulled off its stuff when we get
1358 * here and this routine only gets called with p_encap == ETHER.
1359 * Determine the packet's protocol ID. The rule here is that we
1360 * assume 802.3 if the type field is short enough to be a length.
1361 * This is normal practice and works for any 'now in use' protocol.
1364 static unsigned short
1365 isdn_net_type_trans(struct sk_buff *skb, struct net_device *dev)
1368 unsigned char *rawp;
1370 skb_reset_mac_header(skb);
1371 skb_pull(skb, ETH_HLEN);
1374 if (*eth->h_dest & 1) {
1375 if (memcmp(eth->h_dest, dev->broadcast, ETH_ALEN) == 0)
1376 skb->pkt_type = PACKET_BROADCAST;
1378 skb->pkt_type = PACKET_MULTICAST;
1381 * This ALLMULTI check should be redundant by 1.4
1382 * so don't forget to remove it.
1385 else if (dev->flags & (IFF_PROMISC /*| IFF_ALLMULTI*/)) {
1386 if (memcmp(eth->h_dest, dev->dev_addr, ETH_ALEN))
1387 skb->pkt_type = PACKET_OTHERHOST;
1389 if (ntohs(eth->h_proto) >= 1536)
1390 return eth->h_proto;
1395 * This is a magic hack to spot IPX packets. Older Novell breaks
1396 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
1397 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
1398 * won't work for fault tolerant netware but does for the rest.
1400 if (*(unsigned short *) rawp == 0xFFFF)
1401 return htons(ETH_P_802_3);
1405 return htons(ETH_P_802_2);
1410 * CISCO HDLC keepalive specific stuff
1412 static struct sk_buff*
1413 isdn_net_ciscohdlck_alloc_skb(isdn_net_local *lp, int len)
1415 unsigned short hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
1416 struct sk_buff *skb;
1418 skb = alloc_skb(hl + len, GFP_ATOMIC);
1420 skb_reserve(skb, hl);
1422 printk("isdn out of mem at %s:%d!\n", __FILE__, __LINE__);
1426 /* cisco hdlck device private ioctls */
1428 isdn_ciscohdlck_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1430 isdn_net_local *lp = (isdn_net_local *) dev->priv;
1431 unsigned long len = 0;
1432 unsigned long expires = 0;
1434 int period = lp->cisco_keepalive_period;
1435 s8 debserint = lp->cisco_debserint;
1438 if (lp->p_encap != ISDN_NET_ENCAP_CISCOHDLCK)
1442 /* get/set keepalive period */
1443 case SIOCGKEEPPERIOD:
1444 len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1445 if (copy_to_user(ifr->ifr_data,
1446 &lp->cisco_keepalive_period, len))
1449 case SIOCSKEEPPERIOD:
1450 tmp = lp->cisco_keepalive_period;
1451 len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1452 if (copy_from_user(&period, ifr->ifr_data, len))
1454 if ((period > 0) && (period <= 32767))
1455 lp->cisco_keepalive_period = period;
1458 if (!rc && (tmp != lp->cisco_keepalive_period)) {
1459 expires = (unsigned long)(jiffies +
1460 lp->cisco_keepalive_period * HZ);
1461 mod_timer(&lp->cisco_timer, expires);
1462 printk(KERN_INFO "%s: Keepalive period set "
1464 lp->name, lp->cisco_keepalive_period);
1468 /* get/set debugging */
1469 case SIOCGDEBSERINT:
1470 len = (unsigned long)sizeof(lp->cisco_debserint);
1471 if (copy_to_user(ifr->ifr_data,
1472 &lp->cisco_debserint, len))
1475 case SIOCSDEBSERINT:
1476 len = (unsigned long)sizeof(lp->cisco_debserint);
1477 if (copy_from_user(&debserint,
1478 ifr->ifr_data, len))
1480 if ((debserint >= 0) && (debserint <= 64))
1481 lp->cisco_debserint = debserint;
1493 /* called via cisco_timer.function */
1495 isdn_net_ciscohdlck_slarp_send_keepalive(unsigned long data)
1497 isdn_net_local *lp = (isdn_net_local *) data;
1498 struct sk_buff *skb;
1500 unsigned long last_cisco_myseq = lp->cisco_myseq;
1503 if (!(lp->flags & ISDN_NET_CONNECTED) || lp->dialstate) {
1504 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1509 myseq_diff = (lp->cisco_myseq - lp->cisco_mineseen);
1510 if ((lp->cisco_line_state) && ((myseq_diff >= 3)||(myseq_diff <= -3))) {
1511 /* line up -> down */
1512 lp->cisco_line_state = 0;
1513 printk (KERN_WARNING
1514 "UPDOWN: Line protocol on Interface %s,"
1515 " changed state to down\n", lp->name);
1516 /* should stop routing higher-level data accross */
1517 } else if ((!lp->cisco_line_state) &&
1518 (myseq_diff >= 0) && (myseq_diff <= 2)) {
1519 /* line down -> up */
1520 lp->cisco_line_state = 1;
1521 printk (KERN_WARNING
1522 "UPDOWN: Line protocol on Interface %s,"
1523 " changed state to up\n", lp->name);
1524 /* restart routing higher-level data accross */
1527 if (lp->cisco_debserint)
1528 printk (KERN_DEBUG "%s: HDLC "
1529 "myseq %lu, mineseen %lu%c, yourseen %lu, %s\n",
1530 lp->name, last_cisco_myseq, lp->cisco_mineseen,
1531 ((last_cisco_myseq == lp->cisco_mineseen) ? '*' : 040),
1533 ((lp->cisco_line_state) ? "line up" : "line down"));
1535 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1539 p = skb_put(skb, 4 + 14);
1542 p += put_u8 (p, CISCO_ADDR_UNICAST);
1543 p += put_u8 (p, CISCO_CTRL);
1544 p += put_u16(p, CISCO_TYPE_SLARP);
1546 /* slarp keepalive */
1547 p += put_u32(p, CISCO_SLARP_KEEPALIVE);
1548 p += put_u32(p, lp->cisco_myseq);
1549 p += put_u32(p, lp->cisco_yourseq);
1550 p += put_u16(p, 0xffff); // reliablity, always 0xffff
1552 isdn_net_write_super(lp, skb);
1554 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1556 add_timer(&lp->cisco_timer);
1560 isdn_net_ciscohdlck_slarp_send_request(isdn_net_local *lp)
1562 struct sk_buff *skb;
1565 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1569 p = skb_put(skb, 4 + 14);
1572 p += put_u8 (p, CISCO_ADDR_UNICAST);
1573 p += put_u8 (p, CISCO_CTRL);
1574 p += put_u16(p, CISCO_TYPE_SLARP);
1577 p += put_u32(p, CISCO_SLARP_REQUEST);
1578 p += put_u32(p, 0); // address
1579 p += put_u32(p, 0); // netmask
1580 p += put_u16(p, 0); // unused
1582 isdn_net_write_super(lp, skb);
1586 isdn_net_ciscohdlck_connected(isdn_net_local *lp)
1588 lp->cisco_myseq = 0;
1589 lp->cisco_mineseen = 0;
1590 lp->cisco_yourseq = 0;
1591 lp->cisco_keepalive_period = ISDN_TIMER_KEEPINT;
1592 lp->cisco_last_slarp_in = 0;
1593 lp->cisco_line_state = 0;
1594 lp->cisco_debserint = 0;
1596 /* send slarp request because interface/seq.no.s reset */
1597 isdn_net_ciscohdlck_slarp_send_request(lp);
1599 init_timer(&lp->cisco_timer);
1600 lp->cisco_timer.data = (unsigned long) lp;
1601 lp->cisco_timer.function = isdn_net_ciscohdlck_slarp_send_keepalive;
1602 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1603 add_timer(&lp->cisco_timer);
1607 isdn_net_ciscohdlck_disconnected(isdn_net_local *lp)
1609 del_timer(&lp->cisco_timer);
1613 isdn_net_ciscohdlck_slarp_send_reply(isdn_net_local *lp)
1615 struct sk_buff *skb;
1617 struct in_device *in_dev = NULL;
1618 __be32 addr = 0; /* local ipv4 address */
1619 __be32 mask = 0; /* local netmask */
1621 if ((in_dev = lp->netdev->dev.ip_ptr) != NULL) {
1622 /* take primary(first) address of interface */
1623 struct in_ifaddr *ifa = in_dev->ifa_list;
1625 addr = ifa->ifa_local;
1626 mask = ifa->ifa_mask;
1630 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1634 p = skb_put(skb, 4 + 14);
1637 p += put_u8 (p, CISCO_ADDR_UNICAST);
1638 p += put_u8 (p, CISCO_CTRL);
1639 p += put_u16(p, CISCO_TYPE_SLARP);
1641 /* slarp reply, send own ip/netmask; if values are nonsense remote
1642 * should think we are unable to provide it with an address via SLARP */
1643 p += put_u32(p, CISCO_SLARP_REPLY);
1644 p += put_u32(p, addr); // address
1645 p += put_u32(p, mask); // netmask
1646 p += put_u16(p, 0); // unused
1648 isdn_net_write_super(lp, skb);
1652 isdn_net_ciscohdlck_slarp_in(isdn_net_local *lp, struct sk_buff *skb)
1666 p += get_u32(p, &code);
1669 case CISCO_SLARP_REQUEST:
1670 lp->cisco_yourseq = 0;
1671 isdn_net_ciscohdlck_slarp_send_reply(lp);
1673 case CISCO_SLARP_REPLY:
1674 addr = ntohl(*(u32 *)p);
1675 mask = ntohl(*(u32 *)(p+4));
1676 if (mask != 0xfffffffc)
1677 goto slarp_reply_out;
1678 if ((addr & 3) == 0 || (addr & 3) == 3)
1679 goto slarp_reply_out;
1681 printk(KERN_INFO "%s: got slarp reply: "
1682 "remote ip: %d.%d.%d.%d, "
1683 "local ip: %d.%d.%d.%d "
1684 "mask: %d.%d.%d.%d\n",
1691 printk(KERN_INFO "%s: got invalid slarp "
1692 "reply (%d.%d.%d.%d/%d.%d.%d.%d) "
1693 "- ignored\n", lp->name,
1694 HIPQUAD(addr), HIPQUAD(mask));
1696 case CISCO_SLARP_KEEPALIVE:
1697 period = (int)((jiffies - lp->cisco_last_slarp_in
1699 if (lp->cisco_debserint &&
1700 (period != lp->cisco_keepalive_period) &&
1701 lp->cisco_last_slarp_in) {
1702 printk(KERN_DEBUG "%s: Keepalive period mismatch - "
1703 "is %d but should be %d.\n",
1704 lp->name, period, lp->cisco_keepalive_period);
1706 lp->cisco_last_slarp_in = jiffies;
1707 p += get_u32(p, &my_seq);
1708 p += get_u32(p, &your_seq);
1709 p += get_u16(p, &unused);
1710 lp->cisco_yourseq = my_seq;
1711 lp->cisco_mineseen = your_seq;
1717 isdn_net_ciscohdlck_receive(isdn_net_local *lp, struct sk_buff *skb)
1728 p += get_u8 (p, &addr);
1729 p += get_u8 (p, &ctrl);
1730 p += get_u16(p, &type);
1733 if (addr != CISCO_ADDR_UNICAST && addr != CISCO_ADDR_BROADCAST) {
1734 printk(KERN_WARNING "%s: Unknown Cisco addr 0x%02x\n",
1738 if (ctrl != CISCO_CTRL) {
1739 printk(KERN_WARNING "%s: Unknown Cisco ctrl 0x%02x\n",
1745 case CISCO_TYPE_SLARP:
1746 isdn_net_ciscohdlck_slarp_in(lp, skb);
1748 case CISCO_TYPE_CDP:
1749 if (lp->cisco_debserint)
1750 printk(KERN_DEBUG "%s: Received CDP packet. use "
1751 "\"no cdp enable\" on cisco.\n", lp->name);
1754 /* no special cisco protocol */
1755 skb->protocol = htons(type);
1765 * Got a packet from ISDN-Channel.
1768 isdn_net_receive(struct net_device *ndev, struct sk_buff *skb)
1770 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1771 isdn_net_local *olp = lp; /* original 'lp' */
1772 #ifdef CONFIG_ISDN_X25
1773 struct concap_proto *cprot = lp -> netdev -> cprot;
1775 lp->transcount += skb->len;
1777 lp->stats.rx_packets++;
1778 lp->stats.rx_bytes += skb->len;
1780 /* Bundling: If device is a slave-device, deliver to master, also
1781 * handle master's statistics and hangup-timeout
1784 lp = (isdn_net_local *) ndev->priv;
1785 lp->stats.rx_packets++;
1786 lp->stats.rx_bytes += skb->len;
1789 skb->pkt_type = PACKET_HOST;
1790 skb_reset_mac_header(skb);
1791 #ifdef ISDN_DEBUG_NET_DUMP
1792 isdn_dumppkt("R:", skb->data, skb->len, 40);
1794 switch (lp->p_encap) {
1795 case ISDN_NET_ENCAP_ETHER:
1796 /* Ethernet over ISDN */
1799 skb->protocol = isdn_net_type_trans(skb, ndev);
1801 case ISDN_NET_ENCAP_UIHDLC:
1802 /* HDLC with UI-frame (for ispa with -h1 option) */
1807 case ISDN_NET_ENCAP_RAWIP:
1808 /* RAW-IP without MAC-Header */
1811 skb->protocol = htons(ETH_P_IP);
1813 case ISDN_NET_ENCAP_CISCOHDLCK:
1814 isdn_net_ciscohdlck_receive(lp, skb);
1816 case ISDN_NET_ENCAP_CISCOHDLC:
1817 /* CISCO-HDLC IP with type field and fake I-frame-header */
1820 case ISDN_NET_ENCAP_IPTYP:
1821 /* IP with type field */
1824 skb->protocol = *(unsigned short *) &(skb->data[0]);
1826 if (*(unsigned short *) skb->data == 0xFFFF)
1827 skb->protocol = htons(ETH_P_802_3);
1829 #ifdef CONFIG_ISDN_PPP
1830 case ISDN_NET_ENCAP_SYNCPPP:
1831 /* huptimer is done in isdn_ppp_push_higher */
1832 isdn_ppp_receive(lp->netdev, olp, skb);
1837 #ifdef CONFIG_ISDN_X25
1838 /* try if there are generic sync_device receiver routines */
1839 if(cprot) if(cprot -> pops)
1840 if( cprot -> pops -> data_ind){
1841 cprot -> pops -> data_ind(cprot,skb);
1844 #endif /* CONFIG_ISDN_X25 */
1845 printk(KERN_WARNING "%s: unknown encapsulation, dropping\n",
1856 * A packet arrived via ISDN. Search interface-chain for a corresponding
1857 * interface. If found, deliver packet to receiver-function and return 1,
1861 isdn_net_rcv_skb(int idx, struct sk_buff *skb)
1863 isdn_net_dev *p = dev->rx_netdev[idx];
1866 isdn_net_local *lp = p->local;
1867 if ((lp->flags & ISDN_NET_CONNECTED) &&
1869 isdn_net_receive(&p->dev, skb);
1878 * depends on encaps that is being used.
1881 static int isdn_net_header(struct sk_buff *skb, struct net_device *dev,
1882 unsigned short type,
1883 const void *daddr, const void *saddr, unsigned plen)
1885 isdn_net_local *lp = dev->priv;
1889 switch (lp->p_encap) {
1890 case ISDN_NET_ENCAP_ETHER:
1891 len = eth_header(skb, dev, type, daddr, saddr, plen);
1893 #ifdef CONFIG_ISDN_PPP
1894 case ISDN_NET_ENCAP_SYNCPPP:
1895 /* stick on a fake header to keep fragmentation code happy. */
1896 len = IPPP_MAX_HEADER;
1900 case ISDN_NET_ENCAP_RAWIP:
1901 printk(KERN_WARNING "isdn_net_header called with RAW_IP!\n");
1904 case ISDN_NET_ENCAP_IPTYP:
1905 /* ethernet type field */
1906 *((ushort *) skb_push(skb, 2)) = htons(type);
1909 case ISDN_NET_ENCAP_UIHDLC:
1910 /* HDLC with UI-Frames (for ispa with -h1 option) */
1911 *((ushort *) skb_push(skb, 2)) = htons(0x0103);
1914 case ISDN_NET_ENCAP_CISCOHDLC:
1915 case ISDN_NET_ENCAP_CISCOHDLCK:
1916 p = skb_push(skb, 4);
1917 p += put_u8 (p, CISCO_ADDR_UNICAST);
1918 p += put_u8 (p, CISCO_CTRL);
1919 p += put_u16(p, type);
1922 #ifdef CONFIG_ISDN_X25
1924 /* try if there are generic concap protocol routines */
1925 if( lp-> netdev -> cprot ){
1926 printk(KERN_WARNING "isdn_net_header called with concap_proto!\n");
1931 #endif /* CONFIG_ISDN_X25 */
1936 /* We don't need to send arp, because we have point-to-point connections. */
1938 isdn_net_rebuild_header(struct sk_buff *skb)
1940 struct net_device *dev = skb->dev;
1941 isdn_net_local *lp = dev->priv;
1944 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1945 struct ethhdr *eth = (struct ethhdr *) skb->data;
1948 * Only ARP/IP is currently supported
1951 if (eth->h_proto != htons(ETH_P_IP)) {
1953 "isdn_net: %s don't know how to resolve type %d addresses?\n",
1954 dev->name, (int) eth->h_proto);
1955 memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
1959 * Try to get ARP to resolve the header.
1962 ret = arp_find(eth->h_dest, skb);
1968 static int isdn_header_cache(const struct neighbour *neigh, struct hh_cache *hh)
1970 const struct net_device *dev = neigh->dev;
1971 isdn_net_local *lp = dev->priv;
1973 if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
1974 return eth_header_cache(neigh, hh);
1978 static void isdn_header_cache_update(struct hh_cache *hh,
1979 const struct net_device *dev,
1980 const unsigned char *haddr)
1982 isdn_net_local *lp = dev->priv;
1983 if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
1984 return eth_header_cache_update(hh, dev, haddr);
1987 static const struct header_ops isdn_header_ops = {
1988 .create = isdn_net_header,
1989 .rebuild = isdn_net_rebuild_header,
1990 .cache = isdn_header_cache,
1991 .cache_update = isdn_header_cache_update,
1995 * Interface-setup. (just after registering a new interface)
1998 isdn_net_init(struct net_device *ndev)
2000 ushort max_hlhdr_len = 0;
2004 ndev->header_ops = NULL;
2006 /* Setup the generic properties */
2008 ndev->flags = IFF_NOARP|IFF_POINTOPOINT;
2009 ndev->type = ARPHRD_ETHER;
2010 ndev->addr_len = ETH_ALEN;
2012 /* for clients with MPPP maybe higher values better */
2013 ndev->tx_queue_len = 30;
2015 /* The ISDN-specific entries in the device structure. */
2016 ndev->open = &isdn_net_open;
2017 ndev->hard_start_xmit = &isdn_net_start_xmit;
2020 * up till binding we ask the protocol layer to reserve as much
2021 * as we might need for HL layer
2024 for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++)
2025 if (dev->drv[drvidx])
2026 if (max_hlhdr_len < dev->drv[drvidx]->interface->hl_hdrlen)
2027 max_hlhdr_len = dev->drv[drvidx]->interface->hl_hdrlen;
2029 ndev->hard_header_len = ETH_HLEN + max_hlhdr_len;
2030 ndev->stop = &isdn_net_close;
2031 ndev->get_stats = &isdn_net_get_stats;
2032 ndev->do_ioctl = NULL;
2037 isdn_net_swapbind(int drvidx)
2041 #ifdef ISDN_DEBUG_NET_ICALL
2042 printk(KERN_DEBUG "n_fi: swapping ch of %d\n", drvidx);
2046 if (p->local->pre_device == drvidx)
2047 switch (p->local->pre_channel) {
2049 p->local->pre_channel = 1;
2052 p->local->pre_channel = 0;
2055 p = (isdn_net_dev *) p->next;
2060 isdn_net_swap_usage(int i1, int i2)
2062 int u1 = dev->usage[i1] & ISDN_USAGE_EXCLUSIVE;
2063 int u2 = dev->usage[i2] & ISDN_USAGE_EXCLUSIVE;
2065 #ifdef ISDN_DEBUG_NET_ICALL
2066 printk(KERN_DEBUG "n_fi: usage of %d and %d\n", i1, i2);
2068 dev->usage[i1] &= ~ISDN_USAGE_EXCLUSIVE;
2069 dev->usage[i1] |= u2;
2070 dev->usage[i2] &= ~ISDN_USAGE_EXCLUSIVE;
2071 dev->usage[i2] |= u1;
2076 * An incoming call-request has arrived.
2077 * Search the interface-chain for an appropriate interface.
2078 * If found, connect the interface to the ISDN-channel and initiate
2079 * D- and B-Channel-setup. If secure-flag is set, accept only
2080 * configured phone-numbers. If callback-flag is set, initiate
2083 * Return-Value: 0 = No appropriate interface for this call.
2085 * 2 = Reject call, wait cbdelay, then call back
2087 * 4 = Wait cbdelay, then call back
2088 * 5 = No appropriate interface for this call,
2089 * would eventually match if CID was longer.
2093 isdn_net_find_icall(int di, int ch, int idx, setup_parm *setup)
2108 /* Search name in netdev-chain */
2109 if (!setup->phone[0]) {
2112 printk(KERN_INFO "isdn_net: Incoming call without OAD, assuming '0'\n");
2114 strcpy(nr, setup->phone);
2115 si1 = (int) setup->si1;
2116 si2 = (int) setup->si2;
2117 if (!setup->eazmsn[0]) {
2118 printk(KERN_WARNING "isdn_net: Incoming call without CPN, assuming '0'\n");
2121 eaz = setup->eazmsn;
2122 if (dev->net_verbose > 1)
2123 printk(KERN_INFO "isdn_net: call from %s,%d,%d -> %s\n", nr, si1, si2, eaz);
2124 /* Accept DATA and VOICE calls at this stage
2125 * local eaz is checked later for allowed call types
2127 if ((si1 != 7) && (si1 != 1)) {
2128 if (dev->net_verbose > 1)
2129 printk(KERN_INFO "isdn_net: Service-Indicator not 1 or 7, ignored\n");
2132 n = (isdn_net_phone *) 0;
2134 ematch = wret = swapped = 0;
2135 #ifdef ISDN_DEBUG_NET_ICALL
2136 printk(KERN_DEBUG "n_fi: di=%d ch=%d idx=%d usg=%d\n", di, ch, idx,
2141 isdn_net_local *lp = p->local;
2143 /* If last check has triggered as binding-swap, revert it */
2146 isdn_net_swap_usage(idx, sidx);
2149 isdn_net_swapbind(di);
2153 /* check acceptable call types for DOV */
2154 my_eaz = isdn_map_eaz2msn(lp->msn, di);
2155 if (si1 == 1) { /* it's a DOV call, check if we allow it */
2156 if (*my_eaz == 'v' || *my_eaz == 'V' ||
2157 *my_eaz == 'b' || *my_eaz == 'B')
2158 my_eaz++; /* skip to allow a match */
2160 my_eaz = NULL; /* force non match */
2161 } else { /* it's a DATA call, check if we allow it */
2162 if (*my_eaz == 'b' || *my_eaz == 'B')
2163 my_eaz++; /* skip to allow a match */
2166 matchret = isdn_msncmp(eaz, my_eaz);
2172 /* Remember if more numbers eventually can match */
2173 if (matchret > wret)
2175 #ifdef ISDN_DEBUG_NET_ICALL
2176 printk(KERN_DEBUG "n_fi: if='%s', l.msn=%s, l.flags=%d, l.dstate=%d\n",
2177 lp->name, lp->msn, lp->flags, lp->dialstate);
2179 if ((!matchret) && /* EAZ is matching */
2180 (((!(lp->flags & ISDN_NET_CONNECTED)) && /* but not connected */
2181 (USG_NONE(dev->usage[idx]))) || /* and ch. unused or */
2182 ((((lp->dialstate == 4) || (lp->dialstate == 12)) && /* if dialing */
2183 (!(lp->flags & ISDN_NET_CALLBACK))) /* but no callback */
2186 #ifdef ISDN_DEBUG_NET_ICALL
2187 printk(KERN_DEBUG "n_fi: match1, pdev=%d pch=%d\n",
2188 lp->pre_device, lp->pre_channel);
2190 if (dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) {
2191 if ((lp->pre_channel != ch) ||
2192 (lp->pre_device != di)) {
2193 /* Here we got a problem:
2194 * If using an ICN-Card, an incoming call is always signaled on
2195 * on the first channel of the card, if both channels are
2196 * down. However this channel may be bound exclusive. If the
2197 * second channel is free, this call should be accepted.
2198 * The solution is horribly but it runs, so what:
2199 * We exchange the exclusive bindings of the two channels, the
2200 * corresponding variables in the interface-structs.
2203 sidx = isdn_dc2minor(di, 1);
2204 #ifdef ISDN_DEBUG_NET_ICALL
2205 printk(KERN_DEBUG "n_fi: ch is 0\n");
2207 if (USG_NONE(dev->usage[sidx])) {
2208 /* Second Channel is free, now see if it is bound
2210 if (dev->usage[sidx] & ISDN_USAGE_EXCLUSIVE) {
2211 #ifdef ISDN_DEBUG_NET_ICALL
2212 printk(KERN_DEBUG "n_fi: 2nd channel is down and bound\n");
2214 /* Yes, swap bindings only, if the original
2215 * binding is bound to channel 1 of this driver */
2216 if ((lp->pre_device == di) &&
2217 (lp->pre_channel == 1)) {
2218 isdn_net_swapbind(di);
2221 /* ... else iterate next device */
2222 p = (isdn_net_dev *) p->next;
2226 #ifdef ISDN_DEBUG_NET_ICALL
2227 printk(KERN_DEBUG "n_fi: 2nd channel is down and unbound\n");
2229 /* No, swap always and swap excl-usage also */
2230 isdn_net_swap_usage(idx, sidx);
2231 isdn_net_swapbind(di);
2234 /* Now check for exclusive binding again */
2235 #ifdef ISDN_DEBUG_NET_ICALL
2236 printk(KERN_DEBUG "n_fi: final check\n");
2238 if ((dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) &&
2239 ((lp->pre_channel != ch) ||
2240 (lp->pre_device != di))) {
2241 #ifdef ISDN_DEBUG_NET_ICALL
2242 printk(KERN_DEBUG "n_fi: final check failed\n");
2244 p = (isdn_net_dev *) p->next;
2249 /* We are already on the second channel, so nothing to do */
2250 #ifdef ISDN_DEBUG_NET_ICALL
2251 printk(KERN_DEBUG "n_fi: already on 2nd channel\n");
2256 #ifdef ISDN_DEBUG_NET_ICALL
2257 printk(KERN_DEBUG "n_fi: match2\n");
2260 if (lp->flags & ISDN_NET_SECURE) {
2262 if (!isdn_msncmp(nr, n->num))
2264 n = (isdn_net_phone *) n->next;
2267 if (n || (!(lp->flags & ISDN_NET_SECURE))) {
2268 #ifdef ISDN_DEBUG_NET_ICALL
2269 printk(KERN_DEBUG "n_fi: match3\n");
2271 /* matching interface found */
2274 * Is the state STOPPED?
2275 * If so, no dialin is allowed,
2276 * so reject actively.
2278 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2279 printk(KERN_INFO "incoming call, interface %s `stopped' -> rejected\n",
2284 * Is the interface up?
2285 * If not, reject the call actively.
2287 if (!isdn_net_device_started(p)) {
2288 printk(KERN_INFO "%s: incoming call, interface down -> rejected\n",
2292 /* Interface is up, now see if it's a slave. If so, see if
2293 * it's master and parent slave is online. If not, reject the call.
2296 isdn_net_local *mlp = (isdn_net_local *) lp->master->priv;
2297 printk(KERN_DEBUG "ICALLslv: %s\n", lp->name);
2298 printk(KERN_DEBUG "master=%s\n", mlp->name);
2299 if (mlp->flags & ISDN_NET_CONNECTED) {
2300 printk(KERN_DEBUG "master online\n");
2301 /* Master is online, find parent-slave (master if first slave) */
2302 while (mlp->slave) {
2303 if ((isdn_net_local *) mlp->slave->priv == lp)
2305 mlp = (isdn_net_local *) mlp->slave->priv;
2308 printk(KERN_DEBUG "master offline\n");
2309 /* Found parent, if it's offline iterate next device */
2310 printk(KERN_DEBUG "mlpf: %d\n", mlp->flags & ISDN_NET_CONNECTED);
2311 if (!(mlp->flags & ISDN_NET_CONNECTED)) {
2312 p = (isdn_net_dev *) p->next;
2316 if (lp->flags & ISDN_NET_CALLBACK) {
2319 * Is the state MANUAL?
2320 * If so, no callback can be made,
2321 * so reject actively.
2323 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2324 printk(KERN_INFO "incoming call for callback, interface %s `off' -> rejected\n",
2328 printk(KERN_DEBUG "%s: call from %s -> %s, start callback\n",
2331 /* Grab a free ISDN-Channel */
2332 spin_lock_irqsave(&dev->lock, flags);
2334 isdn_get_free_channel(
2343 printk(KERN_WARNING "isdn_net_find_icall: No channel for %s\n", lp->name);
2344 spin_unlock_irqrestore(&dev->lock, flags);
2347 /* Setup dialstate. */
2350 /* Connect interface with channel */
2351 isdn_net_bind_channel(lp, chi);
2352 #ifdef CONFIG_ISDN_PPP
2353 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2354 if (isdn_ppp_bind(lp) < 0) {
2355 spin_unlock_irqrestore(&dev->lock, flags);
2356 isdn_net_unbind_channel(lp);
2360 spin_unlock_irqrestore(&dev->lock, flags);
2361 /* Initiate dialing by returning 2 or 4 */
2362 return (lp->flags & ISDN_NET_CBHUP) ? 2 : 4;
2364 printk(KERN_WARNING "isdn_net: %s: No phone number\n", lp->name);
2367 printk(KERN_DEBUG "%s: call from %s -> %s accepted\n", lp->name, nr,
2369 /* if this interface is dialing, it does it probably on a different
2370 device, so free this device */
2371 if ((lp->dialstate == 4) || (lp->dialstate == 12)) {
2372 #ifdef CONFIG_ISDN_PPP
2373 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2376 isdn_net_lp_disconnected(lp);
2377 isdn_free_channel(lp->isdn_device, lp->isdn_channel,
2380 spin_lock_irqsave(&dev->lock, flags);
2381 dev->usage[idx] &= ISDN_USAGE_EXCLUSIVE;
2382 dev->usage[idx] |= ISDN_USAGE_NET;
2383 strcpy(dev->num[idx], nr);
2385 dev->st_netdev[idx] = lp->netdev;
2386 lp->isdn_device = di;
2387 lp->isdn_channel = ch;
2389 lp->flags |= ISDN_NET_CONNECTED;
2394 lp->hupflags |= ISDN_WAITCHARGE;
2395 lp->hupflags &= ~ISDN_HAVECHARGE;
2396 #ifdef CONFIG_ISDN_PPP
2397 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
2398 if (isdn_ppp_bind(lp) < 0) {
2399 isdn_net_unbind_channel(lp);
2400 spin_unlock_irqrestore(&dev->lock, flags);
2405 spin_unlock_irqrestore(&dev->lock, flags);
2410 p = (isdn_net_dev *) p->next;
2412 /* If none of configured EAZ/MSN matched and not verbose, be silent */
2413 if (!ematch || dev->net_verbose)
2414 printk(KERN_INFO "isdn_net: call from %s -> %d %s ignored\n", nr, di, eaz);
2415 return (wret == 2)?5:0;
2419 * Search list of net-interfaces for an interface with given name.
2422 isdn_net_findif(char *name)
2424 isdn_net_dev *p = dev->netdev;
2427 if (!strcmp(p->local->name, name))
2429 p = (isdn_net_dev *) p->next;
2431 return (isdn_net_dev *) NULL;
2435 * Force a net-interface to dial out.
2436 * This is called from the userlevel-routine below or
2437 * from isdn_net_start_xmit().
2440 isdn_net_force_dial_lp(isdn_net_local * lp)
2442 if ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) {
2447 /* Grab a free ISDN-Channel */
2448 spin_lock_irqsave(&dev->lock, flags);
2449 if ((chi = isdn_get_free_channel(
2456 printk(KERN_WARNING "isdn_net_force_dial: No channel for %s\n", lp->name);
2457 spin_unlock_irqrestore(&dev->lock, flags);
2461 /* Connect interface with channel */
2462 isdn_net_bind_channel(lp, chi);
2463 #ifdef CONFIG_ISDN_PPP
2464 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2465 if (isdn_ppp_bind(lp) < 0) {
2466 isdn_net_unbind_channel(lp);
2467 spin_unlock_irqrestore(&dev->lock, flags);
2471 /* Initiate dialing */
2472 spin_unlock_irqrestore(&dev->lock, flags);
2482 * This is called from certain upper protocol layers (multilink ppp
2483 * and x25iface encapsulation module) that want to initiate dialing
2487 isdn_net_dial_req(isdn_net_local * lp)
2489 /* is there a better error code? */
2490 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) return -EBUSY;
2492 return isdn_net_force_dial_lp(lp);
2496 * Force a net-interface to dial out.
2497 * This is always called from within userspace (ISDN_IOCTL_NET_DIAL).
2500 isdn_net_force_dial(char *name)
2502 isdn_net_dev *p = isdn_net_findif(name);
2506 return (isdn_net_force_dial_lp(p->local));
2510 * Allocate a new network-interface and initialize its data structures.
2513 isdn_net_new(char *name, struct net_device *master)
2515 isdn_net_dev *netdev;
2517 /* Avoid creating an existing interface */
2518 if (isdn_net_findif(name)) {
2519 printk(KERN_WARNING "isdn_net: interface %s already exists\n", name);
2522 if (!(netdev = kzalloc(sizeof(isdn_net_dev), GFP_KERNEL))) {
2523 printk(KERN_WARNING "isdn_net: Could not allocate net-device\n");
2526 if (!(netdev->local = kzalloc(sizeof(isdn_net_local), GFP_KERNEL))) {
2527 printk(KERN_WARNING "isdn_net: Could not allocate device locals\n");
2532 strcpy(netdev->local->name, " ");
2534 strcpy(netdev->local->name, name);
2535 strcpy(netdev->dev.name, netdev->local->name);
2536 netdev->dev.priv = netdev->local;
2537 netdev->dev.init = isdn_net_init;
2538 netdev->local->p_encap = ISDN_NET_ENCAP_RAWIP;
2540 /* Device shall be a slave */
2541 struct net_device *p = (((isdn_net_local *) master->priv)->slave);
2542 struct net_device *q = master;
2544 netdev->local->master = master;
2545 /* Put device at end of slave-chain */
2548 p = (((isdn_net_local *) p->priv)->slave);
2550 ((isdn_net_local *) q->priv)->slave = &(netdev->dev);
2552 /* Device shall be a master */
2554 * Watchdog timer (currently) for master only.
2556 netdev->dev.tx_timeout = isdn_net_tx_timeout;
2557 netdev->dev.watchdog_timeo = ISDN_NET_TX_TIMEOUT;
2558 if (register_netdev(&netdev->dev) != 0) {
2559 printk(KERN_WARNING "isdn_net: Could not register net-device\n");
2560 kfree(netdev->local);
2565 netdev->local->magic = ISDN_NET_MAGIC;
2567 netdev->queue = netdev->local;
2568 spin_lock_init(&netdev->queue_lock);
2570 netdev->local->last = netdev->local;
2571 netdev->local->netdev = netdev;
2572 netdev->local->next = netdev->local;
2574 INIT_WORK(&netdev->local->tqueue, isdn_net_softint);
2575 spin_lock_init(&netdev->local->xmit_lock);
2577 netdev->local->isdn_device = -1;
2578 netdev->local->isdn_channel = -1;
2579 netdev->local->pre_device = -1;
2580 netdev->local->pre_channel = -1;
2581 netdev->local->exclusive = -1;
2582 netdev->local->ppp_slot = -1;
2583 netdev->local->pppbind = -1;
2584 skb_queue_head_init(&netdev->local->super_tx_queue);
2585 netdev->local->l2_proto = ISDN_PROTO_L2_X75I;
2586 netdev->local->l3_proto = ISDN_PROTO_L3_TRANS;
2587 netdev->local->triggercps = 6000;
2588 netdev->local->slavedelay = 10 * HZ;
2589 netdev->local->hupflags = ISDN_INHUP; /* Do hangup even on incoming calls */
2590 netdev->local->onhtime = 10; /* Default hangup-time for saving costs
2591 of those who forget configuring this */
2592 netdev->local->dialmax = 1;
2593 netdev->local->flags = ISDN_NET_CBHUP | ISDN_NET_DM_MANUAL; /* Hangup before Callback, manual dial */
2594 netdev->local->cbdelay = 25; /* Wait 5 secs before Callback */
2595 netdev->local->dialtimeout = -1; /* Infinite Dial-Timeout */
2596 netdev->local->dialwait = 5 * HZ; /* Wait 5 sec. after failed dial */
2597 netdev->local->dialstarted = 0; /* Jiffies of last dial-start */
2598 netdev->local->dialwait_timer = 0; /* Jiffies of earliest next dial-start */
2600 /* Put into to netdev-chain */
2601 netdev->next = (void *) dev->netdev;
2602 dev->netdev = netdev;
2603 return netdev->dev.name;
2607 isdn_net_newslave(char *parm)
2609 char *p = strchr(parm, ',');
2614 /* Slave-Name MUST not be empty */
2617 strcpy(newname, p + 1);
2619 /* Master must already exist */
2620 if (!(n = isdn_net_findif(parm)))
2622 /* Master must be a real interface, not a slave */
2623 if (n->local->master)
2625 /* Master must not be started yet */
2626 if (isdn_net_device_started(n))
2628 return (isdn_net_new(newname, &(n->dev)));
2634 * Set interface-parameters.
2635 * Always set all parameters, so the user-level application is responsible
2636 * for not overwriting existing setups. It has to get the current
2637 * setup first, if only selected parameters are to be changed.
2640 isdn_net_setcfg(isdn_net_ioctl_cfg * cfg)
2642 isdn_net_dev *p = isdn_net_findif(cfg->name);
2650 isdn_net_local *lp = p->local;
2652 /* See if any registered driver supports the features we want */
2653 features = ((1 << cfg->l2_proto) << ISDN_FEATURE_L2_SHIFT) |
2654 ((1 << cfg->l3_proto) << ISDN_FEATURE_L3_SHIFT);
2655 for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2657 if ((dev->drv[i]->interface->features & features) == features)
2659 if (i == ISDN_MAX_DRIVERS) {
2660 printk(KERN_WARNING "isdn_net: No driver with selected features\n");
2663 if (lp->p_encap != cfg->p_encap){
2664 #ifdef CONFIG_ISDN_X25
2665 struct concap_proto * cprot = p -> cprot;
2667 if (isdn_net_device_started(p)) {
2668 printk(KERN_WARNING "%s: cannot change encap when if is up\n",
2672 #ifdef CONFIG_ISDN_X25
2673 if( cprot && cprot -> pops )
2674 cprot -> pops -> proto_del ( cprot );
2677 /* ... , prepare for configuration of new one ... */
2678 switch ( cfg -> p_encap ){
2679 case ISDN_NET_ENCAP_X25IFACE:
2680 lp -> dops = &isdn_concap_reliable_dl_dops;
2682 /* ... and allocate new one ... */
2683 p -> cprot = isdn_concap_new( cfg -> p_encap );
2684 /* p -> cprot == NULL now if p_encap is not supported
2685 by means of the concap_proto mechanism */
2686 /* the protocol is not configured yet; this will
2687 happen later when isdn_net_reset() is called */
2690 switch ( cfg->p_encap ) {
2691 case ISDN_NET_ENCAP_SYNCPPP:
2692 #ifndef CONFIG_ISDN_PPP
2693 printk(KERN_WARNING "%s: SyncPPP support not configured\n",
2697 p->dev.type = ARPHRD_PPP; /* change ARP type */
2698 p->dev.addr_len = 0;
2699 p->dev.do_ioctl = isdn_ppp_dev_ioctl;
2702 case ISDN_NET_ENCAP_X25IFACE:
2703 #ifndef CONFIG_ISDN_X25
2704 printk(KERN_WARNING "%s: isdn-x25 support not configured\n",
2708 p->dev.type = ARPHRD_X25; /* change ARP type */
2709 p->dev.addr_len = 0;
2712 case ISDN_NET_ENCAP_CISCOHDLCK:
2713 p->dev.do_ioctl = isdn_ciscohdlck_dev_ioctl;
2716 if( cfg->p_encap >= 0 &&
2717 cfg->p_encap <= ISDN_NET_ENCAP_MAX_ENCAP )
2720 "%s: encapsulation protocol %d not supported\n",
2721 p->local->name, cfg->p_encap);
2724 if (strlen(cfg->drvid)) {
2725 /* A bind has been requested ... */
2731 strcpy(drvid, cfg->drvid);
2732 if ((c = strchr(drvid, ','))) {
2733 /* The channel-number is appended to the driver-Id with a comma */
2734 chidx = (int) simple_strtoul(c + 1, &e, 10);
2739 for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2740 /* Lookup driver-Id in array */
2741 if (!(strcmp(dev->drvid[i], drvid))) {
2745 if ((drvidx == -1) || (chidx == -1))
2746 /* Either driver-Id or channel-number invalid */
2749 /* Parameters are valid, so get them */
2750 drvidx = lp->pre_device;
2751 chidx = lp->pre_channel;
2753 if (cfg->exclusive > 0) {
2754 unsigned long flags;
2756 /* If binding is exclusive, try to grab the channel */
2757 spin_lock_irqsave(&dev->lock, flags);
2758 if ((i = isdn_get_free_channel(ISDN_USAGE_NET,
2759 lp->l2_proto, lp->l3_proto, drvidx,
2760 chidx, lp->msn)) < 0) {
2761 /* Grab failed, because desired channel is in use */
2763 spin_unlock_irqrestore(&dev->lock, flags);
2766 /* All went ok, so update isdninfo */
2767 dev->usage[i] = ISDN_USAGE_EXCLUSIVE;
2769 spin_unlock_irqrestore(&dev->lock, flags);
2772 /* Non-exclusive binding or unbind. */
2774 if ((lp->pre_device != -1) && (cfg->exclusive == -1)) {
2775 isdn_unexclusive_channel(lp->pre_device, lp->pre_channel);
2776 isdn_free_channel(lp->pre_device, lp->pre_channel, ISDN_USAGE_NET);
2781 strcpy(lp->msn, cfg->eaz);
2782 lp->pre_device = drvidx;
2783 lp->pre_channel = chidx;
2784 lp->onhtime = cfg->onhtime;
2785 lp->charge = cfg->charge;
2786 lp->l2_proto = cfg->l2_proto;
2787 lp->l3_proto = cfg->l3_proto;
2788 lp->cbdelay = cfg->cbdelay;
2789 lp->dialmax = cfg->dialmax;
2790 lp->triggercps = cfg->triggercps;
2791 lp->slavedelay = cfg->slavedelay * HZ;
2792 lp->pppbind = cfg->pppbind;
2793 lp->dialtimeout = cfg->dialtimeout >= 0 ? cfg->dialtimeout * HZ : -1;
2794 lp->dialwait = cfg->dialwait * HZ;
2796 lp->flags |= ISDN_NET_SECURE;
2798 lp->flags &= ~ISDN_NET_SECURE;
2800 lp->flags |= ISDN_NET_CBHUP;
2802 lp->flags &= ~ISDN_NET_CBHUP;
2803 switch (cfg->callback) {
2805 lp->flags &= ~(ISDN_NET_CALLBACK | ISDN_NET_CBOUT);
2808 lp->flags |= ISDN_NET_CALLBACK;
2809 lp->flags &= ~ISDN_NET_CBOUT;
2812 lp->flags |= ISDN_NET_CBOUT;
2813 lp->flags &= ~ISDN_NET_CALLBACK;
2816 lp->flags &= ~ISDN_NET_DIALMODE_MASK; /* first all bits off */
2817 if (cfg->dialmode && !(cfg->dialmode & ISDN_NET_DIALMODE_MASK)) {
2818 /* old isdnctrl version, where only 0 or 1 is given */
2820 "Old isdnctrl version detected! Please update.\n");
2821 lp->flags |= ISDN_NET_DM_OFF; /* turn on `off' bit */
2824 lp->flags |= cfg->dialmode; /* turn on selected bits */
2827 lp->hupflags |= ISDN_CHARGEHUP;
2829 lp->hupflags &= ~ISDN_CHARGEHUP;
2831 lp->hupflags |= ISDN_INHUP;
2833 lp->hupflags &= ~ISDN_INHUP;
2834 if (cfg->chargeint > 10) {
2835 lp->hupflags |= ISDN_CHARGEHUP | ISDN_HAVECHARGE | ISDN_MANCHARGE;
2836 lp->chargeint = cfg->chargeint * HZ;
2838 if (cfg->p_encap != lp->p_encap) {
2839 if (cfg->p_encap == ISDN_NET_ENCAP_RAWIP) {
2840 p->dev.header_ops = NULL;
2841 p->dev.flags = IFF_NOARP|IFF_POINTOPOINT;
2843 p->dev.header_ops = &isdn_header_ops;
2844 if (cfg->p_encap == ISDN_NET_ENCAP_ETHER)
2845 p->dev.flags = IFF_BROADCAST | IFF_MULTICAST;
2847 p->dev.flags = IFF_NOARP|IFF_POINTOPOINT;
2850 lp->p_encap = cfg->p_encap;
2857 * Perform get-interface-parameters.ioctl
2860 isdn_net_getcfg(isdn_net_ioctl_cfg * cfg)
2862 isdn_net_dev *p = isdn_net_findif(cfg->name);
2865 isdn_net_local *lp = p->local;
2867 strcpy(cfg->eaz, lp->msn);
2868 cfg->exclusive = lp->exclusive;
2869 if (lp->pre_device >= 0) {
2870 sprintf(cfg->drvid, "%s,%d", dev->drvid[lp->pre_device],
2873 cfg->drvid[0] = '\0';
2874 cfg->onhtime = lp->onhtime;
2875 cfg->charge = lp->charge;
2876 cfg->l2_proto = lp->l2_proto;
2877 cfg->l3_proto = lp->l3_proto;
2878 cfg->p_encap = lp->p_encap;
2879 cfg->secure = (lp->flags & ISDN_NET_SECURE) ? 1 : 0;
2881 if (lp->flags & ISDN_NET_CALLBACK)
2883 if (lp->flags & ISDN_NET_CBOUT)
2885 cfg->cbhup = (lp->flags & ISDN_NET_CBHUP) ? 1 : 0;
2886 cfg->dialmode = lp->flags & ISDN_NET_DIALMODE_MASK;
2887 cfg->chargehup = (lp->hupflags & 4) ? 1 : 0;
2888 cfg->ihup = (lp->hupflags & 8) ? 1 : 0;
2889 cfg->cbdelay = lp->cbdelay;
2890 cfg->dialmax = lp->dialmax;
2891 cfg->triggercps = lp->triggercps;
2892 cfg->slavedelay = lp->slavedelay / HZ;
2893 cfg->chargeint = (lp->hupflags & ISDN_CHARGEHUP) ?
2894 (lp->chargeint / HZ) : 0;
2895 cfg->pppbind = lp->pppbind;
2896 cfg->dialtimeout = lp->dialtimeout >= 0 ? lp->dialtimeout / HZ : -1;
2897 cfg->dialwait = lp->dialwait / HZ;
2899 strcpy(cfg->slave, ((isdn_net_local *) lp->slave->priv)->name);
2901 cfg->slave[0] = '\0';
2903 strcpy(cfg->master, ((isdn_net_local *) lp->master->priv)->name);
2905 cfg->master[0] = '\0';
2912 * Add a phone-number to an interface.
2915 isdn_net_addphone(isdn_net_ioctl_phone * phone)
2917 isdn_net_dev *p = isdn_net_findif(phone->name);
2921 if (!(n = kmalloc(sizeof(isdn_net_phone), GFP_KERNEL)))
2923 strcpy(n->num, phone->phone);
2924 n->next = p->local->phone[phone->outgoing & 1];
2925 p->local->phone[phone->outgoing & 1] = n;
2932 * Copy a string of all phone-numbers of an interface to user space.
2933 * This might sleep and must be called with the isdn semaphore down.
2936 isdn_net_getphones(isdn_net_ioctl_phone * phone, char __user *phones)
2938 isdn_net_dev *p = isdn_net_findif(phone->name);
2939 int inout = phone->outgoing & 1;
2947 for (n = p->local->phone[inout]; n; n = n->next) {
2949 put_user(' ', phones++);
2952 if (copy_to_user(phones, n->num, strlen(n->num) + 1)) {
2955 phones += strlen(n->num);
2956 count += strlen(n->num);
2959 put_user(0, phones);
2965 * Copy a string containing the peer's phone number of a connected interface
2969 isdn_net_getpeer(isdn_net_ioctl_phone *phone, isdn_net_ioctl_phone __user *peer)
2971 isdn_net_dev *p = isdn_net_findif(phone->name);
2974 if (!p) return -ENODEV;
2976 * Theoretical race: while this executes, the remote number might
2977 * become invalid (hang up) or change (new connection), resulting
2978 * in (partially) wrong number copied to user. This race
2979 * currently ignored.
2981 ch = p->local->isdn_channel;
2982 dv = p->local->isdn_device;
2983 if(ch<0 && dv<0) return -ENOTCONN;
2984 idx = isdn_dc2minor(dv, ch);
2985 if (idx<0) return -ENODEV;
2986 /* for pre-bound channels, we need this extra check */
2987 if ( strncmp(dev->num[idx],"???",3) == 0 ) return -ENOTCONN;
2988 strncpy(phone->phone,dev->num[idx],ISDN_MSNLEN);
2989 phone->outgoing=USG_OUTGOING(dev->usage[idx]);
2990 if ( copy_to_user(peer,phone,sizeof(*peer)) ) return -EFAULT;
2994 * Delete a phone-number from an interface.
2997 isdn_net_delphone(isdn_net_ioctl_phone * phone)
2999 isdn_net_dev *p = isdn_net_findif(phone->name);
3000 int inout = phone->outgoing & 1;
3005 n = p->local->phone[inout];
3008 if (!strcmp(n->num, phone->phone)) {
3009 if (p->local->dial == n)
3010 p->local->dial = n->next;
3014 p->local->phone[inout] = n->next;
3019 n = (isdn_net_phone *) n->next;
3027 * Delete all phone-numbers of an interface.
3030 isdn_net_rmallphone(isdn_net_dev * p)
3036 for (i = 0; i < 2; i++) {
3037 n = p->local->phone[i];
3043 p->local->phone[i] = NULL;
3045 p->local->dial = NULL;
3050 * Force a hangup of a network-interface.
3053 isdn_net_force_hangup(char *name)
3055 isdn_net_dev *p = isdn_net_findif(name);
3056 struct net_device *q;
3059 if (p->local->isdn_device < 0)
3061 q = p->local->slave;
3062 /* If this interface has slaves, do a hangup for them also. */
3065 q = (((isdn_net_local *) q->priv)->slave);
3067 isdn_net_hangup(&p->dev);
3074 * Helper-function for isdn_net_rm: Do the real work.
3077 isdn_net_realrm(isdn_net_dev * p, isdn_net_dev * q)
3081 if (isdn_net_device_started(p)) {
3084 #ifdef CONFIG_ISDN_X25
3085 if( p -> cprot && p -> cprot -> pops )
3086 p -> cprot -> pops -> proto_del ( p -> cprot );
3088 /* Free all phone-entries */
3089 isdn_net_rmallphone(p);
3090 /* If interface is bound exclusive, free channel-usage */
3091 if (p->local->exclusive != -1)
3092 isdn_unexclusive_channel(p->local->pre_device, p->local->pre_channel);
3093 if (p->local->master) {
3094 /* It's a slave-device, so update master's slave-pointer if necessary */
3095 if (((isdn_net_local *) (p->local->master->priv))->slave == &p->dev)
3096 ((isdn_net_local *) (p->local->master->priv))->slave = p->local->slave;
3098 /* Unregister only if it's a master-device */
3099 unregister_netdev(&p->dev);
3101 /* Unlink device from chain */
3102 spin_lock_irqsave(&dev->lock, flags);
3106 dev->netdev = p->next;
3107 if (p->local->slave) {
3108 /* If this interface has a slave, remove it also */
3109 char *slavename = ((isdn_net_local *) (p->local->slave->priv))->name;
3110 isdn_net_dev *n = dev->netdev;
3113 if (!strcmp(n->local->name, slavename)) {
3114 spin_unlock_irqrestore(&dev->lock, flags);
3115 isdn_net_realrm(n, q);
3116 spin_lock_irqsave(&dev->lock, flags);
3120 n = (isdn_net_dev *) n->next;
3123 spin_unlock_irqrestore(&dev->lock, flags);
3124 /* If no more net-devices remain, disable auto-hangup timer */
3125 if (dev->netdev == NULL)
3126 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0);
3134 * Remove a single network-interface.
3137 isdn_net_rm(char *name)
3143 /* Search name in netdev-chain */
3144 spin_lock_irqsave(&dev->lock, flags);
3148 if (!strcmp(p->local->name, name)) {
3149 spin_unlock_irqrestore(&dev->lock, flags);
3150 return (isdn_net_realrm(p, q));
3153 p = (isdn_net_dev *) p->next;
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);
3163 * Remove all network-interfaces
3166 isdn_net_rmall(void)
3171 /* Walk through netdev-chain */
3172 spin_lock_irqsave(&dev->lock, flags);
3173 while (dev->netdev) {
3174 if (!dev->netdev->local->master) {
3175 /* Remove master-devices only, slaves get removed with their master */
3176 spin_unlock_irqrestore(&dev->lock, flags);
3177 if ((ret = isdn_net_realrm(dev->netdev, NULL))) {
3180 spin_lock_irqsave(&dev->lock, flags);
3184 spin_unlock_irqrestore(&dev->lock, flags);