home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / drivers / net / ppp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-23  |  53.1 KB  |  2,099 lines
  1. /*
  2.    PPP for Linux
  3. */
  4.  
  5. /*
  6.    Sources:
  7.  
  8.    slip.c
  9.  
  10.    RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
  11.    Multi-protocol Datagrams over Point-to-Point Links
  12.  
  13.    RFC1332: IPCP
  14.  
  15.    ppp-2.0
  16.  
  17.    Flags for this module (any combination is acceptable for testing.):
  18.  
  19.    NET02D          -    Define if using Net-2-Debugged in kernels earlier
  20.                than v1.1.4.
  21.  
  22.    NEW_TTY_DRIVERS    -    Define if using new Ted Ts'o's alpha TTY drivers
  23.                from tsx-11.mit.edu. From Ted Ts'o.
  24.  
  25.    OPTIMIZE_FLAG_TIME -    Number of jiffies to force sending of leading flag
  26.             character. This is normally set to ((HZ * 3) / 2).
  27.             This is 1.5 seconds. If not defined then the leading
  28.             flag is always sent.  
  29. */
  30.  
  31. /* #define NET02D                -* */
  32. #define NEW_TTY_DRIVERS                /* */
  33. #define OPTIMIZE_FLAG_TIME  ((HZ * 3)/2)    /* */
  34.  
  35. #ifdef MODULE
  36. #include <linux/module.h>
  37. #include <linux/version.h>
  38. #endif
  39.  
  40. #include <linux/kernel.h>
  41. #include <linux/sched.h>
  42. #include <linux/types.h>
  43. #include <linux/fcntl.h>
  44. #include <linux/interrupt.h>
  45. #include <linux/ptrace.h>
  46. #include <linux/ioport.h>
  47. #include <linux/in.h>
  48. #include <linux/malloc.h>
  49. #include <linux/tty.h>
  50. #include <linux/errno.h>
  51. #include <linux/sched.h>   /* to get the struct task_struct */
  52. #include <linux/string.h>  /* used in new tty drivers */
  53. #include <linux/signal.h>  /* used in new tty drivers */
  54. #include <asm/system.h>
  55. #include <asm/bitops.h>
  56. #include <asm/segment.h>
  57.  
  58. #ifdef NET02D                /* v1.1.4 net code and earlier */
  59. #include <dev.h>
  60. #include <skbuff.h>
  61. #include <inet.h>
  62. #define    skb_queue_head_init(buf)    *(buf) = NULL
  63. #else                    /* v1.1.5 and later */
  64. #include <linux/netdevice.h>
  65. #include <linux/skbuff.h>
  66. #include <linux/inet.h>
  67. #endif
  68.  
  69. #include <linux/ppp.h>
  70.  
  71. #include <linux/ip.h>
  72. #include <linux/tcp.h>
  73.  
  74. #include "slhc.h"
  75.  
  76. #include <linux/if_arp.h>
  77. #ifndef ARPHRD_PPP
  78. #define ARPHRD_PPP 0
  79. #endif
  80.  
  81. #define PRINTK(p) printk p ;
  82. #define ASSERT(p) if (!p) PRINTK ((KERN_CRIT "assertion failed: " # p))
  83. #define PRINTKN(n,p) {if (ppp_debug >= n) PRINTK (p)}
  84. #define CHECK_PPP(a)  if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return a;}
  85. #define CHECK_PPP_VOID()  if (!ppp->inuse) { PRINTK ((ppp_warning, __LINE__)) return;}
  86.  
  87. #define in_xmap(ppp,c)    (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
  88. #define in_rmap(ppp,c)    ((((unsigned int) (unsigned char) (c)) < 0x20) && \
  89.             ppp->recv_async_map & (1 << (c)))
  90.  
  91. #define bset(p,b)    ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
  92.  
  93. int ppp_debug = 2;
  94. int ppp_debug_netpackets = 0;
  95.  
  96. /* Define this string only once for all macro invocations */
  97. static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
  98.  
  99. int ppp_init(struct device *);
  100. static void ppp_init_ctrl_blk(struct ppp *);
  101. static int ppp_dev_open(struct device *);
  102. static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
  103. static int ppp_dev_close(struct device *);
  104. static void ppp_kick_tty(struct ppp *);
  105.  
  106. #ifdef NEW_TTY_DRIVERS
  107. #define ppp_find(tty) ((struct ppp *) tty->disc_data)
  108. #else
  109. static void ppp_output_done(void *);
  110. static void ppp_unesc(struct ppp *ppp, unsigned char *c, int n);
  111. static struct ppp *ppp_find(struct tty_struct *);
  112. #endif
  113.  
  114. static void ppp_doframe(struct ppp *);
  115. static int ppp_do_ip(struct ppp *, unsigned short, unsigned char *, int);
  116. static int ppp_us_queue(struct ppp *, unsigned short, unsigned char *, int);
  117. static int ppp_xmit(struct sk_buff *, struct device *);
  118. static unsigned short ppp_type_trans(struct sk_buff *, struct device *);
  119.  
  120. #ifdef NET02D
  121. static int ppp_header(unsigned char *buff, struct device *dev,
  122.               unsigned short type, unsigned long daddr,
  123.               unsigned long saddr, unsigned len);
  124. static int ppp_rebuild_header(void *buff, struct device *dev);
  125. static void ppp_add_arp(unsigned long addr, struct sk_buff *skb,
  126.             struct device *dev);
  127. #else
  128. static int ppp_header(unsigned char *, struct device *, unsigned short,
  129.               void *, void *, unsigned, struct sk_buff *);
  130. static int ppp_rebuild_header(void *, struct device *, unsigned long,
  131.                   struct sk_buff *);
  132. #endif
  133.  
  134. static struct enet_statistics *ppp_get_stats (struct device *);
  135. static struct ppp *ppp_alloc(void);
  136. static int ppp_lock(struct ppp *);
  137. static void ppp_unlock(struct ppp *);
  138. static void ppp_add_fcs(struct ppp *);
  139. static int ppp_check_fcs(struct ppp *);
  140. static void ppp_print_buffer(const char *,char *,int,int);
  141.  
  142. static int ppp_read(struct tty_struct *, struct file *, unsigned char *,
  143.             unsigned int);
  144. static int ppp_write(struct tty_struct *, struct file *, unsigned char *,
  145.              unsigned int);
  146. static int ppp_ioctl(struct tty_struct *, struct file *, unsigned int,
  147.              unsigned long);
  148. static int ppp_select(struct tty_struct *tty, struct inode * inode,
  149.               struct file * filp, int sel_type, select_table * wait);
  150. static int ppp_open(struct tty_struct *);
  151. static void ppp_close(struct tty_struct *);
  152.  
  153. #ifdef NEW_TTY_DRIVERS
  154. static int ppp_receive_room(struct tty_struct *tty);
  155. static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
  156.                 char *fp, int count);
  157. static void ppp_write_wakeup(struct tty_struct *tty);
  158. #else
  159. static void ppp_tty_input_ready(struct tty_struct *);
  160. #endif
  161.  
  162. /* FCS table from RFC1331 */
  163.  
  164. static unsigned short fcstab[256] = {
  165.   0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  166.   0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  167.   0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  168.   0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  169.   0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  170.   0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  171.   0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  172.   0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  173.   0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  174.   0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  175.   0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  176.   0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  177.   0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  178.   0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  179.   0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  180.   0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  181.   0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  182.   0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  183.   0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  184.   0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  185.   0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  186.   0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  187.   0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  188.   0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  189.   0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  190.   0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  191.   0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  192.   0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  193.   0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  194.   0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  195.   0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  196.   0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  197.   };
  198.  
  199. struct tty_ldisc ppp_ldisc;
  200.  
  201. static struct ppp ppp_ctrl[PPP_NRUNIT];
  202.  
  203. /*************************************************************
  204.  * INITIALIZATION
  205.  *************************************************************/
  206.  
  207. static int first_time = 1;
  208.  
  209. /* called at boot time for each ppp device */
  210.  
  211. int
  212. ppp_init(struct device *dev)
  213. {
  214.   struct ppp *ppp;
  215.   int i;
  216.  
  217.   ppp = &ppp_ctrl[dev->base_addr];
  218.  
  219.   if (first_time) {
  220.     first_time = 0;
  221.  
  222.     printk (KERN_INFO "PPP: version %s (%d channels)"
  223. #ifdef NET02D
  224.        " NET02D"
  225. #endif
  226. #ifdef NEW_TTY_DRIVERS
  227.        " NEW_TTY_DRIVERS"
  228. #endif
  229. #ifdef OPTIMIZE_FLAG_TIME
  230.        " OPTIMIZE_FLAGS"
  231. #endif
  232.        "\n", PPP_VERSION, PPP_NRUNIT);
  233.  
  234.     printk (KERN_INFO
  235.        "TCP compression code copyright 1989 Regents of the "
  236.        "University of California\n");
  237.  
  238.     (void) memset(&ppp_ldisc, 0, sizeof(ppp_ldisc));
  239.     ppp_ldisc.open    = ppp_open;
  240.     ppp_ldisc.close   = ppp_close;
  241.     ppp_ldisc.read    = ppp_read;
  242.     ppp_ldisc.write   = ppp_write;
  243.     ppp_ldisc.ioctl   = ppp_ioctl;
  244.     ppp_ldisc.select  = ppp_select;
  245.  
  246. #ifdef NEW_TTY_DRIVERS
  247.     ppp_ldisc.magic       = TTY_LDISC_MAGIC;
  248.     ppp_ldisc.receive_room = ppp_receive_room;
  249.     ppp_ldisc.receive_buf = ppp_receive_buf;
  250.     ppp_ldisc.write_wakeup = ppp_write_wakeup;
  251. #else
  252.     ppp_ldisc.handler     = ppp_tty_input_ready;
  253. #endif
  254.  
  255.     if ((i = tty_register_ldisc(N_PPP, &ppp_ldisc)) == 0)
  256.       printk(KERN_INFO "PPP line discipline registered.\n");
  257.     else
  258.       printk(KERN_ERR "error registering line discipline: %d\n", i);
  259.   }
  260.  
  261.   /* initialize PPP control block */
  262.   ppp_init_ctrl_blk (ppp);
  263.   ppp->inuse = 0;
  264.   ppp->line  = dev->base_addr;
  265.   ppp->tty   = NULL;
  266.   ppp->dev   = dev;
  267.  
  268.   /* clear statistics */
  269.   memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
  270.  
  271.   /* device INFO */
  272.   dev->mtu             = PPP_MTU;
  273.   dev->hard_start_xmit = ppp_xmit;
  274.   dev->open            = ppp_dev_open;
  275.   dev->stop            = ppp_dev_close;
  276.   dev->get_stats       = ppp_get_stats;
  277.   dev->hard_header     = ppp_header;
  278.   dev->type_trans      = ppp_type_trans;
  279.   dev->rebuild_header  = ppp_rebuild_header;
  280.   dev->hard_header_len = 0;
  281.   dev->addr_len        = 0;
  282.   dev->type            = ARPHRD_PPP;
  283.  
  284. #ifdef NET02D
  285.   dev->add_arp         = ppp_add_arp;
  286.   dev->queue_xmit      = dev_queue_xmit;
  287. #else
  288.   dev->do_ioctl        = ppp_dev_ioctl;
  289. #endif
  290.  
  291.   for (i = 0; i < DEV_NUMBUFFS; i++)
  292.     skb_queue_head_init(&dev->buffs[i]);  /* = NULL if NET02D */
  293.  
  294.   /* New-style flags */
  295.   dev->flags      = IFF_POINTOPOINT;
  296.   dev->family     = AF_INET;
  297.   dev->pa_addr    = 0;
  298.   dev->pa_brdaddr = 0;
  299.   dev->pa_mask    = 0;
  300.   dev->pa_alen    = sizeof(unsigned long);
  301.  
  302.   return 0;
  303. }
  304.  
  305. static void
  306. ppp_init_ctrl_blk(struct ppp *ppp)
  307. {
  308.   ppp->magic        = PPP_MAGIC;
  309.   ppp->sending        = 0;
  310.   ppp->toss        = 0xFE;
  311.   ppp->escape        = 0;
  312.  
  313.   ppp->flags        = 0;
  314.   ppp->mtu        = PPP_MTU;
  315.   ppp->mru        = PPP_MRU;
  316.   ppp->fcs        = 0;
  317.  
  318.   memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
  319.   ppp->xmit_async_map[0] = 0xffffffff;
  320.   ppp->xmit_async_map[3] = 0x60000000;
  321.   ppp->recv_async_map     = 0x00000000;
  322.  
  323.   ppp->slcomp        = NULL;
  324.   ppp->rbuff        = NULL;
  325.   ppp->xbuff        = NULL;
  326.   ppp->cbuff        = NULL;
  327.  
  328.   ppp->rhead        = NULL;
  329.   ppp->rend        = NULL;
  330.   ppp->rcount        = 0;
  331.   ppp->xhead        = NULL;
  332.   ppp->xtail        = NULL;
  333.  
  334.   ppp->us_rbuff        = NULL;
  335.   ppp->us_rbuff_end    = NULL;
  336.   ppp->us_rbuff_head    = NULL;
  337.   ppp->us_rbuff_tail    = NULL;
  338.   ppp->read_wait    = NULL;
  339.   ppp->write_wait    = NULL;
  340.   ppp->us_rbuff_lock    = 0;
  341.   ppp->inp_sig        = 0;
  342.   ppp->inp_sig_pid    = 0;
  343.  
  344. #ifdef OPTIMIZE_FLAG_TIME /* ensure flag will always be sent first time */
  345.   ppp->last_xmit    = jiffies - OPTIMIZE_FLAG_TIME;
  346. #else
  347.   ppp->last_xmit    = 0;
  348. #endif
  349.  
  350.   /* clear statistics */
  351.   memset (&ppp->stats, '\0', sizeof (struct ppp_stats));
  352.  
  353.   /* Reset the demand dial information */
  354.   ppp->ddinfo.ip_sjiffies  =
  355.   ppp->ddinfo.ip_rjiffies  =
  356.   ppp->ddinfo.nip_sjiffies =
  357.   ppp->ddinfo.nip_rjiffies = jiffies;
  358. }
  359.  
  360. /*
  361.  * MTU has been changed by the IP layer. Unfortunately we are not told
  362.  * about this, but we spot it ourselves and fix things up. We could be
  363.  * in an upcall from the tty driver, or in an ip packet queue.
  364.  */
  365.    
  366. static void
  367. ppp_changedmtu (struct ppp *ppp, int new_mtu, int new_mru)
  368. {
  369.   struct device *dev;
  370.   unsigned char *new_rbuff, *new_xbuff, *new_cbuff;
  371.   unsigned char *old_rbuff, *old_xbuff, *old_cbuff;
  372.   int mtu, mru;
  373. /*
  374.  *  Allocate the buffer from the kernel for the data
  375.  */
  376.   dev = ppp->dev;
  377.   mru = new_mru;
  378.   mtu = new_mtu;
  379.  
  380.   /* RFC 1331, section 7.2 says the minimum value is 1500 bytes */
  381.   if (mru < PPP_MRU)
  382.     mru = PPP_MRU;
  383.  
  384.   mtu = (mtu * 2) + 20;
  385.   mru = (mru * 2) + 20;
  386.  
  387.   PRINTKN (2,(KERN_INFO "ppp: channel %s mtu = %d, mru = %d\n",
  388.           dev->name, new_mtu, new_mru));
  389.     
  390.   new_xbuff = (unsigned char *) kmalloc(mtu + 4, GFP_ATOMIC);
  391.   new_rbuff = (unsigned char *) kmalloc(mru + 4, GFP_ATOMIC);
  392.   new_cbuff = (unsigned char *) kmalloc(mru + 4, GFP_ATOMIC);
  393. /*
  394.  *  If the buffers failed to allocate then complain.
  395.  */
  396.   if (new_xbuff == NULL || new_rbuff == NULL || new_cbuff == NULL)
  397.     {
  398.       PRINTKN (2,(KERN_ERR "ppp: failed to allocate new buffers\n"));
  399. /*
  400.  *  Release new buffer pointers if the updates were not performed
  401.  */
  402.       if (new_rbuff != NULL)
  403.     kfree (new_rbuff);
  404.  
  405.       if (new_xbuff != NULL)
  406.     kfree (new_xbuff);
  407.  
  408.       if (new_cbuff != NULL)
  409.     kfree (new_cbuff);
  410.     }
  411. /*
  412.  *  Update the pointers to the new buffer structures.
  413.  */
  414.   else
  415.     {
  416.       cli();
  417.       old_xbuff       = ppp->xbuff;
  418.       old_rbuff       = ppp->rbuff;
  419.       old_cbuff       = ppp->cbuff;
  420.  
  421.       ppp->xbuff      = new_xbuff;
  422.       ppp->rbuff      = new_rbuff;
  423.       ppp->cbuff      = new_cbuff;
  424.  
  425.       dev->mem_start  = (unsigned long) new_xbuff;
  426.       dev->mem_end    = (unsigned long) (dev->mem_start + mtu);
  427.  
  428.       dev->rmem_start = (unsigned long) new_rbuff;
  429.       ppp->rend       = (unsigned char *)
  430.       dev->rmem_end   = (unsigned long) (dev->rmem_start + mru);
  431.  
  432.       ppp->rhead      = new_rbuff;
  433. /*
  434.  *  Update the parameters for the new buffer sizes
  435.  */
  436.       ppp->toss        = 0xFE;
  437.       ppp->escape    = 0;
  438.       ppp->sending    = 0;
  439.       ppp->rcount    = 0;
  440.  
  441.       ppp->mru        = new_mru;
  442.  
  443.       ppp->mtu        =
  444.       dev->mtu        = new_mtu;
  445.  
  446.       sti();
  447. /*
  448.  *  Release old buffer pointers
  449.  */
  450.       if (old_rbuff != NULL)
  451.     kfree (old_rbuff);
  452.  
  453.       if (old_xbuff != NULL)
  454.     kfree (old_xbuff);
  455.  
  456.       if (old_cbuff != NULL)
  457.     kfree (old_cbuff);
  458.     }
  459. }
  460.  
  461. /* called when we abandon the PPP line discipline */
  462.  
  463. static void
  464. ppp_release(struct ppp *ppp)
  465. {
  466. #ifdef NEW_TTY_DRIVERS
  467.   if (ppp->tty != NULL && ppp->tty->disc_data == ppp)
  468.     ppp->tty->disc_data = NULL; /* Break the tty->ppp link */
  469. #endif
  470.  
  471.   if (ppp->dev) {
  472.     ppp->dev->flags &= ~IFF_UP; /* down the device */
  473.     ppp->dev->flags |= IFF_POINTOPOINT;
  474.   }
  475.  
  476.   kfree (ppp->xbuff);
  477.   kfree (ppp->cbuff);
  478.   kfree (ppp->rbuff);
  479.   kfree (ppp->us_rbuff);
  480.  
  481.   ppp->xbuff    =
  482.   ppp->cbuff    =
  483.   ppp->rbuff    =
  484.   ppp->us_rbuff = NULL;
  485.  
  486.   if (ppp->slcomp) {
  487.     slhc_free(ppp->slcomp);
  488.     ppp->slcomp = NULL;
  489.   }
  490.  
  491.   ppp->inuse = 0;
  492.   ppp->tty   = NULL;
  493. }
  494.  
  495. static void
  496. ppp_close(struct tty_struct *tty)
  497. {
  498.   struct ppp *ppp = ppp_find(tty);
  499.  
  500.   if (ppp == NULL || ppp->magic != PPP_MAGIC) {
  501.     PRINTKN (1,(KERN_WARNING "ppp: trying to close unopened tty!\n"));
  502.   } else {
  503.     CHECK_PPP_VOID();
  504.     ppp_release (ppp);
  505.  
  506.     PRINTKN (2,(KERN_INFO "ppp: channel %s closing.\n", ppp->dev->name));
  507.   }
  508. }
  509.  
  510. /* called when PPP line discipline is selected on a tty */
  511. static int
  512. ppp_open(struct tty_struct *tty)
  513. {
  514.   struct ppp *ppp = ppp_find(tty);
  515.  
  516.   if (ppp) {
  517.     PRINTKN (1,(KERN_ERR "ppp_open: gack! tty already associated to %s!\n",
  518.         ppp->magic == PPP_MAGIC ? ppp->dev->name : "unknown"));
  519.     return -EEXIST;
  520.   }
  521.  
  522.   ppp = ppp_alloc();
  523.   if (ppp == NULL) {
  524.     PRINTKN (1,(KERN_ERR "ppp_open: couldn't allocate ppp channel\n"));
  525.     return -ENFILE;
  526.   }
  527.  
  528.   /* make sure the channel is actually open */
  529.   ppp_init_ctrl_blk (ppp);
  530.  
  531.   ppp->tty = tty;
  532.  
  533. #ifdef NEW_TTY_DRIVERS
  534.   tty->disc_data = ppp;
  535.   if (tty->driver.flush_buffer)
  536.     tty->driver.flush_buffer(tty);
  537.   if (tty->ldisc.flush_buffer)
  538.     tty->ldisc.flush_buffer(tty);
  539. #else
  540.   tty_read_flush (tty);
  541.   tty_write_flush (tty);
  542. #endif
  543.  
  544.   if ((ppp->slcomp = slhc_init(16, 16)) == NULL) {
  545.     PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
  546.     ppp_release (ppp);
  547.     return -ENOMEM;
  548.   }
  549.  
  550.   /* Define the buffers for operation */
  551.   ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
  552.   if (ppp->rbuff == NULL) {
  553.     ppp_release (ppp);
  554.     return -ENOMEM;
  555.   }
  556.  
  557.   /* Allocate a user-level receive buffer */
  558.   ppp->us_rbuff = (unsigned char *) kmalloc (RBUFSIZE, GFP_KERNEL);
  559.   if (ppp->us_rbuff == NULL) {
  560.     PRINTKN (1,(KERN_ERR "ppp: no space for user receive buffer\n"));
  561.     ppp_release (ppp);
  562.     return -ENOMEM;
  563.   }
  564.  
  565.   ppp->us_rbuff_head =
  566.   ppp->us_rbuff_tail = ppp->us_rbuff;
  567.   ppp->us_rbuff_end  = ppp->us_rbuff + RBUFSIZE;
  568.  
  569.   PRINTKN (2,(KERN_INFO "ppp: channel %s open\n", ppp->dev->name));
  570.  
  571. #ifdef MODULE
  572.   MOD_INC_USE_COUNT;
  573. #endif
  574.  
  575.   return (ppp->line);
  576. }
  577.  
  578. /* called when ppp interface goes "up".  here this just means we start
  579.    passing IP packets */
  580. static int
  581. ppp_dev_open(struct device *dev)
  582. {
  583.   struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  584.  
  585.   /* reset POINTOPOINT every time, since dev_close zaps it! */
  586.   dev->flags |= IFF_POINTOPOINT;
  587.  
  588.   if (ppp->tty == NULL) {
  589.     PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go open!\n",
  590.         dev->name));
  591.     return -ENXIO;
  592.   }
  593.  
  594.   PRINTKN (2,(KERN_INFO "ppp: channel %s going up for IP packets!\n",
  595.           dev->name));
  596.  
  597.   CHECK_PPP(-ENXIO);
  598.   return 0;
  599. }
  600.  
  601. static int
  602. ppp_dev_close(struct device *dev)
  603. {
  604.   struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  605.  
  606.   if (ppp->tty == NULL) {
  607.     PRINTKN (1,(KERN_ERR "ppp: %s not connected to a TTY! can't go down!\n",
  608.         dev->name));
  609.     return -ENXIO;
  610.   }
  611.  
  612.   PRINTKN (2,(KERN_INFO "ppp: channel %s going down for IP packets!\n",
  613.           dev->name));
  614.   CHECK_PPP(-ENXIO);
  615. #ifdef MODULE
  616.   MOD_DEC_USE_COUNT;
  617. #endif
  618.   return 0;
  619. }
  620.  
  621. #ifndef NET02D
  622. static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
  623. {
  624.   struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  625.   int    error;
  626.  
  627.   struct stats
  628.   {
  629.     struct ppp_stats  ppp_stats;
  630.     struct slcompress slhc;
  631.   } *result;
  632.  
  633.   error = verify_area (VERIFY_READ,
  634.                ifr->ifr_ifru.ifru_data,
  635.                sizeof (struct stats));
  636.  
  637.   if (error == 0) {
  638.     result = (struct stats *) ifr->ifr_ifru.ifru_data;
  639.  
  640.     memcpy_tofs (&result->ppp_stats, &ppp->stats, sizeof (struct ppp_stats));
  641.     if (ppp->slcomp)
  642.       memcpy_tofs (&result->slhc,    ppp->slcomp, sizeof (struct slcompress));
  643.   }
  644.  
  645.   return error;
  646. }
  647. #endif
  648.  
  649. /*************************************************************
  650.  * TTY OUTPUT
  651.  *    The following function delivers a fully-formed PPP
  652.  *    frame in ppp->xbuff to the TTY for output.
  653.  *************************************************************/
  654.  
  655. #ifdef NEW_TTY_DRIVERS
  656. static inline void
  657. #else
  658. static void
  659. #endif
  660. ppp_output_done (void *ppp)
  661. {
  662.   /* unlock the transmitter queue */
  663.   ppp_unlock ((struct ppp *) ppp);
  664.  
  665.   /* If the device is still up then enable the transmitter of the
  666.      next frame. */
  667.   if (((struct ppp *) ppp)->dev->flags & IFF_UP)
  668. #ifndef NET02D
  669.     mark_bh (NET_BH);
  670. #else
  671.     dev_tint (((struct ppp *) ppp)->dev);
  672. #endif
  673.  
  674.   /* enable any blocked process pending transmission */
  675.   wake_up_interruptible (&((struct ppp *) ppp)->write_wait);
  676. }
  677.  
  678. #ifndef NEW_TTY_DRIVERS
  679. static void
  680. ppp_kick_tty (struct ppp *ppp)
  681. {
  682.   register int count = ppp->xhead - ppp->xbuff;
  683.   register int answer;
  684.  
  685.   ppp->stats.sbytes += count;
  686.  
  687.   answer = tty_write_data (ppp->tty,
  688.                ppp->xbuff,
  689.                count,
  690.                ppp_output_done,
  691.                (void *) ppp);
  692.  
  693.   if (answer == 0)
  694.     ppp_output_done (ppp);   /* Should not happen */
  695.   else
  696.     if (answer < 0) {
  697.       ppp->stats.serrors++;
  698.       ppp_output_done (ppp); /* unlock the transmitter */
  699.     }
  700. }
  701.  
  702. #else
  703.  
  704. static void
  705. ppp_kick_tty (struct ppp *ppp)
  706. {
  707.     register int count, actual;
  708.     
  709.     count = ppp->xhead - ppp->xbuff;
  710.     
  711.     actual = ppp->tty->driver.write(ppp->tty, 0, ppp->xbuff, count);
  712.     ppp->stats.sbytes += actual;
  713.     if (actual == count) {
  714.         ppp_output_done(ppp);
  715.     } else {
  716.         ppp->xtail = ppp->xbuff + actual;
  717.         ppp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
  718.     }
  719. }
  720.  
  721. static void ppp_write_wakeup(struct tty_struct *tty)
  722. {
  723.     register int count, actual;
  724.     struct ppp *ppp = ppp_find(tty);
  725.  
  726.     if (!ppp || ppp->magic != PPP_MAGIC) {
  727.         PRINTKN (1,
  728.              (KERN_ERR "PPP: write_wakeup called but couldn't "
  729.               "find PPP struct.\n"));
  730.         return;
  731.     }
  732.  
  733.     if (!ppp->xtail)
  734.         return;
  735.  
  736.     cli();
  737.     if (ppp->flags & SC_XMIT_BUSY) {
  738.         sti();
  739.         return;
  740.     }
  741.     ppp->flags |= SC_XMIT_BUSY;
  742.     sti();
  743.     
  744.     count = ppp->xhead - ppp->xtail;
  745.     
  746.     actual = tty->driver.write(tty, 0, ppp->xtail, count);
  747.     ppp->stats.sbytes += actual;
  748.     if (actual == count) {
  749.         ppp->xtail = 0;
  750.         tty->flags &= ~TTY_DO_WRITE_WAKEUP;
  751.  
  752.         ppp_output_done(ppp);
  753.     } else {
  754.         ppp->xtail += actual;
  755.     }
  756.     ppp->flags &= ~SC_XMIT_BUSY;
  757. }
  758. #endif
  759.  
  760. /*************************************************************
  761.  * TTY INPUT
  762.  *    The following functions handle input that arrives from
  763.  *    the TTY.  It recognizes PPP frames and either hands them
  764.  *    to the network layer or queues them for delivery to a
  765.  *    user process reading this TTY.
  766.  *************************************************************/
  767.  
  768. /* stuff a single character into the receive buffer */
  769.  
  770. static inline void
  771. ppp_enqueue(struct ppp *ppp, unsigned char c)
  772. {
  773.   unsigned long flags;
  774.  
  775.   save_flags(flags);
  776.   cli();
  777.   if (ppp->rhead < ppp->rend) {
  778.     *ppp->rhead = c;
  779.     ppp->rhead++;
  780.     ppp->rcount++;
  781.   } else
  782.     ppp->stats.roverrun++;
  783.   restore_flags(flags);
  784. }
  785.  
  786. #ifdef CHECK_CHARACTERS
  787. static unsigned paritytab[8] = {
  788.     0x96696996, 0x69969669, 0x69969669, 0x96696996,
  789.     0x69969669, 0x96696996, 0x96696996, 0x69969669
  790. };
  791. #endif
  792.  
  793. #ifndef NEW_TTY_DRIVERS
  794. static void
  795. ppp_dump_inqueue(struct tty_struct *tty)
  796. {
  797.   int  head = tty->read_q.head,
  798.        tail = tty->read_q.tail,
  799.        i, count;
  800.   char buffer[8];
  801.  
  802.   PRINTK ((KERN_DEBUG "INQUEUE: head %d tail %d imode %x:\n", head, tail, 
  803.        (unsigned int) tty->termios->c_iflag))
  804.  
  805.   i     = tail;
  806.   count = 0;
  807.  
  808.   while (i != head) {
  809.     buffer [count] = tty->read_q.buf[i];
  810.     if (++count == 8) {
  811.       ppp_print_buffer (NULL, buffer, 8, KERNEL_DS);
  812.       count = 0;
  813.     }
  814.     i = (i + 1) & (TTY_BUF_SIZE - 1);
  815.   }
  816.   ppp_print_buffer (NULL, buffer, count, KERNEL_DS);
  817. }
  818.  
  819. /* called by lower levels of TTY driver when data becomes available.
  820.    all incoming data comes through this function. */
  821.  
  822. void ppp_tty_input_ready(struct tty_struct *tty)
  823. {
  824.   struct ppp *ppp = ppp_find(tty);
  825.   int n, error;
  826.   unsigned char buff[128];
  827.  
  828. /*  PRINTK( (KERN_DEBUG "PPP: handler called.\n") ) */
  829.   if (!ppp || ppp->magic != PPP_MAGIC) {
  830.     PRINTKN (1,
  831.          (KERN_ERR "PPP: handler called but couldn't find PPP struct.\n"));
  832.     return;
  833.   }
  834.  
  835.   CHECK_PPP_VOID();
  836.  
  837.   /* ZZZ */
  838.   if (ppp_debug >= 5)
  839.     ppp_dump_inqueue(ppp->tty);
  840.  
  841.   do {
  842.     n = tty_read_raw_data(tty, buff, 128);
  843.     if ( n == 0 )        /* nothing there */
  844.       break;
  845.  
  846.     if (ppp_debug >= 5)
  847.       ppp_print_buffer ("receive buffer", buff, n > 0 ? n : -n, KERNEL_DS);
  848.  
  849.     if ( n < 0 ) {
  850.       /* Last character is error flag.
  851.      Process the previous characters, then set toss flag. */
  852.       n = (-n) - 1;
  853.       error = buff[n];
  854.     } else error = 0;
  855.     ppp->stats.rbytes += n;
  856.     ppp_unesc(ppp,buff,n);
  857.     if (error)
  858.       ppp->toss = error;
  859.   } while (1);
  860. }
  861.  
  862. /* recover frame by undoing PPP escape mechanism;
  863.    copies N chars of input data from C into PPP->rbuff
  864.    calls ppp_doframe to dispose of any frames it finds
  865. */
  866.  
  867. static void
  868. ppp_unesc(struct ppp *ppp, unsigned char *c, int n)
  869. {
  870.   int i;
  871.  
  872.   for (i = 0; i < n; i++, c++) {
  873.     PRINTKN (6,(KERN_DEBUG "(%x)", (unsigned int) *c));
  874.  
  875. #ifdef CHECK_CHARACTERS
  876.     if (*c & 0x80)
  877.     sc->sc_flags |= SC_RCV_B7_1;
  878.     else
  879.     sc->sc_flags |= SC_RCV_B7_0;
  880.  
  881.     if (paritytab[*c >> 5] & (1 << (*c & 0x1F)))
  882.     sc->sc_flags |= SC_RCV_ODDP;
  883.     else
  884.     sc->sc_flags |= SC_RCV_EVNP;
  885. #endif
  886.  
  887.     switch (*c) {
  888.     case PPP_ESC:        /* PPP_ESC: invert 0x20 in next character */
  889.       ppp->escape = PPP_TRANS;
  890.       break;
  891.  
  892.     case PPP_FLAG:        /* PPP_FLAG: end of frame */
  893.       if (ppp->escape)        /* PPP_ESC just before PPP_FLAG is illegal */
  894.     ppp->toss = 0xFF;
  895.  
  896.       if ((ppp->toss & 0x80) == 0)
  897.     ppp_doframe(ppp);    /* pass frame on to next layers */
  898.  
  899.       ppp->rcount = 0;
  900.       ppp->rhead  = ppp->rbuff;
  901.       ppp->escape = 0;
  902.       ppp->toss   = 0;
  903.       break;
  904.  
  905.     default:            /* regular character */
  906.       if (!in_rmap (ppp, *c)) {
  907.     if (ppp->toss == 0)
  908.       ppp_enqueue (ppp, *c ^ ppp->escape);
  909.     ppp->escape = 0;
  910.       }
  911.       break;
  912.     }
  913.   }
  914. }
  915.  
  916. #else
  917. static int ppp_receive_room(struct tty_struct *tty)
  918. {
  919.     return 65536;  /* We can handle an infinite amount of data. :-) */
  920. }
  921.  
  922.  
  923. static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
  924.                 char *fp, int count)
  925. {
  926.   register struct ppp *ppp = ppp_find (tty);
  927.   unsigned char c;
  928.  
  929. /*  PRINTK( ("PPP: handler called.\n") ); */
  930.  
  931.   if (!ppp || ppp->magic != PPP_MAGIC) {
  932.     PRINTKN (1,("PPP: handler called but couldn't find "
  933.         "PPP struct.\n"));
  934.     return;
  935.   }
  936.  
  937.   CHECK_PPP_VOID();
  938.  
  939.   if (ppp_debug >= 5) {
  940.     ppp_print_buffer ("receive buffer", cp, count, KERNEL_DS);
  941.   }
  942.  
  943.   ppp->stats.rbytes += count;
  944.  
  945.   while (count-- > 0) {
  946.     c = *cp++;
  947.  
  948.     if (fp) {
  949.       if (*fp && ppp->toss == 0)
  950.     ppp->toss = *fp;
  951.       fp++;
  952.     }
  953.  
  954. #ifdef CHECK_CHARACTERS
  955.     if (c & 0x80)
  956.     sc->sc_flags |= SC_RCV_B7_1;
  957.     else
  958.     sc->sc_flags |= SC_RCV_B7_0;
  959.  
  960.     if (paritytab[c >> 5] & (1 << (c & 0x1F)))
  961.     sc->sc_flags |= SC_RCV_ODDP;
  962.     else
  963.     sc->sc_flags |= SC_RCV_EVNP;
  964. #endif
  965.  
  966.     switch (c) {
  967.     case PPP_ESC:        /* PPP_ESC: invert 0x20 in next character */
  968.       ppp->escape = PPP_TRANS;
  969.       break;
  970.  
  971.     case PPP_FLAG:        /* PPP_FLAG: end of frame */
  972.       if (ppp->escape)        /* PPP_ESC just before PPP_FLAG is "cancel"*/
  973.     ppp->toss = 0xFF;
  974.  
  975.       if ((ppp->toss & 0x80) == 0)
  976.     ppp_doframe(ppp);    /* pass frame on to next layers */
  977.  
  978.       ppp->rcount = 0;
  979.       ppp->rhead  = ppp->rbuff;
  980.       ppp->escape = 0;
  981.       ppp->toss   = 0;
  982.       break;
  983.  
  984.     default:            /* regular character */
  985.       if (!in_rmap (ppp, c)) {
  986.     if (ppp->toss == 0)
  987.       ppp_enqueue (ppp, c ^ ppp->escape);
  988.     ppp->escape = 0;
  989.       }
  990.     }
  991.   }
  992. }
  993. #endif
  994.  
  995. /* on entry, a received frame is in ppp->rbuff
  996.    check it and dispose as appropriate */
  997. static void
  998. ppp_doframe(struct ppp *ppp)
  999. {
  1000.   u_char *c = ppp->rbuff;
  1001.   u_short proto;
  1002.   int count = ppp->rcount;
  1003.  
  1004.   /* forget it if we've already noticed an error */
  1005.   if (ppp->toss) {
  1006.     PRINTKN (1, (KERN_WARNING "ppp_toss: tossing frame, reason = %d\n",
  1007.          ppp->toss));
  1008.     ppp->stats.rerrors++;
  1009.     return;
  1010.   }
  1011.  
  1012.   /* do this before printing buffer to avoid generating copious output */
  1013.   if (count == 0)
  1014.     return;
  1015.  
  1016.   if (ppp_debug >= 3)
  1017.     ppp_print_buffer ("receive frame", c, count, KERNEL_DS);
  1018.  
  1019.   if (count < 4) {
  1020.     PRINTKN (1,(KERN_WARNING "ppp: got runt ppp frame, %d chars\n", count));
  1021.     ppp->stats.runts++;
  1022.     return;
  1023.   }
  1024.  
  1025.   /* check PPP error detection field */
  1026.   if (!ppp_check_fcs(ppp)) {
  1027.     PRINTKN (1,(KERN_WARNING "ppp: frame with bad fcs\n"));
  1028.     ppp->stats.rerrors++;
  1029.     return;
  1030.   }
  1031.  
  1032.   count -= 2;            /* ignore last two characters */
  1033.  
  1034.   /* now we have a good frame */
  1035.   /* figure out the protocol field */
  1036.   if ((c[0] == PPP_ADDRESS) && (c[1] == PPP_CONTROL)) {
  1037.     c = c + 2;            /* ADDR/CTRL not compressed, so skip */
  1038.     count -= 2;
  1039.   }
  1040.  
  1041.   proto = (u_short) *c++;        /* PROTO compressed */
  1042.   if (proto & 1) {
  1043.     count--;
  1044.   } else {
  1045.     proto = (proto << 8) | (u_short) *c++; /* PROTO uncompressed */
  1046.     count -= 2;
  1047.   }
  1048.  
  1049.   /* Send the frame to the network if the ppp device is up */
  1050.   if ((ppp->dev->flags & IFF_UP) && ppp_do_ip(ppp, proto, c, count)) {
  1051.     ppp->ddinfo.ip_rjiffies = jiffies;
  1052.     return;
  1053.   }
  1054.  
  1055.   /* If we got here, it has to go to a user process doing a read,
  1056.      so queue it.
  1057.  
  1058.      User process expects to get whole frame (for some reason), so
  1059.      use count+2 so as to include FCS field. */
  1060.  
  1061.   if (ppp_us_queue (ppp, proto, c, count+2)) {
  1062.     ppp->ddinfo.nip_rjiffies = jiffies;
  1063.     ppp->stats.rothers++;
  1064.     return;
  1065.   }
  1066.  
  1067.   /* couldn't cope. */
  1068.   PRINTKN (1,(KERN_WARNING
  1069.           "ppp: dropping packet on the floor: nobody could take it.\n"));
  1070.   ppp->stats.tossed++;
  1071. }
  1072.  
  1073. /* Examine packet at C, attempt to pass up to net layer. 
  1074.    PROTO is the protocol field from the PPP frame.
  1075.    Return 1 if could handle it, 0 otherwise.  */
  1076.  
  1077. static int
  1078. ppp_do_ip (struct ppp *ppp, unsigned short proto, unsigned char *c,
  1079.       int count)
  1080. {
  1081.   int flags, done;
  1082.  
  1083.   PRINTKN (4,(KERN_DEBUG "ppp_do_ip: proto %x len %d first byte %x\n",
  1084.           (int) proto, count, c[0]));
  1085.  
  1086.   if (ppp_debug_netpackets) {
  1087.     PRINTK (("KERN_DEBUG %s <-- proto %x len %d\n", ppp->dev->name,
  1088.          (int) proto, count));
  1089.   }
  1090.     
  1091.   if (proto == PROTO_IP) {
  1092.     ppp->stats.runcomp++;
  1093.     goto sendit;
  1094.   }
  1095.  
  1096.   if ((proto == PROTO_VJCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
  1097.     /* get space for uncompressing the header */
  1098.     done = 0;
  1099.     save_flags (flags);
  1100.     cli();
  1101.     if ((ppp->rhead + 80) < ppp->rend) {
  1102.       ppp->rhead += 80;
  1103.       ppp->rcount += 80;
  1104.       done = 1;
  1105.     }
  1106.     restore_flags(flags);
  1107.  
  1108.     if (! done)    {
  1109.       PRINTKN (1,(KERN_NOTICE
  1110.           "ppp: no space to decompress VJ compressed TCP header.\n"));
  1111.       ppp->stats.roverrun++;
  1112.       return 1;
  1113.     }
  1114.  
  1115.     count = slhc_uncompress(ppp->slcomp, c, count);
  1116.     if (count <= 0) {
  1117.       ppp->stats.rerrors++;
  1118.       PRINTKN (1,(KERN_NOTICE "ppp: error in VJ decompression\n"));
  1119.       return 1;
  1120.     }
  1121.     ppp->stats.rcomp++;
  1122.     goto sendit;
  1123.   }
  1124.   
  1125.   if ((proto == PROTO_VJUNCOMP) && !(ppp->flags & SC_REJ_COMP_TCP)) {
  1126.     if (slhc_remember(ppp->slcomp, c, count) <= 0) {
  1127.       ppp->stats.rerrors++;
  1128.       PRINTKN (1,(KERN_NOTICE "ppp: error in VJ memorizing\n"));
  1129.       return 1;
  1130.     }
  1131.     ppp->stats.runcomp++;
  1132.     goto sendit;
  1133.   }
  1134.  
  1135.   /* not ours */
  1136.   return 0;
  1137.  
  1138.  sendit:
  1139.   if (ppp_debug_netpackets) {
  1140.     struct iphdr *iph = (struct iphdr *) c;
  1141.     PRINTK ((KERN_INFO "%s <--    src %lx dst %lx len %d\n", ppp->dev->name, 
  1142.          iph->saddr, iph->daddr, count))
  1143.   }
  1144.  
  1145.   /* receive the frame through the network software */
  1146.   (void) dev_rint (c, count, 0, ppp->dev);
  1147.   return 1;
  1148. }
  1149.  
  1150. /* stuff packet at BUF, length LEN, into the us_rbuff buffer
  1151.    prepend PROTO information */
  1152.  
  1153. #define PUTC(c,label) *ppp->us_rbuff_head++ = c; \
  1154.                 if (ppp->us_rbuff_head == ppp->us_rbuff_end) \
  1155.                      ppp->us_rbuff_head = ppp->us_rbuff; \
  1156.                 if (ppp->us_rbuff_head == ppp->us_rbuff_tail) \
  1157.                      goto label;
  1158. #define GETC(c) c = *ppp->us_rbuff_tail++; \
  1159.                 if (ppp->us_rbuff_tail == ppp->us_rbuff_end) \
  1160.                      ppp->us_rbuff_tail = ppp->us_rbuff;
  1161.  
  1162. static int
  1163. ppp_us_queue(struct ppp *ppp, unsigned short proto, 
  1164.          unsigned char *buf, int len)
  1165. {
  1166.   int totlen;
  1167.   unsigned char *saved_head;
  1168.  
  1169.   totlen = len+2;        /* including protocol */
  1170.  
  1171.   if (set_bit(1, &ppp->us_rbuff_lock)) {
  1172.     PRINTKN (1, (KERN_NOTICE "ppp_us_queue: can't get lock\n"));
  1173.     return 0;
  1174.   }
  1175.   saved_head = ppp->us_rbuff_head;
  1176.  
  1177.   PUTC((totlen & 0xff00) >> 8, failure);
  1178.   PUTC(totlen & 0x00ff, failure);
  1179.   PUTC((proto & 0xff00) >> 8, failure);
  1180.   PUTC(proto & 0x00ff, failure);
  1181.  
  1182.   while (len-- > 0) {
  1183.     PUTC(*buf++, failure);
  1184.   }
  1185.  
  1186.   PRINTKN (3, (KERN_INFO "ppp: successfully queued %d bytes\n", totlen));
  1187.   clear_bit(1, &ppp->us_rbuff_lock);
  1188.   wake_up_interruptible (&ppp->read_wait);
  1189.  
  1190. #ifdef NEW_TTY_DRIVERS
  1191.   kill_fasync(ppp->tty->fasync, SIGIO);
  1192. #endif
  1193.  
  1194.   if (ppp->inp_sig && ppp->inp_sig_pid)
  1195.     if (kill_proc (ppp->inp_sig_pid, ppp->inp_sig, 1) != 0) {
  1196.       /* process is gone */
  1197.       PRINTKN (2,(KERN_NOTICE
  1198.           "ppp: process that requested notification is gone\n"));
  1199.       ppp->inp_sig = 0;
  1200.       ppp->inp_sig_pid = 0;
  1201.     }
  1202.   return 1;
  1203.  
  1204.  failure:
  1205.   ppp->us_rbuff_head = saved_head;
  1206.   clear_bit(1, &ppp->us_rbuff_lock);
  1207.  
  1208.   PRINTKN (1, (KERN_NOTICE "ppp_us_queue: ran out of buffer space.\n"));
  1209.  
  1210.   return 0;
  1211. }
  1212.  
  1213. /*************************************************************
  1214.  * LINE DISCIPLINE SUPPORT
  1215.  *    The following functions form support user programs
  1216.  *    which read and write data on a TTY with the PPP line
  1217.  *    discipline.  Reading is done from a circular queue,
  1218.  *    filled by the lower TTY levels.
  1219.  *************************************************************/
  1220.  
  1221. /* read a PPP frame from the us_rbuff circular buffer, 
  1222.    waiting if necessary
  1223. */
  1224.  
  1225. static int
  1226. ppp_read(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
  1227. {
  1228.   struct ppp *ppp = ppp_find(tty);
  1229.   unsigned char c;
  1230.   int len, i;
  1231.  
  1232.   if (!ppp || ppp->magic != PPP_MAGIC) {
  1233.     PRINTKN (1,(KERN_ERR "ppp_read: cannot find ppp channel\n"));
  1234.     return -EIO;
  1235.   }
  1236.  
  1237.   CHECK_PPP(-ENXIO);
  1238.  
  1239.   PRINTKN (4,(KERN_DEBUG "ppp_read: called %x num %u\n",
  1240.           (unsigned int) buf,
  1241.           nr));
  1242.  
  1243.   do {
  1244.     /* try to acquire read lock */
  1245.     if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
  1246.       /* got lock */
  1247.       if (ppp->us_rbuff_head == ppp->us_rbuff_tail) {
  1248.     /* no data */
  1249.     PRINTKN (4,(KERN_DEBUG "ppp_read: no data\n"));
  1250.     clear_bit(0, &ppp->us_rbuff_lock);
  1251.         if (ppp->inp_sig) {
  1252.       PRINTKN (4,(KERN_DEBUG "ppp_read: EWOULDBLOCK\n"));
  1253.       return -EWOULDBLOCK;
  1254.         } else goto wait;
  1255.       }
  1256.  
  1257.       /* reset the time of the last read operation */
  1258.       ppp->ddinfo.nip_rjiffies = jiffies;
  1259.  
  1260.       GETC (c); len = c << 8; GETC (c); len += c;
  1261.  
  1262.       PRINTKN (4,(KERN_DEBUG "ppp_read: len = %d\n", len));
  1263.  
  1264.       if (len + 2 > nr) {
  1265.     /* frame too big; can't copy it, but do update us_rbuff_head */
  1266.     PRINTKN (1,(KERN_DEBUG
  1267.             "ppp: read of %u bytes too small for %d frame\n",
  1268.             nr, len+2));
  1269.     ppp->us_rbuff_head += len;
  1270.     if (ppp->us_rbuff_head > ppp->us_rbuff_end)
  1271.       ppp->us_rbuff_head += - (ppp->us_rbuff_end - ppp->us_rbuff);
  1272.     clear_bit(0, &ppp->us_rbuff_lock);
  1273.     wake_up_interruptible (&ppp->read_wait);
  1274.     ppp->stats.rgiants++;
  1275.     return -EOVERFLOW;        /* ZZZ; HACK! */
  1276.       } else {
  1277.     /* have the space: copy the packet, faking the first two bytes */
  1278.     put_fs_byte (PPP_ADDRESS, buf++);
  1279.     put_fs_byte (PPP_CONTROL, buf++);
  1280.     i = len;
  1281.     while (i-- > 0) {
  1282.       GETC (c);
  1283.       put_fs_byte (c, buf++);
  1284.     }
  1285.       }
  1286.  
  1287.       clear_bit(0, &ppp->us_rbuff_lock);
  1288.       PRINTKN (3,(KERN_DEBUG "ppp_read: passing %d bytes up\n", len + 2));
  1289.       ppp->stats.rothers++;
  1290.       return len + 2;
  1291.     }
  1292.  
  1293.     /* need to wait */
  1294.   wait:
  1295.     current->timeout = 0;
  1296.     PRINTKN (3,(KERN_DEBUG "ppp_read: sleeping\n"));
  1297.     interruptible_sleep_on (&ppp->read_wait);
  1298.     if (current->signal & ~current->blocked)
  1299.       return -EINTR;
  1300.   } while (1);
  1301. }
  1302.  
  1303. /* stuff a character into the transmit buffer, using PPP's way of escaping
  1304.    special characters.
  1305.    also, update ppp->fcs to take account of new character */
  1306. static inline void
  1307. ppp_stuff_char(struct ppp *ppp, unsigned char c)
  1308. {
  1309.   int curpt = ppp->xhead - ppp->xbuff;
  1310.   if ((curpt < 0) || (curpt > 3000)) {
  1311.     PRINTK ((KERN_DEBUG "ppp_stuff_char: %x %x %d\n",
  1312.          (unsigned int) ppp->xbuff, (unsigned int) ppp->xhead, curpt))
  1313.   }
  1314.   if (in_xmap (ppp, c)) {
  1315.     *ppp->xhead++ = PPP_ESC;
  1316.     *ppp->xhead++ = c ^ PPP_TRANS;
  1317.   } else
  1318.     *ppp->xhead++ = c;
  1319.   ppp->fcs = (ppp->fcs >> 8) ^ fcstab[(ppp->fcs ^ c) & 0xff];
  1320. }
  1321.  
  1322. /* write a frame with NR chars from BUF to TTY
  1323.    we have to put the FCS field on ourselves
  1324. */
  1325.  
  1326. static int
  1327. ppp_write(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
  1328. {
  1329.   struct ppp *ppp = ppp_find(tty);
  1330.   int i;
  1331.  
  1332.   if (!ppp || ppp->magic != PPP_MAGIC) {
  1333.     PRINTKN (1,(KERN_ERR "ppp_write: cannot find ppp unit\n"));
  1334.     return -EIO;
  1335.   }
  1336.  
  1337.   CHECK_PPP(-ENXIO);
  1338.   
  1339.   if (ppp->mtu != ppp->dev->mtu)    /* Someone has been ifconfigging */
  1340.     ppp_changedmtu (ppp, ppp->dev->mtu, ppp->mru);
  1341.  
  1342.   if (nr > ppp->mtu) {
  1343.     PRINTKN (1,(KERN_WARNING
  1344.         "ppp_write: truncating user packet from %u to mtu %d\n",
  1345.         nr, ppp->mtu));
  1346.     nr = ppp->mtu;
  1347.   }
  1348.  
  1349.   if (ppp_debug >= 3)
  1350.     ppp_print_buffer ("write frame", buf, nr, USER_DS);
  1351.  
  1352.   /* lock this PPP unit so we will be the only writer;
  1353.      sleep if necessary */
  1354.   while ((ppp->sending == 1) || !ppp_lock(ppp)) {
  1355.     current->timeout = 0;
  1356.     PRINTKN (3,(KERN_DEBUG "ppp_write: sleeping\n"));
  1357.     interruptible_sleep_on(&ppp->write_wait);
  1358.     if (current->signal & ~current->blocked)
  1359.       return -EINTR;
  1360.   }
  1361.  
  1362.   /* OK, locked.  Stuff the given bytes into the buffer. */
  1363.  
  1364.   PRINTKN(4,(KERN_DEBUG "ppp_write: acquired write lock\n"));
  1365.   ppp->xhead = ppp->xbuff;
  1366.  
  1367. #ifdef OPTIMIZE_FLAG_TIME
  1368.   if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
  1369.     *ppp->xhead++ = PPP_FLAG;
  1370.   ppp->last_xmit = jiffies;
  1371. #else      
  1372.   *ppp->xhead++ = PPP_FLAG;
  1373. #endif
  1374.  
  1375.   ppp->fcs = PPP_FCS_INIT;
  1376.   i = nr;
  1377.   while (i-- > 0)
  1378.     ppp_stuff_char(ppp,get_fs_byte(buf++));
  1379.  
  1380.   ppp_add_fcs(ppp);        /* concatenate FCS at end */
  1381.  
  1382.   *ppp->xhead++ = PPP_FLAG;
  1383.   
  1384.   /* reset the time of the last write operation */
  1385.   ppp->ddinfo.nip_sjiffies = jiffies;
  1386.  
  1387.   if (ppp_debug >= 6)
  1388.     ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
  1389.   else {
  1390.     PRINTKN (4,(KERN_DEBUG
  1391.         "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
  1392.   }
  1393.  
  1394.   /* packet is ready-to-go */
  1395.   ++ppp->stats.sothers;
  1396.   ppp_kick_tty(ppp);
  1397.  
  1398.   return((int)nr);
  1399. }
  1400.  
  1401. static int
  1402. ppp_ioctl(struct tty_struct *tty, struct file *file, unsigned int i,
  1403.       unsigned long l)
  1404. {
  1405.   struct ppp *ppp = ppp_find(tty);
  1406.   register int temp_i = 0;
  1407.   int error;
  1408.  
  1409.   if (!ppp || ppp->magic != PPP_MAGIC) {
  1410.     PRINTK ((KERN_ERR "ppp_ioctl: can't find PPP block from tty!\n"))
  1411.     return -EBADF;
  1412.   }
  1413.  
  1414.   CHECK_PPP(-ENXIO);
  1415.  
  1416.   /* This must be root user */
  1417.   if (!suser())
  1418.     return -EPERM;
  1419.  
  1420.   switch (i) {
  1421.   case PPPIOCSMRU:
  1422.     error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  1423.     if (error == 0) {
  1424.       temp_i = (int) get_fs_long (l);
  1425.       PRINTKN (3,(KERN_INFO "ppp_ioctl: set mru to %d\n", temp_i));
  1426.       if (ppp->mru != temp_i)
  1427.     ppp_changedmtu (ppp, ppp->dev->mtu, temp_i);
  1428.     }
  1429.     break;
  1430.  
  1431.   case PPPIOCGFLAGS:
  1432.     error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  1433.     if (error == 0) {
  1434.       temp_i = (ppp->flags & SC_MASK);
  1435. #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
  1436.       temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP;
  1437. #endif
  1438.       put_fs_long ((long) temp_i, l);
  1439.       PRINTKN (3,(KERN_DEBUG "ppp_ioctl: get flags: addr %lx flags %x\n",
  1440.           l,
  1441.           temp_i));
  1442.     }
  1443.     break;
  1444.  
  1445.   case PPPIOCSFLAGS:
  1446.     error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  1447.     if (error == 0) {
  1448.       temp_i      = (int) get_fs_long (l);
  1449.       ppp->flags ^= ((ppp->flags ^ temp_i) & SC_MASK);
  1450.       PRINTKN (3,(KERN_INFO "ppp_ioctl: set flags to %x\n", temp_i));
  1451.     }
  1452.     break;
  1453.  
  1454.   case PPPIOCGASYNCMAP:
  1455.     error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  1456.     if (error == 0) {
  1457.       put_fs_long (ppp->xmit_async_map[0], l);
  1458.       PRINTKN (3,(KERN_INFO "ppp_ioctl: get asyncmap: addr %lx asyncmap %lx\n",
  1459.           l, ppp->xmit_async_map[0]));
  1460.     }
  1461.     break;
  1462.  
  1463.   case PPPIOCSASYNCMAP:
  1464.     error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  1465.     if (error == 0) {
  1466.       ppp->xmit_async_map[0] = get_fs_long (l);
  1467.       bset (ppp->xmit_async_map, PPP_FLAG);
  1468.       bset (ppp->xmit_async_map, PPP_ESC);
  1469.       PRINTKN (3,(KERN_INFO "ppp_ioctl: set xmit asyncmap %lx\n",
  1470.           ppp->xmit_async_map[0]));
  1471.     }
  1472.     break;
  1473.  
  1474.   case PPPIOCRASYNCMAP:
  1475.     error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  1476.     if (error == 0) {
  1477.       ppp->recv_async_map = get_fs_long (l);
  1478.       PRINTKN (3,(KERN_INFO "ppp_ioctl: set recv asyncmap %lx\n",
  1479.           ppp->recv_async_map));
  1480.     }
  1481.     break;
  1482.  
  1483.   case PPPIOCGUNIT:
  1484.     error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  1485.     if (error == 0) {
  1486.       put_fs_long (ppp->dev->base_addr, l);
  1487.       PRINTKN (3,(KERN_INFO "ppp_ioctl: get unit: %ld", ppp->dev->base_addr));
  1488.     }
  1489.     break;
  1490.  
  1491.   case PPPIOCSINPSIG:
  1492.     error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  1493.     if (error == 0) {
  1494.       ppp->inp_sig     = (int) get_fs_long (l);
  1495.       ppp->inp_sig_pid = current->pid;
  1496.       PRINTKN (3,(KERN_INFO "ppp_ioctl: set input signal %d\n", ppp->inp_sig));
  1497.     }
  1498.     break;
  1499.  
  1500.   case PPPIOCSDEBUG:
  1501.     error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  1502.     if (error == 0) {
  1503.       ppp_debug = (int) get_fs_long (l);
  1504.       ppp_debug_netpackets = (ppp_debug & 0xff00) >> 8;
  1505.       ppp_debug &= 0xff;
  1506.       PRINTKN (1, (KERN_INFO "ppp_ioctl: set debug level %d, netpacket %d\n", 
  1507.            ppp_debug, ppp_debug_netpackets));
  1508.     }
  1509.     break;
  1510.  
  1511.   case PPPIOCGDEBUG:
  1512.     error = verify_area (VERIFY_WRITE, (void *) l, sizeof (temp_i));
  1513.     if (error == 0) {
  1514.       put_fs_long ((long) (ppp_debug | (ppp_debug_netpackets << 8)), l);
  1515.       PRINTKN (3,(KERN_INFO "ppp_ioctl: get debug level %d\n", 
  1516.           ppp_debug | (ppp_debug_netpackets << 8)));
  1517.     }
  1518.     break;
  1519.  
  1520.   case PPPIOCGSTAT:
  1521.     error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_stats));
  1522.     if (error == 0) {
  1523.       memcpy_tofs ((void *) l, &ppp->stats, sizeof (struct ppp_stats));
  1524.       PRINTKN (3,(KERN_INFO "ppp_ioctl: read statistics\n"));
  1525.     }
  1526.     break;
  1527.  
  1528.   case PPPIOCGTIME:
  1529.     error = verify_area (VERIFY_WRITE, (void *) l, sizeof (struct ppp_ddinfo));
  1530.     if (error == 0) {
  1531.       struct ppp_ddinfo cur_ddinfo;
  1532.       unsigned long cur_jiffies = jiffies;
  1533.  
  1534.       /* change absolute times to relative times. */
  1535.       cur_ddinfo.ip_sjiffies  = cur_jiffies - ppp->ddinfo.ip_sjiffies;
  1536.       cur_ddinfo.ip_rjiffies  = cur_jiffies - ppp->ddinfo.ip_rjiffies;
  1537.       cur_ddinfo.nip_sjiffies = cur_jiffies - ppp->ddinfo.nip_sjiffies;
  1538.       cur_ddinfo.nip_rjiffies = cur_jiffies - ppp->ddinfo.nip_rjiffies;
  1539.       
  1540.       memcpy_tofs ((void *) l, &cur_ddinfo, sizeof (struct ppp_ddinfo));
  1541.       PRINTKN (3,(KERN_INFO "ppp_ioctl: read demand dial info\n"));
  1542.     }
  1543.     break;
  1544.  
  1545.   case PPPIOCGXASYNCMAP:
  1546.     error = verify_area (VERIFY_WRITE,
  1547.              (void *) l,
  1548.              sizeof (ppp->xmit_async_map));
  1549.     if (error == 0) {
  1550.       memcpy_tofs ((void *) l,
  1551.            ppp->xmit_async_map,
  1552.            sizeof (ppp->xmit_async_map));
  1553.       PRINTKN (3,(KERN_INFO "ppp_ioctl: get xasyncmap: addr %lx\n", l));
  1554.     }
  1555.     break;
  1556.  
  1557.   case PPPIOCSXASYNCMAP:
  1558.     error = verify_area (VERIFY_READ, (void *) l,
  1559.              sizeof (ppp->xmit_async_map));
  1560.     if (error == 0) {
  1561.       unsigned long temp_tbl [8];
  1562.  
  1563.       memcpy_fromfs (temp_tbl, (void *) l, sizeof (ppp->xmit_async_map));
  1564.       temp_tbl[1]  =  0x00000000; /* must not escape 0x20 - 0x3f */
  1565.       temp_tbl[2] &= ~0x40000000; /* must not escape 0x5e        */
  1566.       temp_tbl[3] |=  0x60000000; /* must escape 0x7d and 0x7e   */
  1567.  
  1568.       if ((temp_tbl[2] & temp_tbl[3]) != 0 ||
  1569.       (temp_tbl[4] & temp_tbl[5]) != 0 ||
  1570.       (temp_tbl[6] & temp_tbl[7]) != 0)
  1571.     error = -EINVAL;
  1572.       else {
  1573.     memcpy (ppp->xmit_async_map, temp_tbl, sizeof (ppp->xmit_async_map));
  1574.     PRINTKN (3,(KERN_INFO "ppp_ioctl: set xasyncmap\n"));
  1575.       }
  1576.     }
  1577.     break;
  1578.  
  1579.   case PPPIOCSMAXCID:
  1580.     error = verify_area (VERIFY_READ, (void *) l, sizeof (temp_i));
  1581.     if (error == 0) {
  1582.       temp_i = (int) get_fs_long (l) + 1;
  1583.       PRINTKN (3,(KERN_INFO "ppp_ioctl: set maxcid to %d\n", temp_i));
  1584.       if (ppp->slcomp != NULL)
  1585.     slhc_free (ppp->slcomp);
  1586.  
  1587.       ppp->slcomp = slhc_init (temp_i, temp_i);
  1588.  
  1589.       if (ppp->slcomp == NULL) {
  1590.     PRINTKN (1,(KERN_ERR "ppp: no space for compression buffers!\n"));
  1591.     ppp_release (ppp);
  1592.     error = -ENOMEM;
  1593.       }
  1594.     }
  1595.     break;
  1596.  
  1597. #ifdef NEW_TTY_DRIVERS
  1598.     /* Allow stty to read, but not set, the serial port */
  1599.   case TCGETS:
  1600.   case TCGETA:
  1601.     error = n_tty_ioctl(tty, file, i, l);
  1602.     break;
  1603. #endif
  1604.  
  1605. /*
  1606.  *  All other ioctl() events will come here.
  1607.  */
  1608.  
  1609.   default:
  1610.     PRINTKN (1,(KERN_ERR "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
  1611.         i,
  1612.         l));
  1613. #ifdef NEW_TTY_DRIVERS
  1614.     error = -ENOIOCTLCMD;
  1615. #else
  1616.     error = -EINVAL;
  1617. #endif
  1618.     break;
  1619.   }
  1620.   return error;
  1621. }
  1622.  
  1623. static int
  1624. ppp_select (struct tty_struct *tty, struct inode * inode,
  1625.         struct file * filp, int sel_type, select_table * wait)
  1626. {
  1627.   struct ppp *ppp = ppp_find (tty);
  1628.   
  1629.   if (!ppp || ppp->magic != PPP_MAGIC) {
  1630.     PRINTK ((KERN_ERR "ppp_select: can't find PPP block from tty!\n"))
  1631.     return -EBADF;
  1632.   }
  1633.   
  1634.   /* If the PPP protocol is no longer active, return false */
  1635.   CHECK_PPP (0);
  1636.   
  1637.   /* Process the request based upon the type desired */
  1638.   switch (sel_type) {
  1639.   case SEL_IN:
  1640.     if (set_bit(0, &ppp->us_rbuff_lock) == 0) {
  1641.       /* Test for the presence of data in the queue */
  1642.       if (ppp->us_rbuff_head != ppp->us_rbuff_tail) {
  1643.     clear_bit (0, &ppp->us_rbuff_lock);
  1644.     return 1;
  1645.       }
  1646.       clear_bit (0, &ppp->us_rbuff_lock);
  1647.     } /* fall through */
  1648.  
  1649.   case SEL_EX:
  1650.     /* Is there a pending error condition? */
  1651.     if (tty->packet && tty->link->ctrl_status)
  1652.       return 1;
  1653.     
  1654.     /* closed? */
  1655.     if (tty->flags & (1 << TTY_SLAVE_CLOSED))
  1656.       return 1;
  1657.     
  1658.     /* If the tty is disconnected, then this is an exception too */
  1659.     if (tty_hung_up_p(filp))
  1660.       return 1;
  1661.  
  1662.     select_wait (&ppp->read_wait, wait);
  1663.     break;
  1664.     
  1665.   case SEL_OUT:
  1666.     if (ppp_lock (ppp)) {
  1667.       if (ppp->sending == 0) {
  1668.     ppp_unlock (ppp);
  1669.     return 1;
  1670.       }
  1671.       ppp_unlock (ppp);
  1672.     }
  1673.     select_wait (&ppp->write_wait, wait);
  1674.     break;
  1675.   }
  1676.   return 0;
  1677. }
  1678.  
  1679. /*************************************************************
  1680.  * NETWORK OUTPUT
  1681.  *    This routine accepts requests from the network layer
  1682.  *    and attempts to deliver the packets.
  1683.  *    It also includes various routines we are compelled to
  1684.  *    have to make the network layer work (arp, etc...).
  1685.  *************************************************************/
  1686.  
  1687. int
  1688. ppp_xmit(struct sk_buff *skb, struct device *dev)
  1689. {
  1690.   struct tty_struct *tty;
  1691.   struct ppp *ppp;
  1692.   unsigned char *p;
  1693.   unsigned short proto;
  1694.   int len;
  1695.  
  1696.   /* just a little sanity check. */
  1697.   if (skb == NULL) {
  1698.     PRINTKN(3,(KERN_WARNING "ppp_xmit: null packet!\n"));
  1699.     return 0;
  1700.   }
  1701.  
  1702.   /* Get pointers to the various components */
  1703.   ppp   = &ppp_ctrl[dev->base_addr];
  1704.   tty   = ppp->tty;
  1705.   p     = (unsigned char *) (skb + 1);
  1706.   len   = skb->len;
  1707.   proto = PROTO_IP;
  1708.  
  1709.   PRINTKN(4,(KERN_DEBUG "ppp_xmit [%s]: skb %lX busy %d\n", dev->name, 
  1710.          (unsigned long int) skb, ppp->sending));
  1711.  
  1712.   CHECK_PPP(0);
  1713.  
  1714.   if (tty == NULL) {
  1715.     PRINTKN(1,(KERN_ERR "ppp_xmit: %s not connected to a TTY!\n", dev->name));
  1716.     goto done;
  1717.   }
  1718.  
  1719.   if (!(dev->flags & IFF_UP)) {
  1720.     PRINTKN(1,(KERN_WARNING
  1721.            "ppp_xmit: packet sent on interface %s, which is down for IP\n",
  1722.            dev->name));
  1723.     goto done;
  1724.   }
  1725.  
  1726.   /* get length from IP header as per Alan Cox bugfix for slip.c */
  1727.   if (len < sizeof(struct iphdr)) {
  1728.     PRINTKN(0,(KERN_ERR "ppp_xmit: given runt packet, ignoring\n"));
  1729.     return 1;
  1730.   }
  1731.   len = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
  1732.  
  1733.   /* If doing demand dial then divert the first frame to pppd. */
  1734.   if (ppp->flags & SC_IP_DOWN) {
  1735.     if (ppp->flags & SC_IP_FLUSH == 0) {
  1736.       if (ppp_us_queue (ppp, proto, p, len))
  1737.     ppp->flags |= SC_IP_FLUSH;
  1738.     }
  1739.     goto done;
  1740.   }
  1741.  
  1742.   /* Attempt to acquire send lock */
  1743.   if (ppp->sending || !ppp_lock(ppp)) {
  1744.     PRINTKN(3,(KERN_WARNING "ppp_xmit: busy\n"));
  1745.     ppp->stats.sbusy++;
  1746.     return 1;
  1747.   }
  1748.  
  1749.   ppp->xhead = ppp->xbuff;
  1750.  
  1751.   /* try to compress, if VJ compression mode is on */
  1752.   if (ppp->flags & SC_COMP_TCP) {
  1753.     /* NOTE: last 0 argument says never to compress connection ID */
  1754.     len = slhc_compress(ppp->slcomp, p, len, ppp->cbuff, &p, 0);
  1755.     if (p[0] & SL_TYPE_COMPRESSED_TCP)
  1756.       proto = PROTO_VJCOMP;
  1757.     else {
  1758.       if (p[0] >= SL_TYPE_UNCOMPRESSED_TCP) {
  1759.     proto = PROTO_VJUNCOMP;
  1760.     p[0] = (p[0] & 0x0f) | 0x40; 
  1761.       }
  1762.     }
  1763.   }
  1764.  
  1765.   /* increment appropriate counter */
  1766.   if (proto == PROTO_VJCOMP)
  1767.     ++ppp->stats.scomp;
  1768.   else
  1769.     ++ppp->stats.suncomp;
  1770.       
  1771.   if (ppp_debug_netpackets) {
  1772.     struct iphdr *iph = (struct iphdr *) (skb + 1);
  1773.     PRINTK ((KERN_DEBUG "%s ==> proto %x len %d src %x dst %x proto %d\n",
  1774.         dev->name, (int) proto, (int) len, (int) iph->saddr,
  1775.         (int) iph->daddr, (int) iph->protocol))
  1776.   }
  1777.  
  1778.   /* start of frame:   FLAG  ALL_STATIONS  CONTROL  <protohi> <protolo> */
  1779. #ifdef OPTIMIZE_FLAG_TIME
  1780.   if (jiffies - ppp->last_xmit > OPTIMIZE_FLAG_TIME)
  1781.     *ppp->xhead++ = PPP_FLAG;
  1782.   ppp->last_xmit = jiffies;
  1783. #else      
  1784.   *ppp->xhead++ = PPP_FLAG;
  1785. #endif
  1786.  
  1787.   ppp->fcs = PPP_FCS_INIT;
  1788.   if (!(ppp->flags & SC_COMP_AC)) { 
  1789.     ppp_stuff_char(ppp, PPP_ADDRESS);
  1790.     ppp_stuff_char(ppp, PPP_CONTROL);
  1791.   }
  1792.  
  1793.   if (!(ppp->flags & SC_COMP_PROT) || (proto & 0xff00))
  1794.     ppp_stuff_char(ppp, proto>>8);
  1795.   ppp_stuff_char(ppp, proto&0xff);
  1796.  
  1797.   /* data part */
  1798.   while (len-- > 0)
  1799.     ppp_stuff_char(ppp, *p++);
  1800.  
  1801.   /* fcs and flag */
  1802.   ppp_add_fcs(ppp);
  1803.   *ppp->xhead++ = PPP_FLAG;
  1804.  
  1805.   /* update the time for demand dial function */
  1806.   ppp->ddinfo.ip_sjiffies = jiffies;
  1807.  
  1808.   /* send it! */
  1809.   if (ppp_debug >= 6)
  1810.     ppp_print_buffer ("xmit buffer", ppp->xbuff, ppp->xhead - ppp->xbuff, KERNEL_DS);
  1811.   else {
  1812.     PRINTKN (4,(KERN_DEBUG
  1813.         "ppp_write: writing %d chars\n", ppp->xhead - ppp->xbuff));
  1814.   }
  1815.  
  1816.   ppp_kick_tty(ppp);
  1817.  
  1818.  done:
  1819.   dev_kfree_skb(skb, FREE_WRITE);
  1820.   return 0;
  1821. }
  1822.   
  1823. static unsigned short
  1824. ppp_type_trans (struct sk_buff *skb, struct device *dev)
  1825. {
  1826.   return(htons(ETH_P_IP));
  1827. }
  1828.  
  1829. #ifdef NET02D
  1830. static int
  1831. ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
  1832.        unsigned long daddr, unsigned long saddr, unsigned len)
  1833. {
  1834.   return(0);
  1835. }
  1836.  
  1837. static int
  1838. ppp_rebuild_header(void *buff, struct device *dev)
  1839. {
  1840.   return(0);
  1841. }
  1842.  
  1843. static void
  1844. ppp_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
  1845. {
  1846. }
  1847.  
  1848. #else
  1849.  
  1850. static int
  1851. ppp_header(unsigned char *buff, struct device *dev, unsigned short type,
  1852.        void *daddr, void *saddr, unsigned len, struct sk_buff *skb)
  1853. {
  1854.   return(0);
  1855. }
  1856.  
  1857. static int
  1858. ppp_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
  1859.            struct sk_buff *skb)
  1860. {
  1861.   return(0);
  1862. }
  1863. #endif
  1864.  
  1865. static struct enet_statistics *
  1866. ppp_get_stats (struct device *dev)
  1867. {
  1868.   struct ppp *ppp = &ppp_ctrl[dev->base_addr];
  1869.   static struct enet_statistics ppp_stats;
  1870.  
  1871.   ppp_stats.rx_packets = ppp->stats.rcomp + ppp->stats.runcomp;
  1872.   ppp_stats.rx_errors = ppp->stats.rerrors;
  1873.   ppp_stats.rx_dropped = ppp->stats.tossed;
  1874.   ppp_stats.rx_fifo_errors = 0;
  1875.   ppp_stats.rx_length_errors = ppp->stats.runts;
  1876.   ppp_stats.rx_over_errors = ppp->stats.roverrun;
  1877.   ppp_stats.rx_crc_errors = 0;
  1878.   ppp_stats.rx_frame_errors = 0;
  1879.   ppp_stats.tx_packets = ppp->stats.scomp + ppp->stats.suncomp;
  1880.   ppp_stats.tx_errors = ppp->stats.serrors;
  1881.   ppp_stats.tx_dropped = 0;
  1882.   ppp_stats.tx_fifo_errors = 0;
  1883.   ppp_stats.collisions = ppp->stats.sbusy;
  1884.   ppp_stats.tx_carrier_errors = 0;
  1885.   ppp_stats.tx_aborted_errors = 0;
  1886.   ppp_stats.tx_window_errors = 0;
  1887.   ppp_stats.tx_heartbeat_errors = 0;
  1888.  
  1889.   PRINTKN (3, (KERN_INFO "ppp_get_stats called"));
  1890.   return &ppp_stats;
  1891. }
  1892.  
  1893. /*************************************************************
  1894.  * UTILITIES
  1895.  *    Miscellany called by various functions above.
  1896.  *************************************************************/
  1897.  
  1898. #ifndef NEW_TTY_DRIVERS
  1899. /* find a PPP channel given a TTY */
  1900. struct ppp *
  1901. ppp_find(struct tty_struct *tty)
  1902. {
  1903.   int i;
  1904.   for (i = 0; i < PPP_NRUNIT; i++)
  1905.     if (ppp_ctrl[i].inuse && (ppp_ctrl[i].tty == tty)) return &ppp_ctrl[i];
  1906.  
  1907.   return NULL;
  1908. }
  1909. #endif
  1910.  
  1911. /* allocate a PPP channel */
  1912. static struct ppp *
  1913. ppp_alloc(void)
  1914. {
  1915.   int i;
  1916.   for (i = 0; i < PPP_NRUNIT; i++)
  1917.     if (!set_bit(0, &ppp_ctrl[i].inuse)) return &ppp_ctrl[i];
  1918.  
  1919.   return NULL;
  1920. }
  1921.  
  1922. /* marks a PPP interface 'busy'.  user processes will wait, if
  1923.    they try to write, and the network code will refrain from sending
  1924.    return nonzero if succeeded in acquiring lock
  1925. */
  1926.  
  1927. static int
  1928. ppp_lock(struct ppp *ppp)
  1929. {
  1930.   int flags, locked;
  1931.   save_flags(flags);
  1932.   cli();
  1933.   locked = ppp->sending;
  1934.   ppp->sending = 1;
  1935.   if (ppp->dev->flags & IFF_UP)
  1936.     ppp->dev->tbusy = 1;
  1937.   restore_flags(flags);
  1938.   return locked == 0;
  1939. }
  1940.  
  1941. static void
  1942. ppp_unlock(struct ppp *ppp)
  1943. {
  1944.   int flags;
  1945.   save_flags(flags);
  1946.   cli();
  1947.   ppp->sending = 0;
  1948.   if (ppp->dev->flags & IFF_UP)
  1949.     ppp->dev->tbusy = 0;
  1950.   restore_flags(flags);
  1951. }
  1952.  
  1953. /* FCS support functions */
  1954.  
  1955. static void
  1956. ppp_add_fcs(struct ppp *ppp)
  1957. {
  1958.   unsigned short fcs = ppp->fcs;
  1959.  
  1960.   fcs ^= 0xffff;
  1961.   ppp_stuff_char(ppp, fcs & 0x00ff);
  1962.   ppp_stuff_char(ppp, (fcs & 0xff00) >> 8);
  1963.   ASSERT (ppp->fcs == PPP_FCS_GOOD);
  1964.   PRINTKN (4,(KERN_DEBUG "ppp_add_fcs: fcs is %lx\n",
  1965.           (long) (unsigned long) fcs));
  1966. }
  1967.  
  1968. static int
  1969. ppp_check_fcs(struct ppp *ppp)
  1970. {
  1971.   unsigned short fcs = PPP_FCS_INIT, msgfcs;
  1972.   unsigned char *c = ppp->rbuff;
  1973.   int i;
  1974.  
  1975.   for (i = 0; i < ppp->rcount - 2; i++, c++)
  1976.     fcs = (fcs >> 8) ^ fcstab[(fcs ^ *c) & 0xff];
  1977.  
  1978.   fcs ^= 0xffff;
  1979.   msgfcs = (c[1] << 8) + c[0];
  1980.   PRINTKN (4,(KERN_INFO "ppp_check_fcs: got %lx want %lx\n",
  1981.           (unsigned long) msgfcs, (unsigned long) fcs));
  1982.   return fcs == msgfcs;
  1983. }
  1984.  
  1985. static char hex[] = "0123456789ABCDEF";
  1986.  
  1987. static inline void ppp_print_hex (register char *out, char *in, int count)
  1988. {
  1989.   register unsigned char next_ch;
  1990.  
  1991.   while (count-- > 0) {
  1992.     next_ch = (unsigned char) get_fs_byte (in);
  1993.  
  1994.     *out++  = hex[(next_ch >> 4) & 0x0F];
  1995.     *out++  = hex[next_ch        & 0x0F];
  1996.     ++out;
  1997.     ++in;
  1998.   }
  1999. }
  2000.  
  2001. static inline void ppp_print_char (register char *out, char *in, int count)
  2002. {
  2003.   register unsigned char next_ch;
  2004.  
  2005.   while (count-- > 0) {
  2006.     next_ch = (unsigned char) get_fs_byte (in);
  2007.  
  2008.     if (next_ch < 0x20 || next_ch > 0x7e)
  2009.       *out++ = '.';
  2010.     else {
  2011.       *out++ = next_ch;
  2012.       if (next_ch == '%')    /* printk/syslogd has a bug !! */
  2013.     *out++ = '%';
  2014.     }
  2015.     ++in;
  2016.   }
  2017.   *out = '\0';
  2018. }
  2019.  
  2020. static void ppp_print_buffer(const char *name, char *buf, int count, int seg)
  2021. {
  2022.   char line [44];
  2023.   int  old_fs = get_fs();
  2024.  
  2025.   set_fs (seg);
  2026.  
  2027.   if (name != NULL)
  2028.     PRINTK ((KERN_DEBUG "ppp: %s, count = %d\n", name, count));
  2029.  
  2030.   while (count > 8) {
  2031.     memset         (line, ' ', sizeof (line));
  2032.     ppp_print_hex  (line, buf, 8);
  2033.     ppp_print_char (&line[8 * 3], buf, 8);
  2034.     PRINTK ((KERN_DEBUG "%s\n", line));
  2035.     count -= 8;
  2036.     buf   += 8;
  2037.   }
  2038.  
  2039.   if (count > 0) {
  2040.     memset         (line, ' ', sizeof (line));
  2041.     ppp_print_hex  (line, buf, count);
  2042.     ppp_print_char (&line[8 * 3], buf, count);
  2043.     PRINTK ((KERN_DEBUG "%s\n", line));
  2044.   }
  2045.  
  2046.   set_fs (old_fs);
  2047. }
  2048.  
  2049. #ifdef MODULE
  2050. char kernel_version[] = UTS_RELEASE;
  2051.  
  2052. static struct device dev_ppp[PPP_NRUNIT] = {
  2053.     {
  2054.         "ppp0",        /* ppp */
  2055.         0, 0, 0, 0,    /* memory */
  2056.         0, 0,        /* base, irq */
  2057.         0, 0, 0, NULL, ppp_init,
  2058.     },
  2059.     { "ppp1" , 0, 0, 0, 0,  1, 0, 0, 0, 0, NULL, ppp_init },
  2060.     { "ppp2" , 0, 0, 0, 0,  2, 0, 0, 0, 0, NULL, ppp_init },
  2061.     { "ppp3" , 0, 0, 0, 0,  3, 0, 0, 0, 0, NULL, ppp_init },
  2062. };
  2063.  
  2064. int
  2065. init_module(void)
  2066. {
  2067.     int err;
  2068.     int i;
  2069.  
  2070.     for (i = 0; i < PPP_NRUNIT; i++)  {
  2071.         if ((err = register_netdev(&dev_ppp[i])))  {
  2072.             if (err == -EEXIST)  {
  2073.                 printk("PPP: devices already present. Module not loaded.\n");
  2074.             }
  2075.             return err;
  2076.         }
  2077.     }
  2078.     return 0;
  2079. }
  2080.  
  2081. void
  2082. cleanup_module(void)
  2083. {
  2084.     int i;
  2085.  
  2086.     if (MOD_IN_USE)  {
  2087.         printk("PPP: device busy, remove delayed\n");
  2088.         return;
  2089.     }
  2090.     for (i = 0; i < PPP_NRUNIT; i++)  {
  2091.         unregister_netdev(&dev_ppp[i]);
  2092.     }
  2093.     if ((i = tty_register_ldisc(N_PPP, NULL)))  {
  2094.         printk("PPP: can't unregister line discipline (err = %d)\n", i);
  2095.     }
  2096. }
  2097.  
  2098. #endif
  2099.