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