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_all_tx(lp->netdev->dev);
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", p->dev->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 p->dev->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 p->dev->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", p->dev->name);
446 printk(KERN_INFO "%s: Chargesum is %d\n", p->dev->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", p->dev->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 p->dev->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", p->dev->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", p->dev->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", p->dev->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", p->dev->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, p->dev->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 lp->slave->name, d->name);
840 isdn_net_hangup(lp->slave);
843 printk(KERN_INFO "isdn_net: local hangup %s\n", d->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", d->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->netdev->dev->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->netdev->dev->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 dev->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->netdev->dev->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->netdev->dev->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->netdev->dev->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)
1660 __be32 *addr, *mask;
1667 p += get_u32(p, &code);
1670 case CISCO_SLARP_REQUEST:
1671 lp->cisco_yourseq = 0;
1672 isdn_net_ciscohdlck_slarp_send_reply(lp);
1674 case CISCO_SLARP_REPLY:
1676 mask = (__be32 *)(p + 4);
1677 if (*mask != cpu_to_be32(0xfffffffc))
1678 goto slarp_reply_out;
1679 if ((*addr & cpu_to_be32(3)) == cpu_to_be32(0) ||
1680 (*addr & cpu_to_be32(3)) == cpu_to_be32(3))
1681 goto slarp_reply_out;
1682 local = *addr ^ cpu_to_be32(3);
1683 printk(KERN_INFO "%s: got slarp reply: remote ip: %pI4, local ip: %pI4 mask: %pI4\n",
1684 lp->netdev->dev->name, addr, &local, mask);
1687 printk(KERN_INFO "%s: got invalid slarp reply (%pI4/%pI4) - ignored\n",
1688 lp->netdev->dev->name, addr, mask);
1690 case CISCO_SLARP_KEEPALIVE:
1691 period = (int)((jiffies - lp->cisco_last_slarp_in
1693 if (lp->cisco_debserint &&
1694 (period != lp->cisco_keepalive_period) &&
1695 lp->cisco_last_slarp_in) {
1696 printk(KERN_DEBUG "%s: Keepalive period mismatch - "
1697 "is %d but should be %d.\n",
1698 lp->netdev->dev->name, period,
1699 lp->cisco_keepalive_period);
1701 lp->cisco_last_slarp_in = jiffies;
1702 p += get_u32(p, &my_seq);
1703 p += get_u32(p, &your_seq);
1704 p += get_u16(p, &unused);
1705 lp->cisco_yourseq = my_seq;
1706 lp->cisco_mineseen = your_seq;
1712 isdn_net_ciscohdlck_receive(isdn_net_local *lp, struct sk_buff *skb)
1723 p += get_u8 (p, &addr);
1724 p += get_u8 (p, &ctrl);
1725 p += get_u16(p, &type);
1728 if (addr != CISCO_ADDR_UNICAST && addr != CISCO_ADDR_BROADCAST) {
1729 printk(KERN_WARNING "%s: Unknown Cisco addr 0x%02x\n",
1730 lp->netdev->dev->name, addr);
1733 if (ctrl != CISCO_CTRL) {
1734 printk(KERN_WARNING "%s: Unknown Cisco ctrl 0x%02x\n",
1735 lp->netdev->dev->name, ctrl);
1740 case CISCO_TYPE_SLARP:
1741 isdn_net_ciscohdlck_slarp_in(lp, skb);
1743 case CISCO_TYPE_CDP:
1744 if (lp->cisco_debserint)
1745 printk(KERN_DEBUG "%s: Received CDP packet. use "
1746 "\"no cdp enable\" on cisco.\n",
1747 lp->netdev->dev->name);
1750 /* no special cisco protocol */
1751 skb->protocol = htons(type);
1761 * Got a packet from ISDN-Channel.
1764 isdn_net_receive(struct net_device *ndev, struct sk_buff *skb)
1766 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1767 isdn_net_local *olp = lp; /* original 'lp' */
1768 #ifdef CONFIG_ISDN_X25
1769 struct concap_proto *cprot = lp -> netdev -> cprot;
1771 lp->transcount += skb->len;
1773 lp->stats.rx_packets++;
1774 lp->stats.rx_bytes += skb->len;
1776 /* Bundling: If device is a slave-device, deliver to master, also
1777 * handle master's statistics and hangup-timeout
1780 lp = (isdn_net_local *) ndev->priv;
1781 lp->stats.rx_packets++;
1782 lp->stats.rx_bytes += skb->len;
1785 skb->pkt_type = PACKET_HOST;
1786 skb_reset_mac_header(skb);
1787 #ifdef ISDN_DEBUG_NET_DUMP
1788 isdn_dumppkt("R:", skb->data, skb->len, 40);
1790 switch (lp->p_encap) {
1791 case ISDN_NET_ENCAP_ETHER:
1792 /* Ethernet over ISDN */
1795 skb->protocol = isdn_net_type_trans(skb, ndev);
1797 case ISDN_NET_ENCAP_UIHDLC:
1798 /* HDLC with UI-frame (for ispa with -h1 option) */
1803 case ISDN_NET_ENCAP_RAWIP:
1804 /* RAW-IP without MAC-Header */
1807 skb->protocol = htons(ETH_P_IP);
1809 case ISDN_NET_ENCAP_CISCOHDLCK:
1810 isdn_net_ciscohdlck_receive(lp, skb);
1812 case ISDN_NET_ENCAP_CISCOHDLC:
1813 /* CISCO-HDLC IP with type field and fake I-frame-header */
1816 case ISDN_NET_ENCAP_IPTYP:
1817 /* IP with type field */
1820 skb->protocol = *(unsigned short *) &(skb->data[0]);
1822 if (*(unsigned short *) skb->data == 0xFFFF)
1823 skb->protocol = htons(ETH_P_802_3);
1825 #ifdef CONFIG_ISDN_PPP
1826 case ISDN_NET_ENCAP_SYNCPPP:
1827 /* huptimer is done in isdn_ppp_push_higher */
1828 isdn_ppp_receive(lp->netdev, olp, skb);
1833 #ifdef CONFIG_ISDN_X25
1834 /* try if there are generic sync_device receiver routines */
1835 if(cprot) if(cprot -> pops)
1836 if( cprot -> pops -> data_ind){
1837 cprot -> pops -> data_ind(cprot,skb);
1840 #endif /* CONFIG_ISDN_X25 */
1841 printk(KERN_WARNING "%s: unknown encapsulation, dropping\n",
1842 lp->netdev->dev->name);
1852 * A packet arrived via ISDN. Search interface-chain for a corresponding
1853 * interface. If found, deliver packet to receiver-function and return 1,
1857 isdn_net_rcv_skb(int idx, struct sk_buff *skb)
1859 isdn_net_dev *p = dev->rx_netdev[idx];
1862 isdn_net_local *lp = p->local;
1863 if ((lp->flags & ISDN_NET_CONNECTED) &&
1865 isdn_net_receive(p->dev, skb);
1874 * depends on encaps that is being used.
1877 static int isdn_net_header(struct sk_buff *skb, struct net_device *dev,
1878 unsigned short type,
1879 const void *daddr, const void *saddr, unsigned plen)
1881 isdn_net_local *lp = dev->priv;
1885 switch (lp->p_encap) {
1886 case ISDN_NET_ENCAP_ETHER:
1887 len = eth_header(skb, dev, type, daddr, saddr, plen);
1889 #ifdef CONFIG_ISDN_PPP
1890 case ISDN_NET_ENCAP_SYNCPPP:
1891 /* stick on a fake header to keep fragmentation code happy. */
1892 len = IPPP_MAX_HEADER;
1896 case ISDN_NET_ENCAP_RAWIP:
1897 printk(KERN_WARNING "isdn_net_header called with RAW_IP!\n");
1900 case ISDN_NET_ENCAP_IPTYP:
1901 /* ethernet type field */
1902 *((ushort *) skb_push(skb, 2)) = htons(type);
1905 case ISDN_NET_ENCAP_UIHDLC:
1906 /* HDLC with UI-Frames (for ispa with -h1 option) */
1907 *((ushort *) skb_push(skb, 2)) = htons(0x0103);
1910 case ISDN_NET_ENCAP_CISCOHDLC:
1911 case ISDN_NET_ENCAP_CISCOHDLCK:
1912 p = skb_push(skb, 4);
1913 p += put_u8 (p, CISCO_ADDR_UNICAST);
1914 p += put_u8 (p, CISCO_CTRL);
1915 p += put_u16(p, type);
1918 #ifdef CONFIG_ISDN_X25
1920 /* try if there are generic concap protocol routines */
1921 if( lp-> netdev -> cprot ){
1922 printk(KERN_WARNING "isdn_net_header called with concap_proto!\n");
1927 #endif /* CONFIG_ISDN_X25 */
1932 /* We don't need to send arp, because we have point-to-point connections. */
1934 isdn_net_rebuild_header(struct sk_buff *skb)
1936 struct net_device *dev = skb->dev;
1937 isdn_net_local *lp = dev->priv;
1940 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1941 struct ethhdr *eth = (struct ethhdr *) skb->data;
1944 * Only ARP/IP is currently supported
1947 if (eth->h_proto != htons(ETH_P_IP)) {
1949 "isdn_net: %s don't know how to resolve type %d addresses?\n",
1950 dev->name, (int) eth->h_proto);
1951 memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
1955 * Try to get ARP to resolve the header.
1958 ret = arp_find(eth->h_dest, skb);
1964 static int isdn_header_cache(const struct neighbour *neigh, struct hh_cache *hh)
1966 const struct net_device *dev = neigh->dev;
1967 isdn_net_local *lp = dev->priv;
1969 if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
1970 return eth_header_cache(neigh, hh);
1974 static void isdn_header_cache_update(struct hh_cache *hh,
1975 const struct net_device *dev,
1976 const unsigned char *haddr)
1978 isdn_net_local *lp = dev->priv;
1979 if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
1980 return eth_header_cache_update(hh, dev, haddr);
1983 static const struct header_ops isdn_header_ops = {
1984 .create = isdn_net_header,
1985 .rebuild = isdn_net_rebuild_header,
1986 .cache = isdn_header_cache,
1987 .cache_update = isdn_header_cache_update,
1991 * Interface-setup. (just after registering a new interface)
1994 isdn_net_init(struct net_device *ndev)
1996 ushort max_hlhdr_len = 0;
2000 ndev->header_ops = NULL;
2002 /* Setup the generic properties */
2004 ndev->flags = IFF_NOARP|IFF_POINTOPOINT;
2005 ndev->type = ARPHRD_ETHER;
2006 ndev->addr_len = ETH_ALEN;
2007 ndev->validate_addr = NULL;
2009 /* for clients with MPPP maybe higher values better */
2010 ndev->tx_queue_len = 30;
2012 /* The ISDN-specific entries in the device structure. */
2013 ndev->open = &isdn_net_open;
2014 ndev->hard_start_xmit = &isdn_net_start_xmit;
2017 * up till binding we ask the protocol layer to reserve as much
2018 * as we might need for HL layer
2021 for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++)
2022 if (dev->drv[drvidx])
2023 if (max_hlhdr_len < dev->drv[drvidx]->interface->hl_hdrlen)
2024 max_hlhdr_len = dev->drv[drvidx]->interface->hl_hdrlen;
2026 ndev->hard_header_len = ETH_HLEN + max_hlhdr_len;
2027 ndev->stop = &isdn_net_close;
2028 ndev->get_stats = &isdn_net_get_stats;
2029 ndev->do_ioctl = NULL;
2034 isdn_net_swapbind(int drvidx)
2038 #ifdef ISDN_DEBUG_NET_ICALL
2039 printk(KERN_DEBUG "n_fi: swapping ch of %d\n", drvidx);
2043 if (p->local->pre_device == drvidx)
2044 switch (p->local->pre_channel) {
2046 p->local->pre_channel = 1;
2049 p->local->pre_channel = 0;
2052 p = (isdn_net_dev *) p->next;
2057 isdn_net_swap_usage(int i1, int i2)
2059 int u1 = dev->usage[i1] & ISDN_USAGE_EXCLUSIVE;
2060 int u2 = dev->usage[i2] & ISDN_USAGE_EXCLUSIVE;
2062 #ifdef ISDN_DEBUG_NET_ICALL
2063 printk(KERN_DEBUG "n_fi: usage of %d and %d\n", i1, i2);
2065 dev->usage[i1] &= ~ISDN_USAGE_EXCLUSIVE;
2066 dev->usage[i1] |= u2;
2067 dev->usage[i2] &= ~ISDN_USAGE_EXCLUSIVE;
2068 dev->usage[i2] |= u1;
2073 * An incoming call-request has arrived.
2074 * Search the interface-chain for an appropriate interface.
2075 * If found, connect the interface to the ISDN-channel and initiate
2076 * D- and B-Channel-setup. If secure-flag is set, accept only
2077 * configured phone-numbers. If callback-flag is set, initiate
2080 * Return-Value: 0 = No appropriate interface for this call.
2082 * 2 = Reject call, wait cbdelay, then call back
2084 * 4 = Wait cbdelay, then call back
2085 * 5 = No appropriate interface for this call,
2086 * would eventually match if CID was longer.
2090 isdn_net_find_icall(int di, int ch, int idx, setup_parm *setup)
2102 char nr[ISDN_MSNLEN];
2105 /* Search name in netdev-chain */
2106 if (!setup->phone[0]) {
2109 printk(KERN_INFO "isdn_net: Incoming call without OAD, assuming '0'\n");
2111 strlcpy(nr, setup->phone, ISDN_MSNLEN);
2112 si1 = (int) setup->si1;
2113 si2 = (int) setup->si2;
2114 if (!setup->eazmsn[0]) {
2115 printk(KERN_WARNING "isdn_net: Incoming call without CPN, assuming '0'\n");
2118 eaz = setup->eazmsn;
2119 if (dev->net_verbose > 1)
2120 printk(KERN_INFO "isdn_net: call from %s,%d,%d -> %s\n", nr, si1, si2, eaz);
2121 /* Accept DATA and VOICE calls at this stage
2122 * local eaz is checked later for allowed call types
2124 if ((si1 != 7) && (si1 != 1)) {
2125 if (dev->net_verbose > 1)
2126 printk(KERN_INFO "isdn_net: Service-Indicator not 1 or 7, ignored\n");
2129 n = (isdn_net_phone *) 0;
2131 ematch = wret = swapped = 0;
2132 #ifdef ISDN_DEBUG_NET_ICALL
2133 printk(KERN_DEBUG "n_fi: di=%d ch=%d idx=%d usg=%d\n", di, ch, idx,
2138 isdn_net_local *lp = p->local;
2140 /* If last check has triggered as binding-swap, revert it */
2143 isdn_net_swap_usage(idx, sidx);
2146 isdn_net_swapbind(di);
2150 /* check acceptable call types for DOV */
2151 my_eaz = isdn_map_eaz2msn(lp->msn, di);
2152 if (si1 == 1) { /* it's a DOV call, check if we allow it */
2153 if (*my_eaz == 'v' || *my_eaz == 'V' ||
2154 *my_eaz == 'b' || *my_eaz == 'B')
2155 my_eaz++; /* skip to allow a match */
2157 my_eaz = NULL; /* force non match */
2158 } else { /* it's a DATA call, check if we allow it */
2159 if (*my_eaz == 'b' || *my_eaz == 'B')
2160 my_eaz++; /* skip to allow a match */
2163 matchret = isdn_msncmp(eaz, my_eaz);
2169 /* Remember if more numbers eventually can match */
2170 if (matchret > wret)
2172 #ifdef ISDN_DEBUG_NET_ICALL
2173 printk(KERN_DEBUG "n_fi: if='%s', l.msn=%s, l.flags=%d, l.dstate=%d\n",
2174 p->dev->name, lp->msn, lp->flags, lp->dialstate);
2176 if ((!matchret) && /* EAZ is matching */
2177 (((!(lp->flags & ISDN_NET_CONNECTED)) && /* but not connected */
2178 (USG_NONE(dev->usage[idx]))) || /* and ch. unused or */
2179 ((((lp->dialstate == 4) || (lp->dialstate == 12)) && /* if dialing */
2180 (!(lp->flags & ISDN_NET_CALLBACK))) /* but no callback */
2183 #ifdef ISDN_DEBUG_NET_ICALL
2184 printk(KERN_DEBUG "n_fi: match1, pdev=%d pch=%d\n",
2185 lp->pre_device, lp->pre_channel);
2187 if (dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) {
2188 if ((lp->pre_channel != ch) ||
2189 (lp->pre_device != di)) {
2190 /* Here we got a problem:
2191 * If using an ICN-Card, an incoming call is always signaled on
2192 * on the first channel of the card, if both channels are
2193 * down. However this channel may be bound exclusive. If the
2194 * second channel is free, this call should be accepted.
2195 * The solution is horribly but it runs, so what:
2196 * We exchange the exclusive bindings of the two channels, the
2197 * corresponding variables in the interface-structs.
2200 sidx = isdn_dc2minor(di, 1);
2201 #ifdef ISDN_DEBUG_NET_ICALL
2202 printk(KERN_DEBUG "n_fi: ch is 0\n");
2204 if (USG_NONE(dev->usage[sidx])) {
2205 /* Second Channel is free, now see if it is bound
2207 if (dev->usage[sidx] & ISDN_USAGE_EXCLUSIVE) {
2208 #ifdef ISDN_DEBUG_NET_ICALL
2209 printk(KERN_DEBUG "n_fi: 2nd channel is down and bound\n");
2211 /* Yes, swap bindings only, if the original
2212 * binding is bound to channel 1 of this driver */
2213 if ((lp->pre_device == di) &&
2214 (lp->pre_channel == 1)) {
2215 isdn_net_swapbind(di);
2218 /* ... else iterate next device */
2219 p = (isdn_net_dev *) p->next;
2223 #ifdef ISDN_DEBUG_NET_ICALL
2224 printk(KERN_DEBUG "n_fi: 2nd channel is down and unbound\n");
2226 /* No, swap always and swap excl-usage also */
2227 isdn_net_swap_usage(idx, sidx);
2228 isdn_net_swapbind(di);
2231 /* Now check for exclusive binding again */
2232 #ifdef ISDN_DEBUG_NET_ICALL
2233 printk(KERN_DEBUG "n_fi: final check\n");
2235 if ((dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) &&
2236 ((lp->pre_channel != ch) ||
2237 (lp->pre_device != di))) {
2238 #ifdef ISDN_DEBUG_NET_ICALL
2239 printk(KERN_DEBUG "n_fi: final check failed\n");
2241 p = (isdn_net_dev *) p->next;
2246 /* We are already on the second channel, so nothing to do */
2247 #ifdef ISDN_DEBUG_NET_ICALL
2248 printk(KERN_DEBUG "n_fi: already on 2nd channel\n");
2253 #ifdef ISDN_DEBUG_NET_ICALL
2254 printk(KERN_DEBUG "n_fi: match2\n");
2257 if (lp->flags & ISDN_NET_SECURE) {
2259 if (!isdn_msncmp(nr, n->num))
2261 n = (isdn_net_phone *) n->next;
2264 if (n || (!(lp->flags & ISDN_NET_SECURE))) {
2265 #ifdef ISDN_DEBUG_NET_ICALL
2266 printk(KERN_DEBUG "n_fi: match3\n");
2268 /* matching interface found */
2271 * Is the state STOPPED?
2272 * If so, no dialin is allowed,
2273 * so reject actively.
2275 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2276 printk(KERN_INFO "incoming call, interface %s `stopped' -> rejected\n",
2281 * Is the interface up?
2282 * If not, reject the call actively.
2284 if (!isdn_net_device_started(p)) {
2285 printk(KERN_INFO "%s: incoming call, interface down -> rejected\n",
2289 /* Interface is up, now see if it's a slave. If so, see if
2290 * it's master and parent slave is online. If not, reject the call.
2293 isdn_net_local *mlp = (isdn_net_local *) lp->master->priv;
2294 printk(KERN_DEBUG "ICALLslv: %s\n", p->dev->name);
2295 printk(KERN_DEBUG "master=%s\n", lp->master->name);
2296 if (mlp->flags & ISDN_NET_CONNECTED) {
2297 printk(KERN_DEBUG "master online\n");
2298 /* Master is online, find parent-slave (master if first slave) */
2299 while (mlp->slave) {
2300 if ((isdn_net_local *) mlp->slave->priv == lp)
2302 mlp = (isdn_net_local *) mlp->slave->priv;
2305 printk(KERN_DEBUG "master offline\n");
2306 /* Found parent, if it's offline iterate next device */
2307 printk(KERN_DEBUG "mlpf: %d\n", mlp->flags & ISDN_NET_CONNECTED);
2308 if (!(mlp->flags & ISDN_NET_CONNECTED)) {
2309 p = (isdn_net_dev *) p->next;
2313 if (lp->flags & ISDN_NET_CALLBACK) {
2316 * Is the state MANUAL?
2317 * If so, no callback can be made,
2318 * so reject actively.
2320 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2321 printk(KERN_INFO "incoming call for callback, interface %s `off' -> rejected\n",
2325 printk(KERN_DEBUG "%s: call from %s -> %s, start callback\n",
2326 p->dev->name, nr, eaz);
2328 /* Grab a free ISDN-Channel */
2329 spin_lock_irqsave(&dev->lock, flags);
2331 isdn_get_free_channel(
2340 printk(KERN_WARNING "isdn_net_find_icall: No channel for %s\n",
2342 spin_unlock_irqrestore(&dev->lock, flags);
2345 /* Setup dialstate. */
2348 /* Connect interface with channel */
2349 isdn_net_bind_channel(lp, chi);
2350 #ifdef CONFIG_ISDN_PPP
2351 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2352 if (isdn_ppp_bind(lp) < 0) {
2353 spin_unlock_irqrestore(&dev->lock, flags);
2354 isdn_net_unbind_channel(lp);
2358 spin_unlock_irqrestore(&dev->lock, flags);
2359 /* Initiate dialing by returning 2 or 4 */
2360 return (lp->flags & ISDN_NET_CBHUP) ? 2 : 4;
2362 printk(KERN_WARNING "isdn_net: %s: No phone number\n",
2366 printk(KERN_DEBUG "%s: call from %s -> %s accepted\n",
2367 p->dev->name, nr, eaz);
2368 /* if this interface is dialing, it does it probably on a different
2369 device, so free this device */
2370 if ((lp->dialstate == 4) || (lp->dialstate == 12)) {
2371 #ifdef CONFIG_ISDN_PPP
2372 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2375 isdn_net_lp_disconnected(lp);
2376 isdn_free_channel(lp->isdn_device, lp->isdn_channel,
2379 spin_lock_irqsave(&dev->lock, flags);
2380 dev->usage[idx] &= ISDN_USAGE_EXCLUSIVE;
2381 dev->usage[idx] |= ISDN_USAGE_NET;
2382 strcpy(dev->num[idx], nr);
2384 dev->st_netdev[idx] = lp->netdev;
2385 lp->isdn_device = di;
2386 lp->isdn_channel = ch;
2388 lp->flags |= ISDN_NET_CONNECTED;
2393 lp->hupflags |= ISDN_WAITCHARGE;
2394 lp->hupflags &= ~ISDN_HAVECHARGE;
2395 #ifdef CONFIG_ISDN_PPP
2396 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
2397 if (isdn_ppp_bind(lp) < 0) {
2398 isdn_net_unbind_channel(lp);
2399 spin_unlock_irqrestore(&dev->lock, flags);
2404 spin_unlock_irqrestore(&dev->lock, flags);
2409 p = (isdn_net_dev *) p->next;
2411 /* If none of configured EAZ/MSN matched and not verbose, be silent */
2412 if (!ematch || dev->net_verbose)
2413 printk(KERN_INFO "isdn_net: call from %s -> %d %s ignored\n", nr, di, eaz);
2414 return (wret == 2)?5:0;
2418 * Search list of net-interfaces for an interface with given name.
2421 isdn_net_findif(char *name)
2423 isdn_net_dev *p = dev->netdev;
2426 if (!strcmp(p->dev->name, name))
2428 p = (isdn_net_dev *) p->next;
2430 return (isdn_net_dev *) NULL;
2434 * Force a net-interface to dial out.
2435 * This is called from the userlevel-routine below or
2436 * from isdn_net_start_xmit().
2439 isdn_net_force_dial_lp(isdn_net_local * lp)
2441 if ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) {
2446 /* Grab a free ISDN-Channel */
2447 spin_lock_irqsave(&dev->lock, flags);
2448 if ((chi = isdn_get_free_channel(
2455 printk(KERN_WARNING "isdn_net_force_dial: No channel for %s\n",
2456 lp->netdev->dev->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 * Helper for alloc_netdev()
2512 static void _isdn_setup(struct net_device *dev)
2514 isdn_net_local *lp = dev->priv;
2516 dev->flags = IFF_NOARP | IFF_POINTOPOINT;
2517 lp->p_encap = ISDN_NET_ENCAP_RAWIP;
2518 lp->magic = ISDN_NET_MAGIC;
2521 lp->isdn_device = -1;
2522 lp->isdn_channel = -1;
2523 lp->pre_device = -1;
2524 lp->pre_channel = -1;
2528 skb_queue_head_init(&lp->super_tx_queue);
2529 lp->l2_proto = ISDN_PROTO_L2_X75I;
2530 lp->l3_proto = ISDN_PROTO_L3_TRANS;
2531 lp->triggercps = 6000;
2532 lp->slavedelay = 10 * HZ;
2533 lp->hupflags = ISDN_INHUP; /* Do hangup even on incoming calls */
2534 lp->onhtime = 10; /* Default hangup-time for saving costs */
2536 /* Hangup before Callback, manual dial */
2537 lp->flags = ISDN_NET_CBHUP | ISDN_NET_DM_MANUAL;
2538 lp->cbdelay = 25; /* Wait 5 secs before Callback */
2539 lp->dialtimeout = -1; /* Infinite Dial-Timeout */
2540 lp->dialwait = 5 * HZ; /* Wait 5 sec. after failed dial */
2541 lp->dialstarted = 0; /* Jiffies of last dial-start */
2542 lp->dialwait_timer = 0; /* Jiffies of earliest next dial-start */
2546 * Allocate a new network-interface and initialize its data structures.
2549 isdn_net_new(char *name, struct net_device *master)
2551 isdn_net_dev *netdev;
2553 /* Avoid creating an existing interface */
2554 if (isdn_net_findif(name)) {
2555 printk(KERN_WARNING "isdn_net: interface %s already exists\n", name);
2560 if (!(netdev = kzalloc(sizeof(isdn_net_dev), GFP_KERNEL))) {
2561 printk(KERN_WARNING "isdn_net: Could not allocate net-device\n");
2564 netdev->dev = alloc_netdev(sizeof(isdn_net_local), name, _isdn_setup);
2566 printk(KERN_WARNING "isdn_net: Could not allocate network device\n");
2570 netdev->local = netdev->dev->priv;
2571 netdev->dev->init = isdn_net_init;
2573 /* Device shall be a slave */
2574 struct net_device *p = (((isdn_net_local *) master->priv)->slave);
2575 struct net_device *q = master;
2577 netdev->local->master = master;
2578 /* Put device at end of slave-chain */
2581 p = (((isdn_net_local *) p->priv)->slave);
2583 ((isdn_net_local *) q->priv)->slave = netdev->dev;
2585 /* Device shall be a master */
2587 * Watchdog timer (currently) for master only.
2589 netdev->dev->tx_timeout = isdn_net_tx_timeout;
2590 netdev->dev->watchdog_timeo = ISDN_NET_TX_TIMEOUT;
2591 if (register_netdev(netdev->dev) != 0) {
2592 printk(KERN_WARNING "isdn_net: Could not register net-device\n");
2593 free_netdev(netdev->dev);
2598 netdev->queue = netdev->local;
2599 spin_lock_init(&netdev->queue_lock);
2601 netdev->local->netdev = netdev;
2603 INIT_WORK(&netdev->local->tqueue, isdn_net_softint);
2604 spin_lock_init(&netdev->local->xmit_lock);
2606 /* Put into to netdev-chain */
2607 netdev->next = (void *) dev->netdev;
2608 dev->netdev = netdev;
2609 return netdev->dev->name;
2613 isdn_net_newslave(char *parm)
2615 char *p = strchr(parm, ',');
2620 /* Slave-Name MUST not be empty */
2623 strcpy(newname, p + 1);
2625 /* Master must already exist */
2626 if (!(n = isdn_net_findif(parm)))
2628 /* Master must be a real interface, not a slave */
2629 if (n->local->master)
2631 /* Master must not be started yet */
2632 if (isdn_net_device_started(n))
2634 return (isdn_net_new(newname, n->dev));
2640 * Set interface-parameters.
2641 * Always set all parameters, so the user-level application is responsible
2642 * for not overwriting existing setups. It has to get the current
2643 * setup first, if only selected parameters are to be changed.
2646 isdn_net_setcfg(isdn_net_ioctl_cfg * cfg)
2648 isdn_net_dev *p = isdn_net_findif(cfg->name);
2656 isdn_net_local *lp = p->local;
2658 /* See if any registered driver supports the features we want */
2659 features = ((1 << cfg->l2_proto) << ISDN_FEATURE_L2_SHIFT) |
2660 ((1 << cfg->l3_proto) << ISDN_FEATURE_L3_SHIFT);
2661 for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2663 if ((dev->drv[i]->interface->features & features) == features)
2665 if (i == ISDN_MAX_DRIVERS) {
2666 printk(KERN_WARNING "isdn_net: No driver with selected features\n");
2669 if (lp->p_encap != cfg->p_encap){
2670 #ifdef CONFIG_ISDN_X25
2671 struct concap_proto * cprot = p -> cprot;
2673 if (isdn_net_device_started(p)) {
2674 printk(KERN_WARNING "%s: cannot change encap when if is up\n",
2678 #ifdef CONFIG_ISDN_X25
2679 if( cprot && cprot -> pops )
2680 cprot -> pops -> proto_del ( cprot );
2683 /* ... , prepare for configuration of new one ... */
2684 switch ( cfg -> p_encap ){
2685 case ISDN_NET_ENCAP_X25IFACE:
2686 lp -> dops = &isdn_concap_reliable_dl_dops;
2688 /* ... and allocate new one ... */
2689 p -> cprot = isdn_concap_new( cfg -> p_encap );
2690 /* p -> cprot == NULL now if p_encap is not supported
2691 by means of the concap_proto mechanism */
2692 /* the protocol is not configured yet; this will
2693 happen later when isdn_net_reset() is called */
2696 switch ( cfg->p_encap ) {
2697 case ISDN_NET_ENCAP_SYNCPPP:
2698 #ifndef CONFIG_ISDN_PPP
2699 printk(KERN_WARNING "%s: SyncPPP support not configured\n",
2703 p->dev->type = ARPHRD_PPP; /* change ARP type */
2704 p->dev->addr_len = 0;
2705 p->dev->do_ioctl = isdn_ppp_dev_ioctl;
2708 case ISDN_NET_ENCAP_X25IFACE:
2709 #ifndef CONFIG_ISDN_X25
2710 printk(KERN_WARNING "%s: isdn-x25 support not configured\n",
2714 p->dev->type = ARPHRD_X25; /* change ARP type */
2715 p->dev->addr_len = 0;
2718 case ISDN_NET_ENCAP_CISCOHDLCK:
2719 p->dev->do_ioctl = isdn_ciscohdlck_dev_ioctl;
2722 if( cfg->p_encap >= 0 &&
2723 cfg->p_encap <= ISDN_NET_ENCAP_MAX_ENCAP )
2726 "%s: encapsulation protocol %d not supported\n",
2727 p->dev->name, cfg->p_encap);
2730 if (strlen(cfg->drvid)) {
2731 /* A bind has been requested ... */
2737 strcpy(drvid, cfg->drvid);
2738 if ((c = strchr(drvid, ','))) {
2739 /* The channel-number is appended to the driver-Id with a comma */
2740 chidx = (int) simple_strtoul(c + 1, &e, 10);
2745 for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2746 /* Lookup driver-Id in array */
2747 if (!(strcmp(dev->drvid[i], drvid))) {
2751 if ((drvidx == -1) || (chidx == -1))
2752 /* Either driver-Id or channel-number invalid */
2755 /* Parameters are valid, so get them */
2756 drvidx = lp->pre_device;
2757 chidx = lp->pre_channel;
2759 if (cfg->exclusive > 0) {
2760 unsigned long flags;
2762 /* If binding is exclusive, try to grab the channel */
2763 spin_lock_irqsave(&dev->lock, flags);
2764 if ((i = isdn_get_free_channel(ISDN_USAGE_NET,
2765 lp->l2_proto, lp->l3_proto, drvidx,
2766 chidx, lp->msn)) < 0) {
2767 /* Grab failed, because desired channel is in use */
2769 spin_unlock_irqrestore(&dev->lock, flags);
2772 /* All went ok, so update isdninfo */
2773 dev->usage[i] = ISDN_USAGE_EXCLUSIVE;
2775 spin_unlock_irqrestore(&dev->lock, flags);
2778 /* Non-exclusive binding or unbind. */
2780 if ((lp->pre_device != -1) && (cfg->exclusive == -1)) {
2781 isdn_unexclusive_channel(lp->pre_device, lp->pre_channel);
2782 isdn_free_channel(lp->pre_device, lp->pre_channel, ISDN_USAGE_NET);
2787 strlcpy(lp->msn, cfg->eaz, sizeof(lp->msn));
2788 lp->pre_device = drvidx;
2789 lp->pre_channel = chidx;
2790 lp->onhtime = cfg->onhtime;
2791 lp->charge = cfg->charge;
2792 lp->l2_proto = cfg->l2_proto;
2793 lp->l3_proto = cfg->l3_proto;
2794 lp->cbdelay = cfg->cbdelay;
2795 lp->dialmax = cfg->dialmax;
2796 lp->triggercps = cfg->triggercps;
2797 lp->slavedelay = cfg->slavedelay * HZ;
2798 lp->pppbind = cfg->pppbind;
2799 lp->dialtimeout = cfg->dialtimeout >= 0 ? cfg->dialtimeout * HZ : -1;
2800 lp->dialwait = cfg->dialwait * HZ;
2802 lp->flags |= ISDN_NET_SECURE;
2804 lp->flags &= ~ISDN_NET_SECURE;
2806 lp->flags |= ISDN_NET_CBHUP;
2808 lp->flags &= ~ISDN_NET_CBHUP;
2809 switch (cfg->callback) {
2811 lp->flags &= ~(ISDN_NET_CALLBACK | ISDN_NET_CBOUT);
2814 lp->flags |= ISDN_NET_CALLBACK;
2815 lp->flags &= ~ISDN_NET_CBOUT;
2818 lp->flags |= ISDN_NET_CBOUT;
2819 lp->flags &= ~ISDN_NET_CALLBACK;
2822 lp->flags &= ~ISDN_NET_DIALMODE_MASK; /* first all bits off */
2823 if (cfg->dialmode && !(cfg->dialmode & ISDN_NET_DIALMODE_MASK)) {
2824 /* old isdnctrl version, where only 0 or 1 is given */
2826 "Old isdnctrl version detected! Please update.\n");
2827 lp->flags |= ISDN_NET_DM_OFF; /* turn on `off' bit */
2830 lp->flags |= cfg->dialmode; /* turn on selected bits */
2833 lp->hupflags |= ISDN_CHARGEHUP;
2835 lp->hupflags &= ~ISDN_CHARGEHUP;
2837 lp->hupflags |= ISDN_INHUP;
2839 lp->hupflags &= ~ISDN_INHUP;
2840 if (cfg->chargeint > 10) {
2841 lp->hupflags |= ISDN_CHARGEHUP | ISDN_HAVECHARGE | ISDN_MANCHARGE;
2842 lp->chargeint = cfg->chargeint * HZ;
2844 if (cfg->p_encap != lp->p_encap) {
2845 if (cfg->p_encap == ISDN_NET_ENCAP_RAWIP) {
2846 p->dev->header_ops = NULL;
2847 p->dev->flags = IFF_NOARP|IFF_POINTOPOINT;
2849 p->dev->header_ops = &isdn_header_ops;
2850 if (cfg->p_encap == ISDN_NET_ENCAP_ETHER)
2851 p->dev->flags = IFF_BROADCAST | IFF_MULTICAST;
2853 p->dev->flags = IFF_NOARP|IFF_POINTOPOINT;
2856 lp->p_encap = cfg->p_encap;
2863 * Perform get-interface-parameters.ioctl
2866 isdn_net_getcfg(isdn_net_ioctl_cfg * cfg)
2868 isdn_net_dev *p = isdn_net_findif(cfg->name);
2871 isdn_net_local *lp = p->local;
2873 strcpy(cfg->eaz, lp->msn);
2874 cfg->exclusive = lp->exclusive;
2875 if (lp->pre_device >= 0) {
2876 sprintf(cfg->drvid, "%s,%d", dev->drvid[lp->pre_device],
2879 cfg->drvid[0] = '\0';
2880 cfg->onhtime = lp->onhtime;
2881 cfg->charge = lp->charge;
2882 cfg->l2_proto = lp->l2_proto;
2883 cfg->l3_proto = lp->l3_proto;
2884 cfg->p_encap = lp->p_encap;
2885 cfg->secure = (lp->flags & ISDN_NET_SECURE) ? 1 : 0;
2887 if (lp->flags & ISDN_NET_CALLBACK)
2889 if (lp->flags & ISDN_NET_CBOUT)
2891 cfg->cbhup = (lp->flags & ISDN_NET_CBHUP) ? 1 : 0;
2892 cfg->dialmode = lp->flags & ISDN_NET_DIALMODE_MASK;
2893 cfg->chargehup = (lp->hupflags & 4) ? 1 : 0;
2894 cfg->ihup = (lp->hupflags & 8) ? 1 : 0;
2895 cfg->cbdelay = lp->cbdelay;
2896 cfg->dialmax = lp->dialmax;
2897 cfg->triggercps = lp->triggercps;
2898 cfg->slavedelay = lp->slavedelay / HZ;
2899 cfg->chargeint = (lp->hupflags & ISDN_CHARGEHUP) ?
2900 (lp->chargeint / HZ) : 0;
2901 cfg->pppbind = lp->pppbind;
2902 cfg->dialtimeout = lp->dialtimeout >= 0 ? lp->dialtimeout / HZ : -1;
2903 cfg->dialwait = lp->dialwait / HZ;
2905 if (strlen(lp->slave->name) > 8)
2906 strcpy(cfg->slave, "too-long");
2908 strcpy(cfg->slave, lp->slave->name);
2910 cfg->slave[0] = '\0';
2912 if (strlen(lp->master->name) > 8)
2913 strcpy(cfg->master, "too-long");
2914 strcpy(cfg->master, lp->master->name);
2916 cfg->master[0] = '\0';
2923 * Add a phone-number to an interface.
2926 isdn_net_addphone(isdn_net_ioctl_phone * phone)
2928 isdn_net_dev *p = isdn_net_findif(phone->name);
2932 if (!(n = kmalloc(sizeof(isdn_net_phone), GFP_KERNEL)))
2934 strlcpy(n->num, phone->phone, sizeof(n->num));
2935 n->next = p->local->phone[phone->outgoing & 1];
2936 p->local->phone[phone->outgoing & 1] = n;
2943 * Copy a string of all phone-numbers of an interface to user space.
2944 * This might sleep and must be called with the isdn semaphore down.
2947 isdn_net_getphones(isdn_net_ioctl_phone * phone, char __user *phones)
2949 isdn_net_dev *p = isdn_net_findif(phone->name);
2950 int inout = phone->outgoing & 1;
2958 for (n = p->local->phone[inout]; n; n = n->next) {
2960 put_user(' ', phones++);
2963 if (copy_to_user(phones, n->num, strlen(n->num) + 1)) {
2966 phones += strlen(n->num);
2967 count += strlen(n->num);
2970 put_user(0, phones);
2976 * Copy a string containing the peer's phone number of a connected interface
2980 isdn_net_getpeer(isdn_net_ioctl_phone *phone, isdn_net_ioctl_phone __user *peer)
2982 isdn_net_dev *p = isdn_net_findif(phone->name);
2988 * Theoretical race: while this executes, the remote number might
2989 * become invalid (hang up) or change (new connection), resulting
2990 * in (partially) wrong number copied to user. This race
2991 * currently ignored.
2993 ch = p->local->isdn_channel;
2994 dv = p->local->isdn_device;
2995 if(ch < 0 && dv < 0)
2997 idx = isdn_dc2minor(dv, ch);
3000 /* for pre-bound channels, we need this extra check */
3001 if (strncmp(dev->num[idx], "???", 3) == 0)
3003 strncpy(phone->phone, dev->num[idx], ISDN_MSNLEN);
3004 phone->outgoing = USG_OUTGOING(dev->usage[idx]);
3005 if (copy_to_user(peer, phone, sizeof(*peer)))
3010 * Delete a phone-number from an interface.
3013 isdn_net_delphone(isdn_net_ioctl_phone * phone)
3015 isdn_net_dev *p = isdn_net_findif(phone->name);
3016 int inout = phone->outgoing & 1;
3021 n = p->local->phone[inout];
3024 if (!strcmp(n->num, phone->phone)) {
3025 if (p->local->dial == n)
3026 p->local->dial = n->next;
3030 p->local->phone[inout] = n->next;
3035 n = (isdn_net_phone *) n->next;
3043 * Delete all phone-numbers of an interface.
3046 isdn_net_rmallphone(isdn_net_dev * p)
3052 for (i = 0; i < 2; i++) {
3053 n = p->local->phone[i];
3059 p->local->phone[i] = NULL;
3061 p->local->dial = NULL;
3066 * Force a hangup of a network-interface.
3069 isdn_net_force_hangup(char *name)
3071 isdn_net_dev *p = isdn_net_findif(name);
3072 struct net_device *q;
3075 if (p->local->isdn_device < 0)
3077 q = p->local->slave;
3078 /* If this interface has slaves, do a hangup for them also. */
3081 q = (((isdn_net_local *) q->priv)->slave);
3083 isdn_net_hangup(p->dev);
3090 * Helper-function for isdn_net_rm: Do the real work.
3093 isdn_net_realrm(isdn_net_dev * p, isdn_net_dev * q)
3097 if (isdn_net_device_started(p)) {
3100 #ifdef CONFIG_ISDN_X25
3101 if( p -> cprot && p -> cprot -> pops )
3102 p -> cprot -> pops -> proto_del ( p -> cprot );
3104 /* Free all phone-entries */
3105 isdn_net_rmallphone(p);
3106 /* If interface is bound exclusive, free channel-usage */
3107 if (p->local->exclusive != -1)
3108 isdn_unexclusive_channel(p->local->pre_device, p->local->pre_channel);
3109 if (p->local->master) {
3110 /* It's a slave-device, so update master's slave-pointer if necessary */
3111 if (((isdn_net_local *) (p->local->master->priv))->slave == p->dev)
3112 ((isdn_net_local *) (p->local->master->priv))->slave = p->local->slave;
3114 /* Unregister only if it's a master-device */
3115 unregister_netdev(p->dev);
3117 /* Unlink device from chain */
3118 spin_lock_irqsave(&dev->lock, flags);
3122 dev->netdev = p->next;
3123 if (p->local->slave) {
3124 /* If this interface has a slave, remove it also */
3125 char *slavename = p->local->slave->name;
3126 isdn_net_dev *n = dev->netdev;
3129 if (!strcmp(n->dev->name, slavename)) {
3130 spin_unlock_irqrestore(&dev->lock, flags);
3131 isdn_net_realrm(n, q);
3132 spin_lock_irqsave(&dev->lock, flags);
3136 n = (isdn_net_dev *)n->next;
3139 spin_unlock_irqrestore(&dev->lock, flags);
3140 /* If no more net-devices remain, disable auto-hangup timer */
3141 if (dev->netdev == NULL)
3142 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0);
3143 free_netdev(p->dev);
3150 * Remove a single network-interface.
3153 isdn_net_rm(char *name)
3159 /* Search name in netdev-chain */
3160 spin_lock_irqsave(&dev->lock, flags);
3164 if (!strcmp(p->dev->name, name)) {
3165 spin_unlock_irqrestore(&dev->lock, flags);
3166 return (isdn_net_realrm(p, q));
3169 p = (isdn_net_dev *) p->next;
3171 spin_unlock_irqrestore(&dev->lock, flags);
3172 /* If no more net-devices remain, disable auto-hangup timer */
3173 if (dev->netdev == NULL)
3174 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0);
3179 * Remove all network-interfaces
3182 isdn_net_rmall(void)
3187 /* Walk through netdev-chain */
3188 spin_lock_irqsave(&dev->lock, flags);
3189 while (dev->netdev) {
3190 if (!dev->netdev->local->master) {
3191 /* Remove master-devices only, slaves get removed with their master */
3192 spin_unlock_irqrestore(&dev->lock, flags);
3193 if ((ret = isdn_net_realrm(dev->netdev, NULL))) {
3196 spin_lock_irqsave(&dev->lock, flags);
3200 spin_unlock_irqrestore(&dev->lock, flags);