// SPDX-License-Identifier: GPL-2.0-or-later/* * PPP async serial channel driver for Linux. * * Copyright 1999 Paul Mackerras. * * This driver provides the encapsulation and framing for sending * and receiving PPP frames over async serial lines.  It relies on * the generic PPP layer to give it frames to send and to process * received frames.  It implements the PPP line discipline. * * Part of the code in this driver was inspired by the old async-only * PPP driver, written by Michael Callahan and Al Longyear, and * subsequently hacked by Paul Mackerras. */ #include <linux/module.h>#include <linux/kernel.h>#include <linux/skbuff.h>#include <linux/tty.h>#include <linux/netdevice.h>#include <linux/poll.h>#include <linux/crc-ccitt.h>#include <linux/ppp_defs.h>#include <linux/ppp-ioctl.h>#include <linux/ppp_channel.h>#include <linux/spinlock.h>#include <linux/init.h>#include <linux/interrupt.h>#include <linux/jiffies.h>#include <linux/slab.h>#include <linux/unaligned.h>#include <linux/uaccess.h>#include <asm/string.h> #define PPP_VERSION	"2.4.2" #define OBUFSIZE	4096 /* Structure for storing local state. */struct asyncppp {	struct tty_struct *tty;	unsigned int	flags;	unsigned int	state;	unsigned int	rbits;	int		mru;	spinlock_t	xmit_lock;	spinlock_t	recv_lock;	unsigned long	xmit_flags;	u32		xaccm[8];	u32		raccm; 	struct sk_buff	*tpkt;	int		tpkt_pos;	u16		tfcs;	unsigned char	*optr;	unsigned char	*olim;	unsigned long	last_xmit; 	struct sk_buff	*rpkt;	int		lcp_fcs;	struct sk_buff_head rqueue; 	struct tasklet_struct tsk; 	struct ppp_channel chan;	/* interface to generic ppp layer */	unsigned char	obuf[OBUFSIZE];}; /* Bit numbers in xmit_flags */#define XMIT_WAKEUP	0#define XMIT_FULL	1#define XMIT_BUSY	2 /* State bits */#define SC_TOSS		1#define SC_ESCAPE	2#define SC_PREV_ERROR	4 /* Bits in rbits */#define SC_RCV_BITS	(SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP) static int flag_time = HZ;module_param(flag_time, int, 0);MODULE_PARM_DESC(flag_time, "ppp_async: interval between flagged packets (in clock ticks)");MODULE_DESCRIPTION("PPP async serial channel module");MODULE_LICENSE("GPL");MODULE_ALIAS_LDISC(N_PPP); /* * Prototypes. */static int ppp_async_encode(struct asyncppp *ap);static int ppp_async_send(struct ppp_channel *chan, struct sk_buff *skb);static int ppp_async_push(struct asyncppp *ap);static void ppp_async_flush_output(struct asyncppp *ap);static void ppp_async_input(struct asyncppp *ap, const unsigned char *buf,			    const u8 *flags, int count);static int ppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd,			   unsigned long arg);static void ppp_async_process(struct tasklet_struct *t); static void async_lcp_peek(struct asyncppp *ap, unsigned char *data,			   int len, int inbound); static const struct ppp_channel_ops async_ops = {	.start_xmit = ppp_async_send,	.ioctl      = ppp_async_ioctl,}; /* * Routines implementing the PPP line discipline. */ /* * Called when a tty is put into PPP line discipline. Called in process * context. */static intppp_asynctty_open(struct tty_struct *tty){	struct asyncppp *ap;	int err;	int speed; 	if (tty->ops->write == NULL)		return -EOPNOTSUPP; 	err = -ENOMEM;	ap = kzalloc_obj(*ap);	if (!ap)		goto out; 	/* initialize the asyncppp structure */	ap->tty = tty;	ap->mru = PPP_MRU;	spin_lock_init(&ap->xmit_lock);	spin_lock_init(&ap->recv_lock);	ap->xaccm[0] = ~0U;	ap->xaccm[3] = 0x60000000U;	ap->raccm = ~0U;	ap->optr = ap->obuf;	ap->olim = ap->obuf;	ap->lcp_fcs = -1; 	skb_queue_head_init(&ap->rqueue);	tasklet_setup(&ap->tsk, ppp_async_process); 	ap->chan.private = ap;	ap->chan.ops = &async_ops;	ap->chan.mtu = PPP_MRU;	speed = tty_get_baud_rate(tty);	ap->chan.speed = speed;	err = ppp_register_channel(&ap->chan);	if (err)		goto out_free; 	tty->disc_data = ap;	tty->receive_room = 65536;	return 0;  out_free:	kfree(ap); out:	return err;} /* * Called when the tty is put into another line discipline or it hangs up. * This call is serialized against other ldisc functions. */static voidppp_asynctty_close(struct tty_struct *tty){	struct asyncppp *ap = tty->disc_data; 	if (!ap)		return; 	tty->disc_data = NULL;	tasklet_kill(&ap->tsk); 	ppp_unregister_channel(&ap->chan);	kfree_skb(ap->rpkt);	skb_queue_purge(&ap->rqueue);	kfree_skb(ap->tpkt);	kfree(ap);} /* * Read does nothing - no data is ever available this way. * Pppd reads and writes packets via /dev/ppp instead. */static ssize_tppp_asynctty_read(struct tty_struct *tty, struct file *file, u8 *buf,		  size_t count, void **cookie, unsigned long offset){	return -EAGAIN;} /* * Write on the tty does nothing, the packets all come in * from the ppp generic stuff. */static ssize_tppp_asynctty_write(struct tty_struct *tty, struct file *file, const u8 *buf,		   size_t count){	return -EAGAIN;} /* * Called in process context only. May be re-entered by multiple * ioctl calling threads. */ static intppp_asynctty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg){	struct asyncppp *ap = tty->disc_data;	int err, val;	int __user *p = (int __user *)arg; 	if (!ap)		return -ENXIO;	err = -EFAULT;	switch (cmd) {	case PPPIOCGCHAN:		err = -EFAULT;		if (put_user(ppp_channel_index(&ap->chan), p))			break;		err = 0;		break; 	case PPPIOCGUNIT:		err = -EFAULT;		if (put_user(ppp_unit_number(&ap->chan), p))			break;		err = 0;		break; 	case TCFLSH:		/* flush our buffers and the serial port's buffer */		if (arg == TCIOFLUSH || arg == TCOFLUSH)			ppp_async_flush_output(ap);		err = n_tty_ioctl_helper(tty, cmd, arg);		break; 	case FIONREAD:		val = 0;		if (put_user(val, p))			break;		err = 0;		break; 	default:		/* Try the various mode ioctls */		err = tty_mode_ioctl(tty, cmd, arg);	} 	return err;} /* May sleep, don't call from interrupt level or with interrupts disabled */static voidppp_asynctty_receive(struct tty_struct *tty, const u8 *buf, const u8 *cflags,		     size_t count){	struct asyncppp *ap = tty->disc_data;	unsigned long flags; 	if (!ap)		return;	spin_lock_irqsave(&ap->recv_lock, flags);	ppp_async_input(ap, buf, cflags, count);	spin_unlock_irqrestore(&ap->recv_lock, flags);	if (!skb_queue_empty(&ap->rqueue))		tasklet_schedule(&ap->tsk);	tty_unthrottle(tty);} static voidppp_asynctty_wakeup(struct tty_struct *tty){	struct asyncppp *ap = tty->disc_data; 	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);	if (!ap)		return;	set_bit(XMIT_WAKEUP, &ap->xmit_flags);	tasklet_schedule(&ap->tsk);}  static struct tty_ldisc_ops ppp_ldisc = {	.owner  = THIS_MODULE,	.num	= N_PPP,	.name	= "ppp",	.open	= ppp_asynctty_open,	.close	= ppp_asynctty_close,	.read	= ppp_asynctty_read,	.write	= ppp_asynctty_write,	.ioctl	= ppp_asynctty_ioctl,	.receive_buf = ppp_asynctty_receive,	.write_wakeup = ppp_asynctty_wakeup,}; static int __initppp_async_init(void){	int err; 	err = tty_register_ldisc(&ppp_ldisc);	if (err != 0)		printk(KERN_ERR "PPP_async: error %d registering line disc.\n",		       err);	return err;} /* * The following routines provide the PPP channel interface. */static intppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd, unsigned long arg){	struct asyncppp *ap = chan->private;	void __user *argp = (void __user *)arg;	int __user *p = argp;	int err, val;	u32 accm[8]; 	err = -EFAULT;	switch (cmd) {	case PPPIOCGFLAGS:		val = ap->flags | ap->rbits;		if (put_user(val, p))			break;		err = 0;		break;	case PPPIOCSFLAGS:		if (get_user(val, p))			break;		ap->flags = val & ~SC_RCV_BITS;		spin_lock_irq(&ap->recv_lock);		ap->rbits = val & SC_RCV_BITS;		spin_unlock_irq(&ap->recv_lock);		err = 0;		break; 	case PPPIOCGASYNCMAP:		if (put_user(ap->xaccm[0], (u32 __user *)argp))			break;		err = 0;		break;	case PPPIOCSASYNCMAP:		if (get_user(ap->xaccm[0], (u32 __user *)argp))			break;		err = 0;		break; 	case PPPIOCGRASYNCMAP:		if (put_user(ap->raccm, (u32 __user *)argp))			break;		err = 0;		break;	case PPPIOCSRASYNCMAP:		if (get_user(ap->raccm, (u32 __user *)argp))			break;		err = 0;		break; 	case PPPIOCGXASYNCMAP:		if (copy_to_user(argp, ap->xaccm, sizeof(ap->xaccm)))			break;		err = 0;		break;	case PPPIOCSXASYNCMAP:		if (copy_from_user(accm, argp, sizeof(accm)))			break;		accm[2] &= ~0x40000000U;	/* can't escape 0x5e */		accm[3] |= 0x60000000U;		/* must escape 0x7d, 0x7e */		memcpy(ap->xaccm, accm, sizeof(ap->xaccm));		err = 0;		break; 	case PPPIOCGMRU:		if (put_user(ap->mru, p))			break;		err = 0;		break;	case PPPIOCSMRU:		if (get_user(val, p))			break;		if (val > U16_MAX) {			err = -EINVAL;			break;		}		if (val < PPP_MRU)			val = PPP_MRU;		ap->mru = val;		err = 0;		break; 	default:		err = -ENOTTY;	} 	return err;} /* * This is called at softirq level to deliver received packets * to the ppp_generic code, and to tell the ppp_generic code * if we can accept more output now. */static void ppp_async_process(struct tasklet_struct *t){	struct asyncppp *ap = from_tasklet(ap, t, tsk);	struct sk_buff *skb; 	/* process received packets */	while ((skb = skb_dequeue(&ap->rqueue)) != NULL) {		if (skb->cb[0])			ppp_input_error(&ap->chan);		ppp_input(&ap->chan, skb);	} 	/* try to push more stuff out */	if (test_bit(XMIT_WAKEUP, &ap->xmit_flags) && ppp_async_push(ap))		ppp_output_wakeup(&ap->chan);} /* * Procedures for encapsulation and framing. */ /* * Procedure to encode the data for async serial transmission. * Does octet stuffing (escaping), puts the address/control bytes * on if A/C compression is disabled, and does protocol compression. * Assumes ap->tpkt != 0 on entry. * Returns 1 if we finished the current frame, 0 otherwise. */ #define PUT_BYTE(ap, buf, c, islcp)	do {		\	if ((islcp && c < 0x20) || (ap->xaccm[c >> 5] & (1 << (c & 0x1f)))) {\		*buf++ = PPP_ESCAPE;			\		*buf++ = c ^ PPP_TRANS;			\	} else						\		*buf++ = c;				\} while (0) static intppp_async_encode(struct asyncppp *ap){	int fcs, i, count, c, proto;	unsigned char *buf, *buflim;	unsigned char *data;	int islcp; 	buf = ap->obuf;	ap->olim = buf;	ap->optr = buf;	i = ap->tpkt_pos;	data = ap->tpkt->data;	count = ap->tpkt->len;	fcs = ap->tfcs;	proto = get_unaligned_be16(data); 	/*	 * LCP packets with code values between 1 (configure-request)	 * and 7 (code-reject) must be sent as though no options	 * had been negotiated.	 */	islcp = proto == PPP_LCP && count >= 3 && 1 <= data[2] && data[2] <= 7; 	if (i == 0) {		if (islcp)			async_lcp_peek(ap, data, count, 0); 		/*		 * Start of a new packet - insert the leading FLAG		 * character if necessary.		 */		if (islcp || flag_time == 0 ||		    time_after_eq(jiffies, ap->last_xmit + flag_time))			*buf++ = PPP_FLAG;		ap->last_xmit = jiffies;		fcs = PPP_INITFCS; 		/*		 * Put in the address/control bytes if necessary		 */		if ((ap->flags & SC_COMP_AC) == 0 || islcp) {			PUT_BYTE(ap, buf, 0xff, islcp);			fcs = PPP_FCS(fcs, 0xff);			PUT_BYTE(ap, buf, 0x03, islcp);			fcs = PPP_FCS(fcs, 0x03);		}	}

Lines 1–500 of 943. Load more