blob: fa434fb8fb7c087df16bacaf9108dfa3646e35db [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Alan Cox9ce6cf22007-11-19 15:03:38 +000014 * Alan Cox : Found cause of overrun. ifconfig sl0
15 * mtu upwards. Driver now spots this
16 * and grows/shrinks its buffers(hack!).
17 * Memory leak if you run out of memory
18 * setting up a slip driver fixed.
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * Matt Dillon : Printable slip (borrowed from NET2E)
20 * Pauline Middelink : Slip driver fixes.
21 * Alan Cox : Honours the old SL_COMPRESSED flag
22 * Alan Cox : KISS AX.25 and AXUI IP support
23 * Michael Riepe : Automatic CSLIP recognition added
24 * Charles Hedrick : CSLIP header length problem fix.
25 * Alan Cox : Corrected non-IP cases of the above.
26 * Alan Cox : Now uses hardware type as per FvK.
27 * Alan Cox : Default to 192.168.0.0 (RFC 1597)
28 * A.N.Kuznetsov : dev_tint() recursion fix.
29 * Dmitry Gorodchanin : SLIP memory leaks
30 * Dmitry Gorodchanin : Code cleanup. Reduce tty driver
31 * buffering from 4096 to 256 bytes.
32 * Improving SLIP response time.
33 * CONFIG_SLIP_MODE_SLIP6.
Alan Cox9ce6cf22007-11-19 15:03:38 +000034 * ifconfig sl? up & down now works
35 * correctly.
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 * Modularization.
37 * Alan Cox : Oops - fix AX.25 buffer lengths
38 * Dmitry Gorodchanin : Even more cleanups. Preserve CSLIP
39 * statistics. Include CSLIP code only
40 * if it really needed.
41 * Alan Cox : Free slhc buffers in the right place.
42 * Alan Cox : Allow for digipeated IP over AX.25
43 * Matti Aarnio : Dynamic SLIP devices, with ideas taken
44 * from Jim Freeman's <jfree@caldera.com>
45 * dynamic PPP devices. We do NOT kfree()
46 * device entries, just reg./unreg. them
47 * as they are needed. We kfree() them
48 * at module cleanup.
Alan Cox9ce6cf22007-11-19 15:03:38 +000049 * With MODULE-loading ``insmod'', user
50 * can issue parameter: slip_maxdev=1024
51 * (Or how much he/she wants.. Default
52 * is 256)
53 * Stanislav Voronyi : Slip line checking, with ideas taken
54 * from multislip BSDI driver which was
55 * written by Igor Chechik, RELCOM Corp.
56 * Only algorithms have been ported to
57 * Linux SLIP driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 * Vitaly E. Lavrov : Sane behaviour on tty hangup.
Alan Cox9ce6cf22007-11-19 15:03:38 +000059 * Alexey Kuznetsov : Cleanup interfaces to tty & netdevice
60 * modules.
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 */
62
63#define SL_CHECK_TRANSMIT
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <linux/module.h>
65#include <linux/moduleparam.h>
66
67#include <asm/system.h>
68#include <asm/uaccess.h>
69#include <linux/bitops.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040070#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <linux/string.h>
72#include <linux/mm.h>
73#include <linux/interrupt.h>
74#include <linux/in.h>
75#include <linux/tty.h>
76#include <linux/errno.h>
77#include <linux/netdevice.h>
78#include <linux/etherdevice.h>
79#include <linux/skbuff.h>
80#include <linux/rtnetlink.h>
81#include <linux/if_arp.h>
82#include <linux/if_slip.h>
Arnd Bergmann9646e7c2009-11-06 22:51:16 -080083#include <linux/compat.h>
David S. Miller12dc2fd2005-06-28 16:27:32 -070084#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090086#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070087#include "slip.h"
88#ifdef CONFIG_INET
89#include <linux/ip.h>
90#include <linux/tcp.h>
91#include <net/slhc_vj.h>
92#endif
93
94#define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
95
96static struct net_device **slip_devs;
97
98static int slip_maxdev = SL_NRUNIT;
99module_param(slip_maxdev, int, 0);
100MODULE_PARM_DESC(slip_maxdev, "Maximum number of slip devices");
101
102static int slip_esc(unsigned char *p, unsigned char *d, int len);
103static void slip_unesc(struct slip *sl, unsigned char c);
104#ifdef CONFIG_SLIP_MODE_SLIP6
105static int slip_esc6(unsigned char *p, unsigned char *d, int len);
106static void slip_unesc6(struct slip *sl, unsigned char c);
107#endif
108#ifdef CONFIG_SLIP_SMART
109static void sl_keepalive(unsigned long sls);
110static void sl_outfill(unsigned long sls);
Alan Cox9ce6cf22007-11-19 15:03:38 +0000111static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112#endif
113
114/********************************
115* Buffer administration routines:
116* sl_alloc_bufs()
117* sl_free_bufs()
118* sl_realloc_bufs()
119*
120* NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
121* sl_realloc_bufs provides strong atomicity and reallocation
122* on actively running device.
123*********************************/
124
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400125/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 Allocate channel buffers.
127 */
128
Alan Cox9ce6cf22007-11-19 15:03:38 +0000129static int sl_alloc_bufs(struct slip *sl, int mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
131 int err = -ENOBUFS;
132 unsigned long len;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000133 char *rbuff = NULL;
134 char *xbuff = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135#ifdef SL_INCLUDE_CSLIP
Alan Cox9ce6cf22007-11-19 15:03:38 +0000136 char *cbuff = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct slcompress *slcomp = NULL;
138#endif
139
140 /*
141 * Allocate the SLIP frame buffers:
142 *
143 * rbuff Receive buffer.
144 * xbuff Transmit buffer.
145 * cbuff Temporary compression buffer.
146 */
147 len = mtu * 2;
148
149 /*
150 * allow for arrival of larger UDP packets, even if we say not to
151 * also fixes a bug in which SunOS sends 512-byte packets even with
152 * an MSS of 128
153 */
154 if (len < 576 * 2)
155 len = 576 * 2;
156 rbuff = kmalloc(len + 4, GFP_KERNEL);
157 if (rbuff == NULL)
158 goto err_exit;
159 xbuff = kmalloc(len + 4, GFP_KERNEL);
160 if (xbuff == NULL)
161 goto err_exit;
162#ifdef SL_INCLUDE_CSLIP
163 cbuff = kmalloc(len + 4, GFP_KERNEL);
164 if (cbuff == NULL)
165 goto err_exit;
166 slcomp = slhc_init(16, 16);
167 if (slcomp == NULL)
168 goto err_exit;
169#endif
170 spin_lock_bh(&sl->lock);
171 if (sl->tty == NULL) {
172 spin_unlock_bh(&sl->lock);
173 err = -ENODEV;
174 goto err_exit;
175 }
176 sl->mtu = mtu;
177 sl->buffsize = len;
178 sl->rcount = 0;
179 sl->xleft = 0;
180 rbuff = xchg(&sl->rbuff, rbuff);
181 xbuff = xchg(&sl->xbuff, xbuff);
182#ifdef SL_INCLUDE_CSLIP
183 cbuff = xchg(&sl->cbuff, cbuff);
184 slcomp = xchg(&sl->slcomp, slcomp);
185#ifdef CONFIG_SLIP_MODE_SLIP6
186 sl->xdata = 0;
187 sl->xbits = 0;
188#endif
189#endif
190 spin_unlock_bh(&sl->lock);
191 err = 0;
192
193 /* Cleanup */
194err_exit:
195#ifdef SL_INCLUDE_CSLIP
Jesper Juhl158a0e42005-04-24 18:59:30 -0700196 kfree(cbuff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (slcomp)
198 slhc_free(slcomp);
199#endif
Jesper Juhl158a0e42005-04-24 18:59:30 -0700200 kfree(xbuff);
201 kfree(rbuff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return err;
203}
204
205/* Free a SLIP channel buffers. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000206static void sl_free_bufs(struct slip *sl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 /* Free all SLIP frame buffers. */
Jesper Juhl9b200b02005-06-23 21:06:56 -0700209 kfree(xchg(&sl->rbuff, NULL));
210 kfree(xchg(&sl->xbuff, NULL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211#ifdef SL_INCLUDE_CSLIP
Jesper Juhl9b200b02005-06-23 21:06:56 -0700212 kfree(xchg(&sl->cbuff, NULL));
213 slhc_free(xchg(&sl->slcomp, NULL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214#endif
215}
216
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400217/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 Reallocate slip channel buffers.
219 */
220
221static int sl_realloc_bufs(struct slip *sl, int mtu)
222{
223 int err = 0;
224 struct net_device *dev = sl->dev;
225 unsigned char *xbuff, *rbuff;
226#ifdef SL_INCLUDE_CSLIP
227 unsigned char *cbuff;
228#endif
229 int len = mtu * 2;
230
231/*
232 * allow for arrival of larger UDP packets, even if we say not to
233 * also fixes a bug in which SunOS sends 512-byte packets even with
234 * an MSS of 128
235 */
236 if (len < 576 * 2)
237 len = 576 * 2;
238
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800239 xbuff = kmalloc(len + 4, GFP_ATOMIC);
240 rbuff = kmalloc(len + 4, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241#ifdef SL_INCLUDE_CSLIP
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800242 cbuff = kmalloc(len + 4, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243#endif
244
245
246#ifdef SL_INCLUDE_CSLIP
247 if (xbuff == NULL || rbuff == NULL || cbuff == NULL) {
248#else
249 if (xbuff == NULL || rbuff == NULL) {
250#endif
251 if (mtu >= sl->mtu) {
252 printk(KERN_WARNING "%s: unable to grow slip buffers, MTU change cancelled.\n",
253 dev->name);
254 err = -ENOBUFS;
255 }
256 goto done;
257 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 spin_lock_bh(&sl->lock);
259
260 err = -ENODEV;
261 if (sl->tty == NULL)
262 goto done_on_bh;
263
264 xbuff = xchg(&sl->xbuff, xbuff);
265 rbuff = xchg(&sl->rbuff, rbuff);
266#ifdef SL_INCLUDE_CSLIP
267 cbuff = xchg(&sl->cbuff, cbuff);
268#endif
269 if (sl->xleft) {
270 if (sl->xleft <= len) {
271 memcpy(sl->xbuff, sl->xhead, sl->xleft);
272 } else {
273 sl->xleft = 0;
274 sl->tx_dropped++;
275 }
276 }
277 sl->xhead = sl->xbuff;
278
279 if (sl->rcount) {
280 if (sl->rcount <= len) {
281 memcpy(sl->rbuff, rbuff, sl->rcount);
282 } else {
283 sl->rcount = 0;
284 sl->rx_over_errors++;
285 set_bit(SLF_ERROR, &sl->flags);
286 }
287 }
288 sl->mtu = mtu;
289 dev->mtu = mtu;
290 sl->buffsize = len;
291 err = 0;
292
293done_on_bh:
294 spin_unlock_bh(&sl->lock);
295
296done:
Jesper Juhl158a0e42005-04-24 18:59:30 -0700297 kfree(xbuff);
298 kfree(rbuff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299#ifdef SL_INCLUDE_CSLIP
Jesper Juhl158a0e42005-04-24 18:59:30 -0700300 kfree(cbuff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301#endif
302 return err;
303}
304
305
306/* Set the "sending" flag. This must be atomic hence the set_bit. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000307static inline void sl_lock(struct slip *sl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
309 netif_stop_queue(sl->dev);
310}
311
312
313/* Clear the "sending" flag. This must be atomic, hence the ASM. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000314static inline void sl_unlock(struct slip *sl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
316 netif_wake_queue(sl->dev);
317}
318
319/* Send one completely decapsulated IP datagram to the IP layer. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000320static void sl_bump(struct slip *sl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321{
322 struct sk_buff *skb;
323 int count;
324
325 count = sl->rcount;
326#ifdef SL_INCLUDE_CSLIP
327 if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
Alan Cox9ce6cf22007-11-19 15:03:38 +0000328 unsigned char c = sl->rbuff[0];
329 if (c & SL_TYPE_COMPRESSED_TCP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 /* ignore compressed packets when CSLIP is off */
331 if (!(sl->mode & SL_MODE_CSLIP)) {
332 printk(KERN_WARNING "%s: compressed packet ignored\n", sl->dev->name);
333 return;
334 }
Alan Cox9ce6cf22007-11-19 15:03:38 +0000335 /* make sure we've reserved enough space for uncompress
336 to use */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 if (count + 80 > sl->buffsize) {
338 sl->rx_over_errors++;
339 return;
340 }
341 count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
Alan Cox9ce6cf22007-11-19 15:03:38 +0000342 if (count <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 } else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
345 if (!(sl->mode & SL_MODE_CSLIP)) {
346 /* turn on header compression */
347 sl->mode |= SL_MODE_CSLIP;
348 sl->mode &= ~SL_MODE_ADAPTIVE;
349 printk(KERN_INFO "%s: header compression turned on\n", sl->dev->name);
350 }
351 sl->rbuff[0] &= 0x4f;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000352 if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
355 }
356#endif /* SL_INCLUDE_CSLIP */
357
Alan Cox9ce6cf22007-11-19 15:03:38 +0000358 sl->rx_bytes += count;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 skb = dev_alloc_skb(count);
Alan Cox9ce6cf22007-11-19 15:03:38 +0000361 if (skb == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 printk(KERN_WARNING "%s: memory squeeze, dropping packet.\n", sl->dev->name);
363 sl->rx_dropped++;
364 return;
365 }
366 skb->dev = sl->dev;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000367 memcpy(skb_put(skb, count), sl->rbuff, count);
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700368 skb_reset_mac_header(skb);
Alan Cox9ce6cf22007-11-19 15:03:38 +0000369 skb->protocol = htons(ETH_P_IP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 netif_rx(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 sl->rx_packets++;
372}
373
374/* Encapsulate one IP datagram and stuff into a TTY queue. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000375static void sl_encaps(struct slip *sl, unsigned char *icp, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376{
377 unsigned char *p;
378 int actual, count;
379
380 if (len > sl->mtu) { /* Sigh, shouldn't occur BUT ... */
381 printk(KERN_WARNING "%s: truncating oversized transmit packet!\n", sl->dev->name);
382 sl->tx_dropped++;
383 sl_unlock(sl);
384 return;
385 }
386
387 p = icp;
388#ifdef SL_INCLUDE_CSLIP
Alan Cox9ce6cf22007-11-19 15:03:38 +0000389 if (sl->mode & SL_MODE_CSLIP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391#endif
392#ifdef CONFIG_SLIP_MODE_SLIP6
Alan Cox9ce6cf22007-11-19 15:03:38 +0000393 if (sl->mode & SL_MODE_SLIP6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 count = slip_esc6(p, (unsigned char *) sl->xbuff, len);
395 else
396#endif
397 count = slip_esc(p, (unsigned char *) sl->xbuff, len);
398
399 /* Order of next two lines is *very* important.
400 * When we are sending a little amount of data,
Alan Coxf34d7a52008-04-30 00:54:13 -0700401 * the transfer may be completed inside the ops->write()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 * routine, because it's running with interrupts enabled.
403 * In this case we *never* got WRITE_WAKEUP event,
404 * if we did not request it before write operation.
405 * 14 Oct 1994 Dmitry Gorodchanin.
406 */
Alan Cox8a1ec212008-12-05 22:31:52 -0800407 set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700408 actual = sl->tty->ops->write(sl->tty, sl->xbuff, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409#ifdef SL_CHECK_TRANSMIT
410 sl->dev->trans_start = jiffies;
411#endif
412 sl->xleft = count - actual;
413 sl->xhead = sl->xbuff + actual;
414#ifdef CONFIG_SLIP_SMART
415 /* VSV */
416 clear_bit(SLF_OUTWAIT, &sl->flags); /* reset outfill flag */
417#endif
418}
419
420/*
421 * Called by the driver when there's room for more data. If we have
422 * more packets to send, we send them here.
423 */
424static void slip_write_wakeup(struct tty_struct *tty)
425{
426 int actual;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000427 struct slip *sl = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
429 /* First make sure we're connected. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000430 if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 if (sl->xleft <= 0) {
434 /* Now serial buffer is almost free & we can start
435 * transmission of another packet */
436 sl->tx_packets++;
Alan Cox8a1ec212008-12-05 22:31:52 -0800437 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 sl_unlock(sl);
439 return;
440 }
441
Alan Coxf34d7a52008-04-30 00:54:13 -0700442 actual = tty->ops->write(tty, sl->xhead, sl->xleft);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 sl->xleft -= actual;
444 sl->xhead += actual;
445}
446
447static void sl_tx_timeout(struct net_device *dev)
448{
449 struct slip *sl = netdev_priv(dev);
450
451 spin_lock(&sl->lock);
452
453 if (netif_queue_stopped(dev)) {
454 if (!netif_running(dev))
455 goto out;
456
457 /* May be we must check transmitter timeout here ?
458 * 14 Oct 1994 Dmitry Gorodchanin.
459 */
460#ifdef SL_CHECK_TRANSMIT
Eric Dumazet1ae5dc32010-05-10 05:01:31 -0700461 if (time_before(jiffies, dev_trans_start(dev) + 20 * HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 /* 20 sec timeout not reached */
463 goto out;
464 }
Alan Cox9ce6cf22007-11-19 15:03:38 +0000465 printk(KERN_WARNING "%s: transmit timed out, %s?\n",
466 dev->name,
Alan Coxf34d7a52008-04-30 00:54:13 -0700467 (tty_chars_in_buffer(sl->tty) || sl->xleft) ?
Alan Cox9ce6cf22007-11-19 15:03:38 +0000468 "bad line quality" : "driver error");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 sl->xleft = 0;
Alan Cox8a1ec212008-12-05 22:31:52 -0800470 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 sl_unlock(sl);
472#endif
473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474out:
475 spin_unlock(&sl->lock);
476}
477
478
479/* Encapsulate an IP datagram and kick it into a TTY queue. */
Stephen Hemminger424efe92009-08-31 19:50:51 +0000480static netdev_tx_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481sl_xmit(struct sk_buff *skb, struct net_device *dev)
482{
483 struct slip *sl = netdev_priv(dev);
484
485 spin_lock(&sl->lock);
Alan Cox9ce6cf22007-11-19 15:03:38 +0000486 if (!netif_running(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 spin_unlock(&sl->lock);
488 printk(KERN_WARNING "%s: xmit call when iface is down\n", dev->name);
489 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000490 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
492 if (sl->tty == NULL) {
493 spin_unlock(&sl->lock);
494 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000495 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 }
497
498 sl_lock(sl);
Alan Cox9ce6cf22007-11-19 15:03:38 +0000499 sl->tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 sl_encaps(sl, skb->data, skb->len);
501 spin_unlock(&sl->lock);
502
503 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000504 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505}
506
507
508/******************************************
509 * Routines looking at netdevice side.
510 ******************************************/
511
512/* Netdevice UP -> DOWN routine */
513
514static int
515sl_close(struct net_device *dev)
516{
517 struct slip *sl = netdev_priv(dev);
518
519 spin_lock_bh(&sl->lock);
Alan Cox8a1ec212008-12-05 22:31:52 -0800520 if (sl->tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 /* TTY discipline is running. */
Alan Cox8a1ec212008-12-05 22:31:52 -0800522 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 netif_stop_queue(dev);
524 sl->rcount = 0;
525 sl->xleft = 0;
526 spin_unlock_bh(&sl->lock);
527
528 return 0;
529}
530
531/* Netdevice DOWN -> UP routine */
532
533static int sl_open(struct net_device *dev)
534{
535 struct slip *sl = netdev_priv(dev);
536
Alan Cox9ce6cf22007-11-19 15:03:38 +0000537 if (sl->tty == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 return -ENODEV;
539
540 sl->flags &= (1 << SLF_INUSE);
541 netif_start_queue(dev);
542 return 0;
543}
544
545/* Netdevice change MTU request */
546
547static int sl_change_mtu(struct net_device *dev, int new_mtu)
548{
549 struct slip *sl = netdev_priv(dev);
550
551 if (new_mtu < 68 || new_mtu > 65534)
552 return -EINVAL;
553
554 if (new_mtu != dev->mtu)
555 return sl_realloc_bufs(sl, new_mtu);
556 return 0;
557}
558
559/* Netdevice get statistics request */
560
561static struct net_device_stats *
562sl_get_stats(struct net_device *dev)
563{
564 static struct net_device_stats stats;
565 struct slip *sl = netdev_priv(dev);
566#ifdef SL_INCLUDE_CSLIP
567 struct slcompress *comp;
568#endif
569
570 memset(&stats, 0, sizeof(struct net_device_stats));
571
572 stats.rx_packets = sl->rx_packets;
573 stats.tx_packets = sl->tx_packets;
574 stats.rx_bytes = sl->rx_bytes;
575 stats.tx_bytes = sl->tx_bytes;
576 stats.rx_dropped = sl->rx_dropped;
577 stats.tx_dropped = sl->tx_dropped;
578 stats.tx_errors = sl->tx_errors;
579 stats.rx_errors = sl->rx_errors;
580 stats.rx_over_errors = sl->rx_over_errors;
581#ifdef SL_INCLUDE_CSLIP
582 stats.rx_fifo_errors = sl->rx_compressed;
583 stats.tx_fifo_errors = sl->tx_compressed;
584 stats.collisions = sl->tx_misses;
585 comp = sl->slcomp;
586 if (comp) {
587 stats.rx_fifo_errors += comp->sls_i_compressed;
588 stats.rx_dropped += comp->sls_i_tossed;
589 stats.tx_fifo_errors += comp->sls_o_compressed;
590 stats.collisions += comp->sls_o_misses;
591 }
592#endif /* CONFIG_INET */
593 return (&stats);
594}
595
596/* Netdevice register callback */
597
598static int sl_init(struct net_device *dev)
599{
600 struct slip *sl = netdev_priv(dev);
601
602 /*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400603 * Finish setting up the DEVICE info.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 */
605
606 dev->mtu = sl->mtu;
607 dev->type = ARPHRD_SLIP + sl->mode;
608#ifdef SL_CHECK_TRANSMIT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 dev->watchdog_timeo = 20*HZ;
610#endif
611 return 0;
612}
613
614
615static void sl_uninit(struct net_device *dev)
616{
617 struct slip *sl = netdev_priv(dev);
618
619 sl_free_bufs(sl);
620}
621
Alan Cox5342b772009-09-19 13:13:17 -0700622/* Hook the destructor so we can free slip devices at the right point in time */
623static void sl_free_netdev(struct net_device *dev)
624{
625 int i = dev->base_addr;
626 free_netdev(dev);
627 slip_devs[i] = NULL;
628}
629
Stephen Hemmingerb1da6832009-01-07 18:09:36 -0800630static const struct net_device_ops sl_netdev_ops = {
631 .ndo_init = sl_init,
632 .ndo_uninit = sl_uninit,
633 .ndo_open = sl_open,
634 .ndo_stop = sl_close,
635 .ndo_start_xmit = sl_xmit,
636 .ndo_get_stats = sl_get_stats,
637 .ndo_change_mtu = sl_change_mtu,
638 .ndo_tx_timeout = sl_tx_timeout,
639#ifdef CONFIG_SLIP_SMART
640 .ndo_do_ioctl = sl_ioctl,
641#endif
642};
643
644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645static void sl_setup(struct net_device *dev)
646{
Stephen Hemmingerb1da6832009-01-07 18:09:36 -0800647 dev->netdev_ops = &sl_netdev_ops;
Alan Cox5342b772009-09-19 13:13:17 -0700648 dev->destructor = sl_free_netdev;
Stephen Hemmingerb1da6832009-01-07 18:09:36 -0800649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 dev->hard_header_len = 0;
651 dev->addr_len = 0;
652 dev->tx_queue_len = 10;
653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 /* New-style flags. */
655 dev->flags = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST;
656}
657
658/******************************************
659 Routines looking at TTY side.
660 ******************************************/
661
662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663/*
664 * Handle the 'receiver data ready' interrupt.
665 * This function is called by the 'tty_io' module in the kernel when
666 * a block of SLIP data has been received, which can now be decapsulated
667 * and sent on to some IP layer for further processing. This will not
668 * be re-entered while running but other ldisc functions may be called
669 * in parallel
670 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400671
Alan Cox9ce6cf22007-11-19 15:03:38 +0000672static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
673 char *fp, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674{
Alan Cox9ce6cf22007-11-19 15:03:38 +0000675 struct slip *sl = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Alan Cox9ce6cf22007-11-19 15:03:38 +0000677 if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 return;
679
680 /* Read the characters out of the buffer */
681 while (count--) {
682 if (fp && *fp++) {
Alan Cox9ce6cf22007-11-19 15:03:38 +0000683 if (!test_and_set_bit(SLF_ERROR, &sl->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 sl->rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 cp++;
686 continue;
687 }
688#ifdef CONFIG_SLIP_MODE_SLIP6
689 if (sl->mode & SL_MODE_SLIP6)
690 slip_unesc6(sl, *cp++);
691 else
692#endif
693 slip_unesc(sl, *cp++);
694 }
695}
696
697/************************************
698 * slip_open helper routines.
699 ************************************/
700
701/* Collect hanged up channels */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702static void sl_sync(void)
703{
704 int i;
705 struct net_device *dev;
706 struct slip *sl;
707
708 for (i = 0; i < slip_maxdev; i++) {
Alan Cox9ce6cf22007-11-19 15:03:38 +0000709 dev = slip_devs[i];
710 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 break;
712
713 sl = netdev_priv(dev);
714 if (sl->tty || sl->leased)
715 continue;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000716 if (dev->flags & IFF_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 dev_close(dev);
718 }
719}
720
721
722/* Find a free SLIP channel, and link in this `tty' line. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000723static struct slip *sl_alloc(dev_t line)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
725 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 struct net_device *dev = NULL;
727 struct slip *sl;
728
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400729 if (slip_devs == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 return NULL; /* Master array missing ! */
731
732 for (i = 0; i < slip_maxdev; i++) {
733 dev = slip_devs[i];
734 if (dev == NULL)
735 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 /* Sorry, too many, all slots in use */
738 if (i >= slip_maxdev)
739 return NULL;
740
741 if (dev) {
742 sl = netdev_priv(dev);
743 if (test_bit(SLF_INUSE, &sl->flags)) {
744 unregister_netdevice(dev);
745 dev = NULL;
746 slip_devs[i] = NULL;
747 }
748 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 if (!dev) {
751 char name[IFNAMSIZ];
752 sprintf(name, "sl%d", i);
753
754 dev = alloc_netdev(sizeof(*sl), name, sl_setup);
755 if (!dev)
756 return NULL;
757 dev->base_addr = i;
758 }
759
760 sl = netdev_priv(dev);
761
762 /* Initialize channel control data */
763 sl->magic = SLIP_MAGIC;
764 sl->dev = dev;
765 spin_lock_init(&sl->lock);
766 sl->mode = SL_MODE_DEFAULT;
767#ifdef CONFIG_SLIP_SMART
Alan Cox9ce6cf22007-11-19 15:03:38 +0000768 /* initialize timer_list struct */
769 init_timer(&sl->keepalive_timer);
770 sl->keepalive_timer.data = (unsigned long)sl;
771 sl->keepalive_timer.function = sl_keepalive;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 init_timer(&sl->outfill_timer);
Alan Cox9ce6cf22007-11-19 15:03:38 +0000773 sl->outfill_timer.data = (unsigned long)sl;
774 sl->outfill_timer.function = sl_outfill;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775#endif
776 slip_devs[i] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 return sl;
778}
779
780/*
781 * Open the high-level part of the SLIP channel.
782 * This function is called by the TTY module when the
783 * SLIP line discipline is called for. Because we are
784 * sure the tty line exists, we only have to link it to
785 * a free SLIP channel...
786 *
787 * Called in process context serialized from other ldisc calls.
788 */
789
790static int slip_open(struct tty_struct *tty)
791{
792 struct slip *sl;
793 int err;
794
Alan Cox9ce6cf22007-11-19 15:03:38 +0000795 if (!capable(CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 return -EPERM;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400797
Alan Coxf34d7a52008-04-30 00:54:13 -0700798 if (tty->ops->write == NULL)
799 return -EOPNOTSUPP;
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 /* RTnetlink lock is misused here to serialize concurrent
802 opens of slip channels. There are better ways, but it is
803 the simplest one.
804 */
805 rtnl_lock();
806
807 /* Collect hanged up channels. */
808 sl_sync();
809
Alan Cox9ce6cf22007-11-19 15:03:38 +0000810 sl = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812 err = -EEXIST;
813 /* First make sure we're not already connected. */
814 if (sl && sl->magic == SLIP_MAGIC)
815 goto err_exit;
816
817 /* OK. Find a free SLIP channel to use. */
818 err = -ENFILE;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000819 sl = sl_alloc(tty_devnum(tty));
820 if (sl == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 goto err_exit;
822
823 sl->tty = tty;
824 tty->disc_data = sl;
825 sl->line = tty_devnum(tty);
826 sl->pid = current->pid;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 if (!test_bit(SLF_INUSE, &sl->flags)) {
829 /* Perform the low-level SLIP initialization. */
Alan Cox9ce6cf22007-11-19 15:03:38 +0000830 err = sl_alloc_bufs(sl, SL_MTU);
831 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 goto err_free_chan;
833
834 set_bit(SLF_INUSE, &sl->flags);
835
Alan Cox9ce6cf22007-11-19 15:03:38 +0000836 err = register_netdevice(sl->dev);
837 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 goto err_free_bufs;
839 }
840
841#ifdef CONFIG_SLIP_SMART
842 if (sl->keepalive) {
Alan Cox9ce6cf22007-11-19 15:03:38 +0000843 sl->keepalive_timer.expires = jiffies + sl->keepalive * HZ;
844 add_timer(&sl->keepalive_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 }
846 if (sl->outfill) {
Alan Cox9ce6cf22007-11-19 15:03:38 +0000847 sl->outfill_timer.expires = jiffies + sl->outfill * HZ;
848 add_timer(&sl->outfill_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 }
850#endif
851
852 /* Done. We have linked the TTY line to a channel. */
853 rtnl_unlock();
Alan Cox33f0f882006-01-09 20:54:13 -0800854 tty->receive_room = 65536; /* We don't flow control */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 return sl->dev->base_addr;
856
857err_free_bufs:
858 sl_free_bufs(sl);
859
860err_free_chan:
861 sl->tty = NULL;
862 tty->disc_data = NULL;
863 clear_bit(SLF_INUSE, &sl->flags);
864
865err_exit:
866 rtnl_unlock();
867
868 /* Count references from TTY module */
869 return err;
870}
871
872/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 * Close down a SLIP channel.
874 * This means flushing out any pending queues, and then returning. This
875 * call is serialized against other ldisc functions.
Alan Cox5342b772009-09-19 13:13:17 -0700876 *
877 * We also use this method fo a hangup event
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 */
Alan Cox5342b772009-09-19 13:13:17 -0700879
Alan Cox9ce6cf22007-11-19 15:03:38 +0000880static void slip_close(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
Alan Cox9ce6cf22007-11-19 15:03:38 +0000882 struct slip *sl = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
884 /* First make sure we're connected. */
885 if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
886 return;
887
888 tty->disc_data = NULL;
889 sl->tty = NULL;
890 if (!sl->leased)
891 sl->line = 0;
892
893 /* VSV = very important to remove timers */
894#ifdef CONFIG_SLIP_SMART
895 del_timer_sync(&sl->keepalive_timer);
896 del_timer_sync(&sl->outfill_timer);
897#endif
Alan Cox5342b772009-09-19 13:13:17 -0700898 /* Flush network side */
899 unregister_netdev(sl->dev);
900 /* This will complete via sl_free_netdev */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901}
902
Alan Cox5342b772009-09-19 13:13:17 -0700903static int slip_hangup(struct tty_struct *tty)
904{
905 slip_close(tty);
906 return 0;
907}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 /************************************************************************
909 * STANDARD SLIP ENCAPSULATION *
910 ************************************************************************/
911
Alan Cox9ce6cf22007-11-19 15:03:38 +0000912static int slip_esc(unsigned char *s, unsigned char *d, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913{
914 unsigned char *ptr = d;
915 unsigned char c;
916
917 /*
918 * Send an initial END character to flush out any
919 * data that may have accumulated in the receiver
920 * due to line noise.
921 */
922
923 *ptr++ = END;
924
925 /*
926 * For each byte in the packet, send the appropriate
927 * character sequence, according to the SLIP protocol.
928 */
929
930 while (len-- > 0) {
Alan Cox9ce6cf22007-11-19 15:03:38 +0000931 switch (c = *s++) {
932 case END:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 *ptr++ = ESC;
934 *ptr++ = ESC_END;
935 break;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000936 case ESC:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 *ptr++ = ESC;
938 *ptr++ = ESC_ESC;
939 break;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000940 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 *ptr++ = c;
942 break;
943 }
944 }
945 *ptr++ = END;
946 return (ptr - d);
947}
948
949static void slip_unesc(struct slip *sl, unsigned char s)
950{
951
Alan Cox9ce6cf22007-11-19 15:03:38 +0000952 switch (s) {
953 case END:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954#ifdef CONFIG_SLIP_SMART
955 /* drop keeptest bit = VSV */
956 if (test_bit(SLF_KEEPTEST, &sl->flags))
957 clear_bit(SLF_KEEPTEST, &sl->flags);
958#endif
959
Joe Perches8e95a202009-12-03 07:58:21 +0000960 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
961 (sl->rcount > 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 sl_bump(sl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 clear_bit(SLF_ESCAPE, &sl->flags);
964 sl->rcount = 0;
965 return;
966
Alan Cox9ce6cf22007-11-19 15:03:38 +0000967 case ESC:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 set_bit(SLF_ESCAPE, &sl->flags);
969 return;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000970 case ESC_ESC:
971 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 s = ESC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 break;
Alan Cox9ce6cf22007-11-19 15:03:38 +0000974 case ESC_END:
975 if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 s = END;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 break;
978 }
979 if (!test_bit(SLF_ERROR, &sl->flags)) {
980 if (sl->rcount < sl->buffsize) {
981 sl->rbuff[sl->rcount++] = s;
982 return;
983 }
984 sl->rx_over_errors++;
985 set_bit(SLF_ERROR, &sl->flags);
986 }
987}
988
989
990#ifdef CONFIG_SLIP_MODE_SLIP6
991/************************************************************************
992 * 6 BIT SLIP ENCAPSULATION *
993 ************************************************************************/
994
Alan Cox9ce6cf22007-11-19 15:03:38 +0000995static int slip_esc6(unsigned char *s, unsigned char *d, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
997 unsigned char *ptr = d;
998 unsigned char c;
999 int i;
1000 unsigned short v = 0;
1001 short bits = 0;
1002
1003 /*
1004 * Send an initial END character to flush out any
1005 * data that may have accumulated in the receiver
1006 * due to line noise.
1007 */
1008
1009 *ptr++ = 0x70;
1010
1011 /*
1012 * Encode the packet into printable ascii characters
1013 */
1014
1015 for (i = 0; i < len; ++i) {
1016 v = (v << 8) | s[i];
1017 bits += 8;
1018 while (bits >= 6) {
1019 bits -= 6;
1020 c = 0x30 + ((v >> bits) & 0x3F);
1021 *ptr++ = c;
1022 }
1023 }
1024 if (bits) {
1025 c = 0x30 + ((v << (6 - bits)) & 0x3F);
1026 *ptr++ = c;
1027 }
1028 *ptr++ = 0x70;
1029 return ptr - d;
1030}
1031
Alan Cox9ce6cf22007-11-19 15:03:38 +00001032static void slip_unesc6(struct slip *sl, unsigned char s)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033{
1034 unsigned char c;
1035
1036 if (s == 0x70) {
1037#ifdef CONFIG_SLIP_SMART
1038 /* drop keeptest bit = VSV */
1039 if (test_bit(SLF_KEEPTEST, &sl->flags))
1040 clear_bit(SLF_KEEPTEST, &sl->flags);
1041#endif
1042
Joe Perches8e95a202009-12-03 07:58:21 +00001043 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
1044 (sl->rcount > 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 sl_bump(sl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 sl->rcount = 0;
1047 sl->xbits = 0;
1048 sl->xdata = 0;
Alan Cox9ce6cf22007-11-19 15:03:38 +00001049 } else if (s >= 0x30 && s < 0x70) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
1051 sl->xbits += 6;
1052 if (sl->xbits >= 8) {
1053 sl->xbits -= 8;
1054 c = (unsigned char)(sl->xdata >> sl->xbits);
1055 if (!test_bit(SLF_ERROR, &sl->flags)) {
1056 if (sl->rcount < sl->buffsize) {
1057 sl->rbuff[sl->rcount++] = c;
1058 return;
1059 }
1060 sl->rx_over_errors++;
1061 set_bit(SLF_ERROR, &sl->flags);
1062 }
1063 }
Alan Cox9ce6cf22007-11-19 15:03:38 +00001064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065}
1066#endif /* CONFIG_SLIP_MODE_SLIP6 */
1067
1068/* Perform I/O control on an active SLIP channel. */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001069static int slip_ioctl(struct tty_struct *tty, struct file *file,
1070 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071{
Alan Cox9ce6cf22007-11-19 15:03:38 +00001072 struct slip *sl = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 unsigned int tmp;
1074 int __user *p = (int __user *)arg;
1075
1076 /* First make sure we're connected. */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001077 if (!sl || sl->magic != SLIP_MAGIC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
Alan Cox9ce6cf22007-11-19 15:03:38 +00001080 switch (cmd) {
1081 case SIOCGIFNAME:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 tmp = strlen(sl->dev->name) + 1;
1083 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1084 return -EFAULT;
1085 return 0;
1086
1087 case SIOCGIFENCAP:
1088 if (put_user(sl->mode, p))
1089 return -EFAULT;
1090 return 0;
1091
1092 case SIOCSIFENCAP:
1093 if (get_user(tmp, p))
1094 return -EFAULT;
1095#ifndef SL_INCLUDE_CSLIP
Alan Cox9ce6cf22007-11-19 15:03:38 +00001096 if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098#else
1099 if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
Alan Cox9ce6cf22007-11-19 15:03:38 +00001100 (SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 /* return -EINVAL; */
1102 tmp &= ~SL_MODE_ADAPTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103#endif
1104#ifndef CONFIG_SLIP_MODE_SLIP6
Alan Cox9ce6cf22007-11-19 15:03:38 +00001105 if (tmp & SL_MODE_SLIP6)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107#endif
1108 sl->mode = tmp;
Alan Cox9ce6cf22007-11-19 15:03:38 +00001109 sl->dev->type = ARPHRD_SLIP + sl->mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 return 0;
1111
Alan Cox9ce6cf22007-11-19 15:03:38 +00001112 case SIOCSIFHWADDR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 return -EINVAL;
1114
1115#ifdef CONFIG_SLIP_SMART
1116 /* VSV changes start here */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001117 case SIOCSKEEPALIVE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 if (get_user(tmp, p))
1119 return -EFAULT;
Alan Cox9ce6cf22007-11-19 15:03:38 +00001120 if (tmp > 255) /* max for unchar */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 return -EINVAL;
1122
1123 spin_lock_bh(&sl->lock);
1124 if (!sl->tty) {
1125 spin_unlock_bh(&sl->lock);
1126 return -ENODEV;
1127 }
Alan Cox9ce6cf22007-11-19 15:03:38 +00001128 sl->keepalive = (u8)tmp;
1129 if (sl->keepalive != 0) {
1130 mod_timer(&sl->keepalive_timer,
1131 jiffies + sl->keepalive * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 set_bit(SLF_KEEPTEST, &sl->flags);
Alan Cox9ce6cf22007-11-19 15:03:38 +00001133 } else
1134 del_timer(&sl->keepalive_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 spin_unlock_bh(&sl->lock);
1136 return 0;
1137
Alan Cox9ce6cf22007-11-19 15:03:38 +00001138 case SIOCGKEEPALIVE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 if (put_user(sl->keepalive, p))
1140 return -EFAULT;
1141 return 0;
1142
Alan Cox9ce6cf22007-11-19 15:03:38 +00001143 case SIOCSOUTFILL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 if (get_user(tmp, p))
1145 return -EFAULT;
Alan Cox9ce6cf22007-11-19 15:03:38 +00001146 if (tmp > 255) /* max for unchar */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 return -EINVAL;
1148 spin_lock_bh(&sl->lock);
1149 if (!sl->tty) {
1150 spin_unlock_bh(&sl->lock);
1151 return -ENODEV;
1152 }
Alan Cox9ce6cf22007-11-19 15:03:38 +00001153 sl->outfill = (u8)tmp;
1154 if (sl->outfill != 0) {
1155 mod_timer(&sl->outfill_timer,
1156 jiffies + sl->outfill * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 set_bit(SLF_OUTWAIT, &sl->flags);
Alan Cox9ce6cf22007-11-19 15:03:38 +00001158 } else
1159 del_timer(&sl->outfill_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 spin_unlock_bh(&sl->lock);
Alan Cox9ce6cf22007-11-19 15:03:38 +00001161 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
Alan Cox9ce6cf22007-11-19 15:03:38 +00001163 case SIOCGOUTFILL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 if (put_user(sl->outfill, p))
1165 return -EFAULT;
1166 return 0;
1167 /* VSV changes end */
1168#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 default:
Alan Coxd0127532007-11-07 01:27:34 -08001170 return tty_mode_ioctl(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172}
1173
Arnd Bergmann9646e7c2009-11-06 22:51:16 -08001174#ifdef CONFIG_COMPAT
1175static long slip_compat_ioctl(struct tty_struct *tty, struct file *file,
1176 unsigned int cmd, unsigned long arg)
1177{
1178 switch (cmd) {
1179 case SIOCGIFNAME:
1180 case SIOCGIFENCAP:
1181 case SIOCSIFENCAP:
1182 case SIOCSIFHWADDR:
1183 case SIOCSKEEPALIVE:
1184 case SIOCGKEEPALIVE:
1185 case SIOCSOUTFILL:
1186 case SIOCGOUTFILL:
1187 return slip_ioctl(tty, file, cmd,
1188 (unsigned long)compat_ptr(arg));
1189 }
1190
1191 return -ENOIOCTLCMD;
1192}
1193#endif
1194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195/* VSV changes start here */
1196#ifdef CONFIG_SLIP_SMART
1197/* function do_ioctl called from net/core/dev.c
1198 to allow get/set outfill/keepalive parameter
1199 by ifconfig */
1200
Alan Cox9ce6cf22007-11-19 15:03:38 +00001201static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202{
1203 struct slip *sl = netdev_priv(dev);
1204 unsigned long *p = (unsigned long *)&rq->ifr_ifru;
1205
1206 if (sl == NULL) /* Allocation failed ?? */
1207 return -ENODEV;
1208
1209 spin_lock_bh(&sl->lock);
1210
1211 if (!sl->tty) {
1212 spin_unlock_bh(&sl->lock);
1213 return -ENODEV;
1214 }
1215
Alan Cox9ce6cf22007-11-19 15:03:38 +00001216 switch (cmd) {
1217 case SIOCSKEEPALIVE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 /* max for unchar */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001219 if ((unsigned)*p > 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 spin_unlock_bh(&sl->lock);
1221 return -EINVAL;
1222 }
Alan Cox9ce6cf22007-11-19 15:03:38 +00001223 sl->keepalive = (u8)*p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 if (sl->keepalive != 0) {
Alan Cox9ce6cf22007-11-19 15:03:38 +00001225 sl->keepalive_timer.expires =
1226 jiffies + sl->keepalive * HZ;
1227 mod_timer(&sl->keepalive_timer,
1228 jiffies + sl->keepalive * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 set_bit(SLF_KEEPTEST, &sl->flags);
Alan Cox9ce6cf22007-11-19 15:03:38 +00001230 } else
1231 del_timer(&sl->keepalive_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 break;
1233
Alan Cox9ce6cf22007-11-19 15:03:38 +00001234 case SIOCGKEEPALIVE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 *p = sl->keepalive;
1236 break;
1237
Alan Cox9ce6cf22007-11-19 15:03:38 +00001238 case SIOCSOUTFILL:
1239 if ((unsigned)*p > 255) { /* max for unchar */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 spin_unlock_bh(&sl->lock);
1241 return -EINVAL;
1242 }
Alan Cox9ce6cf22007-11-19 15:03:38 +00001243 sl->outfill = (u8)*p;
1244 if (sl->outfill != 0) {
1245 mod_timer(&sl->outfill_timer,
1246 jiffies + sl->outfill * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 set_bit(SLF_OUTWAIT, &sl->flags);
Alan Cox9ce6cf22007-11-19 15:03:38 +00001248 } else
1249 del_timer(&sl->outfill_timer);
1250 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Alan Cox9ce6cf22007-11-19 15:03:38 +00001252 case SIOCGOUTFILL:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 *p = sl->outfill;
1254 break;
1255
Alan Cox9ce6cf22007-11-19 15:03:38 +00001256 case SIOCSLEASE:
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001257 /* Resolve race condition, when ioctl'ing hanged up
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 and opened by another process device.
1259 */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001260 if (sl->tty != current->signal->tty &&
1261 sl->pid != current->pid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 spin_unlock_bh(&sl->lock);
1263 return -EPERM;
1264 }
1265 sl->leased = 0;
Alan Cox9ce6cf22007-11-19 15:03:38 +00001266 if (*p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 sl->leased = 1;
Alan Cox9ce6cf22007-11-19 15:03:38 +00001268 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269
Alan Cox9ce6cf22007-11-19 15:03:38 +00001270 case SIOCGLEASE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 *p = sl->leased;
Joe Perchesee289b62010-05-17 22:47:34 -07001272 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 spin_unlock_bh(&sl->lock);
1274 return 0;
1275}
1276#endif
1277/* VSV changes end */
1278
Alan Coxa352def2008-07-16 21:53:12 +01001279static struct tty_ldisc_ops sl_ldisc = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 .owner = THIS_MODULE,
1281 .magic = TTY_LDISC_MAGIC,
1282 .name = "slip",
1283 .open = slip_open,
1284 .close = slip_close,
Alan Cox5342b772009-09-19 13:13:17 -07001285 .hangup = slip_hangup,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 .ioctl = slip_ioctl,
Arnd Bergmann9646e7c2009-11-06 22:51:16 -08001287#ifdef CONFIG_COMPAT
1288 .compat_ioctl = slip_compat_ioctl,
1289#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 .receive_buf = slip_receive_buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 .write_wakeup = slip_write_wakeup,
1292};
1293
1294static int __init slip_init(void)
1295{
1296 int status;
1297
1298 if (slip_maxdev < 4)
1299 slip_maxdev = 4; /* Sanity */
1300
1301 printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
1302#ifdef CONFIG_SLIP_MODE_SLIP6
1303 " (6 bit encapsulation enabled)"
1304#endif
1305 ".\n",
Alan Cox9ce6cf22007-11-19 15:03:38 +00001306 SLIP_VERSION, slip_maxdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307#if defined(SL_INCLUDE_CSLIP)
1308 printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
1309#endif
1310#ifdef CONFIG_SLIP_SMART
1311 printk(KERN_INFO "SLIP linefill/keepalive option.\n");
1312#endif
1313
Alan Cox9ce6cf22007-11-19 15:03:38 +00001314 slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev,
1315 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 if (!slip_devs) {
Alan Cox9ce6cf22007-11-19 15:03:38 +00001317 printk(KERN_ERR "SLIP: Can't allocate slip devices array.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 return -ENOMEM;
1319 }
1320
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 /* Fill in our line protocol discipline, and register it */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001322 status = tty_register_ldisc(N_SLIP, &sl_ldisc);
1323 if (status != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
1325 kfree(slip_devs);
1326 }
1327 return status;
1328}
1329
1330static void __exit slip_exit(void)
1331{
1332 int i;
1333 struct net_device *dev;
1334 struct slip *sl;
1335 unsigned long timeout = jiffies + HZ;
1336 int busy = 0;
1337
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001338 if (slip_devs == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 return;
1340
1341 /* First of all: check for active disciplines and hangup them.
1342 */
1343 do {
Nishanth Aravamudana9fc2512005-05-01 23:34:57 -07001344 if (busy)
1345 msleep_interruptible(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
1347 busy = 0;
1348 for (i = 0; i < slip_maxdev; i++) {
1349 dev = slip_devs[i];
1350 if (!dev)
1351 continue;
1352 sl = netdev_priv(dev);
1353 spin_lock_bh(&sl->lock);
1354 if (sl->tty) {
1355 busy++;
1356 tty_hangup(sl->tty);
1357 }
1358 spin_unlock_bh(&sl->lock);
1359 }
1360 } while (busy && time_before(jiffies, timeout));
1361
Alan Cox5342b772009-09-19 13:13:17 -07001362 /* FIXME: hangup is async so we should wait when doing this second
1363 phase */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
1365 for (i = 0; i < slip_maxdev; i++) {
1366 dev = slip_devs[i];
1367 if (!dev)
1368 continue;
1369 slip_devs[i] = NULL;
1370
1371 sl = netdev_priv(dev);
1372 if (sl->tty) {
1373 printk(KERN_ERR "%s: tty discipline still running\n",
1374 dev->name);
1375 /* Intentionally leak the control block. */
1376 dev->destructor = NULL;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
1379 unregister_netdev(dev);
1380 }
1381
1382 kfree(slip_devs);
1383 slip_devs = NULL;
1384
Alan Cox9ce6cf22007-11-19 15:03:38 +00001385 i = tty_unregister_ldisc(N_SLIP);
1386 if (i != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388}
1389
1390module_init(slip_init);
1391module_exit(slip_exit);
1392
1393#ifdef CONFIG_SLIP_SMART
1394/*
1395 * This is start of the code for multislip style line checking
1396 * added by Stanislav Voronyi. All changes before marked VSV
1397 */
1398
1399static void sl_outfill(unsigned long sls)
1400{
Alan Cox9ce6cf22007-11-19 15:03:38 +00001401 struct slip *sl = (struct slip *)sls;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
1403 spin_lock(&sl->lock);
1404
1405 if (sl->tty == NULL)
1406 goto out;
1407
Alan Cox9ce6cf22007-11-19 15:03:38 +00001408 if (sl->outfill) {
1409 if (test_bit(SLF_OUTWAIT, &sl->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 /* no packets were transmitted, do outfill */
1411#ifdef CONFIG_SLIP_MODE_SLIP6
1412 unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
1413#else
1414 unsigned char s = END;
1415#endif
1416 /* put END into tty queue. Is it right ??? */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001417 if (!netif_queue_stopped(sl->dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 /* if device busy no outfill */
Alan Coxf34d7a52008-04-30 00:54:13 -07001419 sl->tty->ops->write(sl->tty, &s, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 }
Alan Cox9ce6cf22007-11-19 15:03:38 +00001421 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 set_bit(SLF_OUTWAIT, &sl->flags);
1423
1424 mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
1425 }
1426out:
1427 spin_unlock(&sl->lock);
1428}
1429
1430static void sl_keepalive(unsigned long sls)
1431{
Alan Cox9ce6cf22007-11-19 15:03:38 +00001432 struct slip *sl = (struct slip *)sls;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433
1434 spin_lock(&sl->lock);
1435
1436 if (sl->tty == NULL)
1437 goto out;
1438
Alan Cox9ce6cf22007-11-19 15:03:38 +00001439 if (sl->keepalive) {
1440 if (test_bit(SLF_KEEPTEST, &sl->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 /* keepalive still high :(, we must hangup */
Alan Cox9ce6cf22007-11-19 15:03:38 +00001442 if (sl->outfill)
1443 /* outfill timer must be deleted too */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 (void)del_timer(&sl->outfill_timer);
1445 printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
Alan Cox9ce6cf22007-11-19 15:03:38 +00001446 /* this must hangup tty & close slip */
1447 tty_hangup(sl->tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 /* I think we need not something else */
1449 goto out;
Alan Cox9ce6cf22007-11-19 15:03:38 +00001450 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 set_bit(SLF_KEEPTEST, &sl->flags);
1452
1453 mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
1454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455out:
1456 spin_unlock(&sl->lock);
1457}
1458
1459#endif
1460MODULE_LICENSE("GPL");
1461MODULE_ALIAS_LDISC(N_SLIP);