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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ppp_async.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：22k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ppp_async.c：源码内容
  1. /*
  2.  * PPP async serial channel driver for Linux.
  3.  *
  4.  * Copyright 1999 Paul Mackerras.
  5.  *
  6.  *  This program is free software; you can redistribute it and/or
  7.  *  modify it under the terms of the GNU General Public License
  8.  *  as published by the Free Software Foundation; either version
  9.  *  2 of the License, or (at your option) any later version.
  10.  *
  11.  * This driver provides the encapsulation and framing for sending
  12.  * and receiving PPP frames over async serial lines.  It relies on
  13.  * the generic PPP layer to give it frames to send and to process
  14.  * received frames.  It implements the PPP line discipline.
  15.  *
  16.  * Part of the code in this driver was inspired by the old async-only
  17.  * PPP driver, written by Michael Callahan and Al Longyear, and
  18.  * subsequently hacked by Paul Mackerras.
  19.  *
  20.  * ==FILEVERSION 20000227==
  21.  */
  23. #include <linux/module.h>
  24. #include <linux/kernel.h>
  25. #include <linux/skbuff.h>
  26. #include <linux/tty.h>
  27. #include <linux/netdevice.h>
  28. #include <linux/poll.h>
  29. #include <linux/ppp_defs.h>
  30. #include <linux/if_ppp.h>
  31. #include <linux/ppp_channel.h>
  32. #include <linux/spinlock.h>
  33. #include <linux/init.h>
  34. #include <asm/uaccess.h>
  36. #define PPP_VERSION "2.4.1"
  38. #define OBUFSIZE 256
  40. /* Structure for storing local state. */
  41. struct asyncppp {
  42. struct tty_struct *tty;
  43. unsigned int flags;
  44. unsigned int state;
  45. unsigned int rbits;
  46. int mru;
  47. spinlock_t xmit_lock;
  48. spinlock_t recv_lock;
  49. unsigned long xmit_flags;
  50. u32 xaccm[8];
  51. u32 raccm;
  52. unsigned int bytes_sent;
  53. unsigned int bytes_rcvd;
  55. struct sk_buff *tpkt;
  56. int tpkt_pos;
  57. u16 tfcs;
  58. unsigned char *optr;
  59. unsigned char *olim;
  60. unsigned long last_xmit;
  62. struct sk_buff *rpkt;
  63. int lcp_fcs;
  65. struct ppp_channel chan; /* interface to generic ppp layer */
  66. unsigned char obuf[OBUFSIZE];
  67. };
  69. /* Bit numbers in xmit_flags */
  70. #define XMIT_WAKEUP 0
  71. #define XMIT_FULL 1
  72. #define XMIT_BUSY 2
  74. /* State bits */
  75. #define SC_TOSS 0x20000000
  76. #define SC_ESCAPE 0x40000000
  78. /* Bits in rbits */
  79. #define SC_RCV_BITS (SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
  81. static int flag_time = HZ;
  82. MODULE_PARM(flag_time, "i");
  83. MODULE_PARM_DESC(flag_time, "ppp_async: interval between flagged packets (in clock ticks)");
  84. MODULE_LICENSE("GPL");
  87. /*
  88.  * Prototypes.
  89.  */
  90. static int ppp_async_encode(struct asyncppp *ap);
  91. static int ppp_async_send(struct ppp_channel *chan, struct sk_buff *skb);
  92. static int ppp_async_push(struct asyncppp *ap);
  93. static void ppp_async_flush_output(struct asyncppp *ap);
  94. static void ppp_async_input(struct asyncppp *ap, const unsigned char *buf,
  95.     char *flags, int count);
  96. static int ppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd,
  97.    unsigned long arg);
  98. static void async_lcp_peek(struct asyncppp *ap, unsigned char *data,
  99.    int len, int inbound);
  101. static struct ppp_channel_ops async_ops = {
  102. ppp_async_send,
  103. ppp_async_ioctl
  104. };
  106. /*
  107.  * Routines implementing the PPP line discipline.
  108.  */
  110. /*
  111.  * Called when a tty is put into PPP line discipline.
  112.  */
  113. static int
  114. ppp_asynctty_open(struct tty_struct *tty)
  115. {
  116. struct asyncppp *ap;
  117. int err;
  119. MOD_INC_USE_COUNT;
  120. err = -ENOMEM;
  121. ap = kmalloc(sizeof(*ap), GFP_KERNEL);
  122. if (ap == 0)
  123. goto out;
  125. /* initialize the asyncppp structure */
  126. memset(ap, 0, sizeof(*ap));
  127. ap->tty = tty;
  128. ap->mru = PPP_MRU;
  129. spin_lock_init(&ap->xmit_lock);
  130. spin_lock_init(&ap->recv_lock);
  131. ap->xaccm[0] = ~0U;
  132. ap->xaccm[3] = 0x60000000U;
  133. ap->raccm = ~0U;
  134. ap->optr = ap->obuf;
  135. ap->olim = ap->obuf;
  136. ap->lcp_fcs = -1;
  138. ap->chan.private = ap;
  139. ap->chan.ops = &async_ops;
  140. ap->chan.mtu = PPP_MRU;
  141. err = ppp_register_channel(&ap->chan);
  142. if (err)
  143. goto out_free;
  145. tty->disc_data = ap;
  147. return 0;
  149.  out_free:
  150. kfree(ap);
  151.  out:
  152. MOD_DEC_USE_COUNT;
  153. return err;
  154. }
  156. /*
  157.  * Called when the tty is put into another line discipline
  158.  * or it hangs up.
  159.  * We assume that while we are in this routine, the tty layer
  160.  * won't call any of the other line discipline entries for the
  161.  * same tty.
  162.  */
  163. static void
  164. ppp_asynctty_close(struct tty_struct *tty)
  165. {
  166. struct asyncppp *ap = tty->disc_data;
  168. if (ap == 0)
  169. return;
  170. tty->disc_data = 0;
  171. ppp_unregister_channel(&ap->chan);
  172. if (ap->rpkt != 0)
  173. kfree_skb(ap->rpkt);
  174. if (ap->tpkt != 0)
  175. kfree_skb(ap->tpkt);
  176. kfree(ap);
  177. MOD_DEC_USE_COUNT;
  178. }
  180. /*
  181.  * Read does nothing - no data is ever available this way.
  182.  * Pppd reads and writes packets via /dev/ppp instead.
  183.  */
  184. static ssize_t
  185. ppp_asynctty_read(struct tty_struct *tty, struct file *file,
  186.   unsigned char *buf, size_t count)
  187. {
  188. return -EAGAIN;
  189. }
  191. /*
  192.  * Write on the tty does nothing, the packets all come in
  193.  * from the ppp generic stuff.
  194.  */
  195. static ssize_t
  196. ppp_asynctty_write(struct tty_struct *tty, struct file *file,
  197.    const unsigned char *buf, size_t count)
  198. {
  199. return -EAGAIN;
  200. }
  202. static int
  203. ppp_asynctty_ioctl(struct tty_struct *tty, struct file *file,
  204.    unsigned int cmd, unsigned long arg)
  205. {
  206. struct asyncppp *ap = tty->disc_data;
  207. int err, val;
  209. err = -EFAULT;
  210. switch (cmd) {
  211. case PPPIOCGCHAN:
  212. err = -ENXIO;
  213. if (ap == 0)
  214. break;
  215. err = -EFAULT;
  216. if (put_user(ppp_channel_index(&ap->chan), (int *) arg))
  217. break;
  218. err = 0;
  219. break;
  221. case PPPIOCGUNIT:
  222. err = -ENXIO;
  223. if (ap == 0)
  224. break;
  225. err = -EFAULT;
  226. if (put_user(ppp_unit_number(&ap->chan), (int *) arg))
  227. break;
  228. err = 0;
  229. break;
  231. case TCGETS:
  232. case TCGETA:
  233. err = n_tty_ioctl(tty, file, cmd, arg);
  234. break;
  236. case TCFLSH:
  237. /* flush our buffers and the serial port's buffer */
  238. if (arg == TCIOFLUSH || arg == TCOFLUSH)
  239. ppp_async_flush_output(ap);
  240. err = n_tty_ioctl(tty, file, cmd, arg);
  241. break;
  243. case FIONREAD:
  244. val = 0;
  245. if (put_user(val, (int *) arg))
  246. break;
  247. err = 0;
  248. break;
  250. default:
  251. err = -ENOIOCTLCMD;
  252. }
  254. return err;
  255. }
  257. /* No kernel lock - fine */
  258. static unsigned int
  259. ppp_asynctty_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
  260. {
  261. return 0;
  262. }
  264. static int
  265. ppp_asynctty_room(struct tty_struct *tty)
  266. {
  267. return 65535;
  268. }
  270. static void
  271. ppp_asynctty_receive(struct tty_struct *tty, const unsigned char *buf,
  272.   char *flags, int count)
  273. {
  274. struct asyncppp *ap = tty->disc_data;
  276. if (ap == 0)
  277. return;
  278. spin_lock_bh(&ap->recv_lock);
  279. ppp_async_input(ap, buf, flags, count);
  280. spin_unlock_bh(&ap->recv_lock);
  281. if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
  282.     && tty->driver.unthrottle)
  283. tty->driver.unthrottle(tty);
  284. }
  286. static void
  287. ppp_asynctty_wakeup(struct tty_struct *tty)
  288. {
  289. struct asyncppp *ap = tty->disc_data;
  291. clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
  292. if (ap == 0)
  293. return;
  294. if (ppp_async_push(ap))
  295. ppp_output_wakeup(&ap->chan);
  296. }
  299. static struct tty_ldisc ppp_ldisc = {
  300. magic: TTY_LDISC_MAGIC,
  301. name: "ppp",
  302. open: ppp_asynctty_open,
  303. close: ppp_asynctty_close,
  304. read: ppp_asynctty_read,
  305. write: ppp_asynctty_write,
  306. ioctl: ppp_asynctty_ioctl,
  307. poll: ppp_asynctty_poll,
  308. receive_room: ppp_asynctty_room,
  309. receive_buf: ppp_asynctty_receive,
  310. write_wakeup: ppp_asynctty_wakeup,
  311. };
  313. static int __init
  314. ppp_async_init(void)
  315. {
  316. int err;
  318. err = tty_register_ldisc(N_PPP, &ppp_ldisc);
  319. if (err != 0)
  320. printk(KERN_ERR "PPP_async: error %d registering line disc.n",
  321.        err);
  322. return err;
  323. }
  325. /*
  326.  * The following routines provide the PPP channel interface.
  327.  */
  328. static int
  329. ppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd, unsigned long arg)
  330. {
  331. struct asyncppp *ap = chan->private;
  332. int err, val;
  333. u32 accm[8];
  335. err = -EFAULT;
  336. switch (cmd) {
  337. case PPPIOCGFLAGS:
  338. val = ap->flags | ap->rbits;
  339. if (put_user(val, (int *) arg))
  340. break;
  341. err = 0;
  342. break;
  343. case PPPIOCSFLAGS:
  344. if (get_user(val, (int *) arg))
  345. break;
  346. ap->flags = val & ~SC_RCV_BITS;
  347. spin_lock_bh(&ap->recv_lock);
  348. ap->rbits = val & SC_RCV_BITS;
  349. spin_unlock_bh(&ap->recv_lock);
  350. err = 0;
  351. break;
  353. case PPPIOCGASYNCMAP:
  354. if (put_user(ap->xaccm[0], (u32 *) arg))
  355. break;
  356. err = 0;
  357. break;
  358. case PPPIOCSASYNCMAP:
  359. if (get_user(ap->xaccm[0], (u32 *) arg))
  360. break;
  361. err = 0;
  362. break;
  364. case PPPIOCGRASYNCMAP:
  365. if (put_user(ap->raccm, (u32 *) arg))
  366. break;
  367. err = 0;
  368. break;
  369. case PPPIOCSRASYNCMAP:
  370. if (get_user(ap->raccm, (u32 *) arg))
  371. break;
  372. err = 0;
  373. break;
  375. case PPPIOCGXASYNCMAP:
  376. if (copy_to_user((void *) arg, ap->xaccm, sizeof(ap->xaccm)))
  377. break;
  378. err = 0;
  379. break;
  380. case PPPIOCSXASYNCMAP:
  381. if (copy_from_user(accm, (void *) arg, sizeof(accm)))
  382. break;
  383. accm[2] &= ~0x40000000U; /* can't escape 0x5e */
  384. accm[3] |= 0x60000000U; /* must escape 0x7d, 0x7e */
  385. memcpy(ap->xaccm, accm, sizeof(ap->xaccm));
  386. err = 0;
  387. break;
  389. case PPPIOCGMRU:
  390. if (put_user(ap->mru, (int *) arg))
  391. break;
  392. err = 0;
  393. break;
  394. case PPPIOCSMRU:
  395. if (get_user(val, (int *) arg))
  396. break;
  397. if (val < PPP_MRU)
  398. val = PPP_MRU;
  399. ap->mru = val;
  400. err = 0;
  401. break;
  403. default:
  404. err = -ENOTTY;
  405. }
  407. return err;
  408. }
  410. /*
  411.  * Procedures for encapsulation and framing.
  412.  */
  414. u16 ppp_crc16_table[256] = {
  415. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  416. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  417. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  418. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  419. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  420. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  421. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  422. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  423. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  424. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  425. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  426. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  427. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  428. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  429. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  430. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  431. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  432. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  433. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  434. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  435. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  436. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  437. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  438. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  439. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  440. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  441. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  442. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  443. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  444. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  445. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  446. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  447. };
  448. EXPORT_SYMBOL(ppp_crc16_table);
  449. #define fcstab ppp_crc16_table /* for PPP_FCS macro */
  451. /*
  452.  * Procedure to encode the data for async serial transmission.
  453.  * Does octet stuffing (escaping), puts the address/control bytes
  454.  * on if A/C compression is disabled, and does protocol compression.
  455.  * Assumes ap->tpkt != 0 on entry.
  456.  * Returns 1 if we finished the current frame, 0 otherwise.
  457.  */
  459. #define PUT_BYTE(ap, buf, c, islcp) do {
  460. if ((islcp && c < 0x20) || (ap->xaccm[c >> 5] & (1 << (c & 0x1f)))) {
  461. *buf++ = PPP_ESCAPE;
  462. *buf++ = c ^ 0x20;
  463. } else
  464. *buf++ = c;
  465. } while (0)
  467. static int
  468. ppp_async_encode(struct asyncppp *ap)
  469. {
  470. int fcs, i, count, c, proto;
  471. unsigned char *buf, *buflim;
  472. unsigned char *data;
  473. int islcp;
  475. buf = ap->obuf;
  476. ap->olim = buf;
  477. ap->optr = buf;
  478. i = ap->tpkt_pos;
  479. data = ap->tpkt->data;
  480. count = ap->tpkt->len;
  481. fcs = ap->tfcs;
  482. proto = (data[0] << 8) + data[1];
  484. /*
  485.  * LCP packets with code values between 1 (configure-reqest)
  486.  * and 7 (code-reject) must be sent as though no options
  487.  * had been negotiated.
  488.  */
  489. islcp = proto == PPP_LCP && 1 <= data[2] && data[2] <= 7;
  491. if (i == 0) {
  492. if (islcp)
  493. async_lcp_peek(ap, data, count, 0);
  495. /*
  496.  * Start of a new packet - insert the leading FLAG
  497.  * character if necessary.
  498.  */
  499. if (islcp || flag_time == 0
  500.     || jiffies - ap->last_xmit >= flag_time)
  501. *buf++ = PPP_FLAG;
  502. ap->last_xmit = jiffies;
  503. fcs = PPP_INITFCS;
  505. /*
  506.  * Put in the address/control bytes if necessary
  507.  */
  508. if ((ap->flags & SC_COMP_AC) == 0 || islcp) {
  509. PUT_BYTE(ap, buf, 0xff, islcp);
  510. fcs = PPP_FCS(fcs, 0xff);
  511. PUT_BYTE(ap, buf, 0x03, islcp);
  512. fcs = PPP_FCS(fcs, 0x03);
  513. }
  514. }
  516. /*
  517.  * Once we put in the last byte, we need to put in the FCS
  518.  * and closing flag, so make sure there is at least 7 bytes
  519.  * of free space in the output buffer.
  520.  */
  521. buflim = ap->obuf + OBUFSIZE - 6;
  522. while (i < count && buf < buflim) {
  523. c = data[i++];
  524. if (i == 1 && c == 0 && (ap->flags & SC_COMP_PROT))
  525. continue; /* compress protocol field */
  526. fcs = PPP_FCS(fcs, c);
  527. PUT_BYTE(ap, buf, c, islcp);
  528. }
  530. if (i < count) {
  531. /*
  532.  * Remember where we are up to in this packet.
  533.  */
  534. ap->olim = buf;
  535. ap->tpkt_pos = i;
  536. ap->tfcs = fcs;
  537. return 0;
  538. }
  540. /*
  541.  * We have finished the packet.  Add the FCS and flag.
  542.  */
  543. fcs = ~fcs;
  544. c = fcs & 0xff;
  545. PUT_BYTE(ap, buf, c, islcp);
  546. c = (fcs >> 8) & 0xff;
  547. PUT_BYTE(ap, buf, c, islcp);
  548. *buf++ = PPP_FLAG;
  549. ap->olim = buf;
  551. kfree_skb(ap->tpkt);
  552. ap->tpkt = 0;
  553. return 1;
  554. }
  556. /*
  557.  * Transmit-side routines.
  558.  */
  560. /*
  561.  * Send a packet to the peer over an async tty line.
  562.  * Returns 1 iff the packet was accepted.
  563.  * If the packet was not accepted, we will call ppp_output_wakeup
  564.  * at some later time.
  565.  */
  566. static int
  567. ppp_async_send(struct ppp_channel *chan, struct sk_buff *skb)
  568. {
  569. struct asyncppp *ap = chan->private;
  571. ppp_async_push(ap);
  573. if (test_and_set_bit(XMIT_FULL, &ap->xmit_flags))
  574. return 0; /* already full */
  575. ap->tpkt = skb;
  576. ap->tpkt_pos = 0;
  578. ppp_async_push(ap);
  579. return 1;
  580. }
  582. /*
  583.  * Push as much data as possible out to the tty.
  584.  */
  585. static int
  586. ppp_async_push(struct asyncppp *ap)
  587. {
  588. int avail, sent, done = 0;
  589. struct tty_struct *tty = ap->tty;
  590. int tty_stuffed = 0;
  592. set_bit(XMIT_WAKEUP, &ap->xmit_flags);
  593. /*
  594.  * We can get called recursively here if the tty write
  595.  * function calls our wakeup function.  This can happen
  596.  * for example on a pty with both the master and slave
  597.  * set to PPP line discipline.
  598.  * We use the XMIT_BUSY bit to detect this and get out,
  599.  * leaving the XMIT_WAKEUP bit set to tell the other
  600.  * instance that it may now be able to write more now.
  601.  */
  602. if (test_and_set_bit(XMIT_BUSY, &ap->xmit_flags))
  603. return 0;
  604. spin_lock_bh(&ap->xmit_lock);
  605. for (;;) {
  606. if (test_and_clear_bit(XMIT_WAKEUP, &ap->xmit_flags))
  607. tty_stuffed = 0;
  608. if (!tty_stuffed && ap->optr < ap->olim) {
  609. avail = ap->olim - ap->optr;
  610. set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
  611. sent = tty->driver.write(tty, 0, ap->optr, avail);
  612. if (sent < 0)
  613. goto flush; /* error, e.g. loss of CD */
  614. ap->optr += sent;
  615. if (sent < avail)
  616. tty_stuffed = 1;
  617. continue;
  618. }
  619. if (ap->optr >= ap->olim && ap->tpkt != 0) {
  620. if (ppp_async_encode(ap)) {
  621. /* finished processing ap->tpkt */
  622. clear_bit(XMIT_FULL, &ap->xmit_flags);
  623. done = 1;
  624. }
  625. continue;
  626. }
  627. /*
  628.  * We haven't made any progress this time around.
  629.  * Clear XMIT_BUSY to let other callers in, but
  630.  * after doing so we have to check if anyone set
  631.  * XMIT_WAKEUP since we last checked it.  If they
  632.  * did, we should try again to set XMIT_BUSY and go
  633.  * around again in case XMIT_BUSY was still set when
  634.  * the other caller tried.
  635.  */
  636. clear_bit(XMIT_BUSY, &ap->xmit_flags);
  637. /* any more work to do? if not, exit the loop */
  638. if (!(test_bit(XMIT_WAKEUP, &ap->xmit_flags)
  639.       || (!tty_stuffed && ap->tpkt != 0)))
  640. break;
  641. /* more work to do, see if we can do it now */
  642. if (test_and_set_bit(XMIT_BUSY, &ap->xmit_flags))
  643. break;
  644. }
  645. spin_unlock_bh(&ap->xmit_lock);
  646. return done;
  648. flush:
  649. clear_bit(XMIT_BUSY, &ap->xmit_flags);
  650. if (ap->tpkt != 0) {
  651. kfree_skb(ap->tpkt);
  652. ap->tpkt = 0;
  653. clear_bit(XMIT_FULL, &ap->xmit_flags);
  654. done = 1;
  655. }
  656. ap->optr = ap->olim;
  657. spin_unlock_bh(&ap->xmit_lock);
  658. return done;
  659. }
  661. /*
  662.  * Flush output from our internal buffers.
  663.  * Called for the TCFLSH ioctl.
  664.  */
  665. static void
  666. ppp_async_flush_output(struct asyncppp *ap)
  667. {
  668. int done = 0;
  670. spin_lock_bh(&ap->xmit_lock);
  671. ap->optr = ap->olim;
  672. if (ap->tpkt != NULL) {
  673. kfree_skb(ap->tpkt);
  674. ap->tpkt = 0;
  675. clear_bit(XMIT_FULL, &ap->xmit_flags);
  676. done = 1;
  677. }
  678. spin_unlock_bh(&ap->xmit_lock);
  679. if (done)
  680. ppp_output_wakeup(&ap->chan);
  681. }
  683. /*
  684.  * Receive-side routines.
  685.  */
  687. /* see how many ordinary chars there are at the start of buf */
  688. static inline int
  689. scan_ordinary(struct asyncppp *ap, const unsigned char *buf, int count)
  690. {
  691. int i, c;
  693. for (i = 0; i < count; ++i) {
  694. c = buf[i];
  695. if (c == PPP_ESCAPE || c == PPP_FLAG
  696.     || (c < 0x20 && (ap->raccm & (1 << c)) != 0))
  697. break;
  698. }
  699. return i;
  700. }
  702. /* called when a flag is seen - do end-of-packet processing */
  703. static inline void
  704. process_input_packet(struct asyncppp *ap)
  705. {
  706. struct sk_buff *skb;
  707. unsigned char *p;
  708. unsigned int len, fcs, proto;
  709. int code = 0;
  711. skb = ap->rpkt;
  712. ap->rpkt = 0;
  713. if ((ap->state & (SC_TOSS | SC_ESCAPE)) || skb == 0) {
  714. ap->state &= ~(SC_TOSS | SC_ESCAPE);
  715. if (skb != 0)
  716. kfree_skb(skb);
  717. return;
  718. }
  720. /* check the FCS */
  721. p = skb->data;
  722. len = skb->len;
  723. if (len < 3)
  724. goto err; /* too short */
  725. fcs = PPP_INITFCS;
  726. for (; len > 0; --len)
  727. fcs = PPP_FCS(fcs, *p++);
  728. if (fcs != PPP_GOODFCS)
  729. goto err; /* bad FCS */
  730. skb_trim(skb, skb->len - 2);
  732. /* check for address/control and protocol compression */
  733. p = skb->data;
  734. if (p[0] == PPP_ALLSTATIONS && p[1] == PPP_UI) {
  735. /* chop off address/control */
  736. if (skb->len < 3)
  737. goto err;
  738. p = skb_pull(skb, 2);
  739. }
  740. proto = p[0];
  741. if (proto & 1) {
  742. /* protocol is compressed */
  743. skb_push(skb, 1)[0] = 0;
  744. } else {
  745. if (skb->len < 2)
  746. goto err;
  747. proto = (proto << 8) + p[1];
  748. if (proto == PPP_LCP)
  749. async_lcp_peek(ap, p, skb->len, 1);
  750. }
  752. /* all OK, give it to the generic layer */
  753. ppp_input(&ap->chan, skb);
  754. return;
  756.  err:
  757. kfree_skb(skb);
  758. ppp_input_error(&ap->chan, code);
  759. }
  761. static inline void
  762. input_error(struct asyncppp *ap, int code)
  763. {
  764. ap->state |= SC_TOSS;
  765. ppp_input_error(&ap->chan, code);
  766. }
  768. /* called when the tty driver has data for us. */
  769. static void
  770. ppp_async_input(struct asyncppp *ap, const unsigned char *buf,
  771. char *flags, int count)
  772. {
  773. struct sk_buff *skb;
  774. int c, i, j, n, s, f;
  775. unsigned char *sp;
  777. /* update bits used for 8-bit cleanness detection */
  778. if (~ap->rbits & SC_RCV_BITS) {
  779. s = 0;
  780. for (i = 0; i < count; ++i) {
  781. c = buf[i];
  782. if (flags != 0 && flags[i] != 0)
  783. continue;
  784. s |= (c & 0x80)? SC_RCV_B7_1: SC_RCV_B7_0;
  785. c = ((c >> 4) ^ c) & 0xf;
  786. s |= (0x6996 & (1 << c))? SC_RCV_ODDP: SC_RCV_EVNP;
  787. }
  788. ap->rbits |= s;
  789. }
  791. while (count > 0) {
  792. /* scan through and see how many chars we can do in bulk */
  793. if ((ap->state & SC_ESCAPE) && buf[0] == PPP_ESCAPE)
  794. n = 1;
  795. else
  796. n = scan_ordinary(ap, buf, count);
  798. f = 0;
  799. if (flags != 0 && (ap->state & SC_TOSS) == 0) {
  800. /* check the flags to see if any char had an error */
  801. for (j = 0; j < n; ++j)
  802. if ((f = flags[j]) != 0)
  803. break;
  804. }
  805. if (f != 0) {
  806. /* start tossing */
  807. input_error(ap, f);
  809. } else if (n > 0 && (ap->state & SC_TOSS) == 0) {
  810. /* stuff the chars in the skb */
  811. skb = ap->rpkt;
  812. if (skb == 0) {
  813. skb = dev_alloc_skb(ap->mru + PPP_HDRLEN + 2);
  814. if (skb == 0)
  815. goto nomem;
  816. /* Try to get the payload 4-byte aligned */
  817. if (buf[0] != PPP_ALLSTATIONS)
  818. skb_reserve(skb, 2 + (buf[0] & 1));
  819. ap->rpkt = skb;
  820. }
  821. if (n > skb_tailroom(skb)) {
  822. /* packet overflowed MRU */
  823. input_error(ap, 1);
  824. } else {
  825. sp = skb_put(skb, n);
  826. memcpy(sp, buf, n);
  827. if (ap->state & SC_ESCAPE) {
  828. sp[0] ^= 0x20;
  829. ap->state &= ~SC_ESCAPE;
  830. }
  831. }
  832. }
  834. if (n >= count)
  835. break;
  837. c = buf[n];
  838. if (c == PPP_FLAG) {
  839. process_input_packet(ap);
  840. } else if (c == PPP_ESCAPE) {
  841. ap->state |= SC_ESCAPE;
  842. }
  843. /* otherwise it's a char in the recv ACCM */
  844. ++n;
  846. buf += n;
  847. if (flags != 0)
  848. flags += n;
  849. count -= n;
  850. }
  851. return;
  853.  nomem:
  854. printk(KERN_ERR "PPPasync: no memory (input pkt)n");
  855. input_error(ap, 0);
  856. }
  858. /*
  859.  * We look at LCP frames going past so that we can notice
  860.  * and react to the LCP configure-ack from the peer.
  861.  * In the situation where the peer has been sent a configure-ack
  862.  * already, LCP is up once it has sent its configure-ack
  863.  * so the immediately following packet can be sent with the
  864.  * configured LCP options.  This allows us to process the following
  865.  * packet correctly without pppd needing to respond quickly.
  866.  *
  867.  * We only respond to the received configure-ack if we have just
  868.  * sent a configure-request, and the configure-ack contains the
  869.  * same data (this is checked using a 16-bit crc of the data).
  870.  */
  871. #define CONFREQ 1 /* LCP code field values */
  872. #define CONFACK 2
  873. #define LCP_MRU 1 /* LCP option numbers */
  874. #define LCP_ASYNCMAP 2
  876. static void async_lcp_peek(struct asyncppp *ap, unsigned char *data,
  877.    int len, int inbound)
  878. {
  879. int dlen, fcs, i, code;
  880. u32 val;
  882. data += 2; /* skip protocol bytes */
  883. len -= 2;
  884. if (len < 4) /* 4 = code, ID, length */
  885. return;
  886. code = data[0];
  887. if (code != CONFACK && code != CONFREQ)
  888. return;
  889. dlen = (data[2] << 8) + data[3];
  890. if (len < dlen)
  891. return; /* packet got truncated or length is bogus */
  893. if (code == (inbound? CONFACK: CONFREQ)) {
  894. /*
  895.  * sent confreq or received confack:
  896.  * calculate the crc of the data from the ID field on.
  897.  */
  898. fcs = PPP_INITFCS;
  899. for (i = 1; i < dlen; ++i)
  900. fcs = PPP_FCS(fcs, data[i]);
  902. if (!inbound) {
  903. /* outbound confreq - remember the crc for later */
  904. ap->lcp_fcs = fcs;
  905. return;
  906. }
  908. /* received confack, check the crc */
  909. fcs ^= ap->lcp_fcs;
  910. ap->lcp_fcs = -1;
  911. if (fcs != 0)
  912. return;
  913. } else if (inbound)
  914. return; /* not interested in received confreq */
  916. /* process the options in the confack */
  917. data += 4;
  918. dlen -= 4;
  919. /* data[0] is code, data[1] is length */
  920. while (dlen >= 2 && dlen >= data[1]) {
  921. switch (data[0]) {
  922. case LCP_MRU:
  923. val = (data[2] << 8) + data[3];
  924. if (inbound)
  925. ap->mru = val;
  926. else
  927. ap->chan.mtu = val;
  928. break;
  929. case LCP_ASYNCMAP:
  930. val = (data[2] << 24) + (data[3] << 16)
  931. + (data[4] << 8) + data[5];
  932. if (inbound)
  933. ap->raccm = val;
  934. else
  935. ap->xaccm[0] = val;
  936. break;
  937. }
  938. dlen -= data[1];
  939. data += data[1];
  940. }
  941. }
  943. static void __exit ppp_async_cleanup(void)
  944. {
  945. if (tty_register_ldisc(N_PPP, NULL) != 0)
  946. printk(KERN_ERR "failed to unregister PPP line disciplinen");
  947. }
  949. module_init(ppp_async_init);
  950. module_exit(ppp_async_cleanup);