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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
if_ppp.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：51k
源码类别：

VxWorks

开发平台：

C/C++

if_ppp.c：源码内容
  1. /* if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver */
  3. /* Copyright 1996 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /* $NetBSD: if_ppp.c,v 1.20 1994/10/30 21:48:52 cgd Exp $ */
  8. /*
  9.  * if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver.
  10.  *
  11.  * Copyright (c) 1989 Carnegie Mellon University.
  12.  * All rights reserved.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted
  15.  * provided that the above copyright notice and this paragraph are
  16.  * duplicated in all such forms and that any documentation,
  17.  * advertising materials, and other materials related to such
  18.  * distribution and use acknowledge that the software was developed
  19.  * by Carnegie Mellon University.  The name of the
  20.  * University may not be used to endorse or promote products derived
  21.  * from this software without specific prior written permission.
  22.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  23.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  24.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  25.  *
  26.  * Drew D. Perkins
  27.  * Carnegie Mellon University
  28.  * 4910 Forbes Ave.
  29.  * Pittsburgh, PA 15213
  30.  * (412) 268-8576
  31.  * ddp@andrew.cmu.edu
  32.  *
  33.  * Based on:
  34.  * @(#)if_sl.c 7.6.1.2 (Berkeley) 2/15/89
  35.  *
  36.  * Copyright (c) 1987 Regents of the University of California.
  37.  * All rights reserved.
  38.  *
  39.  * Redistribution and use in source and binary forms are permitted
  40.  * provided that the above copyright notice and this paragraph are
  41.  * duplicated in all such forms and that any documentation,
  42.  * advertising materials, and other materials related to such
  43.  * distribution and use acknowledge that the software was developed
  44.  * by the University of California, Berkeley.  The name of the
  45.  * University may not be used to endorse or promote products derived
  46.  * from this software without specific prior written permission.
  47.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  48.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  49.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  50.  *
  51.  * Serial Line interface
  52.  *
  53.  * Rick Adams
  54.  * Center for Seismic Studies
  55.  * 1300 N 17th Street, Suite 1450
  56.  * Arlington, Virginia 22209
  57.  * (703)276-7900
  58.  * rick@seismo.ARPA
  59.  * seismo!rick
  60.  *
  61.  * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
  62.  * Converted to 4.3BSD Beta by Chris Torek.
  63.  * Other changes made at Berkeley, based in part on code by Kirk Smith.
  64.  *
  65.  * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com)
  66.  * Added VJ tcp header compression; more unified ioctls
  67.  *
  68.  * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au).
  69.  * Cleaned up a lot of the mbuf-related code to fix bugs that
  70.  * caused system crashes and packet corruption.  Changed pppstart
  71.  * so that it doesn't just give up with a collision if the whole
  72.  * packet doesn't fit in the output ring buffer.
  73.  *
  74.  * Added priority queueing for interactive IP packets, following
  75.  * the model of if_sl.c, plus hooks for bpf.
  76.  * Paul Mackerras (paulus@cs.anu.edu.au).
  77.  */
  79. /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
  81. /*
  82. modification history
  83. --------------------
  84. 01y,20may02,vvv  modified receive mechanism to use ipintr without queueing
  85. 01x,28mar02,jmp  Increased again read buffer size for solaris simulator and
  86.  added global variable simPppRBufSize to make this buffer
  87.  size increasable from solaris's bsp (SPR #74733).
  88. 01w,17sep01,jmp  Increased read buffer size for solaris simulator (SPR
  89.                  #34025).
  90. 01v,06feb01,ijm  Fix for SPR# 62196: pppDelete should not delete ppp_wrt_task
  91.  while it holds the semaphore that tNetTask needs to run.
  92. 01u,17oct00,spm  updated for new if_attach: reports memory allocation failures
  93. 01t,16apr99,koz  Fix for 25165, communications error handling
  94. 01s,17feb99,sgv  Fix for spr 23702, pppintr check for NULL ppp_softc
  95. 01r,17feb99,sgv  Fix for spr 24459. pppalloc was not setting the correct
  96.  ppp_softc structure to NULL on error condition
  97. 01q.10sep98,sgv  Added fix for interoperating with Windows
  98. 01p,18aug97,jmb  Add code to discard packets at interrupt level due
  99.  to overflow of input ring buffer.
  100. 01o,30dec97,sgv  fixed problem in PPP output Hooks
  101. 01n,26sep97,sgv  Added PPP output Hooks
  102. 01m,19sep97,vin  changed m_ext.ext_buf to m_extBuf and m_ext.ext_size to
  103.  m_extSize
  104. 01l,14nov96,vin  upgraded to use new buffering scheme.
  105. 01k,13aug96,vin  upgraded to BSD4.4, removed call in_ifaddr_remove as it is 
  106.  being done in if_dettach. 
  107. 01j,30jul95,dzb  cleanup on errors while openning serial device.
  108. 01i,05jul95,dzb  close out serial fd on errors in pppalloc().
  109. 01h,12jun95,dzb  added SNMP MIBII support (counters and ioctl).
  110.                  header file consolidation.
  111. 01g,24apr95,dzb  removed in_ifaddr_remove() because added to in.c (SPR #4109).
  112. 01f,09mar95,dzb  added counters for ip packets sent/received.
  113. 01e,06mar95,dzb  changed cfree() to free() (ANSI).
  114. 01d,09feb95,dab  added SIOCGIFMTU command to ppptioctl().
  115. 01c,07feb95,dzb  changed pppoutput() to return errno, instead of ERROR.
  116.                  removed redundant mbuf check from ppp_wrt_flush().
  117.  zeroed out m_len after MGET (SPR #4037).
  118. 01b,16jan95,dzb  warnings cleanup.  moved global prototypes to if_ppp.h.
  119. 01a,21dec94,dab  VxWorks port - first WRS version.
  120.            +dzb  added: path for ppp header files, WRS copyright.
  121. */
  123. #include "vxWorks.h"
  124. #include "net/mbuf.h"
  125. #include "sockLib.h"
  126. #include "ioctl.h"
  127. #include "stdio.h"
  128. #include "errnoLib.h"
  129. #include "ioLib.h"
  130. #include "iosLib.h"
  131. #include "semLib.h"
  132. #include "memLib.h"
  133. #include "taskLib.h"
  134. #include "signal.h"
  135. #include "sigLib.h"
  136. #include "etherLib.h"
  137. #include "netLib.h"
  138. #include "m2Lib.h"
  139. #include "private/m2LibP.h"
  140. #include "net/if.h"
  141. #include "net/unixLib.h"
  142. #include "net/route.h"
  143. #include "netinet/in.h"
  144. #include "netinet/in_systm.h"
  145. #include "netinet/in_var.h"
  146. #include "netinet/ip.h"
  147. #include "netinet/ip_var.h"
  148. #include "pppLib.h"
  149. #include "rngLib.h"
  150. #include "tyLib.h"
  152. #include "tickLib.h"
  154. #if NPPP > 0
  156. #ifdef VJC
  157. #define HDROFF  MAX_HDR
  158. /* HDROFF should really be 128, but other parts of the system will
  159.    panic on TCP+IP headers bigger than MAX_HDR = MHLEN (100). */
  161. #else
  162. #define HDROFF  (0)
  163. #endif
  165. #define PPP_HIWAT       400     /* Don't start a new packet if HIWAT on que */
  167. /* external variables */
  169. IMPORT void if_dettach();
  170. IMPORT void if_down();
  172. /* global variables */
  174. struct ppp_softc *ppp_softc[NPPP] = { 0 } ;
  176. int ppp_wrt_task_priority     = 60;
  177. int ppp_wrt_task_options      = VX_SUPERVISOR_MODE | VX_UNBREAKABLE;
  178. int ppp_wrt_task_stack_size    = 0x4000;
  180. char *ppp_device_name = "ppp";
  182. #if (CPU_FAMILY==SIMSPARCSOLARIS)
  183. int simPppRBufSize = 48 * PPP_MTU; /* size of PPP read ring buffer */
  184. #endif
  186. static int pppioctl __ARGS((struct ifnet *, int , caddr_t));
  187. static int pppattach __ARGS((int));
  188. static int pppoutput __ARGS((struct ifnet *, struct mbuf *, struct sockaddr *,
  189.      struct rtentry *));
  190. static void pppinput __ARGS((struct ppp_softc *, int));
  191. static int pppasyncstart __ARGS((struct ppp_softc *));
  192. static u_short pppfcs __ARGS((int, u_char *, int));
  193. static int pppgetm __ARGS((struct ppp_softc *sc));
  194. static void pppdumpm __ARGS((struct mbuf *, int));
  195. static void pppdumpb __ARGS((u_char *, int));
  196. static void ppplogchar __ARGS((struct ppp_softc *, int));
  197. static void pppdealloc __ARGS((struct ppp_softc *));
  198. static struct ppp_softc *pppalloc __ARGS((int, char *));
  200. static void ppp_wrt_flush __ARGS((struct ppp_softc *));
  201. static void pinit __ARGS((int));
  202. static int pppintr __ARGS((int, int));
  203. static void ppp_tty_read __ARGS((int, struct ppp_softc *, int));
  205. /*
  206.  * Some useful mbuf macros not in mbuf.h.
  207.  */
  208. #define M_DATASTART(m) (m)->m_extBuf
  210. #define M_DATASIZE(m) (m)->m_extSize
  212. #define PPPBUFSIZE        (PPP_MTU * 2)
  214. /*
  215.  * The following disgusting hack gets around the problem that IP TOS
  216.  * can't be set yet.  We want to put "interactive" traffic on a high
  217.  * priority queue.  To decide if traffic is interactive, we check that
  218.  * a) it is TCP and b) one of its ports is telnet, rlogin or ftp control.
  219.  */
  220. static u_short interactive_ports[8] = {
  221.         0,      513,    0,      0,
  222.         0,      21,     0,      23,
  223. };
  224. #define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p))
  226. /*
  227.  * Does c need to be escaped?
  228.  */
  229. #define ESCAPE_P(c)     (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
  231. /*
  232.  * Called to establish ppp interfaces.
  233.  */
  234. static int
  235. pppattach(unit)
  236.     int unit;
  237. {
  238.     register struct ppp_softc *sc;
  239.     int status;
  241.     sc = ppp_softc[unit];
  243.     sc->sc_if.if_name = "ppp";
  244.     sc->sc_if.if_unit = unit;
  245.     sc->sc_if.if_mtu = PPP_MTU;
  246.     sc->sc_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST ;
  247.     sc->sc_if.if_type = IFT_PPP;
  248.     sc->sc_if.if_hdrlen = PPP_HDRLEN;
  249.     sc->sc_if.if_ioctl = pppioctl;
  250.     sc->sc_if.if_output = pppoutput;
  251.     sc->sc_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
  252.     sc->sc_inq.ifq_maxlen = IFQ_MAXLEN;
  253.     sc->sc_fastq.ifq_maxlen = IFQ_MAXLEN;
  254.     sc->sc_if.if_reset = pppclose;
  255.     sc->sc_if.if_init = (FUNCPTR) pinit;
  256.     status = if_attach(&sc->sc_if);
  258.     return (status);
  259. }
  261. /*
  262.  * Allocate a ppp interface unit and initialize it.
  263.  */
  264. static struct ppp_softc *
  265. pppalloc(unit, device)
  266.     int unit;
  267.     char *device;
  268. {
  269.     struct ppp_softc *sc;
  271.     if (ppp_softc[unit] != NULL)
  272.         return NULL;
  274.     if ((sc = (struct ppp_softc *)calloc(1, sizeof(struct ppp_softc))) == NULL)
  275.         return (NULL);
  277.     ppp_softc[unit] = sc;
  279.     if ((sc->sc_fd = open(device, O_RDWR, 0)) == ERROR)
  280.         {
  281.         ppp_softc[unit] = (struct ppp_softc *)NULL;
  282.         free((char *) sc);
  283.         return NULL;
  284. }
  286. #if (CPU_FAMILY==SIMSPARCSOLARIS)
  287.     /*
  288.      * For PPP on solaris simulator, the receive buffer size must be more
  289.      * important. This is necessary because the solaris host can send several 
  290.      * several PPP packets to the simulator before he is able to
  291.      * handle them (don't forget that they share the same CPU).
  292.      * If the receive buffer size is too small to store all the received
  293.      * characters, some of them may be lost. The new value has been chosen
  294.      * after some testing (with this value, the simulator has time to
  295.      * handle packets before the receive buffer is full) but may not be
  296.      * sufficient in all cases, if not sufficient simPppRBufSize can be
  297.      * increased in sysLib.c.
  298.      */
  300.     if (ioctl(sc->sc_fd, FIORBUFSET, simPppRBufSize) == ERROR ||
  301. #else /* CPU_FAMILY==SIMSPARCSOLARIS */
  302.     if (ioctl(sc->sc_fd, FIORBUFSET, 4 * PPP_MTU) == ERROR ||
  303. #endif
  304.         ioctl(sc->sc_fd, FIOWBUFSET, 4 * PPP_MTU) == ERROR) {
  305.         close(sc->sc_fd);
  306.         ppp_softc[unit] = (struct ppp_softc *)NULL;
  307.         free((char *) sc);
  308.         return NULL;
  309.     }
  311.     if (pppattach(unit) == ERROR) { 
  312.         close(sc->sc_fd);
  313.         ppp_softc[unit] = (struct ppp_softc *)NULL;
  314.         free((char *) sc);
  315.         return (NULL);
  316.     }
  318.     if (ioctl(sc->sc_fd, FIOPROTOHOOK, (int)pppintr) == ERROR ||
  319.         ioctl(sc->sc_fd, FIOPROTOARG, unit) == ERROR) {
  320.         close(sc->sc_fd);
  321.         pppdealloc(sc);
  322.         return (NULL);
  323.     }
  325.     sc->sc_flags = 0;
  326.     sc->sc_mru = PPP_MRU;
  327. #ifdef VJC
  328.     sl_compress_init(&sc->sc_comp);
  329. #endif
  330.     sc->sc_if.if_flags |=  IFF_RUNNING;
  332.     return sc;
  333. }
  335. /*
  336.  * Deallocate a ppp unit.
  337.  */
  338. static void
  339. pppdealloc(sc)
  340.     struct ppp_softc *sc;
  341. {
  342.     struct mbuf *m;
  344.     if_down(&sc->sc_if);
  345.     sc->sc_devp = NULL;
  346.     sc->sc_xfer = 0;
  347.     for (;;) {
  348.         IF_DEQUEUE(&sc->sc_inq, m);
  349.         if (m == NULL)
  350.             break;
  351.         m_freem(m);
  352.     }
  353.     for (;;) {
  354.         IF_DEQUEUE(&sc->sc_fastq, m);
  355.         if (m == NULL)
  356.             break;
  357.         m_freem(m);
  358.     }
  359.     sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
  361.     if_dettach(&sc->sc_if);
  363.     ppp_softc[sc->sc_if.if_unit] = (struct ppp_softc *)NULL;
  365.     free((char *) sc);
  366. }
  368. /*
  369.  * pppopen - open the ppp interface.
  370.  *       Returns unit id.
  371.  */
  372. int
  373. pppopen(unit, device)
  374.     int unit;
  375.     char *device;
  376. {
  377.     register struct ppp_softc *sc;
  378.     char ppp_wrt_name[10];
  380.     if ((sc = pppalloc(unit, device)) == NULL)
  381.         return (ERROR);
  383.     if (sc->sc_outm != NULL) {
  384.         m_freem(sc->sc_outm);
  385.         sc->sc_outm = NULL;
  386.     }
  388.     if (pppgetm(sc) == 0) {
  389.         sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
  390.         return (ERROR);
  391.     }
  393.     sc->sc_ilen  = 0;
  394.     bzero((char *)sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
  395.     sc->sc_asyncmap[0] = 0xffffffff;
  396.     sc->sc_asyncmap[3] = 0x60000000;
  397.     sc->sc_rasyncmap = 0;
  398.     sc->sc_devp = (void *) NULL;
  399.     sc->sc_start = pppasyncstart;
  400.     sc->sc_qlen  = 0;
  401.     sc->sc_tid = taskIdSelf();
  403.     semBInit(&sc->sc_wrtsem, SEM_Q_PRIORITY, SEM_EMPTY);
  405.     ioctl(sc->sc_fd, FIOFLUSH, 0);
  407.     sprintf(ppp_wrt_name, "tPPP%dWrt", sc->sc_if.if_unit);
  408.     sc->sc_wrt_task_id = taskSpawn(ppp_wrt_name, ppp_wrt_task_priority,
  409.                                    ppp_wrt_task_options,
  410.                                    ppp_wrt_task_stack_size,
  411.    (FUNCPTR)ppp_wrt_task, (int)sc,
  412.    0, 0, 0, 0, 0, 0, 0, 0, 0);
  414.     if (sc->sc_wrt_task_id == ERROR) {
  415.         close(sc->sc_fd);
  416.         pppdealloc(sc);
  417.         return (ERROR);
  418.     }
  420.     return (OK);
  421. }
  422.     
  423. /*
  424.  * Line specific close routine.
  425.  * Detach the tty from the ppp unit.
  426.  * Mimics part of ttyclose().
  427.  */
  428. int
  429. pppclose(unit)
  430.     int unit;
  431. {
  432.     register struct ppp_softc *sc;
  433.     int s;
  435.     if (unit >= 0 && unit < NPPP)
  436.         sc = ppp_softc[unit];
  437.     else
  438.         return (ERROR);
  440.     if (sc != NULL) {
  441. ppp_wrt_flush(sc);
  443.         ioctl(sc->sc_fd, FIOPROTOHOOK, (int) NULL);
  445.         taskDelete(sc->sc_wrt_task_id);
  447.         s = splimp(); /* paranoid; splnet probably ok */
  449.         close(sc->sc_fd);
  451.         m_freem(sc->sc_outm);
  452.         sc->sc_outm = NULL;
  453.         m_freem(sc->sc_m);
  454.         sc->sc_m = NULL;
  455.         pppdealloc(sc);
  457.         splx(s);
  458.     }
  459.     else
  460.         return (ERROR);
  462.     return(OK);
  463. }
  465. /*
  466.  * Line specific (tty) read routine.
  467.  */
  468. int
  469. pppread(unit, buf, count)
  470.     int unit;
  471.     char *buf;
  472.     int count;
  473. {
  474.     register struct ppp_softc *sc = ppp_softc[unit];
  475.     struct mbuf *m;
  476.     register int s;
  478.     s = splimp();
  479.     IF_DEQUEUE(&sc->sc_inq, m);
  480.     splx(s);
  481.     if (m == NULL)
  482. return 0;
  483.     copy_from_mbufs(buf, m, count);
  484.     return (count);
  485. }
  487. /*
  488.  * Line specific (tty) write routine.
  489.  */
  490. int
  491. pppwrite(unit, buf, count)
  492.     int unit;
  493.     char *buf;
  494.     int count;
  495. {
  496.     register struct ppp_softc *sc = ppp_softc[unit];
  497.     struct mbuf *m, *m0, **mp;
  498.     struct sockaddr dst;
  499.     struct ppp_header *ph1, *ph2;
  500.     int len;
  502.     if (count > sc->sc_if.if_mtu + PPP_HDRLEN ||
  503.         count < PPP_HDRLEN) {
  504.         errno = EMSGSIZE;
  505.         return (-1);
  506.     }
  507.     for (mp = &m0; count; mp = &m->m_next) {
  508.         m = mBufClGet(M_WAIT, MT_DATA, count, FALSE);
  510.         if ((*mp = m) == NULL) {
  511.             m_freem(m0);
  512.             errno = ENOBUFS;
  513.             return (-1);
  514.         }
  515. len = min (count, m->m_extSize); /* num for copy */
  516.         bcopy(buf, mtod(m, caddr_t), len);
  517.         count -= len;
  518.         m->m_len = len;
  519.     }
  520.     dst.sa_family = AF_UNSPEC;
  521.     ph1 = (struct ppp_header *) &dst.sa_data;
  522.     ph2 = mtod(m0, struct ppp_header *);
  523.     memcpy (ph1, ph2, sizeof (*ph1)); /* from RTP for bug on 29k */
  524.     m0->m_data += PPP_HDRLEN;
  525.     m0->m_len -= PPP_HDRLEN;
  526.     return (pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0));
  527. }
  529. /*
  530.  * Line specific (tty) ioctl routine.
  531.  * Provide a way to get the ppp unit number.
  532.  * This discipline requires that tty device drivers call
  533.  * the line specific l_ioctl routine from their ioctl routines.
  534.  */
  535. int
  536. ppptioctl(unit, cmd, data)
  537.     int unit;
  538.     int cmd;
  539.     caddr_t data;
  540. {
  541.     register struct ppp_softc *sc = ppp_softc[unit];
  542.     int s, flags, mru;
  543.     int error = 0; 
  545.     if (sc == NULL)
  546.         return -1;
  548.     switch (cmd) {
  549.     case FIONREAD:
  550.         *(int *)data = sc->sc_qlen;
  551.         break;
  553.     case PPPIOCGUNIT:
  554.         *(int *)data = sc->sc_if.if_unit;
  555.         break;
  557.     case PPPIOCGFLAGS:
  558.         *(u_int *)data = sc->sc_flags;
  559.         break;
  561.     case PPPIOCSFLAGS:
  562.         flags = *(int *)data & SC_MASK;
  563.         s = splimp();
  564.         sc->sc_flags = (sc->sc_flags & ~SC_MASK) | flags;
  565.         splx(s);
  566.         break;
  568.     case PPPIOCSASYNCMAP:
  569.         sc->sc_asyncmap[0] = *(u_int *)data;
  570.         break;
  572.     case PPPIOCGASYNCMAP:
  573.         *(u_int *)data = sc->sc_asyncmap[0];
  574.         break;
  576.     case PPPIOCSRASYNCMAP:
  577.         sc->sc_rasyncmap = *(u_int *)data;
  578.         break;
  580.     case PPPIOCGRASYNCMAP:
  581.         *(u_int *)data = sc->sc_rasyncmap;
  582.         break;
  584.     case PPPIOCSXASYNCMAP:
  585.         bcopy((char *)data, (char *)sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
  586.         sc->sc_asyncmap[1] = 0;             /* mustn't escape 0x20 - 0x3f */
  587.         sc->sc_asyncmap[2] &= ~0x40000000;  /* mustn't escape 0x5e */
  588.         sc->sc_asyncmap[3] |= 0x60000000;   /* must escape 0x7d, 0x7e */
  589.         break;
  591.     case PPPIOCGXASYNCMAP:
  592.         bcopy((char *)sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
  593.         break;
  595.     case PPPIOCSMRU:
  596.         mru = *(int *)data;
  597.         if (mru >= PPP_MRU && mru <= PPP_MAXMRU) {
  598.             sc->sc_mru = mru;
  599.             if (pppgetm(sc) == 0) {
  600.         error = ENOBUFS;
  601.         sc->sc_mru = PPP_MRU;
  602.         if (pppgetm(sc) == 0)
  603. sc->sc_if.if_flags &= ~IFF_UP;
  604.             }
  605.         }
  606.         break;
  608.     case PPPIOCGMRU:
  609.         *(int *)data = sc->sc_mru;
  610.         break;
  612. #ifdef VJC
  613.     case PPPIOCSMAXCID:
  614. if (*(int *)data > MAX_STATES)
  615.     {
  616.     error = EINVAL; 
  617.     break;
  618.     }
  619.         sl_compress_init(&sc->sc_comp);
  620.         break;
  621. #endif
  623.     case PPPIOCXFERUNIT:
  624.         sc->sc_xfer = 0;
  625.         break;
  627.     case SIOCSIFMTU:
  628. sc->sc_if.if_mtu = *(int *)data;
  629. break;
  631.     case SIOCGIFMTU:
  632.         *(int *)data = sc->sc_if.if_mtu;
  633.         break;
  635.     case PPPIOCGFD:
  636.         *(int *)data = sc->sc_fd;
  637.         break;
  639.     default:
  640.         return (ENOTSUP);
  641.     }
  642.     return (error);
  643. }
  645. static
  646. void pinit(unit)
  647.     int unit;
  648. {
  649.     struct ppp_softc *ppp = ppp_softc [unit];
  651.     ppp->sc_if.if_flags |= IFF_UP | IFF_RUNNING; /* open for business */
  652. }
  654. /*
  655.  * FCS lookup table as calculated by genfcstab.
  656.  */
  657. static u_short fcstab[256] = {
  658. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  659. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  660. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  661. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  662. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  663. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  664. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  665. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  666. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  667. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  668. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  669. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  670. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  671. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  672. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  673. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  674. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  675. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  676. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  677. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  678. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  679. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  680. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  681. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  682. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  683. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  684. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  685. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  686. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  687. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  688. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  689. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  690. };
  692. /*
  693.  * Calculate a new FCS given the current FCS and the new data.
  694.  */
  695. static u_short
  696. pppfcs(fcs, cp, len)
  697.     register u_short fcs;
  698.     register u_char *cp;
  699.     register int len;
  700. {
  701.     while (len--)
  702.         fcs = PPP_FCS(fcs, *cp++);
  703.     return (fcs);
  704. }
  706. /*
  707.  * Queue a packet.  Start transmission if not active.
  708.  * Packet is placed in Information field of PPP frame.
  709.  */
  710. static int
  711. pppoutput(ifp, m0, dst, pRtEntry)
  712.     struct ifnet *ifp;
  713.     struct mbuf *m0;
  714.     struct sockaddr *dst;
  715.     struct rtentry * pRtEntry;  /* to satisfy compiler */
  716. {
  717.     register struct ppp_softc *sc = ppp_softc[ifp->if_unit];
  718.     struct ppp_header *ph;
  719.     int protocol, address, control;
  720.     u_char *cp;
  721.     int s, error;
  722.     struct ip *ip;
  723.     struct ifqueue *ifq;
  724.     char buf[PPPBUFSIZE];
  726.     if ((sc->sc_fd == 0 || (ifp->if_flags & IFF_RUNNING) == 0
  727.         || (ifp->if_flags & IFF_UP) == 0) && dst->sa_family != AF_UNSPEC) {
  728.         error = ENETDOWN; /* sort of */
  729.         goto bad;
  730.     }
  732.     /*
  733.      * Compute PPP header.
  734.      */
  735.     address = PPP_ALLSTATIONS;
  736.     control = PPP_UI;
  737.     ifq = &ifp->if_snd;
  738.     switch (dst->sa_family) {
  739.     case AF_INET:
  740.         protocol = PPP_IP;
  741.         if ((sc->sc_flags & SC_ENABLE_IP) == 0) {
  742.             error = ENETDOWN;
  743.             goto bad;
  744.         }
  746. sc->sc_ipsent++; /* incr ip packets sent */
  747.         /*
  748.          * If this is a TCP packet to or from an "interactive" port,
  749.          * put the packet on the fastq instead.
  750.          */
  751.         if ((ip = mtod(m0, struct ip *))->ip_p == IPPROTO_TCP) {
  752.             register int p = ntohl(((int *)ip)[ip->ip_hl]);
  753.             if (INTERACTIVE(p & 0xffff) || INTERACTIVE(p >> 16))
  754.                 ifq = &sc->sc_fastq;
  755.         }
  756.         break;
  757. #ifdef NS
  758.     case AF_NS:
  759.         protocol = PPP_XNS;
  760.             break;
  761. #endif
  762.     case AF_UNSPEC:
  763.         ph = (struct ppp_header *)dst->sa_data;
  764.         address = ph->ph_address;
  765.         control = ph->ph_control;
  766.         protocol = ntohs(ph->ph_protocol);
  767.         break;
  768.     default:
  769.         printf("ppp%d: af%d not supportedn",
  770.         ifp->if_unit, dst->sa_family);
  771.         error = EAFNOSUPPORT;
  772.         goto bad;
  773.     }
  775.     /*
  776.      * Add PPP header.  If no space in first mbuf, allocate another.
  777.      * (This assumes M_LEADINGSPACE is always 0 for a cluster mbuf.)
  778.      */
  779.     if (M_LEADINGSPACE(m0) < PPP_HDRLEN) {
  780.         m0 = m_prepend(m0, PPP_HDRLEN, M_DONTWAIT);
  781.         if (m0 == 0) {
  782.             error = ENOBUFS;
  783.         goto bad;
  784.         }
  785.         m0->m_len = 0;
  786.     } else
  787.         m0->m_data -= PPP_HDRLEN;
  789.     cp = mtod(m0, u_char *);
  790.     *cp++ = address;
  791.     *cp++ = control;
  792.     *cp++ = protocol >> 8;
  793.     *cp++ = protocol & 0xff;
  794.     m0->m_len += PPP_HDRLEN;
  796.     if (sc->sc_flags & SC_LOG_OUTPKT) {
  797.         printf("ppp%d output: ", ifp->if_unit);
  798.         pppdumpm(m0, -1);
  799.     }
  801.     /* Process etherOutputHook */
  803.     if ((etherOutputHookRtn != NULL))
  804. {
  805. struct mbuf *mp;
  806. int ilen;
  807. FAST char *p = (char *)buf;
  809. ilen = 0;
  811. /* Calculate the packet len */
  813. for (mp = m0; mp != NULL; mp = mp->m_next)
  814.         ilen += mp->m_len;
  816. /* Copy the packet to the buffer */
  818. for (mp = m0; mp != NULL; p += mp->m_len, mp = mp->m_next)
  819.             bcopy(mtod (mp, char *), p, mp->m_len);
  821. if ((*etherOutputHookRtn) (ifp, buf, ilen) != 0)
  822.             {
  823.     /* output hook has already processed this packet */
  824.             return (OK);
  825.             }
  826. }
  829.     /*
  830.      * Put the packet on the appropriate queue.
  831.      */
  832.     s = splimp();
  833.     if (IF_QFULL(ifq)) {
  834.         IF_DROP(ifq);
  835.         splx(s);
  836.         sc->sc_if.if_oerrors++;
  837.         error = ENOBUFS;
  838.         goto bad;
  839.     }
  840.     IF_ENQUEUE(ifq, m0);
  841.     ifp->if_lastchange = tickGet ();  /* record the last change */
  843.     /*
  844.      * Tell the device to send it out.
  845.      */
  846.     (*sc->sc_start)(sc);
  848.     splx(s);
  849.     return (OK);
  851. bad:
  852.     m_freem(m0);
  853.     errno = error;
  854.     return (error);
  855. }
  857. /*
  858.  * Grab another packet off a queue and apply VJ compression,
  859.  * address/control and/or protocol compression if appropriate.
  860.  */
  861. static struct mbuf *
  862. ppp_dequeue(sc)
  863.     struct ppp_softc *sc;
  864. {
  865.     int s;
  866.     struct mbuf *m;
  867.     u_char *cp;
  868.     int address, control, protocol;
  870.     s = splimp();
  871.     IF_DEQUEUE(&sc->sc_fastq, m);
  872.     if (m == NULL)
  873.         IF_DEQUEUE(&sc->sc_if.if_snd, m);
  874.     splx(s);
  875.     if (m == NULL)
  876.         return NULL;
  878.     /*
  879.      * Extract the ppp header of the new packet.
  880.      * The ppp header will be in one mbuf.
  881.      */
  882.     cp = mtod(m, u_char *);
  883.     address = cp[0];
  884.     control = cp[1];
  885.     protocol = (cp[2] << 8) + cp[3];
  887.     switch (protocol) {
  888. #ifdef VJC
  889.     case PPP_IP:
  890.     /*
  891.      * If the packet is a TCP/IP packet, see if we can compress it.
  892.      */
  893. if (sc->sc_flags & SC_COMP_TCP) {
  894.             struct ip *ip;
  895.     int type;
  896.     struct mbuf *mp;
  898.     mp = m;
  899.     ip = (struct ip *) (cp + PPP_HDRLEN);
  900.     if (mp->m_len <= PPP_HDRLEN) {
  901.                 mp = mp->m_next;
  902. if (mp == NULL)
  903.     break;
  904. ip = mtod(mp, struct ip *);
  905.     }
  906.         /* this code assumes the IP/TCP header is in one non-shared mbuf */
  907.     if (ip->ip_p == IPPROTO_TCP) {
  908.                 type = sl_compress_tcp(mp, ip, &sc->sc_comp,
  909.        !(sc->sc_flags & SC_NO_TCP_CCID));
  910. switch (type) {
  911. case TYPE_UNCOMPRESSED_TCP:
  912.     protocol = PPP_VJC_UNCOMP;
  913.     break;
  914. case TYPE_COMPRESSED_TCP:
  915.     protocol = PPP_VJC_COMP;
  916.     cp = mtod(m, u_char *);
  917.     cp[0] = address;        /* header has moved */
  918.     cp[1] = control;
  919.     cp[2] = 0;
  920.     break;
  921. }
  922. cp[3] = protocol;   /* update protocol in PPP header */
  923.     }
  924. }
  925. #endif  /* VJC */
  926.     }
  928.     /*
  929.      * Compress the address/control and protocol, if possible.
  930.      */
  931.     if (sc->sc_flags & SC_COMP_AC && address == PPP_ALLSTATIONS &&
  932.         control == PPP_UI && protocol != PPP_ALLSTATIONS &&
  933.         protocol != PPP_LCP) {
  934.         /* can compress address/control */
  935.         m->m_data += 2;
  936.         m->m_len -= 2;
  937.     }
  938.     if (sc->sc_flags & SC_COMP_PROT && protocol < 0xFF) {
  939.         /* can compress protocol */
  940.         if (mtod(m, u_char *) == cp) {
  941.             cp[2] = cp[1];      /* move address/control up */
  942.             cp[1] = cp[0];
  943.         }
  944.         ++m->m_data;
  945.         --m->m_len;
  946.     }
  948.     return m;
  949. }
  951. /*
  952.  * This gets called from pppoutput when a new packet is
  953.  * put on a queue.
  954.  */
  955. static int
  956. pppasyncstart(sc)
  957.     register struct ppp_softc *sc;
  958. {
  959.     semGive(&sc->sc_wrtsem);
  960.     return 1;
  961. }
  963. /* 
  964.  * Start output on interface.  Get another datagram
  965.  * to send from the interface queue and map it to
  966.  * the interface before starting output.
  967.  */
  968. void
  969. ppp_wrt_task(sc)
  970.     register struct ppp_softc *sc;
  971. {
  972.     register struct mbuf *m;
  973.     register int len;
  974.     register u_char *start, *stop, *cp;
  975.     int n, ndone, done;
  976.     struct mbuf *m2;
  977.     int count, fd;
  978.     char ch;
  980.     fd = sc->sc_fd;
  982.     for (;;) {
  983. semTake(&sc->sc_wrtsem, WAIT_FOREVER);
  985. taskSafe();
  987. for (;;) {
  988.             /*
  989.              * See if we have an existing packet partly sent.
  990.              * If not, get a new packet and start sending it.
  991.              * We take packets on the priority queue ahead of those
  992.              * on the normal queue.
  993.              */
  994.             m = sc->sc_outm;
  995.             if (m == NULL) {
  996.                 /*
  997.                  * Get another packet to be sent
  998.                  */
  999.                 m = ppp_dequeue(sc);
  1000.                 if (m == NULL)
  1001.                     break;
  1003.                 /*
  1004.                  * The extra PPP_FLAG will start up a new packet, and thus
  1005.                  * will flush any accumulated garbage.  We do this whenever
  1006.                  * the line may have been idle for some time.
  1007.                  */
  1008.         ioctl(fd, FIONWRITE, (int) &count);
  1009.         if (count == 0) {
  1010.     ++sc->sc_bytessent;
  1011.     ch = PPP_FLAG;
  1012.     (void) write(fd, &ch, 1);
  1013.         }
  1015.                 /* Calculate the FCS for the first mbuf's worth. */
  1016.                 sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
  1017.             }
  1019.     for (;;) {
  1020. start = mtod(m, u_char *);
  1021. len = m->m_len;
  1022. stop = start + len;
  1023.         while (len > 0) {
  1024.                     /*
  1025.                      * Find out how many bytes in the string we can
  1026.                      * handle without doing something special.
  1027.                      */
  1028.                     for (cp = start; cp < stop; cp++)
  1029.                         if (ESCAPE_P(*cp))
  1030.                             break;
  1031.                     n = cp - start;
  1032.     if (n) {
  1033.                         int cc, nleft;
  1034.                         for (nleft = n; nleft > 0; nleft -= cc) {
  1035.                             if ((cc =  write(fd, (char *)start, n)) <= 0)
  1036.                                 break;
  1037.                             if (cc > nleft)
  1038.                                 cc = nleft;
  1039.                         }
  1040.                         ndone = n - nleft;
  1041.                         len -= ndone;
  1042.                         start += ndone;
  1043.                         sc->sc_bytessent += ndone;
  1045.                         if (ndone < n)
  1046.                             break;  /* packet doesn't fit */
  1047.                     }
  1048.     /*
  1049.      * If there are characters left in the mbuf,
  1050.      * the first one must be special..
  1051.      * Put it out in a different form.
  1052.      */
  1053.     if (len) {
  1054. ch = PPP_ESCAPE;
  1055. if (write(fd, &ch, 1) != 1)
  1056.     break;
  1057.     
  1058. ch = *start ^ PPP_TRANS;
  1059. if (write(fd, &ch, 1) != 1)
  1060.     break;
  1061.     
  1062. sc->sc_bytessent += 2;
  1063. start++;
  1064. len--;
  1065.     }
  1066.         }
  1067.                 /*
  1068.                  * If we didn't empty this mbuf, remember where we're up to.
  1069.                  * If we emptied the last mbuf, try to add the FCS and closing
  1070.                  * flag, and if we can't, leave sc_outm pointing to m, but with
  1071.                  * m->m_len == 0, to remind us to output the FCS and flag later.
  1072.                  */
  1073.                 done = len == 0;
  1074.                 if (done && m->m_next == NULL) {
  1075.                     u_char *p;
  1076.                     int c;
  1077.                     u_char endseq[8];
  1079.                     /*
  1080.                      * We may have to escape the bytes in the FCS.
  1081.                      */
  1082.                     p = endseq;
  1083.                     c = ~sc->sc_outfcs & 0xFF;
  1084.                     if (ESCAPE_P(c)) {
  1085.                         *p++ = PPP_ESCAPE;
  1086.                         *p++ = c ^ PPP_TRANS;
  1087.                     } else
  1088.                         *p++ = c;
  1089.                     c = (~sc->sc_outfcs >> 8) & 0xFF;
  1090.                     if (ESCAPE_P(c)) {
  1091.                         *p++ = PPP_ESCAPE;
  1092.                         *p++ = c ^ PPP_TRANS;
  1093.                     } else
  1094.                         *p++ = c;
  1095.                     *p++ = PPP_FLAG;
  1097.                     /*
  1098.                      * Try to output the FCS and flag.  If the bytes
  1099.                      * don't all fit, back out.
  1100.                      */
  1101.                     write(fd, (char *)endseq, (int)p-(int)endseq);
  1102.                 }
  1104.                 if (!done) {
  1105.     m->m_data = (caddr_t)start; 
  1106.                     m->m_len = len;
  1107.                     sc->sc_outm = m;
  1108.                     break;         /* can't do any more at the moment */
  1109.                 }
  1111.                 /* Finished with this mbuf; free it and move on. */
  1112.                 m2 = m_free (m);
  1113.                 if (m2 == NULL)
  1114.                     break;
  1116.                 m = m2;
  1117.                 sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
  1118.             }
  1120.             /* Finished a packet */
  1121.             sc->sc_outm = NULL;
  1122.             sc->sc_bytessent++;     /* account for closing flag */
  1123.             sc->sc_if.if_opackets++;
  1124.     sc->sc_if.if_obytes = sc->sc_bytessent;
  1125. }
  1127. taskUnsafe();
  1128.     }
  1129. }
  1131. /*
  1132.  * Allocate enough mbuf to handle current MRU.
  1133.  */
  1134. static int
  1135. pppgetm(sc)
  1136.     register struct ppp_softc *sc;
  1137. {
  1138.     struct mbuf *m, **mp;
  1139.     int len;
  1140.     int s;
  1142.     s = splimp();
  1143.     mp = &sc->sc_m;
  1144.     for (len = HDROFF + sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){
  1145. if ((m = *mp) == NULL) {
  1146.     m = mHdrClGet (M_DONTWAIT, MT_DATA, len, FALSE);
  1147.     if (m == NULL)
  1148. break;
  1149.     *mp = m;
  1150. }
  1151. len -= M_DATASIZE(m);
  1152. mp = &m->m_next;
  1153.     }
  1154.     splx(s);
  1155.     return len <= 0;
  1156. }
  1158. /*
  1159.  * pppintr - PPP tty protocol hook routine
  1160.  */
  1161. static int
  1162. pppintr(unit, c)
  1163.     int unit;
  1164.     int c;
  1165. {
  1166.     register struct ppp_softc *sc = ppp_softc[unit];
  1168.     TY_DEV * pTyDev;
  1169.     RING_ID ringId;
  1171.     if (ppp_softc[unit] == NULL)
  1172.         return FALSE;
  1174.     /* Set discard flag if this is a new packet and ring buffer full */
  1176.     if ( sc->sc_qlen == 0 )
  1177.     {
  1178.         pTyDev = (TY_DEV *) iosFdDevFind(sc->sc_fd);
  1179.         ringId = pTyDev->rdBuf;
  1180.         if (rngIsFull (ringId))
  1181.             sc->sc_flags |= SC_DISCARD_PKT;
  1182.         else
  1183.             sc->sc_flags &= ~SC_DISCARD_PKT;
  1184.     }
  1186.     ++sc->sc_qlen;
  1188.     if (sc->sc_qlen > PPPBUFSIZE)
  1189.         {
  1190.         netJobAdd((FUNCPTR) ppp_tty_read, (int)unit, (int) sc,
  1191.                   (int) sc->sc_qlen, 0, 0);
  1192.         sc->sc_qlen = 0;
  1193.         return (FALSE);
  1194.         }
  1195.      
  1196.     if (((ppp_if[unit]->lcp_fsm.state) != OPENED) && ((c & 0xff) == 'T'))
  1197.         {
  1198.         netJobAdd((FUNCPTR) ppp_tty_read, (int)unit, (int) sc,
  1199.                   (int) sc->sc_qlen, 0, 0);
  1200.         return (FALSE);
  1201.         }
  1203.     if ((c & 0xff) == PPP_FLAG) 
  1204.         {
  1205.         netJobAdd((FUNCPTR) ppp_tty_read, (int)unit, (int) sc, 
  1206.                       (int) sc->sc_qlen, 0, 0);
  1207.         sc->sc_qlen = 0;
  1208.         }
  1210.     return (FALSE);
  1211. }
  1213. /*
  1214.  * ppp_tty_read - read from ppp tty interface
  1215.  */
  1216. static void
  1217. ppp_tty_read(unit, sc, count)
  1218.     int unit;
  1219.     register struct ppp_softc *sc;
  1220.     register int count;
  1221. {
  1222.     register int i;
  1223.     register int num;
  1224.     char buf[PPPBUFSIZE + 2];
  1226.     /* count should never be greater than PPPBUFSIZE+1 */
  1228.     num = read(sc->sc_fd, buf, count);
  1230.     if (count > PPPBUFSIZE)
  1231.        {
  1232.        /* The received packet is greater than the MTU - Drop the packet */
  1233.        sc->sc_if.if_ierrors++;
  1234.        return;
  1235.        }
  1237.     if ((ppp_if[unit]->lcp_fsm.state) != OPENED)
  1238.         {
  1239.         if (strncmp("CLIENT", buf, strlen("CLIENT") )==0)
  1240.            {
  1241.            sc->sc_qlen = 0;
  1242.            write(sc->sc_fd, "CLIENTSERVER", strlen("CLIENTSERVER"));
  1243.            return;
  1244.            }
  1245.         }
  1247.     if (sc->sc_flags & SC_DISCARD_PKT)
  1248.         {
  1249.         /* Packet discarded */
  1250.         sc->sc_if.if_ierrors++;
  1251.         sc->sc_flags &= ~SC_DISCARD_PKT;
  1252.         return;
  1253.         }
  1255.     for (i = 0; i < num; i++)
  1256.         pppinput(sc, buf[i]);
  1257. }
  1259. /*
  1260.  * PPP packet input routine.
  1261.  * The caller has checked and removed the FCS.
  1262.  * The return value is 1 if the packet was put on sc->sc_inq,
  1263.  * 0 otherwise.
  1264.  */
  1265. #define COMPTYPE(proto) ((proto) == PPP_VJC_COMP? TYPE_COMPRESSED_TCP: 
  1266.                          TYPE_UNCOMPRESSED_TCP)
  1268. /*******************************************************************************
  1269. * ppppktin - pass the packet to the appropriate stack LCP or IP
  1270. * 
  1271. * This routine determines packet type and queues the mbuf to the appropriate
  1272. * queue. This routine returns a value of 1 if the packet type is other than
  1273. * PPP_IP.
  1274. *
  1275. * NOMANUAL
  1276. *
  1277. * RETURNS: 0/1
  1278. */
  1280. static int
  1281. ppppktin(sc, m)
  1282.     struct ppp_softc *sc;
  1283.     struct mbuf *m;
  1284. {
  1285.     struct ifqueue *inq;
  1286.     int s, ilen, xlen, proto, rv;
  1287.     u_char *cp, adrs, ctrl;
  1288.     struct mbuf *mp;
  1289.     char buf[PPPBUFSIZE];
  1291.     sc->sc_if.if_ipackets++;
  1292.     sc->sc_if.if_lastchange = tickGet ();  /* record the last change */
  1293.     rv = 0;
  1295.     cp = mtod(m, u_char *);
  1296.     adrs = cp[0];
  1297.     ctrl = cp[1];
  1298.     proto = (cp[2] << 8) + cp[3];
  1300.     ilen = 0;
  1301.     for (mp = m; mp != NULL; mp = mp->m_next)
  1302. ilen += mp->m_len;
  1304. #ifdef VJC
  1305.     /*
  1306.      * See if we have a VJ-compressed packet to uncompress.
  1307.      */
  1308.     if (proto == PPP_VJC_COMP || proto == PPP_VJC_UNCOMP) {
  1309. char *pkttype = proto == PPP_VJC_COMP? "": "un";
  1311. if (sc->sc_flags & SC_REJ_COMP_TCP) {
  1312.     if (sc->sc_flags & SC_DEBUG)
  1313. printf("ppp%d: %scomp pkt w/o compression; flags 0x%xn",
  1314. sc->sc_if.if_unit, pkttype, sc->sc_flags);
  1315.     m_freem(m);
  1316.     sc->sc_if.if_ierrors++;
  1317.     return 0;
  1318. }
  1320. if (proto == PPP_VJC_COMP && m->m_data - M_DATASTART(m) < MAX_HDR) {
  1321.     /*
  1322.      * We don't have room in the mbuf to decompress this packet.
  1323.      * XXX For now we just drop the packet.
  1324.      */
  1325.     if (sc->sc_flags & SC_DEBUG)
  1326. printf("ppp%d: no room to VJ-decompress packetn",
  1327.        sc->sc_if.if_unit);
  1328.     m_freem(m);
  1329.     sc->sc_if.if_ierrors++;
  1330.     return 0;
  1331. }
  1333. m->m_data += PPP_HDRLEN;
  1334. m->m_len -= PPP_HDRLEN;
  1335. ilen -= PPP_HDRLEN;
  1336. xlen = sl_uncompress_tcp((u_char **)(&m->m_data), m->m_len,
  1337.   COMPTYPE(proto), &sc->sc_comp);
  1339. if (xlen == 0) {
  1340.     if (sc->sc_flags & SC_DEBUG)
  1341. printf("ppp%d: sl_uncompress failed on type %scompn",
  1342. sc->sc_if.if_unit, pkttype);
  1343.     m_freem(m);
  1344.     sc->sc_if.if_ierrors++;
  1345.     return 0;
  1346. }
  1348. /* adjust the first mbuf by the decompressed amt */
  1349. xlen += PPP_HDRLEN;
  1350. m->m_len += xlen - ilen;
  1351. ilen = xlen;
  1352. m->m_data -= PPP_HDRLEN;
  1353. proto = PPP_IP;
  1355. /* put the ppp header back in place */
  1356. if (cp != mtod(m, u_char *)) {
  1357.     cp = mtod(m, u_char *);
  1358.     cp[0] = adrs;
  1359.     cp[1] = ctrl;
  1360.     cp[2] = 0;
  1361. }
  1362. cp[3] = PPP_IP;
  1363.     }
  1364. #endif /* VJC */
  1366.     /*
  1367.      * If the packet will fit in a header mbuf, don't waste a
  1368.      * whole cluster on it.
  1369.      */
  1370.     m->m_pkthdr.len = ilen;
  1371.     m->m_pkthdr.rcvif = &sc->sc_if;
  1373. #if NBPFILTER > 0
  1374.     /* See if bpf wants to look at the packet. */
  1375.     if (sc->sc_bpf)
  1376. bpf_mtap(sc->sc_bpf, m);
  1377. #endif
  1378.     
  1379.     /* call etherInputHookRtn here */
  1380.     if (etherInputHookRtn != NULL) {
  1381.         FAST char *p = (char *) buf;
  1382.  
  1383. for (mp = m; mp != NULL; p += mp->m_len, mp = mp->m_next)
  1384.     bcopy(mtod (mp, char *), p, mp->m_len);
  1385.  
  1386. if ((*etherInputHookRtn) (&sc->sc_if, buf, ilen) != 0)
  1387.     {
  1388.     m_freem (m);  /* free mbuf, not handed to the upperlayer */
  1389.     return (OK);
  1390.     }
  1391.     }
  1393.     switch (proto) {
  1394. #ifdef INET
  1395.     case PPP_IP:
  1396. /*
  1397.  * IP packet - take off the ppp header and pass it up to IP.
  1398.  */
  1399. if ((sc->sc_if.if_flags & IFF_UP) == 0
  1400.     || (sc->sc_flags & SC_ENABLE_IP) == 0) {
  1401.     /* interface is down - drop the packet. */
  1402.     m_freem(m);
  1403.     return 0;
  1404. }
  1405. m->m_pkthdr.len -= PPP_HDRLEN;
  1406. m->m_data += PPP_HDRLEN;
  1407. m->m_len -= PPP_HDRLEN;
  1408. inq = &ipintrq;
  1409. break;
  1410. #endif
  1412.     default:
  1413. /*
  1414.  * Some other protocol - place on input queue for read().
  1415.  */
  1416. inq = &sc->sc_inq;
  1417. rv = 1;
  1418. break;
  1419.     }
  1421.     /*
  1422.      * Put the packet on the appropriate input queue.
  1423.      */
  1425.     if (proto == PPP_IP)
  1426. {
  1427. sc->sc_iprcvd++;            /* incr ip packets received */
  1428. ipintr (m);
  1429. }
  1430.     else
  1431. {
  1432.         s = splimp();
  1433.         if (IF_QFULL(inq)) 
  1434.     {
  1435.     IF_DROP(inq);
  1436.     if (sc->sc_flags & SC_DEBUG)
  1437.     printf("ppp%d: queue fulln", sc->sc_if.if_unit);
  1438.     sc->sc_if.if_ierrors++;
  1439.     sc->sc_if.if_iqdrops++;
  1440.     m_freem(m);
  1441.     rv = 0;
  1442.             } 
  1443.         else
  1444.     {
  1445.             IF_ENQUEUE(inq, m);
  1446.     kill(sc->sc_tid, SIGIO);  /* give to alternate processing */
  1447.     }
  1448.         splx(s);
  1449. }
  1450.     return rv;
  1451. }
  1453. /*
  1454.  * tty interface receiver interrupt.
  1455.  */
  1456. static unsigned paritytab[8] = {
  1457.     0x96696996, 0x69969669, 0x69969669, 0x96696996,
  1458.     0x69969669, 0x96696996, 0x96696996, 0x69969669
  1459. };
  1461. static void
  1462. pppinput(sc, c)
  1463.     struct ppp_softc *sc;
  1464.     register int c;
  1465. {
  1466.     struct mbuf *m;
  1467.     int ilen;
  1469.     ++sc->sc_bytesrcvd;
  1471.     c &= 0xff;
  1473.     if (c & 0x80)
  1474. sc->sc_flags |= SC_RCV_B7_1;
  1475.     else
  1476. sc->sc_flags |= SC_RCV_B7_0;
  1477.     if (paritytab[c >> 5] & (1 << (c & 0x1F)))
  1478. sc->sc_flags |= SC_RCV_ODDP;
  1479.     else
  1480. sc->sc_flags |= SC_RCV_EVNP;
  1482.     if (sc->sc_flags & SC_LOG_RAWIN)
  1483. ppplogchar(sc, c);
  1485.     if (c == PPP_FLAG) {
  1486. ilen = sc->sc_ilen;
  1487. sc->sc_ilen = 0;
  1488. sc->sc_if.if_ibytes = sc->sc_bytesrcvd;
  1490. if (sc->sc_rawin_count > 0) 
  1491.     ppplogchar(sc, -1);
  1493. /*
  1494.  * If SC_ESCAPED is set, then we've seen the packet
  1495.  * abort sequence "}~".
  1496.  */
  1497. if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
  1498.     || (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) {
  1499. #ifdef VJC
  1500.     /*
  1501.      * If we've missed a packet, we must toss subsequent compressed
  1502.      * packets which don't have an explicit connection ID.
  1503.      */
  1504.     sl_uncompress_tcp(NULL, 0, TYPE_ERROR, &sc->sc_comp);
  1505. #endif
  1506.     if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
  1507. if (sc->sc_flags & SC_DEBUG)
  1508.     printf("ppp%d: bad fcs %xn", sc->sc_if.if_unit,
  1509.    sc->sc_fcs);
  1510. sc->sc_if.if_ierrors++;
  1511.     } else
  1512. sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
  1513.     return;
  1514. }
  1516. if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
  1517.     if (ilen) {
  1518. if (sc->sc_flags & SC_DEBUG)
  1519.     printf("ppp%d: too short (%d)n", sc->sc_if.if_unit, ilen);
  1520. sc->sc_if.if_ierrors++;
  1521.     }
  1522.     return;
  1523. }
  1525. /*
  1526.  * Remove FCS trailer.  Somewhat painful...
  1527.  */
  1528. ilen -= 2;
  1529. if (--sc->sc_mc->m_len == 0) {
  1530.     for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next)
  1531. ;
  1532.     sc->sc_mc = m;
  1533. }
  1534. sc->sc_mc->m_len--;
  1536. /* excise this mbuf chain */
  1537. m = sc->sc_m;
  1538. sc->sc_m = sc->sc_mc->m_next;
  1539. sc->sc_mc->m_next = NULL;
  1541. if (sc->sc_flags & SC_LOG_INPKT) {
  1542.     printf("ppp%d: got %d bytesn", sc->sc_if.if_unit, ilen);
  1543.     pppdumpm(m, ilen);
  1544. }
  1546. ppppktin(sc, m);  /* handover packet to upper layer */
  1547. pppgetm(sc);
  1548. return;
  1549.     }
  1551.     if (sc->sc_flags & SC_FLUSH) {
  1552. if (sc->sc_flags & SC_LOG_FLUSH)
  1553.     ppplogchar(sc, c);
  1554. return;
  1555.     }
  1557.     if (c < 0x20 && (sc->sc_rasyncmap & (1 << c)))
  1558. return;
  1560.     if (sc->sc_flags & SC_ESCAPED) {
  1561. sc->sc_flags &= ~SC_ESCAPED;
  1562. c ^= PPP_TRANS;
  1563.     } else if (c == PPP_ESCAPE) {
  1564. sc->sc_flags |= SC_ESCAPED;
  1565. return;
  1566.     }
  1568.     /*
  1569.      * Initialize buffer on first octet received.
  1570.      * First octet could be address or protocol (when compressing
  1571.      * address/control).
  1572.      * Second octet is control.
  1573.      * Third octet is first or second (when compressing protocol)
  1574.      * octet of protocol.
  1575.      * Fourth octet is second octet of protocol.
  1576.      */
  1577.     if (sc->sc_ilen == 0) {
  1578. /* reset the first input mbuf */
  1579. if (sc->sc_m == NULL) {
  1580.     pppgetm(sc);
  1581.     if (sc->sc_m == NULL) {
  1582. if (sc->sc_flags & SC_DEBUG)
  1583.     printf("ppp%d: no input mbufs!n", sc->sc_if.if_unit);
  1584. goto flush;
  1585.     }
  1586. }
  1587. m = sc->sc_m;
  1588. m->m_len = 0;
  1589. m->m_data = M_DATASTART(sc->sc_m);
  1590. if (M_DATASIZE(sc->sc_m) >= HDROFF + PPP_HDRLEN)
  1591.     m->m_data += HDROFF; /* allow room for VJ decompression */
  1592. sc->sc_mc = m;
  1593. sc->sc_mp = mtod(m, char *);
  1594. sc->sc_fcs = PPP_INITFCS;
  1595. if (c != PPP_ALLSTATIONS) {
  1596.     if (sc->sc_flags & SC_REJ_COMP_AC) {
  1597. if (sc->sc_flags & SC_DEBUG)
  1598.     printf("ppp%d: garbage received: 0x%x (need 0xFF)n",
  1599.    sc->sc_if.if_unit, c);
  1600. goto flush;
  1601.     }
  1602.     *sc->sc_mp++ = PPP_ALLSTATIONS;
  1603.     *sc->sc_mp++ = PPP_UI;
  1604.     sc->sc_ilen += 2;
  1605.     m->m_len += 2;
  1606. }
  1607.     }
  1608.     if (sc->sc_ilen == 1 && c != PPP_UI) {
  1609. if (sc->sc_flags & SC_DEBUG)
  1610.     printf("ppp%d: missing UI (0x3), got 0x%xn",
  1611.    sc->sc_if.if_unit, c);
  1612. goto flush;
  1613.     }
  1614.     if (sc->sc_ilen == 2 && (c & 1) == 1) {
  1615. /* a compressed protocol */
  1616. *sc->sc_mp++ = 0;
  1617. sc->sc_ilen++;
  1618. sc->sc_mc->m_len++;
  1619.     }
  1620.     if (sc->sc_ilen == 3 && (c & 1) == 0) {
  1621. if (sc->sc_flags & SC_DEBUG)
  1622.     printf("ppp%d: bad protocol %xn", sc->sc_if.if_unit,
  1623.    (sc->sc_mp[-1] << 8) + c);
  1624. goto flush;
  1625.     }
  1627.     /* packet beyond configured mru? */
  1628.     if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
  1629. if (sc->sc_flags & SC_DEBUG)
  1630.     printf("ppp%d: packet too bign", sc->sc_if.if_unit);
  1631. goto flush;
  1632.     }
  1634.     /* is this mbuf full? */
  1635.     m = sc->sc_mc;
  1636.     if (M_TRAILINGSPACE(m) <= 0) {
  1637. if (m->m_next == NULL) {
  1638.     pppgetm(sc);
  1639.     if (m->m_next == NULL) {
  1640. if (sc->sc_flags & SC_DEBUG)
  1641.     printf("ppp%d: too few input mbufs!n", sc->sc_if.if_unit);
  1642. goto flush;
  1643.     }
  1644. }
  1645. sc->sc_mc = m = m->m_next;
  1646. m->m_len = 0;
  1647. m->m_data = M_DATASTART(m);
  1648. sc->sc_mp = mtod(m, char *);
  1649.     }
  1651.     ++m->m_len;
  1652.     *sc->sc_mp++ = c;
  1653.     sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
  1654.     return;
  1656.  flush:
  1657.     if (!(sc->sc_flags & SC_FLUSH)) {
  1658. sc->sc_if.if_ierrors++;
  1659. sc->sc_flags |= SC_FLUSH;
  1660. if (sc->sc_flags & SC_LOG_FLUSH)
  1661.     ppplogchar(sc, c);
  1662.     }
  1663. }
  1665. /*
  1666.  * Process an ioctl request to interface.
  1667.  */
  1668. static int
  1669. pppioctl(ifp, cmd, data)
  1670.     register struct ifnet *ifp;
  1671.     int cmd;
  1672.     caddr_t data;
  1673. {
  1674.     register struct ppp_softc *sc = ppp_softc[ifp->if_unit];
  1675.     register struct ifaddr *ifa = (struct ifaddr *)data;
  1676.     register struct ifreq *ifr = (struct ifreq *)data;
  1677.     register M2_NETDRVCNFG *pm2DrvCnfg = (M2_NETDRVCNFG *)data;
  1678.     register M2_NETDRVCNTRS *pm2DrvCntr = (M2_NETDRVCNTRS *)data;
  1679.     int s = splimp(), error = 0;
  1681.     switch (cmd) {
  1682.     case SIOCGIFFLAGS:
  1683.         *(short *)data = ifp->if_flags;
  1684.          break;
  1686.     case SIOCSIFFLAGS:
  1687. if ((ifp->if_flags & IFF_RUNNING) == 0)
  1688.     ifp->if_flags &= ~IFF_UP;
  1689. break;
  1691.     case SIOCSIFADDR:
  1692. if (ifa->ifa_addr->sa_family != AF_INET)
  1693.     error = EAFNOSUPPORT;
  1694. break;
  1696.     case SIOCSIFDSTADDR:
  1697. if (ifa->ifa_dstaddr->sa_family != AF_INET)
  1698.     error = EAFNOSUPPORT;
  1699. break;
  1701.     case SIOCSIFMTU:
  1702. sc->sc_if.if_mtu = ifr->ifr_mtu;
  1703. break;
  1705.     case SIOCGIFMTU:
  1706. ifr->ifr_mtu = sc->sc_if.if_mtu;
  1707. break;
  1709.     case SIOCADDMULTI:
  1710.     case SIOCDELMULTI:
  1711.         if (ifr == 0) {
  1712.             error = EAFNOSUPPORT;
  1713.             break;
  1714.         }
  1715.         switch(ifr->ifr_addr.sa_family) {
  1716. #ifdef INET
  1717.         case AF_INET:
  1718.             break;
  1719. #endif
  1720.         default:
  1721.             error = EAFNOSUPPORT;
  1722.             break;
  1723.         }
  1724.         break;
  1726.     case SIOCGMIB2CNFG:
  1727.         pm2DrvCnfg->ifType = M2_ifType_ppp; /* ppp type */
  1728.         pm2DrvCnfg->ifSpecific.idLength = 0; /* use default */
  1729. break;
  1731.     case SIOCGMIB2CNTRS: /* fill in counters */
  1732. pm2DrvCntr->ifInOctets = sc->sc_bytesrcvd;
  1733.         pm2DrvCntr->ifInNUcastPkts = 0;
  1734.         pm2DrvCntr->ifInDiscards = 0;
  1735.         pm2DrvCntr->ifInUnknownProtos = ppp_if[ppp_unit]->unknownProto;
  1736. pm2DrvCntr->ifOutOctets = sc->sc_bytessent;
  1737.         pm2DrvCntr->ifOutNUcastPkts = 0;
  1738.         pm2DrvCntr->ifOutDiscards = 0;
  1740. if ((pm2DrvCntr->ifSpeed = ppp_if[ppp_unit]->baud_rate) == 0)
  1741.     pm2DrvCntr->ifSpeed = 9600; /* nominal default */
  1743. break;
  1745.     default:
  1746. error = EINVAL;
  1747.     }
  1748.     splx(s);
  1749.     return (error);
  1750. }
  1752. #define MAX_DUMP_BYTES 128
  1754. static void
  1755. pppdumpm(m0, pktlen)
  1756.     struct mbuf *m0;
  1757.     int pktlen;
  1758. {
  1759.     char buf [3*MAX_DUMP_BYTES+4];
  1760.     char *bp = buf;
  1761.     struct mbuf *m;
  1762.     static char digits [] = "0123456789abcdef";
  1764.     for (m = m0; m && pktlen; m = m->m_next) {
  1765. int l = m->m_len;
  1766. u_char *rptr = mtod(m, u_char *);
  1768.         if (pktlen > 0) {
  1769.             if (l > pktlen)
  1770.                 l = pktlen;
  1771.     pktlen -= l;
  1772. }
  1773.         while (l--) {
  1774.             if (bp > buf + sizeof(buf) - 4)
  1775.                 goto done;
  1776.             *bp++ = digits[*rptr >> 4]; /* convert byte to ascii hex */
  1777.             *bp++ = digits[*rptr++ & 0xf];
  1778.         }
  1780.         if (m->m_next) {
  1781.             if (bp > buf + sizeof(buf) - 3)
  1782.                 goto done;
  1783.             *bp++ = '|';
  1784.         } else
  1785.             *bp++ = ' ';
  1786.     }
  1787. done:
  1788.     if (m && pktlen)
  1789.         *bp++ = '>';
  1790.     *bp = 0;
  1791.     printf("%sn", buf);
  1792. }
  1794. static void
  1795. ppplogchar(sc, c)
  1796.     struct ppp_softc *sc;
  1797.     int c;
  1798. {
  1799.     if (c >= 0)
  1800.         sc->sc_rawin[sc->sc_rawin_count++] = c;
  1801.     if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
  1802.         || (c < 0 && sc->sc_rawin_count > 0)) {
  1803.         printf("ppp%d input: ", sc->sc_if.if_unit);
  1804.         pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
  1805.         sc->sc_rawin_count = 0;
  1806.     }
  1807. }
  1809. static void
  1810. pppdumpb(b, l)
  1811.     u_char *b;
  1812.     int l;
  1813. {
  1814.     char buf [3*MAX_DUMP_BYTES+4];
  1815.     char *bp = buf;
  1816.     static char digits[] = "0123456789abcdef";
  1818.     while (l--) {
  1819. if (bp >= buf + sizeof (buf) - 3) {
  1820.     *bp++ = '>';
  1821.     break;
  1822. }
  1823. *bp++ = digits [*b >> 4]; /* convert byte to ascii hex */
  1824. *bp++ = digits [*b++ & 0xf];
  1825.         *bp++ = ' ';
  1826.     }
  1828.     *bp = 0;
  1829.     printf("%sn", buf);
  1830. }
  1832. /* 
  1833.  * Flush write output on the interface. 
  1834.  */
  1835. static void
  1836. ppp_wrt_flush(sc)
  1837.     register struct ppp_softc *sc;
  1838. {
  1839.     register struct mbuf *m;
  1840.     register int len;
  1841.     register u_char *start, *stop, *cp;
  1842.     int n, ndone, done;
  1843.     struct mbuf *m2;
  1844.     int count, fd;
  1845.     char ch;
  1847.     fd = sc->sc_fd;
  1849.     for (;;) {
  1850.         /*
  1851.          * See if we have an existing packet partly sent.
  1852.          * If not, get a new packet and start sending it.
  1853.          * We take packets on the priority queue ahead of those
  1854.          * on the normal queue.
  1855.          */
  1856.         m = sc->sc_outm;
  1857.         if (m == NULL) {
  1858.     /*
  1859.      * Get another packet to be sent
  1860.      */
  1861.     m = ppp_dequeue(sc);
  1862.     if (m == NULL)
  1863.         break;
  1865.     /*
  1866.      * The extra PPP_FLAG will start up a new packet, and thus
  1867.      * will flush any accumulated garbage.  We do this whenever
  1868.      * the line may have been idle for some time.
  1869.      */
  1870.     ioctl(fd, FIONWRITE, (int) &count);
  1871.     if (count == 0) {
  1872.         ++sc->sc_bytessent;
  1873.         ch = PPP_FLAG;
  1874.         (void) write(fd, &ch, 1);
  1875.     }
  1877.     /* Calculate the FCS for the first mbuf's worth. */
  1878.     sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
  1879.         }
  1881.         for (;;) {
  1882.     start = mtod(m, u_char *);
  1883.     len = m->m_len;
  1884.     stop = start + len;
  1885.     while (len > 0) {
  1886.         /*
  1887.          * Find out how many bytes in the string we can
  1888.          * handle without doing something special.
  1889.          */
  1890.         for (cp = start; cp < stop; cp++)
  1891.     if (ESCAPE_P(*cp))
  1892.         break;
  1893.         n = cp - start;
  1894.         if (n) {
  1895.     int cc, nleft;
  1896.     for (nleft = n; nleft > 0; nleft -= cc) {
  1897.         if ((cc =  write(fd, (char *)start, n)) <= 0)
  1898.     break;
  1899.         if (cc > nleft)
  1900.     cc = nleft;
  1901.     }
  1902.     ndone = n - nleft;
  1903.     len -= ndone;
  1904.     start += ndone;
  1905.     sc->sc_bytessent += ndone;
  1907.     if (ndone < n)
  1908.         break;  /* packet doesn't fit */
  1909.         }
  1910.         /*
  1911.          * If there are characters left in the mbuf,
  1912.          * the first one must be special..
  1913.          * Put it out in a different form.
  1914.          */
  1915.         if (len) {
  1916.     ch = PPP_ESCAPE;
  1917.     if (write(fd, &ch, 1) != 1)
  1918.         break;
  1920.     ch = *start ^ PPP_TRANS;
  1921.     if (write(fd, &ch, 1) != 1)
  1922.         break;
  1924.     sc->sc_bytessent += 2;
  1925.     start++;
  1926.     len--;
  1927.         }
  1928.     }
  1929.     /*
  1930.      * If we didn't empty this mbuf, remember where we're up to.
  1931.      * If we emptied the last mbuf, try to add the FCS and closing
  1932.      * flag, and if we can't, leave sc_outm pointing to m, but with
  1933.      * m->m_len == 0, to remind us to output the FCS and flag later.
  1934.      */
  1935.     done = len == 0;
  1936.     if (done && m->m_next == NULL) {
  1937.         u_char *p;
  1938.         int c;
  1939.         u_char endseq[8];
  1940.     
  1941.         /*
  1942.          * We may have to escape the bytes in the FCS.
  1943.          */
  1944.         p = endseq;
  1945.         c = ~sc->sc_outfcs & 0xFF;
  1946.         if (ESCAPE_P(c)) {
  1947.     *p++ = PPP_ESCAPE;
  1948.     *p++ = c ^ PPP_TRANS;
  1949.         } else
  1950.     *p++ = c;
  1951.         c = (~sc->sc_outfcs >> 8) & 0xFF;
  1952.         if (ESCAPE_P(c)) {
  1953.     *p++ = PPP_ESCAPE;
  1954.     *p++ = c ^ PPP_TRANS;
  1955.         } else
  1956.     *p++ = c;
  1957.         *p++ = PPP_FLAG;
  1959.         /*
  1960.          * Try to output the FCS and flag.  If the bytes
  1961.          * don't all fit, back out.
  1962.          */
  1963.         write(fd, (char *)endseq, (int)p-(int)endseq);
  1964.     }
  1966.     if (!done) {
  1967.         m->m_data = (caddr_t)start; 
  1968.         m->m_len = len;
  1969.         sc->sc_outm = m;
  1970.         break;         /* can't do any more at the moment */
  1971.     }
  1973.     /* Finished with this mbuf; free it and move on. */
  1974.     m2 = m_free (m);
  1976.     if (m2 == NULL)
  1977.         break;
  1979.     m = m2;
  1980.     sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
  1981.         }
  1983.         /* Finished a packet */
  1984.         sc->sc_outm = NULL;
  1985.         sc->sc_bytessent++;     /* account for closing flag */
  1986.         sc->sc_if.if_opackets++;
  1987.     }
  1988. }
  1989. #endif  /* NPPP > 0 */