开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
slip.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：35k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

slip.c：源码内容
  1. /*
  2.  * slip.c This module implements the SLIP protocol for kernel-based
  3.  * devices like TTY.  It interfaces between a raw TTY, and the
  4.  * kernel's INET protocol layers.
  5.  *
  6.  * Version: @(#)slip.c 0.8.3 12/24/94
  7.  *
  8.  * Authors: Laurence Culhane, <loz@holmes.demon.co.uk>
  9.  * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
  10.  *
  11.  * Fixes:
  12.  * Alan Cox :  Sanity checks and avoid tx overruns.
  13.  * Has a new sl->mtu field.
  14.  * Alan Cox :  Found cause of overrun. ifconfig sl0 mtu upwards.
  15.  * Driver now spots this and grows/shrinks its buffers(hack!).
  16.  * Memory leak if you run out of memory setting up a slip driver fixed.
  17.  * Matt Dillon : Printable slip (borrowed from NET2E)
  18.  * Pauline Middelink : Slip driver fixes.
  19.  * Alan Cox : Honours the old SL_COMPRESSED flag
  20.  * Alan Cox : KISS AX.25 and AXUI IP support
  21.  * Michael Riepe : Automatic CSLIP recognition added
  22.  * Charles Hedrick : CSLIP header length problem fix.
  23.  * Alan Cox : Corrected non-IP cases of the above.
  24.  * Alan Cox : Now uses hardware type as per FvK.
  25.  * Alan Cox : Default to 192.168.0.0 (RFC 1597)
  26.  * A.N.Kuznetsov : dev_tint() recursion fix.
  27.  * Dmitry Gorodchanin : SLIP memory leaks
  28.  *      Dmitry Gorodchanin      :       Code cleanup. Reduce tty driver
  29.  *                                      buffering from 4096 to 256 bytes.
  30.  *                                      Improving SLIP response time.
  31.  *                                      CONFIG_SLIP_MODE_SLIP6.
  32.  *                                      ifconfig sl? up & down now works correctly.
  33.  * Modularization.
  34.  *              Alan Cox        :       Oops - fix AX.25 buffer lengths
  35.  *      Dmitry Gorodchanin      :       Even more cleanups. Preserve CSLIP
  36.  *                                      statistics. Include CSLIP code only
  37.  *                                      if it really needed.
  38.  * Alan Cox : Free slhc buffers in the right place.
  39.  * Alan Cox : Allow for digipeated IP over AX.25
  40.  * Matti Aarnio : Dynamic SLIP devices, with ideas taken
  41.  * from Jim Freeman's <jfree@caldera.com>
  42.  * dynamic PPP devices.  We do NOT kfree()
  43.  * device entries, just reg./unreg. them
  44.  * as they are needed.  We kfree() them
  45.  * at module cleanup.
  46.  * With MODULE-loading ``insmod'', user can
  47.  * issue parameter:   slip_maxdev=1024
  48.  * (Or how much he/she wants.. Default is 256)
  49.  * * Stanislav Voronyi : Slip line checking, with ideas taken
  50.  * from multislip BSDI driver which was written
  51.  * by Igor Chechik, RELCOM Corp. Only algorithms
  52.  *  have been ported to Linux SLIP driver.
  53.  * Vitaly E. Lavrov : Sane behaviour on tty hangup.
  54.  * Alexey Kuznetsov : Cleanup interfaces to tty&netdevice modules.
  55.  */
  57. #define SL_CHECK_TRANSMIT
  58. #include <linux/config.h>
  59. #include <linux/module.h>
  61. #include <asm/system.h>
  62. #include <asm/uaccess.h>
  63. #include <asm/bitops.h>
  64. #include <linux/string.h>
  65. #include <linux/mm.h>
  66. #include <linux/interrupt.h>
  67. #include <linux/in.h>
  68. #include <linux/tty.h>
  69. #include <linux/errno.h>
  70. #include <linux/netdevice.h>
  71. #include <linux/etherdevice.h>
  72. #include <linux/skbuff.h>
  73. #include <linux/rtnetlink.h>
  74. #include <linux/if_arp.h>
  75. #include <linux/if_slip.h>
  76. #include <linux/init.h>
  77. #include "slip.h"
  78. #ifdef CONFIG_INET
  79. #include <linux/ip.h>
  80. #include <linux/tcp.h>
  81. #include <net/slhc_vj.h>
  82. #endif
  84. #ifdef MODULE
  85. #define SLIP_VERSION    "0.8.4-NET3.019-NEWTTY-MODULAR"
  86. #else
  87. #define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
  88. #endif
  91. typedef struct slip_ctrl {
  92. struct slip ctrl; /* SLIP things */
  93. struct net_device dev; /* the device */
  94. } slip_ctrl_t;
  95. static slip_ctrl_t **slip_ctrls;
  97. int slip_maxdev = SL_NRUNIT; /* Can be overridden with insmod! */
  98. MODULE_PARM(slip_maxdev, "i");
  99. MODULE_PARM_DESC(slip_maxdev, "Maximum number of slip devices");
  101. static struct tty_ldisc sl_ldisc;
  103. static int slip_esc(unsigned char *p, unsigned char *d, int len);
  104. static void slip_unesc(struct slip *sl, unsigned char c);
  105. #ifdef CONFIG_SLIP_MODE_SLIP6
  106. static int slip_esc6(unsigned char *p, unsigned char *d, int len);
  107. static void slip_unesc6(struct slip *sl, unsigned char c);
  108. #endif
  109. #ifdef CONFIG_SLIP_SMART
  110. static void sl_keepalive(unsigned long sls);
  111. static void sl_outfill(unsigned long sls);
  112. static int sl_ioctl(struct net_device *dev,struct ifreq *rq,int cmd);
  113. #endif
  115. /********************************
  116. *  Buffer administration routines:
  117. * sl_alloc_bufs()
  118. * sl_free_bufs()
  119. * sl_realloc_bufs()
  120. *
  121. * NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
  122. * sl_realloc_bufs provides strong atomicity and reallocation
  123. * on actively running device.
  124. *********************************/
  126. /* 
  127.    Allocate channel buffers.
  128.  */
  130. static int
  131. sl_alloc_bufs(struct slip *sl, int mtu)
  132. {
  133. int err = -ENOBUFS;
  134. unsigned long len;
  135. char * rbuff = NULL;
  136. char * xbuff = NULL;
  137. #ifdef SL_INCLUDE_CSLIP
  138. char * cbuff = NULL;
  139. struct slcompress *slcomp = NULL;
  140. #endif
  142. /*
  143.  * Allocate the SLIP frame buffers:
  144.  *
  145.  * rbuff Receive buffer.
  146.  * xbuff Transmit buffer.
  147.  * cbuff        Temporary compression buffer.
  148.  */
  149. len = mtu * 2;
  151. /*
  152.  * allow for arrival of larger UDP packets, even if we say not to
  153.  * also fixes a bug in which SunOS sends 512-byte packets even with
  154.  * an MSS of 128
  155.  */
  156. if (len < 576 * 2)
  157. len = 576 * 2;
  158. rbuff = kmalloc(len + 4, GFP_KERNEL);
  159. if (rbuff == NULL)
  160. goto err_exit;
  161. xbuff = kmalloc(len + 4, GFP_KERNEL);
  162. if (xbuff == NULL)
  163. goto err_exit;
  164. #ifdef SL_INCLUDE_CSLIP
  165. cbuff = kmalloc(len + 4, GFP_KERNEL);
  166. if (cbuff == NULL)
  167. goto err_exit;
  168. slcomp = slhc_init(16, 16);
  169. if (slcomp == NULL)
  170. goto err_exit;
  171. #endif
  172. spin_lock_bh(&sl->lock);
  173. if (sl->tty == NULL) {
  174. spin_unlock_bh(&sl->lock);
  175. err = -ENODEV;
  176. goto err_exit;
  177. }
  178. sl->mtu      = mtu;
  179. sl->buffsize = len;
  180. sl->rcount   = 0;
  181. sl->xleft    = 0;
  182. rbuff = xchg(&sl->rbuff, rbuff);
  183. xbuff = xchg(&sl->xbuff, xbuff);
  184. #ifdef SL_INCLUDE_CSLIP
  185. cbuff = xchg(&sl->cbuff, cbuff);
  186. slcomp = xchg(&sl->slcomp, slcomp);
  187. #ifdef CONFIG_SLIP_MODE_SLIP6
  188. sl->xdata    = 0;
  189. sl->xbits    = 0;
  190. #endif
  191. #endif
  192. spin_unlock_bh(&sl->lock);
  193. err = 0;
  195. /* Cleanup */
  196. err_exit:
  197. #ifdef SL_INCLUDE_CSLIP
  198. if (cbuff)
  199. kfree(cbuff);
  200. if (slcomp)
  201. slhc_free(slcomp);
  202. #endif
  203. if (xbuff)
  204. kfree(xbuff);
  205. if (rbuff)
  206. kfree(rbuff);
  207. return err;
  208. }
  210. /* Free a SLIP channel buffers. */
  211. static void
  212. sl_free_bufs(struct slip *sl)
  213. {
  214. void * tmp;
  216. /* Free all SLIP frame buffers. */
  217. if ((tmp = xchg(&sl->rbuff, NULL)) != NULL)
  218. kfree(tmp);
  219. if ((tmp = xchg(&sl->xbuff, NULL)) != NULL)
  220. kfree(tmp);
  221. #ifdef SL_INCLUDE_CSLIP
  222. if ((tmp = xchg(&sl->cbuff, NULL)) != NULL)
  223. kfree(tmp);
  224. if ((tmp = xchg(&sl->slcomp, NULL)) != NULL)
  225. slhc_free(tmp);
  226. #endif
  227. }
  229. /* 
  230.    Reallocate slip channel buffers.
  231.  */
  233. static int sl_realloc_bufs(struct slip *sl, int mtu)
  234. {
  235. int err = 0;
  236. struct net_device *dev = sl->dev;
  237. unsigned char *xbuff, *rbuff;
  238. #ifdef SL_INCLUDE_CSLIP
  239. unsigned char *cbuff;
  240. #endif
  241. int len = mtu * 2;
  243. /*
  244.  * allow for arrival of larger UDP packets, even if we say not to
  245.  * also fixes a bug in which SunOS sends 512-byte packets even with
  246.  * an MSS of 128
  247.  */
  248. if (len < 576 * 2)
  249. len = 576 * 2;
  251. xbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
  252. rbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
  253. #ifdef SL_INCLUDE_CSLIP
  254. cbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
  255. #endif
  258. #ifdef SL_INCLUDE_CSLIP
  259. if (xbuff == NULL || rbuff == NULL || cbuff == NULL)  {
  260. #else
  261. if (xbuff == NULL || rbuff == NULL)  {
  262. #endif
  263. if (mtu >= sl->mtu) {
  264. printk("%s: unable to grow slip buffers, MTU change cancelled.n",
  265.        dev->name);
  266. err = -ENOBUFS;
  267. }
  268. goto done;
  269. }
  271. spin_lock_bh(&sl->lock);
  273. err = -ENODEV;
  274. if (sl->tty == NULL)
  275. goto done_on_bh;
  277. xbuff    = xchg(&sl->xbuff, xbuff);
  278. rbuff    = xchg(&sl->rbuff, rbuff);
  279. #ifdef SL_INCLUDE_CSLIP
  280. cbuff    = xchg(&sl->cbuff, cbuff);
  281. #endif
  282. if (sl->xleft)  {
  283. if (sl->xleft <= len)  {
  284. memcpy(sl->xbuff, sl->xhead, sl->xleft);
  285. } else  {
  286. sl->xleft = 0;
  287. sl->tx_dropped++;
  288. }
  289. }
  290. sl->xhead = sl->xbuff;
  292. if (sl->rcount)  {
  293. if (sl->rcount <= len) {
  294. memcpy(sl->rbuff, rbuff, sl->rcount);
  295. } else  {
  296. sl->rcount = 0;
  297. sl->rx_over_errors++;
  298. set_bit(SLF_ERROR, &sl->flags);
  299. }
  300. }
  301. sl->mtu      = mtu;
  302. dev->mtu      = mtu;
  303. sl->buffsize = len;
  304. err = 0;
  306. done_on_bh:
  307. spin_unlock_bh(&sl->lock);
  309. done:
  310. if (xbuff)
  311. kfree(xbuff);
  312. if (rbuff)
  313. kfree(rbuff);
  314. #ifdef SL_INCLUDE_CSLIP
  315. if (cbuff)
  316. kfree(cbuff);
  317. #endif
  318. return err;
  319. }
  322. /* Set the "sending" flag.  This must be atomic hence the set_bit. */
  323. static inline void
  324. sl_lock(struct slip *sl)
  325. {
  326. netif_stop_queue(sl->dev);
  327. }
  330. /* Clear the "sending" flag.  This must be atomic, hence the ASM. */
  331. static inline void
  332. sl_unlock(struct slip *sl)
  333. {
  334. netif_wake_queue(sl->dev);
  335. }
  337. /* Send one completely decapsulated IP datagram to the IP layer. */
  338. static void
  339. sl_bump(struct slip *sl)
  340. {
  341. struct sk_buff *skb;
  342. int count;
  344. count = sl->rcount;
  345. #ifdef SL_INCLUDE_CSLIP
  346. if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
  347. unsigned char c;
  348. if ((c = sl->rbuff[0]) & SL_TYPE_COMPRESSED_TCP) {
  349. /* ignore compressed packets when CSLIP is off */
  350. if (!(sl->mode & SL_MODE_CSLIP)) {
  351. printk("%s: compressed packet ignoredn", sl->dev->name);
  352. return;
  353. }
  354. /* make sure we've reserved enough space for uncompress to use */
  355. if (count + 80 > sl->buffsize) {
  356. sl->rx_over_errors++;
  357. return;
  358. }
  359. count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
  360. if (count <= 0) {
  361. return;
  362. }
  363. } else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
  364. if (!(sl->mode & SL_MODE_CSLIP)) {
  365. /* turn on header compression */
  366. sl->mode |= SL_MODE_CSLIP;
  367. sl->mode &= ~SL_MODE_ADAPTIVE;
  368. printk("%s: header compression turned onn", sl->dev->name);
  369. }
  370. sl->rbuff[0] &= 0x4f;
  371. if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0) {
  372. return;
  373. }
  374. }
  375. }
  376. #endif  /* SL_INCLUDE_CSLIP */
  378. sl->rx_bytes+=count;
  380. skb = dev_alloc_skb(count);
  381. if (skb == NULL)  {
  382. printk("%s: memory squeeze, dropping packet.n", sl->dev->name);
  383. sl->rx_dropped++;
  384. return;
  385. }
  386. skb->dev = sl->dev;
  387. memcpy(skb_put(skb,count), sl->rbuff, count);
  388. skb->mac.raw=skb->data;
  389. skb->protocol=htons(ETH_P_IP);
  390. netif_rx(skb);
  391. sl->dev->last_rx = jiffies;
  392. sl->rx_packets++;
  393. }
  395. /* Encapsulate one IP datagram and stuff into a TTY queue. */
  396. static void
  397. sl_encaps(struct slip *sl, unsigned char *icp, int len)
  398. {
  399. unsigned char *p;
  400. int actual, count;
  402. if (len > sl->mtu) { /* Sigh, shouldn't occur BUT ... */
  403. printk ("%s: truncating oversized transmit packet!n", sl->dev->name);
  404. sl->tx_dropped++;
  405. sl_unlock(sl);
  406. return;
  407. }
  409. p = icp;
  410. #ifdef SL_INCLUDE_CSLIP
  411. if (sl->mode & SL_MODE_CSLIP)  {
  412. len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
  413. }
  414. #endif
  415. #ifdef CONFIG_SLIP_MODE_SLIP6
  416. if(sl->mode & SL_MODE_SLIP6)
  417. count = slip_esc6(p, (unsigned char *) sl->xbuff, len);
  418. else
  419. #endif
  420. count = slip_esc(p, (unsigned char *) sl->xbuff, len);
  422. /* Order of next two lines is *very* important.
  423.  * When we are sending a little amount of data,
  424.  * the transfer may be completed inside driver.write()
  425.  * routine, because it's running with interrupts enabled.
  426.  * In this case we *never* got WRITE_WAKEUP event,
  427.  * if we did not request it before write operation.
  428.  *       14 Oct 1994  Dmitry Gorodchanin.
  429.  */
  430. sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  431. actual = sl->tty->driver.write(sl->tty, 0, sl->xbuff, count);
  432. #ifdef SL_CHECK_TRANSMIT
  433. sl->dev->trans_start = jiffies;
  434. #endif
  435. sl->xleft = count - actual;
  436. sl->xhead = sl->xbuff + actual;
  437. #ifdef CONFIG_SLIP_SMART
  438. /* VSV */
  439. clear_bit(SLF_OUTWAIT, &sl->flags); /* reset outfill flag */
  440. #endif
  441. }
  443. /*
  444.  * Called by the driver when there's room for more data.  If we have
  445.  * more packets to send, we send them here.
  446.  */
  447. static void slip_write_wakeup(struct tty_struct *tty)
  448. {
  449. int actual;
  450. struct slip *sl = (struct slip *) tty->disc_data;
  452. /* First make sure we're connected. */
  453. if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev)) {
  454. return;
  455. }
  456. if (sl->xleft <= 0)  {
  457. /* Now serial buffer is almost free & we can start
  458.  * transmission of another packet */
  459. sl->tx_packets++;
  460. tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  461. sl_unlock(sl);
  462. return;
  463. }
  465. actual = tty->driver.write(tty, 0, sl->xhead, sl->xleft);
  466. sl->xleft -= actual;
  467. sl->xhead += actual;
  468. }
  470. static void sl_tx_timeout(struct net_device *dev)
  471. {
  472. struct slip *sl = (struct slip*)(dev->priv);
  474. spin_lock(&sl->lock);
  476. if (netif_queue_stopped(dev)) {
  477. struct slip *sl = (struct slip*)(dev->priv);
  479. if (!netif_running(dev))
  480. goto out;
  482. /* May be we must check transmitter timeout here ?
  483.  *      14 Oct 1994 Dmitry Gorodchanin.
  484.  */
  485. #ifdef SL_CHECK_TRANSMIT
  486. if (time_before(jiffies, dev->trans_start + 20 * HZ))  {
  487. /* 20 sec timeout not reached */
  488. goto out;
  489. }
  490. printk("%s: transmit timed out, %s?n", dev->name,
  491.        (sl->tty->driver.chars_in_buffer(sl->tty) || sl->xleft) ?
  492.        "bad line quality" : "driver error");
  493. sl->xleft = 0;
  494. sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  495. sl_unlock(sl);
  496. #endif
  497. }
  499. out:
  500. spin_unlock(&sl->lock);
  501. }
  504. /* Encapsulate an IP datagram and kick it into a TTY queue. */
  505. static int
  506. sl_xmit(struct sk_buff *skb, struct net_device *dev)
  507. {
  508. struct slip *sl = (struct slip*)(dev->priv);
  510. spin_lock(&sl->lock);
  511. if (!netif_running(dev))  {
  512. spin_unlock(&sl->lock);
  513. printk("%s: xmit call when iface is downn", dev->name);
  514. dev_kfree_skb(skb);
  515. return 0;
  516. }
  517. if (sl->tty == NULL) {
  518. spin_unlock(&sl->lock);
  519. dev_kfree_skb(skb);
  520. return 0;
  521. }
  523. sl_lock(sl);
  524. sl->tx_bytes+=skb->len;
  525. sl_encaps(sl, skb->data, skb->len);
  526. spin_unlock(&sl->lock);
  528. dev_kfree_skb(skb);
  529. return 0;
  530. }
  533. /******************************************
  534.  *   Routines looking at netdevice side.
  535.  ******************************************/
  537. /* Netdevice UP -> DOWN routine */
  539. static int
  540. sl_close(struct net_device *dev)
  541. {
  542. struct slip *sl = (struct slip*)(dev->priv);
  544. spin_lock_bh(&sl->lock);
  545. if (sl->tty) {
  546. /* TTY discipline is running. */
  547. sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
  548. }
  549. netif_stop_queue(dev);
  550. sl->rcount   = 0;
  551. sl->xleft    = 0;
  552. spin_unlock_bh(&sl->lock);
  554. return 0;
  555. }
  557. /* Netdevice DOWN -> UP routine */
  559. static int sl_open(struct net_device *dev)
  560. {
  561. struct slip *sl = (struct slip*)(dev->priv);
  563. if (sl->tty==NULL)
  564. return -ENODEV;
  566. sl->flags &= (1 << SLF_INUSE);
  567. netif_start_queue(dev);
  568. return 0;
  569. }
  571. /* Netdevice change MTU request */
  573. static int sl_change_mtu(struct net_device *dev, int new_mtu)
  574. {
  575. struct slip *sl = (struct slip*)(dev->priv);
  577. if (new_mtu < 68 || new_mtu > 65534)
  578. return -EINVAL;
  580. if (new_mtu != dev->mtu)
  581. return sl_realloc_bufs(sl, new_mtu);
  582. return 0;
  583. }
  585. /* Netdevice get statistics request */
  587. static struct net_device_stats *
  588. sl_get_stats(struct net_device *dev)
  589. {
  590. static struct net_device_stats stats;
  591. struct slip *sl = (struct slip*)(dev->priv);
  592. #ifdef SL_INCLUDE_CSLIP
  593. struct slcompress *comp;
  594. #endif
  596. memset(&stats, 0, sizeof(struct net_device_stats));
  598. stats.rx_packets     = sl->rx_packets;
  599. stats.tx_packets     = sl->tx_packets;
  600. stats.rx_bytes      = sl->rx_bytes;
  601. stats.tx_bytes      = sl->tx_bytes;
  602. stats.rx_dropped     = sl->rx_dropped;
  603. stats.tx_dropped     = sl->tx_dropped;
  604. stats.tx_errors      = sl->tx_errors;
  605. stats.rx_errors      = sl->rx_errors;
  606. stats.rx_over_errors = sl->rx_over_errors;
  607. #ifdef SL_INCLUDE_CSLIP
  608. stats.rx_fifo_errors = sl->rx_compressed;
  609. stats.tx_fifo_errors = sl->tx_compressed;
  610. stats.collisions     = sl->tx_misses;
  611. comp = sl->slcomp;
  612. if (comp) {
  613. stats.rx_fifo_errors += comp->sls_i_compressed;
  614. stats.rx_dropped     += comp->sls_i_tossed;
  615. stats.tx_fifo_errors += comp->sls_o_compressed;
  616. stats.collisions     += comp->sls_o_misses;
  617. }
  618. #endif /* CONFIG_INET */
  619. return (&stats);
  620. }
  622. /* Netdevice register callback */
  624. static int sl_init(struct net_device *dev)
  625. {
  626. struct slip *sl = (struct slip*)(dev->priv);
  628. /*
  629.  * Finish setting up the DEVICE info. 
  630.  */
  632. dev->mtu = sl->mtu;
  633. dev->hard_start_xmit = sl_xmit;
  634. #ifdef SL_CHECK_TRANSMIT
  635. dev->tx_timeout = sl_tx_timeout;
  636. dev->watchdog_timeo = 20*HZ;
  637. #endif
  638. dev->open = sl_open;
  639. dev->stop = sl_close;
  640. dev->get_stats         = sl_get_stats;
  641. dev->change_mtu = sl_change_mtu;
  642. #ifdef CONFIG_SLIP_SMART
  643. dev->do_ioctl = sl_ioctl;
  644. #endif
  645. dev->hard_header_len = 0;
  646. dev->addr_len = 0;
  647. dev->type = ARPHRD_SLIP + sl->mode;
  648. dev->tx_queue_len = 10;
  650. SET_MODULE_OWNER(dev);
  652. /* New-style flags. */
  653. dev->flags = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST;
  655. return 0;
  656. }
  659. /******************************************
  660.   Routines looking at TTY side.
  661.  ******************************************/
  664. static int slip_receive_room(struct tty_struct *tty)
  665. {
  666. return 65536;  /* We can handle an infinite amount of data. :-) */
  667. }
  669. /*
  670.  * Handle the 'receiver data ready' interrupt.
  671.  * This function is called by the 'tty_io' module in the kernel when
  672.  * a block of SLIP data has been received, which can now be decapsulated
  673.  * and sent on to some IP layer for further processing.
  674.  */
  675.  
  676. static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
  677. {
  678. struct slip *sl = (struct slip *) tty->disc_data;
  680. if (!sl || sl->magic != SLIP_MAGIC ||
  681.     !netif_running(sl->dev))
  682. return;
  684. /* Read the characters out of the buffer */
  685. while (count--) {
  686. if (fp && *fp++) {
  687. if (!test_and_set_bit(SLF_ERROR, &sl->flags))  {
  688. sl->rx_errors++;
  689. }
  690. cp++;
  691. continue;
  692. }
  693. #ifdef CONFIG_SLIP_MODE_SLIP6
  694. if (sl->mode & SL_MODE_SLIP6)
  695. slip_unesc6(sl, *cp++);
  696. else
  697. #endif
  698. slip_unesc(sl, *cp++);
  699. }
  700. }
  702. /************************************
  703.  *  slip_open helper routines.
  704.  ************************************/
  706. /* Collect hanged up channels */
  708. static void sl_sync(void)
  709. {
  710. int i;
  712. for (i = 0; i < slip_maxdev; i++) {
  713. slip_ctrl_t *slp = slip_ctrls[i];
  714. if (slp == NULL)
  715. break;
  716. if (slp->ctrl.tty || slp->ctrl.leased)
  717. continue;
  718. if (slp->dev.flags&IFF_UP)
  719. dev_close(&slp->dev);
  720. }
  721. }
  723. /* Find a free SLIP channel, and link in this `tty' line. */
  724. static struct slip *
  725. sl_alloc(kdev_t line)
  726. {
  727. struct slip *sl;
  728. slip_ctrl_t *slp = NULL;
  729. int i;
  730. int sel = -1;
  731. int score = -1;
  733. if (slip_ctrls == NULL)
  734. return NULL; /* Master array missing ! */
  736. for (i = 0; i < slip_maxdev; i++) {
  737. slp = slip_ctrls[i];
  738. if (slp == NULL)
  739. break;
  741. if (slp->ctrl.leased) {
  742. if (slp->ctrl.line != line)
  743. continue;
  744. if (slp->ctrl.tty)
  745. return NULL;
  747. /* Clear ESCAPE & ERROR flags */
  748. slp->ctrl.flags &= (1 << SLF_INUSE);
  749. return &slp->ctrl;
  750. }
  752. if (slp->ctrl.tty)
  753. continue;
  755. if (current->pid == slp->ctrl.pid) {
  756. if (slp->ctrl.line == line && score < 3) {
  757. sel = i;
  758. score = 3;
  759. continue;
  760. }
  761. if (score < 2) {
  762. sel = i;
  763. score = 2;
  764. }
  765. continue;
  766. }
  767. if (slp->ctrl.line == line && score < 1) {
  768. sel = i;
  769. score = 1;
  770. continue;
  771. }
  772. if (score < 0) {
  773. sel = i;
  774. score = 0;
  775. }
  776. }
  778. if (sel >= 0) {
  779. i = sel;
  780. slp = slip_ctrls[i];
  781. if (score > 1) {
  782. slp->ctrl.flags &= (1 << SLF_INUSE);
  783. return &slp->ctrl;
  784. }
  785. }
  787. /* Sorry, too many, all slots in use */
  788. if (i >= slip_maxdev)
  789. return NULL;
  791. if (slp) {
  792. if (test_bit(SLF_INUSE, &slp->ctrl.flags)) {
  793. unregister_netdevice(&slp->dev);
  794. sl_free_bufs(&slp->ctrl);
  795. }
  796. } else if ((slp = (slip_ctrl_t *)kmalloc(sizeof(slip_ctrl_t),GFP_KERNEL)) == NULL)
  797. return NULL;
  799. memset(slp, 0, sizeof(slip_ctrl_t));
  801. sl = &slp->ctrl;
  802. /* Initialize channel control data */
  803. sl->magic       = SLIP_MAGIC;
  804. sl->dev        = &slp->dev;
  805. spin_lock_init(&sl->lock);
  806. sl->mode        = SL_MODE_DEFAULT;
  807. sprintf(slp->dev.name, "sl%d", i);
  808. slp->dev.base_addr    = i;
  809. slp->dev.priv         = (void*)sl;
  810. slp->dev.init         = sl_init;
  811. #ifdef CONFIG_SLIP_SMART
  812. init_timer(&sl->keepalive_timer); /* initialize timer_list struct */
  813. sl->keepalive_timer.data=(unsigned long)sl;
  814. sl->keepalive_timer.function=sl_keepalive;
  815. init_timer(&sl->outfill_timer);
  816. sl->outfill_timer.data=(unsigned long)sl;
  817. sl->outfill_timer.function=sl_outfill;
  818. #endif
  819. slip_ctrls[i]        = slp;
  820. return &slp->ctrl;
  821. }
  823. /*
  824.  * Open the high-level part of the SLIP channel.
  825.  * This function is called by the TTY module when the
  826.  * SLIP line discipline is called for.  Because we are
  827.  * sure the tty line exists, we only have to link it to
  828.  * a free SLIP channel...
  829.  */
  830. static int
  831. slip_open(struct tty_struct *tty)
  832. {
  833. struct slip *sl;
  834. int err;
  836. if(!capable(CAP_NET_ADMIN))
  837. return -EPERM;
  839. MOD_INC_USE_COUNT;
  841. /* RTnetlink lock is misused here to serialize concurrent
  842.    opens of slip channels. There are better ways, but it is
  843.    the simplest one.
  844.  */
  845. rtnl_lock();
  847. /* Collect hanged up channels. */
  848. sl_sync();
  850. sl = (struct slip *) tty->disc_data;
  852. err = -EEXIST;
  853. /* First make sure we're not already connected. */
  854. if (sl && sl->magic == SLIP_MAGIC)
  855. goto err_exit;
  857. /* OK.  Find a free SLIP channel to use. */
  858. err = -ENFILE;
  859. if ((sl = sl_alloc(tty->device)) == NULL)
  860. goto err_exit;
  862. sl->tty = tty;
  863. tty->disc_data = sl;
  864. sl->line = tty->device;
  865. sl->pid = current->pid;
  866. if (tty->driver.flush_buffer)
  867. tty->driver.flush_buffer(tty);
  868. if (tty->ldisc.flush_buffer)
  869. tty->ldisc.flush_buffer(tty);
  871. if (!test_bit(SLF_INUSE, &sl->flags)) {
  872. /* Perform the low-level SLIP initialization. */
  873. if ((err = sl_alloc_bufs(sl, SL_MTU)) != 0)
  874. goto err_free_chan;
  876. if (register_netdevice(sl->dev)) {
  877. sl_free_bufs(sl);
  878. goto err_free_chan;
  879. }
  881. set_bit(SLF_INUSE, &sl->flags);
  882. }
  884. #ifdef CONFIG_SLIP_SMART
  885. if (sl->keepalive) {
  886. sl->keepalive_timer.expires=jiffies+sl->keepalive*HZ;
  887. add_timer (&sl->keepalive_timer);
  888. }
  889. if (sl->outfill) {
  890. sl->outfill_timer.expires=jiffies+sl->outfill*HZ;
  891. add_timer (&sl->outfill_timer);
  892. }
  893. #endif
  895. /* Done.  We have linked the TTY line to a channel. */
  896. rtnl_unlock();
  897. return sl->dev->base_addr;
  899. err_free_chan:
  900. sl->tty = NULL;
  901. tty->disc_data = NULL;
  902. clear_bit(SLF_INUSE, &sl->flags);
  904. err_exit:
  905. rtnl_unlock();
  907. /* Count references from TTY module */
  908. MOD_DEC_USE_COUNT;
  909. return err;
  910. }
  912. /*
  913.    Let me to blame a bit.
  914.    1. TTY module calls this funstion on soft interrupt.
  915.    2. TTY module calls this function WITH MASKED INTERRUPTS!
  916.    3. TTY module does not notify us about line discipline
  917.       shutdown,
  919.    Seems, now it is clean. The solution is to consider netdevice and
  920.    line discipline sides as two independent threads.
  922.    By-product (not desired): sl? does not feel hangups and remains open.
  923.    It is supposed, that user level program (dip, diald, slattach...)
  924.    will catch SIGHUP and make the rest of work. 
  926.    I see no way to make more with current tty code. --ANK
  927.  */
  929. /*
  930.  * Close down a SLIP channel.
  931.  * This means flushing out any pending queues, and then restoring the
  932.  * TTY line discipline to what it was before it got hooked to SLIP
  933.  * (which usually is TTY again).
  934.  */
  935. static void
  936. slip_close(struct tty_struct *tty)
  937. {
  938. struct slip *sl = (struct slip *) tty->disc_data;
  940. /* First make sure we're connected. */
  941. if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
  942. return;
  944. tty->disc_data = 0;
  945. sl->tty = NULL;
  946. if (!sl->leased)
  947. sl->line = 0;
  949. /* VSV = very important to remove timers */
  950. #ifdef CONFIG_SLIP_SMART
  951. del_timer_sync(&sl->keepalive_timer);
  952. del_timer_sync(&sl->outfill_timer);
  953. #endif
  955. /* Count references from TTY module */
  956. MOD_DEC_USE_COUNT;
  957. }
  959.  /************************************************************************
  960.   * STANDARD SLIP ENCAPSULATION     *
  961.   ************************************************************************/
  963. int
  964. slip_esc(unsigned char *s, unsigned char *d, int len)
  965. {
  966. unsigned char *ptr = d;
  967. unsigned char c;
  969. /*
  970.  * Send an initial END character to flush out any
  971.  * data that may have accumulated in the receiver
  972.  * due to line noise.
  973.  */
  975. *ptr++ = END;
  977. /*
  978.  * For each byte in the packet, send the appropriate
  979.  * character sequence, according to the SLIP protocol.
  980.  */
  982. while (len-- > 0) {
  983. switch(c = *s++) {
  984.  case END:
  985. *ptr++ = ESC;
  986. *ptr++ = ESC_END;
  987. break;
  988.  case ESC:
  989. *ptr++ = ESC;
  990. *ptr++ = ESC_ESC;
  991. break;
  992.  default:
  993. *ptr++ = c;
  994. break;
  995. }
  996. }
  997. *ptr++ = END;
  998. return (ptr - d);
  999. }
  1001. static void slip_unesc(struct slip *sl, unsigned char s)
  1002. {
  1004. switch(s) {
  1005.  case END:
  1006. #ifdef CONFIG_SLIP_SMART
  1007. /* drop keeptest bit = VSV */
  1008. if (test_bit(SLF_KEEPTEST, &sl->flags))
  1009. clear_bit(SLF_KEEPTEST, &sl->flags);
  1010. #endif
  1012. if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2))  {
  1013. sl_bump(sl);
  1014. }
  1015. clear_bit(SLF_ESCAPE, &sl->flags);
  1016. sl->rcount = 0;
  1017. return;
  1019.  case ESC:
  1020. set_bit(SLF_ESCAPE, &sl->flags);
  1021. return;
  1022.  case ESC_ESC:
  1023. if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))  {
  1024. s = ESC;
  1025. }
  1026. break;
  1027.  case ESC_END:
  1028. if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))  {
  1029. s = END;
  1030. }
  1031. break;
  1032. }
  1033. if (!test_bit(SLF_ERROR, &sl->flags))  {
  1034. if (sl->rcount < sl->buffsize)  {
  1035. sl->rbuff[sl->rcount++] = s;
  1036. return;
  1037. }
  1038. sl->rx_over_errors++;
  1039. set_bit(SLF_ERROR, &sl->flags);
  1040. }
  1041. }
  1044. #ifdef CONFIG_SLIP_MODE_SLIP6
  1045. /************************************************************************
  1046.  *  6 BIT SLIP ENCAPSULATION *
  1047.  ************************************************************************/
  1049. int
  1050. slip_esc6(unsigned char *s, unsigned char *d, int len)
  1051. {
  1052. unsigned char *ptr = d;
  1053. unsigned char c;
  1054. int i;
  1055. unsigned short v = 0;
  1056. short bits = 0;
  1058. /*
  1059.  * Send an initial END character to flush out any
  1060.  * data that may have accumulated in the receiver
  1061.  * due to line noise.
  1062.  */
  1064. *ptr++ = 0x70;
  1066. /*
  1067.  * Encode the packet into printable ascii characters
  1068.  */
  1070. for (i = 0; i < len; ++i) {
  1071. v = (v << 8) | s[i];
  1072. bits += 8;
  1073. while (bits >= 6) {
  1074. bits -= 6;
  1075. c = 0x30 + ((v >> bits) & 0x3F);
  1076. *ptr++ = c;
  1077. }
  1078. }
  1079. if (bits) {
  1080. c = 0x30 + ((v << (6 - bits)) & 0x3F);
  1081. *ptr++ = c;
  1082. }
  1083. *ptr++ = 0x70;
  1084. return ptr - d;
  1085. }
  1087. void
  1088. slip_unesc6(struct slip *sl, unsigned char s)
  1089. {
  1090. unsigned char c;
  1092. if (s == 0x70) {
  1093. #ifdef CONFIG_SLIP_SMART
  1094. /* drop keeptest bit = VSV */
  1095. if (test_bit(SLF_KEEPTEST, &sl->flags))
  1096. clear_bit(SLF_KEEPTEST, &sl->flags);
  1097. #endif
  1099. if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2))  {
  1100. sl_bump(sl);
  1101. }
  1102. sl->rcount = 0;
  1103. sl->xbits = 0;
  1104. sl->xdata = 0;
  1105.   } else if (s >= 0x30 && s < 0x70) {
  1106. sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
  1107. sl->xbits += 6;
  1108. if (sl->xbits >= 8) {
  1109. sl->xbits -= 8;
  1110. c = (unsigned char)(sl->xdata >> sl->xbits);
  1111. if (!test_bit(SLF_ERROR, &sl->flags))  {
  1112. if (sl->rcount < sl->buffsize)  {
  1113. sl->rbuff[sl->rcount++] = c;
  1114. return;
  1115. }
  1116. sl->rx_over_errors++;
  1117. set_bit(SLF_ERROR, &sl->flags);
  1118. }
  1119. }
  1120.   }
  1121. }
  1122. #endif /* CONFIG_SLIP_MODE_SLIP6 */
  1124. /* Perform I/O control on an active SLIP channel. */
  1125. static int
  1126. slip_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
  1127. {
  1128. struct slip *sl = (struct slip *) tty->disc_data;
  1129. unsigned int tmp;
  1131. /* First make sure we're connected. */
  1132. if (!sl || sl->magic != SLIP_MAGIC) {
  1133. return -EINVAL;
  1134. }
  1136. switch(cmd) {
  1137.  case SIOCGIFNAME:
  1138. /* Please, do not put this line under copy_to_user,
  1139.    it breaks my old poor gcc on alpha --ANK
  1140.  */
  1141. tmp = strlen(sl->dev->name) + 1;
  1142. if (copy_to_user(arg, sl->dev->name, tmp))
  1143. return -EFAULT;
  1144. return 0;
  1146. case SIOCGIFENCAP:
  1147. if (put_user(sl->mode, (int *)arg))
  1148. return -EFAULT;
  1149. return 0;
  1151. case SIOCSIFENCAP:
  1152. if (get_user(tmp,(int *)arg))
  1153. return -EFAULT;
  1154. #ifndef SL_INCLUDE_CSLIP
  1155. if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))  {
  1156. return -EINVAL;
  1157. }
  1158. #else
  1159. if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
  1160.     (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))  {
  1161. /* return -EINVAL; */
  1162. tmp &= ~SL_MODE_ADAPTIVE;
  1163. }
  1164. #endif
  1165. #ifndef CONFIG_SLIP_MODE_SLIP6
  1166. if (tmp & SL_MODE_SLIP6)  {
  1167. return -EINVAL;
  1168. }
  1169. #endif
  1170. sl->mode = tmp;
  1171. sl->dev->type = ARPHRD_SLIP+sl->mode;
  1172. return 0;
  1174.  case SIOCSIFHWADDR:
  1175. return -EINVAL;
  1177. #ifdef CONFIG_SLIP_SMART
  1178. /* VSV changes start here */
  1179.         case SIOCSKEEPALIVE:
  1180. if (get_user(tmp,(int *)arg))
  1181. return -EFAULT;
  1182.                 if (tmp > 255) /* max for unchar */
  1183. return -EINVAL;
  1185. spin_lock_bh(&sl->lock);
  1186. if (!sl->tty) {
  1187. spin_unlock_bh(&sl->lock);
  1188. return -ENODEV;
  1189. }
  1190. if ((sl->keepalive = (unchar) tmp) != 0) {
  1191. mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
  1192. set_bit(SLF_KEEPTEST, &sl->flags);
  1193.                 } else {
  1194.                         del_timer (&sl->keepalive_timer);
  1195. }
  1196. spin_unlock_bh(&sl->lock);
  1197. return 0;
  1199.         case SIOCGKEEPALIVE:
  1200. if (put_user(sl->keepalive, (int *)arg))
  1201. return -EFAULT;
  1202. return 0;
  1204.         case SIOCSOUTFILL:
  1205. if (get_user(tmp,(int *)arg))
  1206. return -EFAULT;
  1207.                 if (tmp > 255) /* max for unchar */
  1208. return -EINVAL;
  1209. spin_lock_bh(&sl->lock);
  1210. if (!sl->tty) {
  1211. spin_unlock_bh(&sl->lock);
  1212. return -ENODEV;
  1213. }
  1214.                 if ((sl->outfill = (unchar) tmp) != 0){
  1215. mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
  1216. set_bit(SLF_OUTWAIT, &sl->flags);
  1217. } else {
  1218.                         del_timer (&sl->outfill_timer);
  1219. }
  1220. spin_unlock_bh(&sl->lock);
  1221.                 return 0;
  1223.         case SIOCGOUTFILL:
  1224. if (put_user(sl->outfill, (int *)arg))
  1225. return -EFAULT;
  1226. return 0;
  1227. /* VSV changes end */
  1228. #endif
  1230. /* Allow stty to read, but not set, the serial port */
  1231. case TCGETS:
  1232. case TCGETA:
  1233. return n_tty_ioctl(tty, (struct file *) file, cmd, (unsigned long) arg);
  1235. default:
  1236. return -ENOIOCTLCMD;
  1237. }
  1238. }
  1240. /* VSV changes start here */
  1241. #ifdef CONFIG_SLIP_SMART
  1242. /* function do_ioctl called from net/core/dev.c
  1243.    to allow get/set outfill/keepalive parameter
  1244.    by ifconfig                                 */
  1246. static int sl_ioctl(struct net_device *dev,struct ifreq *rq,int cmd)
  1247. {
  1248. struct slip *sl = (struct slip*)(dev->priv);
  1250. if (sl == NULL) /* Allocation failed ?? */
  1251. return -ENODEV;
  1253. spin_lock_bh(&sl->lock);
  1255. if (!sl->tty) {
  1256. spin_unlock_bh(&sl->lock);
  1257. return -ENODEV;
  1258. }
  1260. switch(cmd){
  1261.         case SIOCSKEEPALIVE:
  1262. /* max for unchar */
  1263.                 if (((unsigned int)((unsigned long)rq->ifr_data)) > 255) {
  1264. spin_unlock_bh(&sl->lock);
  1265. return -EINVAL;
  1266. }
  1267. sl->keepalive = (unchar) ((unsigned long)rq->ifr_data);
  1268. if (sl->keepalive != 0) {
  1269. sl->keepalive_timer.expires=jiffies+sl->keepalive*HZ;
  1270. mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
  1271. set_bit(SLF_KEEPTEST, &sl->flags);
  1272.                 } else {
  1273.                         del_timer(&sl->keepalive_timer);
  1274. }
  1275. break;
  1277.         case SIOCGKEEPALIVE:
  1278. rq->ifr_data=(caddr_t)((unsigned long)sl->keepalive);
  1279. break;
  1281.         case SIOCSOUTFILL:
  1282.                 if (((unsigned)((unsigned long)rq->ifr_data)) > 255) { /* max for unchar */
  1283. spin_unlock_bh(&sl->lock);
  1284. return -EINVAL;
  1285. }
  1286.                 if ((sl->outfill = (unchar)((unsigned long) rq->ifr_data)) != 0){
  1287. mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
  1288. set_bit(SLF_OUTWAIT, &sl->flags);
  1289. } else {
  1290.                         del_timer (&sl->outfill_timer);
  1291. }
  1292.                 break;
  1294.         case SIOCGOUTFILL:
  1295. rq->ifr_data=(caddr_t)((unsigned long)sl->outfill);
  1296. break;
  1298.         case SIOCSLEASE:
  1299. /* Resolve race condition, when ioctl'ing hanged up 
  1300.    and opened by another process device.
  1301.  */
  1302. if (sl->tty != current->tty && sl->pid != current->pid) {
  1303. spin_unlock_bh(&sl->lock);
  1304. return -EPERM;
  1305. }
  1306. sl->leased = 0;
  1307.                 if ((unsigned long)rq->ifr_data)
  1308. sl->leased = 1;
  1309.                 break;
  1311.         case SIOCGLEASE:
  1312. rq->ifr_data=(caddr_t)((unsigned long)sl->leased);
  1313. };
  1314. spin_unlock_bh(&sl->lock);
  1315. return 0;
  1316. }
  1317. #endif
  1318. /* VSV changes end */
  1320. /* Initialize SLIP control device -- register SLIP line discipline */
  1322. int __init slip_init_ctrl_dev(void)
  1323. {
  1324. int status;
  1326. if (slip_maxdev < 4) slip_maxdev = 4; /* Sanity */
  1328. printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
  1329. #ifdef CONFIG_SLIP_MODE_SLIP6
  1330.        " (6 bit encapsulation enabled)"
  1331. #endif
  1332.        ".n",
  1333.        SLIP_VERSION, slip_maxdev );
  1334. #if defined(SL_INCLUDE_CSLIP) && !defined(MODULE)
  1335. printk("CSLIP: code copyright 1989 Regents of the University of California.n");
  1336. #endif
  1337. #ifdef CONFIG_SLIP_SMART
  1338. printk(KERN_INFO "SLIP linefill/keepalive option.n");
  1339. #endif
  1341. slip_ctrls = (slip_ctrl_t **) kmalloc(sizeof(void*)*slip_maxdev, GFP_KERNEL);
  1342. if (slip_ctrls == NULL)
  1343. {
  1344. printk("SLIP: Can't allocate slip_ctrls[] array!  Uaargh! (-> No SLIP available)n");
  1345. return -ENOMEM;
  1346. }
  1348. /* Clear the pointer array, we allocate devices when we need them */
  1349. memset(slip_ctrls, 0, sizeof(void*)*slip_maxdev); /* Pointers */
  1351. /* Fill in our line protocol discipline, and register it */
  1352. memset(&sl_ldisc, 0, sizeof(sl_ldisc));
  1353. sl_ldisc.magic  = TTY_LDISC_MAGIC;
  1354. sl_ldisc.name   = "slip";
  1355. sl_ldisc.flags  = 0;
  1356. sl_ldisc.open   = slip_open;
  1357. sl_ldisc.close  = slip_close;
  1358. sl_ldisc.read   = NULL;
  1359. sl_ldisc.write  = NULL;
  1360. sl_ldisc.ioctl  = (int (*)(struct tty_struct *, struct file *,
  1361.    unsigned int, unsigned long)) slip_ioctl;
  1362. sl_ldisc.poll   = NULL;
  1363. sl_ldisc.receive_buf = slip_receive_buf;
  1364. sl_ldisc.receive_room = slip_receive_room;
  1365. sl_ldisc.write_wakeup = slip_write_wakeup;
  1366. if ((status = tty_register_ldisc(N_SLIP, &sl_ldisc)) != 0)  {
  1367. printk("SLIP: can't register line discipline (err = %d)n", status);
  1368. }
  1371. return status;
  1372. }
  1376. #ifdef MODULE
  1378. int
  1379. init_module(void)
  1380. {
  1381. return slip_init_ctrl_dev();
  1382. }
  1384. void
  1385. cleanup_module(void)
  1386. {
  1387. int i;
  1389. if (slip_ctrls != NULL) {
  1390. unsigned long timeout = jiffies + HZ;
  1391. int busy = 0;
  1393. /* First of all: check for active disciplines and hangup them.
  1394.  */
  1395. do {
  1396. if (busy)
  1397. yield();
  1399. busy = 0;
  1400. local_bh_disable();
  1401. for (i = 0; i < slip_maxdev; i++) {
  1402. struct slip_ctrl *slc = slip_ctrls[i];
  1403. if (!slc)
  1404. continue;
  1405. spin_lock(&slc->ctrl.lock);
  1406. if (slc->ctrl.tty) {
  1407. busy++;
  1408. tty_hangup(slc->ctrl.tty);
  1409. }
  1410. spin_unlock(&slc->ctrl.lock);
  1411. }
  1412. local_bh_enable();
  1413. } while (busy && time_before(jiffies, timeout));
  1415. busy = 0;
  1416. for (i = 0; i < slip_maxdev; i++) {
  1417. struct slip_ctrl *slc = slip_ctrls[i];
  1418. if (slc) {
  1419. unregister_netdev(&slc->dev);
  1420. if (slc->ctrl.tty) {
  1421. printk("%s: tty discipline is still runningn", slc->dev.name);
  1422. /* Pin module forever */
  1423. MOD_INC_USE_COUNT;
  1424. busy++;
  1425. continue;
  1426. }
  1427. sl_free_bufs(&slc->ctrl);
  1428. kfree(slc);
  1429. slip_ctrls[i] = NULL;
  1430. }
  1431. }
  1432. if (!busy) {
  1433. kfree(slip_ctrls);
  1434. slip_ctrls = NULL;
  1435. }
  1436. }
  1437. if ((i = tty_register_ldisc(N_SLIP, NULL)))
  1438. {
  1439. printk("SLIP: can't unregister line discipline (err = %d)n", i);
  1440. }
  1441. }
  1442. #endif /* MODULE */
  1444. #ifdef CONFIG_SLIP_SMART
  1445. /*
  1446.  * This is start of the code for multislip style line checking
  1447.  * added by Stanislav Voronyi. All changes before marked VSV
  1448.  */
  1450. static void sl_outfill(unsigned long sls)
  1451. {
  1452. struct slip *sl=(struct slip *)sls;
  1454. spin_lock(&sl->lock);
  1456. if (sl->tty == NULL)
  1457. goto out;
  1459. if(sl->outfill)
  1460. {
  1461. if( test_bit(SLF_OUTWAIT, &sl->flags) )
  1462. {
  1463. /* no packets were transmitted, do outfill */
  1464. #ifdef CONFIG_SLIP_MODE_SLIP6
  1465. unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
  1466. #else
  1467. unsigned char s = END;
  1468. #endif
  1469. /* put END into tty queue. Is it right ??? */
  1470. if (!netif_queue_stopped(sl->dev))
  1471. {
  1472. /* if device busy no outfill */
  1473. sl->tty->driver.write(sl->tty, 0, &s, 1);
  1474. }
  1475. }
  1476. else
  1477. set_bit(SLF_OUTWAIT, &sl->flags);
  1479. mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
  1480. }
  1481. out:
  1482. spin_unlock(&sl->lock);
  1483. }
  1485. static void sl_keepalive(unsigned long sls)
  1486. {
  1487. struct slip *sl=(struct slip *)sls;
  1489. spin_lock(&sl->lock);
  1491. if (sl->tty == NULL)
  1492. goto out;
  1494. if( sl->keepalive)
  1495. {
  1496. if(test_bit(SLF_KEEPTEST, &sl->flags))
  1497. {
  1498. /* keepalive still high :(, we must hangup */
  1499. if( sl->outfill ) /* outfill timer must be deleted too */
  1500. (void)del_timer(&sl->outfill_timer);
  1501. printk("%s: no packets received during keepalive timeout, hangup.n", sl->dev->name);
  1502. tty_hangup(sl->tty); /* this must hangup tty & close slip */
  1503. /* I think we need not something else */
  1504. goto out;
  1505. }
  1506. else
  1507. set_bit(SLF_KEEPTEST, &sl->flags);
  1509. mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
  1510. }
  1512. out:
  1513. spin_unlock(&sl->lock);
  1514. }
  1516. #endif
  1517. MODULE_LICENSE("GPL");