ppp_synctty.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787
  1. /*
  2. * PPP synchronous tty channel driver for Linux.
  3. *
  4. * This is a ppp channel driver that can be used with tty device drivers
  5. * that are frame oriented, such as synchronous HDLC devices.
  6. *
  7. * Complete PPP frames without encoding/decoding are exchanged between
  8. * the channel driver and the device driver.
  9. *
  10. * The async map IOCTL codes are implemented to keep the user mode
  11. * applications happy if they call them. Synchronous PPP does not use
  12. * the async maps.
  13. *
  14. * Copyright 1999 Paul Mackerras.
  15. *
  16. * Also touched by the grubby hands of Paul Fulghum paulkf@microgate.com
  17. *
  18. * This program is free software; you can redistribute it and/or
  19. * modify it under the terms of the GNU General Public License
  20. * as published by the Free Software Foundation; either version
  21. * 2 of the License, or (at your option) any later version.
  22. *
  23. * This driver provides the encapsulation and framing for sending
  24. * and receiving PPP frames over sync serial lines. It relies on
  25. * the generic PPP layer to give it frames to send and to process
  26. * received frames. It implements the PPP line discipline.
  27. *
  28. * Part of the code in this driver was inspired by the old async-only
  29. * PPP driver, written by Michael Callahan and Al Longyear, and
  30. * subsequently hacked by Paul Mackerras.
  31. *
  32. * ==FILEVERSION 20040616==
  33. */
  34. #include <linux/module.h>
  35. #include <linux/kernel.h>
  36. #include <linux/skbuff.h>
  37. #include <linux/tty.h>
  38. #include <linux/netdevice.h>
  39. #include <linux/poll.h>
  40. #include <linux/ppp_defs.h>
  41. #include <linux/if_ppp.h>
  42. #include <linux/ppp_channel.h>
  43. #include <linux/spinlock.h>
  44. #include <linux/completion.h>
  45. #include <linux/init.h>
  46. #include <asm/uaccess.h>
  47. #define PPP_VERSION "2.4.2"
  48. /* Structure for storing local state. */
  49. struct syncppp {
  50. struct tty_struct *tty;
  51. unsigned int flags;
  52. unsigned int rbits;
  53. int mru;
  54. spinlock_t xmit_lock;
  55. spinlock_t recv_lock;
  56. unsigned long xmit_flags;
  57. u32 xaccm[8];
  58. u32 raccm;
  59. unsigned int bytes_sent;
  60. unsigned int bytes_rcvd;
  61. struct sk_buff *tpkt;
  62. unsigned long last_xmit;
  63. struct sk_buff_head rqueue;
  64. struct tasklet_struct tsk;
  65. atomic_t refcnt;
  66. struct completion dead_cmp;
  67. struct ppp_channel chan; /* interface to generic ppp layer */
  68. };
  69. /* Bit numbers in xmit_flags */
  70. #define XMIT_WAKEUP 0
  71. #define XMIT_FULL 1
  72. /* Bits in rbits */
  73. #define SC_RCV_BITS (SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
  74. #define PPPSYNC_MAX_RQLEN 32 /* arbitrary */
  75. /*
  76. * Prototypes.
  77. */
  78. static struct sk_buff* ppp_sync_txmunge(struct syncppp *ap, struct sk_buff *);
  79. static int ppp_sync_send(struct ppp_channel *chan, struct sk_buff *skb);
  80. static int ppp_sync_ioctl(struct ppp_channel *chan, unsigned int cmd,
  81. unsigned long arg);
  82. static void ppp_sync_process(unsigned long arg);
  83. static int ppp_sync_push(struct syncppp *ap);
  84. static void ppp_sync_flush_output(struct syncppp *ap);
  85. static void ppp_sync_input(struct syncppp *ap, const unsigned char *buf,
  86. char *flags, int count);
  87. static struct ppp_channel_ops sync_ops = {
  88. ppp_sync_send,
  89. ppp_sync_ioctl
  90. };
  91. /*
  92. * Utility procedures to print a buffer in hex/ascii
  93. */
  94. static void
  95. ppp_print_hex (register __u8 * out, const __u8 * in, int count)
  96. {
  97. register __u8 next_ch;
  98. static const char hex[] = "0123456789ABCDEF";
  99. while (count-- > 0) {
  100. next_ch = *in++;
  101. *out++ = hex[(next_ch >> 4) & 0x0F];
  102. *out++ = hex[next_ch & 0x0F];
  103. ++out;
  104. }
  105. }
  106. static void
  107. ppp_print_char (register __u8 * out, const __u8 * in, int count)
  108. {
  109. register __u8 next_ch;
  110. while (count-- > 0) {
  111. next_ch = *in++;
  112. if (next_ch < 0x20 || next_ch > 0x7e)
  113. *out++ = '.';
  114. else {
  115. *out++ = next_ch;
  116. if (next_ch == '%') /* printk/syslogd has a bug !! */
  117. *out++ = '%';
  118. }
  119. }
  120. *out = '\0';
  121. }
  122. static void
  123. ppp_print_buffer (const char *name, const __u8 *buf, int count)
  124. {
  125. __u8 line[44];
  126. if (name != NULL)
  127. printk(KERN_DEBUG "ppp_synctty: %s, count = %d\n", name, count);
  128. while (count > 8) {
  129. memset (line, 32, 44);
  130. ppp_print_hex (line, buf, 8);
  131. ppp_print_char (&line[8 * 3], buf, 8);
  132. printk(KERN_DEBUG "%s\n", line);
  133. count -= 8;
  134. buf += 8;
  135. }
  136. if (count > 0) {
  137. memset (line, 32, 44);
  138. ppp_print_hex (line, buf, count);
  139. ppp_print_char (&line[8 * 3], buf, count);
  140. printk(KERN_DEBUG "%s\n", line);
  141. }
  142. }
  143. /*
  144. * Routines implementing the synchronous PPP line discipline.
  145. */
  146. /*
  147. * We have a potential race on dereferencing tty->disc_data,
  148. * because the tty layer provides no locking at all - thus one
  149. * cpu could be running ppp_synctty_receive while another
  150. * calls ppp_synctty_close, which zeroes tty->disc_data and
  151. * frees the memory that ppp_synctty_receive is using. The best
  152. * way to fix this is to use a rwlock in the tty struct, but for now
  153. * we use a single global rwlock for all ttys in ppp line discipline.
  154. *
  155. * FIXME: Fixed in tty_io nowdays.
  156. */
  157. static DEFINE_RWLOCK(disc_data_lock);
  158. static struct syncppp *sp_get(struct tty_struct *tty)
  159. {
  160. struct syncppp *ap;
  161. read_lock(&disc_data_lock);
  162. ap = tty->disc_data;
  163. if (ap != NULL)
  164. atomic_inc(&ap->refcnt);
  165. read_unlock(&disc_data_lock);
  166. return ap;
  167. }
  168. static void sp_put(struct syncppp *ap)
  169. {
  170. if (atomic_dec_and_test(&ap->refcnt))
  171. complete(&ap->dead_cmp);
  172. }
  173. /*
  174. * Called when a tty is put into sync-PPP line discipline.
  175. */
  176. static int
  177. ppp_sync_open(struct tty_struct *tty)
  178. {
  179. struct syncppp *ap;
  180. int err;
  181. int speed;
  182. if (tty->ops->write == NULL)
  183. return -EOPNOTSUPP;
  184. ap = kzalloc(sizeof(*ap), GFP_KERNEL);
  185. err = -ENOMEM;
  186. if (!ap)
  187. goto out;
  188. /* initialize the syncppp structure */
  189. ap->tty = tty;
  190. ap->mru = PPP_MRU;
  191. spin_lock_init(&ap->xmit_lock);
  192. spin_lock_init(&ap->recv_lock);
  193. ap->xaccm[0] = ~0U;
  194. ap->xaccm[3] = 0x60000000U;
  195. ap->raccm = ~0U;
  196. skb_queue_head_init(&ap->rqueue);
  197. tasklet_init(&ap->tsk, ppp_sync_process, (unsigned long) ap);
  198. atomic_set(&ap->refcnt, 1);
  199. init_completion(&ap->dead_cmp);
  200. ap->chan.private = ap;
  201. ap->chan.ops = &sync_ops;
  202. ap->chan.mtu = PPP_MRU;
  203. ap->chan.hdrlen = 2; /* for A/C bytes */
  204. speed = tty_get_baud_rate(tty);
  205. ap->chan.speed = speed;
  206. err = ppp_register_channel(&ap->chan);
  207. if (err)
  208. goto out_free;
  209. tty->disc_data = ap;
  210. tty->receive_room = 65536;
  211. return 0;
  212. out_free:
  213. kfree(ap);
  214. out:
  215. return err;
  216. }
  217. /*
  218. * Called when the tty is put into another line discipline
  219. * or it hangs up. We have to wait for any cpu currently
  220. * executing in any of the other ppp_synctty_* routines to
  221. * finish before we can call ppp_unregister_channel and free
  222. * the syncppp struct. This routine must be called from
  223. * process context, not interrupt or softirq context.
  224. */
  225. static void
  226. ppp_sync_close(struct tty_struct *tty)
  227. {
  228. struct syncppp *ap;
  229. write_lock_irq(&disc_data_lock);
  230. ap = tty->disc_data;
  231. tty->disc_data = NULL;
  232. write_unlock_irq(&disc_data_lock);
  233. if (!ap)
  234. return;
  235. /*
  236. * We have now ensured that nobody can start using ap from now
  237. * on, but we have to wait for all existing users to finish.
  238. * Note that ppp_unregister_channel ensures that no calls to
  239. * our channel ops (i.e. ppp_sync_send/ioctl) are in progress
  240. * by the time it returns.
  241. */
  242. if (!atomic_dec_and_test(&ap->refcnt))
  243. wait_for_completion(&ap->dead_cmp);
  244. tasklet_kill(&ap->tsk);
  245. ppp_unregister_channel(&ap->chan);
  246. skb_queue_purge(&ap->rqueue);
  247. kfree_skb(ap->tpkt);
  248. kfree(ap);
  249. }
  250. /*
  251. * Called on tty hangup in process context.
  252. *
  253. * Wait for I/O to driver to complete and unregister PPP channel.
  254. * This is already done by the close routine, so just call that.
  255. */
  256. static int ppp_sync_hangup(struct tty_struct *tty)
  257. {
  258. ppp_sync_close(tty);
  259. return 0;
  260. }
  261. /*
  262. * Read does nothing - no data is ever available this way.
  263. * Pppd reads and writes packets via /dev/ppp instead.
  264. */
  265. static ssize_t
  266. ppp_sync_read(struct tty_struct *tty, struct file *file,
  267. unsigned char __user *buf, size_t count)
  268. {
  269. return -EAGAIN;
  270. }
  271. /*
  272. * Write on the tty does nothing, the packets all come in
  273. * from the ppp generic stuff.
  274. */
  275. static ssize_t
  276. ppp_sync_write(struct tty_struct *tty, struct file *file,
  277. const unsigned char *buf, size_t count)
  278. {
  279. return -EAGAIN;
  280. }
  281. static int
  282. ppp_synctty_ioctl(struct tty_struct *tty, struct file *file,
  283. unsigned int cmd, unsigned long arg)
  284. {
  285. struct syncppp *ap = sp_get(tty);
  286. int __user *p = (int __user *)arg;
  287. int err, val;
  288. if (!ap)
  289. return -ENXIO;
  290. err = -EFAULT;
  291. switch (cmd) {
  292. case PPPIOCGCHAN:
  293. err = -EFAULT;
  294. if (put_user(ppp_channel_index(&ap->chan), p))
  295. break;
  296. err = 0;
  297. break;
  298. case PPPIOCGUNIT:
  299. err = -EFAULT;
  300. if (put_user(ppp_unit_number(&ap->chan), p))
  301. break;
  302. err = 0;
  303. break;
  304. case TCFLSH:
  305. /* flush our buffers and the serial port's buffer */
  306. if (arg == TCIOFLUSH || arg == TCOFLUSH)
  307. ppp_sync_flush_output(ap);
  308. err = tty_perform_flush(tty, arg);
  309. break;
  310. case FIONREAD:
  311. val = 0;
  312. if (put_user(val, p))
  313. break;
  314. err = 0;
  315. break;
  316. default:
  317. err = tty_mode_ioctl(tty, file, cmd, arg);
  318. break;
  319. }
  320. sp_put(ap);
  321. return err;
  322. }
  323. /* No kernel lock - fine */
  324. static unsigned int
  325. ppp_sync_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
  326. {
  327. return 0;
  328. }
  329. /* May sleep, don't call from interrupt level or with interrupts disabled */
  330. static void
  331. ppp_sync_receive(struct tty_struct *tty, const unsigned char *buf,
  332. char *cflags, int count)
  333. {
  334. struct syncppp *ap = sp_get(tty);
  335. unsigned long flags;
  336. if (!ap)
  337. return;
  338. spin_lock_irqsave(&ap->recv_lock, flags);
  339. ppp_sync_input(ap, buf, cflags, count);
  340. spin_unlock_irqrestore(&ap->recv_lock, flags);
  341. if (!skb_queue_empty(&ap->rqueue))
  342. tasklet_schedule(&ap->tsk);
  343. sp_put(ap);
  344. tty_unthrottle(tty);
  345. }
  346. static void
  347. ppp_sync_wakeup(struct tty_struct *tty)
  348. {
  349. struct syncppp *ap = sp_get(tty);
  350. clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
  351. if (!ap)
  352. return;
  353. set_bit(XMIT_WAKEUP, &ap->xmit_flags);
  354. tasklet_schedule(&ap->tsk);
  355. sp_put(ap);
  356. }
  357. static struct tty_ldisc_ops ppp_sync_ldisc = {
  358. .owner = THIS_MODULE,
  359. .magic = TTY_LDISC_MAGIC,
  360. .name = "pppsync",
  361. .open = ppp_sync_open,
  362. .close = ppp_sync_close,
  363. .hangup = ppp_sync_hangup,
  364. .read = ppp_sync_read,
  365. .write = ppp_sync_write,
  366. .ioctl = ppp_synctty_ioctl,
  367. .poll = ppp_sync_poll,
  368. .receive_buf = ppp_sync_receive,
  369. .write_wakeup = ppp_sync_wakeup,
  370. };
  371. static int __init
  372. ppp_sync_init(void)
  373. {
  374. int err;
  375. err = tty_register_ldisc(N_SYNC_PPP, &ppp_sync_ldisc);
  376. if (err != 0)
  377. printk(KERN_ERR "PPP_sync: error %d registering line disc.\n",
  378. err);
  379. return err;
  380. }
  381. /*
  382. * The following routines provide the PPP channel interface.
  383. */
  384. static int
  385. ppp_sync_ioctl(struct ppp_channel *chan, unsigned int cmd, unsigned long arg)
  386. {
  387. struct syncppp *ap = chan->private;
  388. int err, val;
  389. u32 accm[8];
  390. void __user *argp = (void __user *)arg;
  391. u32 __user *p = argp;
  392. err = -EFAULT;
  393. switch (cmd) {
  394. case PPPIOCGFLAGS:
  395. val = ap->flags | ap->rbits;
  396. if (put_user(val, (int __user *) argp))
  397. break;
  398. err = 0;
  399. break;
  400. case PPPIOCSFLAGS:
  401. if (get_user(val, (int __user *) argp))
  402. break;
  403. ap->flags = val & ~SC_RCV_BITS;
  404. spin_lock_irq(&ap->recv_lock);
  405. ap->rbits = val & SC_RCV_BITS;
  406. spin_unlock_irq(&ap->recv_lock);
  407. err = 0;
  408. break;
  409. case PPPIOCGASYNCMAP:
  410. if (put_user(ap->xaccm[0], p))
  411. break;
  412. err = 0;
  413. break;
  414. case PPPIOCSASYNCMAP:
  415. if (get_user(ap->xaccm[0], p))
  416. break;
  417. err = 0;
  418. break;
  419. case PPPIOCGRASYNCMAP:
  420. if (put_user(ap->raccm, p))
  421. break;
  422. err = 0;
  423. break;
  424. case PPPIOCSRASYNCMAP:
  425. if (get_user(ap->raccm, p))
  426. break;
  427. err = 0;
  428. break;
  429. case PPPIOCGXASYNCMAP:
  430. if (copy_to_user(argp, ap->xaccm, sizeof(ap->xaccm)))
  431. break;
  432. err = 0;
  433. break;
  434. case PPPIOCSXASYNCMAP:
  435. if (copy_from_user(accm, argp, sizeof(accm)))
  436. break;
  437. accm[2] &= ~0x40000000U; /* can't escape 0x5e */
  438. accm[3] |= 0x60000000U; /* must escape 0x7d, 0x7e */
  439. memcpy(ap->xaccm, accm, sizeof(ap->xaccm));
  440. err = 0;
  441. break;
  442. case PPPIOCGMRU:
  443. if (put_user(ap->mru, (int __user *) argp))
  444. break;
  445. err = 0;
  446. break;
  447. case PPPIOCSMRU:
  448. if (get_user(val, (int __user *) argp))
  449. break;
  450. if (val < PPP_MRU)
  451. val = PPP_MRU;
  452. ap->mru = val;
  453. err = 0;
  454. break;
  455. default:
  456. err = -ENOTTY;
  457. }
  458. return err;
  459. }
  460. /*
  461. * This is called at softirq level to deliver received packets
  462. * to the ppp_generic code, and to tell the ppp_generic code
  463. * if we can accept more output now.
  464. */
  465. static void ppp_sync_process(unsigned long arg)
  466. {
  467. struct syncppp *ap = (struct syncppp *) arg;
  468. struct sk_buff *skb;
  469. /* process received packets */
  470. while ((skb = skb_dequeue(&ap->rqueue)) != NULL) {
  471. if (skb->len == 0) {
  472. /* zero length buffers indicate error */
  473. ppp_input_error(&ap->chan, 0);
  474. kfree_skb(skb);
  475. }
  476. else
  477. ppp_input(&ap->chan, skb);
  478. }
  479. /* try to push more stuff out */
  480. if (test_bit(XMIT_WAKEUP, &ap->xmit_flags) && ppp_sync_push(ap))
  481. ppp_output_wakeup(&ap->chan);
  482. }
  483. /*
  484. * Procedures for encapsulation and framing.
  485. */
  486. static struct sk_buff*
  487. ppp_sync_txmunge(struct syncppp *ap, struct sk_buff *skb)
  488. {
  489. int proto;
  490. unsigned char *data;
  491. int islcp;
  492. data = skb->data;
  493. proto = (data[0] << 8) + data[1];
  494. /* LCP packets with codes between 1 (configure-request)
  495. * and 7 (code-reject) must be sent as though no options
  496. * have been negotiated.
  497. */
  498. islcp = proto == PPP_LCP && 1 <= data[2] && data[2] <= 7;
  499. /* compress protocol field if option enabled */
  500. if (data[0] == 0 && (ap->flags & SC_COMP_PROT) && !islcp)
  501. skb_pull(skb,1);
  502. /* prepend address/control fields if necessary */
  503. if ((ap->flags & SC_COMP_AC) == 0 || islcp) {
  504. if (skb_headroom(skb) < 2) {
  505. struct sk_buff *npkt = dev_alloc_skb(skb->len + 2);
  506. if (npkt == NULL) {
  507. kfree_skb(skb);
  508. return NULL;
  509. }
  510. skb_reserve(npkt,2);
  511. skb_copy_from_linear_data(skb,
  512. skb_put(npkt, skb->len), skb->len);
  513. kfree_skb(skb);
  514. skb = npkt;
  515. }
  516. skb_push(skb,2);
  517. skb->data[0] = PPP_ALLSTATIONS;
  518. skb->data[1] = PPP_UI;
  519. }
  520. ap->last_xmit = jiffies;
  521. if (skb && ap->flags & SC_LOG_OUTPKT)
  522. ppp_print_buffer ("send buffer", skb->data, skb->len);
  523. return skb;
  524. }
  525. /*
  526. * Transmit-side routines.
  527. */
  528. /*
  529. * Send a packet to the peer over an sync tty line.
  530. * Returns 1 iff the packet was accepted.
  531. * If the packet was not accepted, we will call ppp_output_wakeup
  532. * at some later time.
  533. */
  534. static int
  535. ppp_sync_send(struct ppp_channel *chan, struct sk_buff *skb)
  536. {
  537. struct syncppp *ap = chan->private;
  538. ppp_sync_push(ap);
  539. if (test_and_set_bit(XMIT_FULL, &ap->xmit_flags))
  540. return 0; /* already full */
  541. skb = ppp_sync_txmunge(ap, skb);
  542. if (skb != NULL)
  543. ap->tpkt = skb;
  544. else
  545. clear_bit(XMIT_FULL, &ap->xmit_flags);
  546. ppp_sync_push(ap);
  547. return 1;
  548. }
  549. /*
  550. * Push as much data as possible out to the tty.
  551. */
  552. static int
  553. ppp_sync_push(struct syncppp *ap)
  554. {
  555. int sent, done = 0;
  556. struct tty_struct *tty = ap->tty;
  557. int tty_stuffed = 0;
  558. if (!spin_trylock_bh(&ap->xmit_lock))
  559. return 0;
  560. for (;;) {
  561. if (test_and_clear_bit(XMIT_WAKEUP, &ap->xmit_flags))
  562. tty_stuffed = 0;
  563. if (!tty_stuffed && ap->tpkt) {
  564. set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
  565. sent = tty->ops->write(tty, ap->tpkt->data, ap->tpkt->len);
  566. if (sent < 0)
  567. goto flush; /* error, e.g. loss of CD */
  568. if (sent < ap->tpkt->len) {
  569. tty_stuffed = 1;
  570. } else {
  571. kfree_skb(ap->tpkt);
  572. ap->tpkt = NULL;
  573. clear_bit(XMIT_FULL, &ap->xmit_flags);
  574. done = 1;
  575. }
  576. continue;
  577. }
  578. /* haven't made any progress */
  579. spin_unlock_bh(&ap->xmit_lock);
  580. if (!(test_bit(XMIT_WAKEUP, &ap->xmit_flags) ||
  581. (!tty_stuffed && ap->tpkt)))
  582. break;
  583. if (!spin_trylock_bh(&ap->xmit_lock))
  584. break;
  585. }
  586. return done;
  587. flush:
  588. if (ap->tpkt) {
  589. kfree_skb(ap->tpkt);
  590. ap->tpkt = NULL;
  591. clear_bit(XMIT_FULL, &ap->xmit_flags);
  592. done = 1;
  593. }
  594. spin_unlock_bh(&ap->xmit_lock);
  595. return done;
  596. }
  597. /*
  598. * Flush output from our internal buffers.
  599. * Called for the TCFLSH ioctl.
  600. */
  601. static void
  602. ppp_sync_flush_output(struct syncppp *ap)
  603. {
  604. int done = 0;
  605. spin_lock_bh(&ap->xmit_lock);
  606. if (ap->tpkt != NULL) {
  607. kfree_skb(ap->tpkt);
  608. ap->tpkt = NULL;
  609. clear_bit(XMIT_FULL, &ap->xmit_flags);
  610. done = 1;
  611. }
  612. spin_unlock_bh(&ap->xmit_lock);
  613. if (done)
  614. ppp_output_wakeup(&ap->chan);
  615. }
  616. /*
  617. * Receive-side routines.
  618. */
  619. /* called when the tty driver has data for us.
  620. *
  621. * Data is frame oriented: each call to ppp_sync_input is considered
  622. * a whole frame. If the 1st flag byte is non-zero then the whole
  623. * frame is considered to be in error and is tossed.
  624. */
  625. static void
  626. ppp_sync_input(struct syncppp *ap, const unsigned char *buf,
  627. char *flags, int count)
  628. {
  629. struct sk_buff *skb;
  630. unsigned char *p;
  631. if (count == 0)
  632. return;
  633. if (ap->flags & SC_LOG_INPKT)
  634. ppp_print_buffer ("receive buffer", buf, count);
  635. /* stuff the chars in the skb */
  636. skb = dev_alloc_skb(ap->mru + PPP_HDRLEN + 2);
  637. if (!skb) {
  638. printk(KERN_ERR "PPPsync: no memory (input pkt)\n");
  639. goto err;
  640. }
  641. /* Try to get the payload 4-byte aligned */
  642. if (buf[0] != PPP_ALLSTATIONS)
  643. skb_reserve(skb, 2 + (buf[0] & 1));
  644. if (flags && *flags) {
  645. /* error flag set, ignore frame */
  646. goto err;
  647. } else if (count > skb_tailroom(skb)) {
  648. /* packet overflowed MRU */
  649. goto err;
  650. }
  651. p = skb_put(skb, count);
  652. memcpy(p, buf, count);
  653. /* strip address/control field if present */
  654. p = skb->data;
  655. if (p[0] == PPP_ALLSTATIONS && p[1] == PPP_UI) {
  656. /* chop off address/control */
  657. if (skb->len < 3)
  658. goto err;
  659. p = skb_pull(skb, 2);
  660. }
  661. /* decompress protocol field if compressed */
  662. if (p[0] & 1) {
  663. /* protocol is compressed */
  664. skb_push(skb, 1)[0] = 0;
  665. } else if (skb->len < 2)
  666. goto err;
  667. /* queue the frame to be processed */
  668. skb_queue_tail(&ap->rqueue, skb);
  669. return;
  670. err:
  671. /* queue zero length packet as error indication */
  672. if (skb || (skb = dev_alloc_skb(0))) {
  673. skb_trim(skb, 0);
  674. skb_queue_tail(&ap->rqueue, skb);
  675. }
  676. }
  677. static void __exit
  678. ppp_sync_cleanup(void)
  679. {
  680. if (tty_unregister_ldisc(N_SYNC_PPP) != 0)
  681. printk(KERN_ERR "failed to unregister Sync PPP line discipline\n");
  682. }
  683. module_init(ppp_sync_init);
  684. module_exit(ppp_sync_cleanup);
  685. MODULE_LICENSE("GPL");
  686. MODULE_ALIAS_LDISC(N_SYNC_PPP);