PageRenderTime 99ms CodeModel.GetById 36ms app.highlight 50ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/isdn/i4l/isdn_net.c

https://bitbucket.org/ndreys/linux-sunxi
C | 3228 lines | 2447 code | 231 blank | 550 comment | 494 complexity | e4af6b4412a18b08bb4a326450040524 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

   1/* $Id: isdn_net.c,v 1.1.2.2 2004/01/12 22:37:19 keil Exp $
   2 *
   3 * Linux ISDN subsystem, network interfaces and related functions (linklevel).
   4 *
   5 * Copyright 1994-1998  by Fritz Elfert (fritz@isdn4linux.de)
   6 * Copyright 1995,96    by Thinking Objects Software GmbH Wuerzburg
   7 * Copyright 1995,96    by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
   8 *
   9 * This software may be used and distributed according to the terms
  10 * of the GNU General Public License, incorporated herein by reference.
  11 *
  12 * Data Over Voice (DOV) support added - Guy Ellis 23-Mar-02 
  13 *                                       guy@traverse.com.au
  14 * Outgoing calls - looks for a 'V' in first char of dialed number
  15 * Incoming calls - checks first character of eaz as follows:
  16 *   Numeric - accept DATA only - original functionality
  17 *   'V'     - accept VOICE (DOV) only
  18 *   'B'     - accept BOTH DATA and DOV types
  19 *
  20 * Jan 2001: fix CISCO HDLC      Bjoern A. Zeeb <i4l@zabbadoz.net>
  21 *           for info on the protocol, see 
  22 *           http://i4l.zabbadoz.net/i4l/cisco-hdlc.txt
  23 */
  24
  25#include <linux/isdn.h>
  26#include <linux/slab.h>
  27#include <net/arp.h>
  28#include <net/dst.h>
  29#include <net/pkt_sched.h>
  30#include <linux/inetdevice.h>
  31#include "isdn_common.h"
  32#include "isdn_net.h"
  33#ifdef CONFIG_ISDN_PPP
  34#include "isdn_ppp.h"
  35#endif
  36#ifdef CONFIG_ISDN_X25
  37#include <linux/concap.h>
  38#include "isdn_concap.h"
  39#endif
  40
  41
  42/*
  43 * Outline of new tbusy handling: 
  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 *
  61 * One problem of the isdn net device code is that is uses struct net_device
  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_* 
  64 * functions on them.
  65 *
  66 * --KG
  67 */
  68
  69/* 
  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;
  77	
  78	if (lp->master) 
  79		dev = lp->master;
  80	else
  81		dev = n->dev;
  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{
  91	if (lp->master) 
  92		netif_wake_queue(lp->master);
  93	else
  94		netif_wake_queue(lp->netdev->dev);
  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
 106		netif_stop_queue(lp->netdev->dev);
 107}
 108
 109/*
 110 * find out if the net_device which this lp belongs to (lp can be
 111 * master or slave) is busy. It's busy iff all (master and slave) 
 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)
 124		nd = ISDN_MASTER_PRIV(lp)->netdev;
 125	else
 126		nd = lp->netdev;
 127	
 128	spin_lock_irqsave(&nd->queue_lock, flags);
 129	nlp = lp->next;
 130	while (nlp != lp) {
 131		if (!isdn_net_lp_busy(nlp)) {
 132			spin_unlock_irqrestore(&nd->queue_lock, flags);
 133			return 0;
 134		}
 135		nlp = nlp->next;
 136	}
 137	spin_unlock_irqrestore(&nd->queue_lock, flags);
 138	return 1;
 139}
 140
 141static __inline__ void isdn_net_inc_frame_cnt(isdn_net_local *lp)
 142{
 143	atomic_inc(&lp->frame_cnt);
 144	if (isdn_net_device_busy(lp))
 145		isdn_net_device_stop_queue(lp);
 146}
 147
 148static __inline__ void isdn_net_dec_frame_cnt(isdn_net_local *lp)
 149{
 150	atomic_dec(&lp->frame_cnt);
 151
 152	if (!(isdn_net_device_busy(lp))) {
 153		if (!skb_queue_empty(&lp->super_tx_queue)) {
 154			schedule_work(&lp->tqueue);
 155		} else {
 156			isdn_net_device_wake_queue(lp);
 157		}
 158       }                                                                      
 159}
 160
 161static __inline__ void isdn_net_zero_frame_cnt(isdn_net_local *lp)
 162{
 163	atomic_set(&lp->frame_cnt, 0);
 164}
 165
 166/* For 2.2.x we leave the transmitter busy timeout at 2 secs, just 
 167 * to be safe.
 168 * For 2.3.x we push it up to 20 secs, because call establishment
 169 * (in particular callback) may take such a long time, and we 
 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
 175#define ISDN_NET_TX_TIMEOUT (20*HZ) 
 176
 177/* Prototypes */
 178
 179static int isdn_net_force_dial_lp(isdn_net_local *);
 180static netdev_tx_t isdn_net_start_xmit(struct sk_buff *,
 181					     struct net_device *);
 182
 183static void isdn_net_ciscohdlck_connected(isdn_net_local *lp);
 184static void isdn_net_ciscohdlck_disconnected(isdn_net_local *lp);
 185
 186char *isdn_net_revision = "$Revision: 1.1.2.2 $";
 187
 188 /*
 189  * Code for raw-networking over ISDN
 190  */
 191
 192static void
 193isdn_net_unreachable(struct net_device *dev, struct sk_buff *skb, char *reason)
 194{
 195	if(skb) {
 196
 197		u_short proto = ntohs(skb->protocol);
 198
 199		printk(KERN_DEBUG "isdn_net: %s: %s, signalling dst_link_failure %s\n",
 200		       dev->name,
 201		       (reason != NULL) ? reason : "unknown",
 202		       (proto != ETH_P_IP) ? "Protocol != ETH_P_IP" : "");
 203		
 204		dst_link_failure(skb);
 205	}
 206	else {  /* dial not triggered by rawIP packet */
 207		printk(KERN_DEBUG "isdn_net: %s: %s\n",
 208			   dev->name,
 209			   (reason != NULL) ? reason : "reason unknown");
 210	}
 211}
 212
 213static void
 214isdn_net_reset(struct net_device *dev)
 215{
 216#ifdef CONFIG_ISDN_X25
 217	struct concap_device_ops * dops =
 218		((isdn_net_local *) netdev_priv(dev))->dops;
 219	struct concap_proto * cprot =
 220		((isdn_net_local *) netdev_priv(dev))->netdev->cprot;
 221#endif
 222#ifdef CONFIG_ISDN_X25
 223	if( cprot && cprot -> pops && dops )
 224		cprot -> pops -> restart ( cprot, dev, dops );
 225#endif
 226}
 227
 228/* 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)
 251			memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
 252	}
 253
 254	/* If this interface has slaves, start them also */
 255	p = MASTER_TO_SLAVE(dev);
 256	if (p) {
 257		while (p) {
 258			isdn_net_reset(p);
 259			p = MASTER_TO_SLAVE(p);
 260		}
 261	}
 262	isdn_lock_drivers();
 263	return 0;
 264}
 265
 266/*
 267 * Assign an ISDN-channel to a net-interface
 268 */
 269static void
 270isdn_net_bind_channel(isdn_net_local * lp, int idx)
 271{
 272	lp->flags |= ISDN_NET_CONNECTED;
 273	lp->isdn_device = dev->drvmap[idx];
 274	lp->isdn_channel = dev->chanmap[idx];
 275	dev->rx_netdev[idx] = lp->netdev;
 276	dev->st_netdev[idx] = lp->netdev;
 277}
 278
 279/*
 280 * unbind a net-interface (resets interface after an error)
 281 */
 282static void
 283isdn_net_unbind_channel(isdn_net_local * lp)
 284{
 285	skb_queue_purge(&lp->super_tx_queue);
 286
 287	if (!lp->master) {	/* 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
 291		 */
 292		qdisc_reset_all_tx(lp->netdev->dev);
 293	}
 294	lp->dialstate = 0;
 295	dev->rx_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
 296	dev->st_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
 297	if (lp->isdn_device != -1 && lp->isdn_channel != -1)
 298		isdn_free_channel(lp->isdn_device, lp->isdn_channel,
 299				  ISDN_USAGE_NET);
 300	lp->flags &= ~ISDN_NET_CONNECTED;
 301	lp->isdn_device = -1;
 302	lp->isdn_channel = -1;
 303}
 304
 305/*
 306 * 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 */
 318static unsigned long last_jiffies = -HZ;
 319
 320void
 321isdn_net_autohup(void)
 322{
 323	isdn_net_dev *p = dev->netdev;
 324	int anymore;
 325
 326	anymore = 0;
 327	while (p) {
 328		isdn_net_local *l = p->local;
 329		if (jiffies == last_jiffies)
 330			l->cps = l->transcount;
 331		else
 332			l->cps = (l->transcount * HZ) / (jiffies - last_jiffies);
 333		l->transcount = 0;
 334		if (dev->net_verbose > 3)
 335			printk(KERN_DEBUG "%s: %d bogocps\n", p->dev->name, l->cps);
 336		if ((l->flags & ISDN_NET_CONNECTED) && (!l->dialstate)) {
 337			anymore = 1;
 338			l->huptimer++;
 339			/*
 340			 * 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)
 352							isdn_net_hangup(p->dev);
 353				} else if (l->outgoing) {
 354					if (l->hupflags & ISDN_CHARGEHUP) {
 355						if (l->hupflags & ISDN_WAITCHARGE) {
 356							printk(KERN_DEBUG "isdn_net: Hupflags of %s are %X\n",
 357							       p->dev->name, l->hupflags);
 358							isdn_net_hangup(p->dev);
 359						} else if (time_after(jiffies, l->chargetime + l->chargeint)) {
 360							printk(KERN_DEBUG
 361							       "isdn_net: %s: chtime = %lu, chint = %d\n",
 362							       p->dev->name, l->chargetime, l->chargeint);
 363							isdn_net_hangup(p->dev);
 364						}
 365					} else
 366						isdn_net_hangup(p->dev);
 367				} else if (l->hupflags & ISDN_INHUP)
 368					isdn_net_hangup(p->dev);
 369			}
 370
 371			if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*l) == ISDN_NET_DM_OFF)) {
 372				isdn_net_hangup(p->dev);
 373				break;
 374			}
 375		}
 376		p = (isdn_net_dev *) p->next;
 377	}
 378	last_jiffies = jiffies;
 379	isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, anymore);
 380}
 381
 382static void isdn_net_lp_disconnected(isdn_net_local *lp)
 383{
 384	isdn_net_rm_from_bundle(lp);
 385}
 386
 387/*
 388 * 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) {
 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++;
 422						return 1;
 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 */
 430#ifdef CONFIG_ISDN_X25
 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);
 439#endif /* CONFIG_ISDN_X25 */
 440				if ((!lp->dialstate) && (lp->flags & ISDN_NET_CONNECTED)) {
 441					if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK)
 442						isdn_net_ciscohdlck_disconnected(lp);
 443#ifdef CONFIG_ISDN_PPP
 444					if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
 445						isdn_ppp_free(lp);
 446#endif
 447					isdn_net_lp_disconnected(lp);
 448					isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
 449					printk(KERN_INFO "%s: remote hangup\n", p->dev->name);
 450					printk(KERN_INFO "%s: Chargesum is %d\n", p->dev->name,
 451					       lp->charge);
 452					isdn_net_unbind_channel(lp);
 453					return 1;
 454				}
 455				break;
 456#ifdef CONFIG_ISDN_X25
 457			case ISDN_STAT_BHUP:
 458				/* 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;
 467#endif /* CONFIG_ISDN_X25 */
 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;
 499
 500						/* reset dial-timeout */
 501						lp->dialstarted = 0;
 502						lp->dialwait_timer = 0;
 503
 504#ifdef CONFIG_ISDN_PPP
 505						if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
 506							isdn_ppp_wakeup_daemon(lp);
 507#endif
 508#ifdef CONFIG_ISDN_X25
 509						/* try if there are generic concap receiver routines */
 510						if( pops )
 511							if( pops->connect_ind)
 512								pops->connect_ind(cprot);
 513#endif /* CONFIG_ISDN_X25 */
 514						/* ppp needs to do negotiations first */
 515						if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
 516							isdn_net_device_wake_queue(lp);
 517						return 1;
 518				}
 519				break;
 520			case ISDN_STAT_NODCH:
 521				/* 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;
 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;
 565        u_char *phone_number;
 566
 567	while (p) {
 568		isdn_net_local *lp = p->local;
 569
 570#ifdef ISDN_DEBUG_NET_DIAL
 571		if (lp->dialstate)
 572			printk(KERN_DEBUG "%s: dialstate=%d\n", p->dev->name, lp->dialstate);
 573#endif
 574		switch (lp->dialstate) {
 575			case 0:
 576				/* 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);
 587					break;
 588				}
 589				anymore = 1;
 590
 591				if(lp->dialtimeout > 0)
 592					if(lp->dialstarted == 0 || time_after(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait)) {
 593						lp->dialstarted = jiffies;
 594						lp->dialwait_timer = 0;
 595					}
 596
 597				lp->dialstate++;
 598				/* 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;
 654						}
 655
 656					cmd.driver = lp->isdn_device;
 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;
 667					}
 668
 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++;
 676
 677						if (lp->dialretry > lp->dialmax) {
 678							if (lp->dialtimeout == 0) {
 679								lp->dialwait_timer = jiffies + lp->dialwait;
 680								lp->dialstarted = 0;
 681								isdn_net_unreachable(p->dev, NULL, "dial: tried all numbers dialmax times");
 682							}
 683							isdn_net_hangup(p->dev);
 684							break;
 685						}
 686					}
 687					sprintf(cmd.parm.setup.eazmsn, "%s",
 688						isdn_map_eaz2msn(lp->msn, cmd.driver));
 689					i = isdn_dc2minor(lp->isdn_device, lp->isdn_channel);
 690					if (i >= 0) {
 691						strcpy(dev->num[i], cmd.parm.setup.phone);
 692						dev->usage[i] |= ISDN_USAGE_OUTGOING;
 693						isdn_info_update();
 694					}
 695					printk(KERN_INFO "%s: dialing %d %s... %s\n", p->dev->name,
 696					       lp->dialretry, cmd.parm.setup.phone,
 697					       (cmd.parm.setup.si1 == 1) ? "DOV" : "");
 698					lp->dtimer = 0;
 699#ifdef ISDN_DEBUG_NET_DIAL
 700					printk(KERN_DEBUG "dial: d=%d c=%d\n", lp->isdn_device,
 701					       lp->isdn_channel);
 702#endif
 703					isdn_command(&cmd);
 704				}
 705				lp->huptimer = 0;
 706				lp->outgoing = 1;
 707				if (lp->chargeint) {
 708					lp->hupflags |= ISDN_HAVECHARGE;
 709					lp->hupflags &= ~ISDN_WAITCHARGE;
 710				} else {
 711					lp->hupflags |= ISDN_WAITCHARGE;
 712					lp->hupflags &= ~ISDN_HAVECHARGE;
 713				}
 714				anymore = 1;
 715				lp->dialstate =
 716				    (lp->cbdelay &&
 717				     (lp->flags & ISDN_NET_CBOUT)) ? 12 : 4;
 718				break;
 719			case 4:
 720				/* 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				 */
 742#ifdef ISDN_DEBUG_NET_DIAL
 743				printk(KERN_DEBUG "dialtimer2: %d\n", lp->dtimer);
 744#endif
 745				if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
 746					lp->dialstate = 3;
 747				anymore = 1;
 748				break;
 749			case 7:
 750				/* Got incoming Call, setup L2 and L3 protocols,
 751				 * then wait for D-Channel-connect
 752				 */
 753#ifdef ISDN_DEBUG_NET_DIAL
 754				printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
 755#endif
 756				cmd.driver = lp->isdn_device;
 757				cmd.command = ISDN_CMD_SETL2;
 758				cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
 759				isdn_command(&cmd);
 760				cmd.driver = lp->isdn_device;
 761				cmd.command = ISDN_CMD_SETL3;
 762				cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
 763				isdn_command(&cmd);
 764				if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT15)
 765					isdn_net_hangup(p->dev);
 766				else {
 767					anymore = 1;
 768					lp->dialstate++;
 769				}
 770				break;
 771			case 9:
 772				/* 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 */
 784#ifdef ISDN_DEBUG_NET_DIAL
 785				printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
 786#endif
 787				if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
 788					isdn_net_hangup(p->dev);
 789				else
 790					anymore = 1;
 791				break;
 792			case 11:
 793				/* 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);
 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{
 830	isdn_net_local *lp = netdev_priv(d);
 831	isdn_ctrl cmd;
 832#ifdef CONFIG_ISDN_X25
 833	struct concap_proto *cprot = lp->netdev->cprot;
 834	struct concap_proto_ops *pops = cprot ? cprot->pops : NULL;
 835#endif
 836
 837	if (lp->flags & ISDN_NET_CONNECTED) {
 838		if (lp->slave != NULL) {
 839			isdn_net_local *slp = ISDN_SLAVE_PRIV(lp);
 840			if (slp->flags & ISDN_NET_CONNECTED) {
 841				printk(KERN_INFO
 842					"isdn_net: hang up slave %s before %s\n",
 843					lp->slave->name, d->name);
 844				isdn_net_hangup(lp->slave);
 845			}
 846		}
 847		printk(KERN_INFO "isdn_net: local hangup %s\n", d->name);
 848#ifdef CONFIG_ISDN_PPP
 849		if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
 850			isdn_ppp_free(lp);
 851#endif
 852		isdn_net_lp_disconnected(lp);
 853#ifdef CONFIG_ISDN_X25
 854		/* try if there are generic encap protocol
 855		   receiver routines and signal the closure of
 856		   the link */
 857		if( pops && pops -> disconn_ind )
 858		  pops -> disconn_ind(cprot);
 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);
 865		printk(KERN_INFO "%s: Chargesum is %d\n", d->name, lp->charge);
 866		isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
 867	}
 868	isdn_net_unbind_channel(lp);
 869}
 870
 871typedef struct {
 872	__be16 source;
 873	__be16 dest;
 874} ip_ports;
 875
 876static void
 877isdn_net_log_skb(struct sk_buff * skb, isdn_net_local * lp)
 878{
 879	/* hopefully, this was set correctly */
 880	const u_char *p = skb_network_header(skb);
 881	unsigned short proto = ntohs(skb->protocol);
 882	int data_ofs;
 883	ip_ports *ipp;
 884	char addinfo[100];
 885
 886	addinfo[0] = '\0';
 887	/* This check stolen from 2.1.72 dev_queue_xmit_nit() */
 888	if (p < skb->data || skb->network_header >= skb->tail) {
 889		/* fall back to old isdn_net_log_packet method() */
 890		char * buf = skb->data;
 891
 892		printk(KERN_DEBUG "isdn_net: protocol %04x is buggy, dev %s\n", skb->protocol, lp->netdev->dev->name);
 893		p = buf;
 894		proto = ETH_P_IP;
 895		switch (lp->p_encap) {
 896			case ISDN_NET_ENCAP_IPTYP:
 897				proto = ntohs(*(__be16 *)&buf[0]);
 898				p = &buf[2];
 899				break;
 900			case ISDN_NET_ENCAP_ETHER:
 901				proto = ntohs(*(__be16 *)&buf[12]);
 902				p = &buf[14];
 903				break;
 904			case ISDN_NET_ENCAP_CISCOHDLC:
 905				proto = ntohs(*(__be16 *)&buf[2]);
 906				p = &buf[4];
 907				break;
 908#ifdef CONFIG_ISDN_PPP
 909			case ISDN_NET_ENCAP_SYNCPPP:
 910				proto = ntohs(skb->protocol);
 911				p = &buf[IPPP_MAX_HEADER];
 912				break;
 913#endif
 914		}
 915	}
 916	data_ofs = ((p[0] & 15) * 4);
 917	switch (proto) {
 918		case ETH_P_IP:
 919			switch (p[9]) {
 920				case 1:
 921					strcpy(addinfo, " ICMP");
 922					break;
 923				case 2:
 924					strcpy(addinfo, " IGMP");
 925					break;
 926				case 4:
 927					strcpy(addinfo, " IPIP");
 928					break;
 929				case 6:
 930					ipp = (ip_ports *) (&p[data_ofs]);
 931					sprintf(addinfo, " TCP, port: %d -> %d", ntohs(ipp->source),
 932						ntohs(ipp->dest));
 933					break;
 934				case 8:
 935					strcpy(addinfo, " EGP");
 936					break;
 937				case 12:
 938					strcpy(addinfo, " PUP");
 939					break;
 940				case 17:
 941					ipp = (ip_ports *) (&p[data_ofs]);
 942					sprintf(addinfo, " UDP, port: %d -> %d", ntohs(ipp->source),
 943						ntohs(ipp->dest));
 944					break;
 945				case 22:
 946					strcpy(addinfo, " IDP");
 947					break;
 948			}
 949			printk(KERN_INFO "OPEN: %pI4 -> %pI4%s\n",
 950			       p + 12, p + 16, addinfo);
 951			break;
 952		case ETH_P_ARP:
 953			printk(KERN_INFO "OPEN: ARP %pI4 -> *.*.*.* ?%pI4\n",
 954			       p + 14, p + 24);
 955			break;
 956	}
 957}
 958
 959/*
 960 * 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()) {
 967		// we can't grab the lock from irq context, 
 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 */
 986static void isdn_net_softint(struct work_struct *work)
 987{
 988	isdn_net_local *lp = container_of(work, isdn_net_local, tqueue);
 989	struct sk_buff *skb;
 990
 991	spin_lock_bh(&lp->xmit_lock);
 992	while (!isdn_net_lp_busy(lp)) {
 993		skb = skb_dequeue(&lp->super_tx_queue);
 994		if (!skb)
 995			break;
 996		isdn_net_writebuf_skb(lp, skb);                                
 997	}
 998	spin_unlock_bh(&lp->xmit_lock);
 999}
1000
1001/* 
1002 * 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 */
1024		printk(KERN_WARNING "%s: HL driver queue full\n", lp->netdev->dev->name);
1025		goto error;
1026	}
1027	
1028	lp->transcount += len;
1029	isdn_net_inc_frame_cnt(lp);
1030	return;
1031
1032 error:
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;
1055	isdn_net_local *lp = netdev_priv(ndev);
1056	int retv = NETDEV_TX_OK;
1057
1058	if (((isdn_net_local *) netdev_priv(ndev))->master) {
1059		printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1060		dev_kfree_skb(skb);
1061		return NETDEV_TX_OK;
1062	}
1063
1064	/* 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
1070	nd = ((isdn_net_local *) netdev_priv(ndev))->netdev;
1071	lp = isdn_net_get_locked_lp(nd);
1072	if (!lp) {
1073		printk(KERN_WARNING "%s: all channels busy - requeuing!\n", ndev->name);
1074		return NETDEV_TX_BUSY;
1075	}
1076	/* 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)) {
1097					slp = ISDN_SLAVE_PRIV(lp);
1098					if (!(slp->flags & ISDN_NET_CONNECTED)) {
1099						isdn_net_force_dial_lp(ISDN_SLAVE_PRIV(lp));
1100					}
1101				}
1102			}
1103		}
1104	} else {
1105		if (lp->sqfull && time_after(jiffies, lp->sqfull_stamp + lp->slavedelay + (10 * HZ))) {
1106			lp->sqfull = 0;
1107		}
1108		/* 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{
1119	isdn_net_local *lp = netdev_priv(dev);
1120	if (!skb)
1121		return;
1122	if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1123		const int pullsize = skb_network_offset(skb) - ETH_HLEN;
1124		if (pullsize > 0) {
1125			printk(KERN_DEBUG "isdn_net: Pull junk %d\n", pullsize);
1126			skb_pull(skb, pullsize);
1127		}
1128	}
1129}
1130
1131
1132static void isdn_net_tx_timeout(struct net_device * ndev)
1133{
1134	isdn_net_local *lp = netdev_priv(ndev);
1135
1136	printk(KERN_WARNING "isdn_tx_timeout dev %s dialstate %d\n", ndev->name, lp->dialstate);
1137	if (!lp->dialstate){
1138		lp->stats.tx_errors++;
1139                /*
1140		 * 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
1152		 * changed KERN_DEBUG to KERN_WARNING to find out if this is 
1153		 * ever called   --KG
1154		 */
1155	}
1156	ndev->trans_start = jiffies;
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 */
1165static netdev_tx_t
1166isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1167{
1168	isdn_net_local *lp = netdev_priv(ndev);
1169#ifdef CONFIG_ISDN_X25
1170	struct concap_proto * cprot = lp -> netdev -> cprot;
1171/* 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
1175     service as needed by X.25 PLP.
1176   - I don't want that the interface starts dialing when the network layer
1177     sends a message which requests to disconnect the lapb link (or if it
1178     sends any other message not resulting in data transmission).
1179   Instead, dialing will be initiated by the encapsulation protocol entity
1180   when a dl_establish request is received from the upper layer.
1181*/
1182	if (cprot && cprot -> pops) {
1183		int ret = cprot -> pops -> encap_and_xmit ( cprot , skb);
1184
1185		if (ret)
1186			netif_stop_queue(ndev);
1187		return ret;
1188	} else
1189#endif
1190	/* auto-dialing xmit function */
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);
1207				return NETDEV_TX_OK;
1208			}
1209			if (lp->phone[1]) {
1210				ulong flags;
1211
1212				if(lp->dialwait_timer <= 0)
1213					if(lp->dialstarted > 0 && lp->dialtimeout > 0 && time_before(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait))
1214						lp->dialwait_timer = lp->dialstarted + lp->dialtimeout + lp->dialwait;
1215
1216				if(lp->dialwait_timer > 0) {
1217					if(time_before(jiffies, lp->dialwait_timer)) {
1218						isdn_net_unreachable(ndev, skb, "dial rejected: retry-time not reached");
1219						dev_kfree_skb(skb);
1220						return NETDEV_TX_OK;
1221					} else
1222						lp->dialwait_timer = 0;
1223				}
1224				/* Grab a free ISDN-Channel */
1225				spin_lock_irqsave(&dev->lock, flags);
1226				if (((chi =
1227				     isdn_get_free_channel(
1228					 		ISDN_USAGE_NET,
1229							lp->l2_proto,
1230							lp->l3_proto,
1231							lp->pre_device,
1232						 	lp->pre_channel,
1233							lp->msn)
1234							) < 0) &&
1235					((chi =
1236				     isdn_get_free_channel(
1237					 		ISDN_USAGE_NET,
1238							lp->l2_proto,
1239							lp->l3_proto,
1240							lp->pre_device,
1241							lp->pre_channel^1,
1242							lp->msn)
1243							) < 0)) {
1244					spin_unlock_irqrestore(&dev->lock, flags);
1245					isdn_net_unreachable(ndev, skb,
1246							   "No channel");
1247					dev_kfree_skb(skb);
1248					return NETDEV_TX_OK;
1249				}
1250				/* 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);
1263						return NETDEV_TX_OK;	/* STN (skb to nirvana) ;) */
1264					}
1265#ifdef CONFIG_IPPP_FILTER
1266					if (isdn_ppp_autodial_filter(skb, lp)) {
1267						isdn_ppp_free(lp);
1268						isdn_net_unbind_channel(lp);
1269						spin_unlock_irqrestore(&dev->lock, flags);
1270						isdn_net_unreachable(ndev, skb, "dial rejected: packet filtered");
1271						dev_kfree_skb(skb);
1272						return NETDEV_TX_OK;
1273					}
1274#endif
1275					spin_unlock_irqrestore(&dev->lock, flags);
1276					isdn_net_dial();	/* Initiate dialing */
1277					netif_stop_queue(ndev);
1278					return NETDEV_TX_BUSY;	/* let upper layer requeue skb packet */
1279				}
1280#endif
1281				/* Initiate dialing */
1282				spin_unlock_irqrestore(&dev->lock, flags);
1283				isdn_net_dial();
1284				isdn_net_device_stop_queue(lp);
1285				return NETDEV_TX_BUSY;
1286			} else {
1287				isdn_net_unreachable(ndev, skb,
1288						     "No phone number");
1289				dev_kfree_skb(skb);
1290				return NETDEV_TX_OK;
1291			}
1292		} else {
1293			/* Device is connected to an ISDN channel */ 
1294			ndev->trans_start = jiffies;
1295			if (!lp->dialstate) {
1296				/* ISDN connection is established, try sending */
1297				int ret;
1298				ret = (isdn_net_xmit(ndev, skb));
1299				if(ret) netif_stop_queue(ndev);
1300				return ret;
1301			} else
1302				netif_stop_queue(ndev);
1303		}
1304	}
1305	return NETDEV_TX_BUSY;
1306}
1307
1308/*
1309 * 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
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 ); */
1319#endif
1320
1321#ifdef CONFIG_ISDN_X25
1322	if( cprot && cprot -> pops ) cprot -> pops -> close( cprot );
1323#endif
1324	netif_stop_queue(dev);
1325	p = MASTER_TO_SLAVE(dev);
1326	if (p) {
1327		/* If this interface has slaves, stop them also */
1328		while (p) {
1329#ifdef CONFIG_ISDN_X25
1330			cprot = ((isdn_net_local *) netdev_priv(p))
1331				-> netdev -> cprot;
1332			if( cprot && cprot -> pops )
1333				cprot -> pops -> close( cprot );
1334#endif
1335			isdn_net_hangup(p);
1336			p = MASTER_TO_SLAVE(p);
1337		}
1338	}
1339	isdn_net_hangup(dev);
1340	isdn_unlock_drivers();
1341	return 0;
1342}
1343
1344/*
1345 * Get statistics
1346 */
1347static struct net_device_stats *
1348isdn_net_get_stats(struct net_device *dev)
1349{
1350	isdn_net_local *lp = netdev_priv(dev);
1351	return &lp->stats;
1352}
1353
1354/*      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
1363static __be16
1364isdn_net_type_trans(struct sk_buff *skb, struct net_device *dev)
1365{
1366	struct ethhdr *eth;
1367	unsigned char *rawp;
1368
1369	skb_reset_mac_header(skb);
1370	skb_pull(skb, ETH_HLEN);
1371	eth = eth_hdr(skb);
1372
1373	if (*eth->h_dest & 1) {
1374		if (memcmp(eth->h_dest, dev->broadcast, ETH_ALEN) == 0)
1375			skb->pkt_type = PACKET_BROADCAST;
1376		else
1377			skb->pkt_type = PACKET_MULTICAST;
1378	}
1379	/*
1380	 *      This ALLMULTI check should be redundant by 1.4
1381	 *      so don't forget to remove it.
1382	 */
1383
1384	else if (dev->flags & (IFF_PROMISC /*| IFF_ALLMULTI*/)) {
1385		if (memcmp(eth->h_dest, dev->dev_addr, ETH_ALEN))
1386			skb->pkt_type = PACKET_OTHERHOST;
1387	}
1388	if (ntohs(eth->h_proto) >= 1536)
1389		return eth->h_proto;
1390
1391	rawp = skb->data;
1392
1393	/*
1394	 *      This is a magic hack to spot IPX packets. Older Novell breaks
1395	 *      the protocol design and runs IPX over 802.3 without an 802.2 LLC
1396	 *      layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
1397	 *      won't work for fault tolerant netware but does for the rest.
1398	 */
1399	if (*(unsigned short *) rawp == 0xFFFF)
1400		return htons(ETH_P_802_3);
1401	/*
1402	 *      Real 802.2 LLC
1403	 */
1404	return htons(ETH_P_802_2);
1405}
1406
1407
1408/* 
1409 * CISCO HDLC keepalive specific stuff
1410 */
1411static struct sk_buff*
1412isdn_net_ciscohdlck_alloc_skb(isdn_net_local *lp, int len)
1413{
1414	unsigned short hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
1415	struct sk_buff *skb;
1416
1417	skb = alloc_skb(hl + len, GFP_ATOMIC);
1418	if (skb)
1419		skb_reserve(skb, hl);
1420	else 
1421		printk("isdn out of mem at %s:%d!\n", __FILE__, __LINE__);
1422	return skb;
1423}
1424
1425/* cisco hdlck device private ioctls */
1426static int
1427isdn_ciscohdlck_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1428{
1429	isdn_net_local *lp = netdev_priv(dev);
1430	unsigned long len = 0;
1431	unsigned long expires = 0;
1432	int tmp = 0;
1433	int period = lp->cisco_keepalive_period;
1434	s8 debserint = lp->cisco_debserint;
1435	int rc = 0;
1436
1437	if (lp->p_encap != ISDN_NET_ENCAP_CISCOHDLCK)
1438		return -EINVAL;
1439
1440	switch (cmd) {
1441		/* get/set keepalive period */
1442		case SIOCGKEEPPERIOD:
1443			len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1444			if (copy_to_user(ifr->ifr_data,
1445				&lp->cisco_keepalive_period, len))
1446				rc = -EFAULT;
1447			break;
1448		case SIOCSKEEPPERIOD:
1449			tmp = lp->cisco_keepalive_period;
1450			len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1451			if (copy_from_user(&period, ifr->ifr_data, len))
1452				rc = -EFAULT;
1453			if ((period > 0) && (period <= 32767))
1454				lp->cisco_keepalive_period = period;
1455			else
1456				rc = -EINVAL;
1457			if (!rc && (tmp != lp->cisco_keepalive_period)) {
1458				expires = (unsigned long)(jiffies +
1459					lp->cisco_keepalive_period * HZ);
1460				mod_timer(&lp->cisco_timer, expires);
1461				printk(KERN_INFO "%s: Keepalive period set "
1462					"to %d seconds.\n",
1463					dev->name, lp->cisco_keepalive_period);
1464			}
1465			break;
1466
1467		/* get/set debugging */
1468		case SIOCGDEBSERINT:
1469			len = (unsigned long)sizeof(lp->cisco_debserint);
1470			if (copy_to_user(ifr->ifr_data,
1471				&lp->cisco_debserint, len))
1472				rc = -EFAULT;
1473			break;
1474		case SIOCSDEBSERINT:
1475			len = (unsigned long)sizeof(lp->cisco_debserint);
1476			if (copy_from_user(&debserint,
1477				ifr->ifr_data, len))
1478				rc = -EFAULT;
1479			if ((debserint >= 0) && (debserint <= 64))
1480				lp->cisco_debserint = debserint;
1481			else
1482				rc = -EINVAL;
1483			break;
1484
1485		default:
1486			rc = -EINVAL;
1487			break;
1488	}
1489	return (rc);
1490}
1491
1492
1493static int isdn_net_ioctl(struct net_device *dev,
1494			  struct ifreq *ifr, int cmd)
1495{
1496	isdn_net_local *lp = netdev_priv(dev);
1497
1498	switch (lp->p_encap) {
1499#ifdef CONFIG_ISDN_PPP
1500	case ISDN_NET_ENCAP_SYNCPPP:
1501		return isdn_ppp_dev_ioctl(dev, ifr, cmd);
1502#endif
1503	case ISDN_NET_ENCAP_CISCOHDLCK:
1504		return isdn_ciscohdlck_dev_ioctl(dev, ifr, cmd);
1505	default:
1506		return -EINVAL;
1507	}
1508}
1509
1510/* 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);
1527	if ((lp->cisco_line_state) && ((myseq_diff >= 3)||(myseq_diff <= -3))) {
1528		/* line up -> down */
1529		lp->cisco_line_state = 0;
1530		printk (KERN_WARNING
1531				"UPDOWN: Line protocol on Interface %s,"
1532				" changed state to down\n", lp->netdev->dev->name);
1533		/* should stop routing higher-level data across */
1534	} else if ((!lp->cisco_line_state) &&
1535		(myseq_diff >= 0) && (myseq_diff <= 2)) {
1536		/* line down -> up */
1537		lp->cisco_line_state = 1;
1538		printk (KERN_WARNING
1539				"UPDOWN: Line protocol on Interface %s,"
1540				" changed state to up\n", lp->netdev->dev->name);
1541		/* restart routing higher-level data across */
1542	}
1543
1544	if (lp->cisco_debserint)
1545		printk (KERN_DEBUG "%s: HDLC "
1546			"myseq %lu, mineseen %lu%c, yourseen %lu, %s\n",
1547			lp->netdev->dev->name, last_cisco_myseq, lp->cisco_mineseen,
1548			((last_cisco_myseq == lp->cisco_mineseen) ? '*' : 040),
1549			lp->cisco_yourseq,
1550			((lp->cisco_line_state) ? "line up" : "line down"));
1551
1552	skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1553	if (!skb)
1554		return;
1555
1556	p = skb_put(skb, 4 + 14);
1557
1558	/* cisco header */
1559	*(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1560	*(u8 *)(p + 1) = CISCO_CTRL;
1561	*(__be16 *)(p + 2) = cpu_to_be16(CISCO_TYPE_SLARP);
1562
1563	/* slarp keepalive */
1564	*(__be32 *)(p +  4) = cpu_to_be32(CISCO_SLARP_KEEPALIVE);
1565	*(__be32 *)(p +  8) = cpu_to_be32(lp->cisco_myseq);
1566	*(__be32 *)(p + 12) = cpu_to_be32(lp->cisco_yourseq);
1567	*(__be16 *)(p + 16) = cpu_to_be16(0xffff); // reliability, always 0xffff
1568	p += 18;
1569
1570	isdn_net_write_super(lp, skb);
1571
1572	lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1573	
1574	add_timer(&lp->cisco_timer);
1575}
1576
1577static void
1578isdn_net_ciscohdlck_slarp_send_request(isdn_net_local *lp)
1579{
1580	struct sk_buff *skb;
1581	unsigned char *p;
1582
1583	skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1584	if (!skb)
1585		return;
1586
1587	p = skb_put(skb, 4 + 14);
1588
1589	/* cisco header */
1590	*(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1591	*(u8 *)(p + 1) = CISCO_CTRL;
1592	*(__be16 *)(p + 2) = cpu_to_be16(CISCO_TYPE_SLARP);
1593
1594	/* slarp request */
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;
1600
1601	isdn_net_write_super(lp, skb);
1602}
1603
1604static void 
1605isdn_net_ciscohdlck_connected(isdn_net_local *lp)
1606{
1607	lp->cisco_myseq = 0;
1608	lp->cisco_mineseen = 0;
1609	lp->cisco_yourseq = 0;
1610	lp->cisco_keepalive_period = ISDN_TIMER_KEEPINT;
1611	lp->cisco_last_slarp_in = 0;
1612	lp->cisco_line_state = 0;
1613	lp->cisco_debserint = 0;
1614
1615	/* 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
1625static void 
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;
1637	__be32 addr = 0;		/* local ipv4 address */
1638	__be32 mask = 0;		/* local netmask */
1639
1640	if ((in_dev = lp->netdev->dev->ip_ptr) != NULL) {
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 */
1656	*(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1657	*(u8 *)(p + 1) = CISCO_CTRL;
1658	*(__be16 *)(p + 2) = cpu_to_be16(CISCO_TYPE_SLARP);
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 */
1662	*(__be32 *)(p +  4) = cpu_to_be32(CISCO_SLARP_REPLY);
1663	*(__be32 *)(p +  8) = addr; // address
1664	*(__be32 *)(p + 12) = mask; // netmask
1665	*(__be16 *)(p + 16) = cpu_to_be16(0); // unused
1666	p += 18;
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;
1677	u32 my_seq;
1678	u32 your_seq;
1679	__be32 local;
1680	__be32 *addr, *mask;
1681
1682	if (skb->len < 14)
1683		return;
1684
1685	p = skb->data;
1686	code = be32_to_cpup((__be32 *)p);
1687	p += 4;
1688
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:
1695		addr = (__be32 *)p;
1696		mask = (__be32 *)(p + 4);
1697		if (*mask != cpu_to_be32(0xfffffffc))
1698			goto slarp_reply_out;
1699		if ((*addr & cpu_to_be32(3)) == cpu_to_be32(0) ||
1700		    (*addr & cpu_to_be32(3)) == cpu_to_be32(3))
1701			goto slarp_reply_out;
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);
1705		break;
1706  slarp_reply_out:
1707		printk(KERN_INFO "%s: got invalid slarp reply (%pI4/%pI4) - ignored\n",
1708		       lp->netdev->dev->name, addr, mask);
1709		break;
1710	case CISCO_SLARP_KEEPALIVE:
1711		period = (int)((jiffies - lp->cisco_last_slarp_in
1712				+ HZ/2 - 1) / HZ);
1713		if (lp->cisco_debserint &&
1714				(period != lp->cisco_keepalive_period) &&
1715				lp->cisco_last_slarp_in) {
1716			printk(KERN_DEBUG "%s: Keepalive period mismatch - "
1717				"is %d but should be %d.\n",
1718				lp->netdev->dev->name, period,
1719				lp->cisco_keepalive_period);
1720		}
1721		lp->cisco_last_slarp_in = jiffies;
1722		my_seq = be32_to_cpup((__be32 *)(p + 0));
1723		your_seq = be32_to_cpup((__be32 *)(p + 4));
1724		p += 10;
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;
1735 	u8 addr;
1736 	u8 ctrl;
1737 	u16 type;
1738	
1739	if (skb->len < 4)
1740		goto out_free;
1741
1742	p = skb->data;
1743	addr = *(u8 *)(p + 0);
1744	ctrl = *(u8 *)(p + 1);
1745	type = be16_to_cpup((__be16 *)(p + 2));
1746	p += 4;
1747	skb_pull(skb, 4);
1748	
1749	if (addr != CISCO_ADDR_UNICAST && addr != CISCO_ADDR_BROADCAST) {
1750		printk(KERN_WARNING "%s: Unknown Cisco addr 0x%02x\n",
1751		       lp->netdev->dev->name, addr);
1752		goto out_free;
1753	}
1754	if (ctrl != CISCO_CTRL) {
1755		printk(KERN_WARNING "%s: Unknown Cisco ctrl 0x%02x\n",
1756		       lp->netdev->dev->name, ctrl);
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 "
1767				"\"no cdp enable\" on cisco.\n",
1768				lp->netdev->dev->name);
1769		goto out_free;
1770	default:
1771		/* no special cisco protocol */
1772		skb->protocol = htons(type);
1773		netif_rx(skb);
1774		return;
1775	}
1776
1777 out_free:
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{
1787	isdn_net_local *lp = netdev_priv(ndev);
1788	isdn_net_local *olp = lp;	/* original 'lp' */
1789#ifdef CONFIG_ISDN_X25
1790	struct concap_proto *cprot = lp -> netdev -> cprot;
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;
1801		lp = netdev_priv(ndev);
1802		lp->stats.rx_packets++;
1803		lp->stats.rx_bytes += skb->len;
1804	}
1805	skb->dev = ndev;
1806	skb->pkt_type = P

Large files files are truncated, but you can click here to view the full file