The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net/if_ppp.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: if_ppp.c,v 1.123 2008/06/15 16:37:21 christos Exp $    */
    2 /*      Id: if_ppp.c,v 1.6 1997/03/04 03:33:00 paulus Exp       */
    3 
    4 /*
    5  * if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver.
    6  *
    7  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  *
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  *
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in
   18  *    the documentation and/or other materials provided with the
   19  *    distribution.
   20  *
   21  * 3. The name "Carnegie Mellon University" must not be used to
   22  *    endorse or promote products derived from this software without
   23  *    prior written permission. For permission or any legal
   24  *    details, please contact
   25  *      Office of Technology Transfer
   26  *      Carnegie Mellon University
   27  *      5000 Forbes Avenue
   28  *      Pittsburgh, PA  15213-3890
   29  *      (412) 268-4387, fax: (412) 268-7395
   30  *      tech-transfer@andrew.cmu.edu
   31  *
   32  * 4. Redistributions of any form whatsoever must retain the following
   33  *    acknowledgment:
   34  *    "This product includes software developed by Computing Services
   35  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
   36  *
   37  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
   38  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
   39  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
   40  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   41  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
   42  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
   43  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   44  *
   45  * Based on:
   46  *      @(#)if_sl.c     7.6.1.2 (Berkeley) 2/15/89
   47  *
   48  * Copyright (c) 1987 Regents of the University of California.
   49  * All rights reserved.
   50  *
   51  * Redistribution and use in source and binary forms are permitted
   52  * provided that the above copyright notice and this paragraph are
   53  * duplicated in all such forms and that any documentation,
   54  * advertising materials, and other materials related to such
   55  * distribution and use acknowledge that the software was developed
   56  * by the University of California, Berkeley.  The name of the
   57  * University may not be used to endorse or promote products derived
   58  * from this software without specific prior written permission.
   59  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
   60  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
   61  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
   62  *
   63  * Serial Line interface
   64  *
   65  * Rick Adams
   66  * Center for Seismic Studies
   67  * 1300 N 17th Street, Suite 1450
   68  * Arlington, Virginia 22209
   69  * (703)276-7900
   70  * rick@seismo.ARPA
   71  * seismo!rick
   72  *
   73  * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
   74  * Converted to 4.3BSD Beta by Chris Torek.
   75  * Other changes made at Berkeley, based in part on code by Kirk Smith.
   76  *
   77  * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com)
   78  * Added VJ tcp header compression; more unified ioctls
   79  *
   80  * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au).
   81  * Cleaned up a lot of the mbuf-related code to fix bugs that
   82  * caused system crashes and packet corruption.  Changed pppstart
   83  * so that it doesn't just give up with a collision if the whole
   84  * packet doesn't fit in the output ring buffer.
   85  *
   86  * Added priority queueing for interactive IP packets, following
   87  * the model of if_sl.c, plus hooks for bpf.
   88  * Paul Mackerras (paulus@cs.anu.edu.au).
   89  */
   90 
   91 /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
   92 /* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:58 cgd Exp */
   93 
   94 /*
   95  * XXX IMP ME HARDER
   96  *
   97  * This is an explanation of that comment.  This code used to use
   98  * splimp() to block both network and tty interrupts.  However,
   99  * that call is deprecated.  So, we have replaced the uses of
  100  * splimp() with splhigh() in order to applomplish what it needs
  101  * to accomplish, and added that happy little comment.
  102  */
  103 
  104 #include <sys/cdefs.h>
  105 __KERNEL_RCSID(0, "$NetBSD: if_ppp.c,v 1.123 2008/06/15 16:37:21 christos Exp $");
  106 
  107 #include "ppp.h"
  108 
  109 #include "opt_inet.h"
  110 #include "opt_gateway.h"
  111 #include "opt_ppp.h"
  112 
  113 #ifdef INET
  114 #define VJC
  115 #endif
  116 #define PPP_COMPRESS
  117 
  118 #include <sys/param.h>
  119 #include <sys/proc.h>
  120 #include <sys/mbuf.h>
  121 #include <sys/socket.h>
  122 #include <sys/ioctl.h>
  123 #include <sys/kernel.h>
  124 #include <sys/systm.h>
  125 #include <sys/time.h>
  126 #include <sys/malloc.h>
  127 #include <sys/conf.h>
  128 #include <sys/kauth.h>
  129 #include <sys/intr.h>
  130 #include <sys/simplelock.h>
  131 #include <sys/socketvar.h>
  132 
  133 #include <net/if.h>
  134 #include <net/if_types.h>
  135 #include <net/netisr.h>
  136 #include <net/route.h>
  137 #ifdef PPP_FILTER
  138 #include <net/bpf.h>
  139 #endif
  140 
  141 #include <netinet/in.h>
  142 #include <netinet/in_systm.h>
  143 #include <netinet/in_var.h>
  144 #ifdef INET
  145 #include <netinet/ip.h>
  146 #endif
  147 
  148 #include "bpfilter.h"
  149 #if NBPFILTER > 0
  150 #include <net/bpf.h>
  151 #endif
  152 
  153 #if defined(PPP_FILTER) || NBPFILTER > 0
  154 #include <net/slip.h>
  155 #endif
  156 
  157 #ifdef VJC
  158 #include <net/slcompress.h>
  159 #endif
  160 
  161 #include <net/ppp_defs.h>
  162 #include <net/if_ppp.h>
  163 #include <net/if_pppvar.h>
  164 #include <sys/cpu.h>
  165 
  166 #ifdef PPP_COMPRESS
  167 #define PACKETPTR       struct mbuf *
  168 #include <net/ppp-comp.h>
  169 #endif
  170 
  171 static int      pppsioctl(struct ifnet *, u_long, void *);
  172 static void     ppp_requeue(struct ppp_softc *);
  173 static void     ppp_ccp(struct ppp_softc *, struct mbuf *m, int rcvd);
  174 static void     ppp_ccp_closed(struct ppp_softc *);
  175 static void     ppp_inproc(struct ppp_softc *, struct mbuf *);
  176 static void     pppdumpm(struct mbuf *m0);
  177 #ifdef ALTQ
  178 static void     ppp_ifstart(struct ifnet *ifp);
  179 #endif
  180 
  181 static void     pppintr(void *);
  182 
  183 /*
  184  * Some useful mbuf macros not in mbuf.h.
  185  */
  186 #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
  187 
  188 #define M_DATASTART(m)  \
  189         (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
  190             (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
  191 
  192 #define M_DATASIZE(m)   \
  193         (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
  194             (m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
  195 
  196 /*
  197  * We define two link layer specific mbuf flags, to mark high-priority
  198  * packets for output, and received packets following lost/corrupted
  199  * packets.
  200  */
  201 #define M_HIGHPRI       M_LINK0 /* output packet for sc_fastq */
  202 #define M_ERRMARK       M_LINK1 /* rx packet following lost/corrupted pkt */
  203 
  204 static int              ppp_clone_create(struct if_clone *, int);
  205 static int              ppp_clone_destroy(struct ifnet *);
  206 
  207 static struct ppp_softc *ppp_create(const char *, int);
  208 
  209 static LIST_HEAD(, ppp_softc) ppp_softc_list;
  210 
  211 struct if_clone ppp_cloner =
  212     IF_CLONE_INITIALIZER("ppp", ppp_clone_create, ppp_clone_destroy);
  213 
  214 static struct simplelock ppp_list_mutex = SIMPLELOCK_INITIALIZER;
  215 
  216 #ifdef PPP_COMPRESS
  217 /*
  218  * List of compressors we know about.
  219  * We leave some space so maybe we can modload compressors.
  220  */
  221 
  222 extern struct compressor ppp_bsd_compress;
  223 extern struct compressor ppp_deflate, ppp_deflate_draft;
  224 
  225 struct compressor *ppp_compressors[PPP_COMPRESSORS_MAX] = {
  226 #if DO_BSD_COMPRESS && defined(PPP_BSDCOMP)
  227     &ppp_bsd_compress,
  228 #endif
  229 #if DO_DEFLATE && defined(PPP_DEFLATE)
  230     &ppp_deflate,
  231     &ppp_deflate_draft,
  232 #endif
  233     NULL
  234 };
  235 #endif /* PPP_COMPRESS */
  236 
  237 
  238 /*
  239  * Called from boot code to establish ppp interfaces.
  240  */
  241 void
  242 pppattach(void)
  243 {
  244     extern struct linesw ppp_disc;
  245 
  246     if (ttyldisc_attach(&ppp_disc) != 0)
  247         panic("pppattach");
  248     LIST_INIT(&ppp_softc_list);
  249     if_clone_attach(&ppp_cloner);
  250 }
  251 
  252 static struct ppp_softc *
  253 ppp_create(const char *name, int unit)
  254 {
  255     struct ppp_softc *sc, *sci, *scl = NULL;
  256 
  257     MALLOC(sc, struct ppp_softc *, sizeof(*sc), M_DEVBUF, M_WAIT|M_ZERO);
  258 
  259     simple_lock(&ppp_list_mutex);
  260     if (unit == -1) {
  261         int i = 0;
  262         LIST_FOREACH(sci, &ppp_softc_list, sc_iflist) {
  263             scl = sci;
  264             if (i < sci->sc_unit) {
  265                 unit = i;
  266                 break;
  267             } else {
  268 #ifdef DIAGNOSTIC
  269                 KASSERT(i == sci->sc_unit);
  270 #endif
  271                 i++;
  272             }
  273         }
  274         if (unit == -1)
  275             unit = i;
  276     } else {
  277         LIST_FOREACH(sci, &ppp_softc_list, sc_iflist) {
  278             scl = sci;
  279             if (unit < sci->sc_unit)
  280                 break;
  281             else if (unit == sci->sc_unit) {
  282                 FREE(sc, M_DEVBUF);
  283                 return NULL;
  284             }
  285         }
  286     }
  287 
  288     if (sci != NULL)
  289         LIST_INSERT_BEFORE(sci, sc, sc_iflist);
  290     else if (scl != NULL)
  291         LIST_INSERT_AFTER(scl, sc, sc_iflist);
  292     else
  293         LIST_INSERT_HEAD(&ppp_softc_list, sc, sc_iflist);
  294 
  295     simple_unlock(&ppp_list_mutex);
  296 
  297     if_initname(&sc->sc_if, name, sc->sc_unit = unit);
  298     callout_init(&sc->sc_timo_ch, 0);
  299     sc->sc_if.if_softc = sc;
  300     sc->sc_if.if_mtu = PPP_MTU;
  301     sc->sc_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
  302     sc->sc_if.if_type = IFT_PPP;
  303     sc->sc_if.if_hdrlen = PPP_HDRLEN;
  304     sc->sc_if.if_dlt = DLT_NULL;
  305     sc->sc_if.if_ioctl = pppsioctl;
  306     sc->sc_if.if_output = pppoutput;
  307 #ifdef ALTQ
  308     sc->sc_if.if_start = ppp_ifstart;
  309 #endif
  310     IFQ_SET_MAXLEN(&sc->sc_if.if_snd, IFQ_MAXLEN);
  311     sc->sc_inq.ifq_maxlen = IFQ_MAXLEN;
  312     sc->sc_fastq.ifq_maxlen = IFQ_MAXLEN;
  313     sc->sc_rawq.ifq_maxlen = IFQ_MAXLEN;
  314     /* Ratio of 1:2 packets between the regular and the fast queue */
  315     sc->sc_maxfastq = 2;        
  316     IFQ_SET_READY(&sc->sc_if.if_snd);
  317     if_attach(&sc->sc_if);
  318     if_alloc_sadl(&sc->sc_if);
  319 #if NBPFILTER > 0
  320     bpfattach(&sc->sc_if, DLT_NULL, 0);
  321 #endif
  322     return sc;
  323 }
  324 
  325 static int
  326 ppp_clone_create(struct if_clone *ifc, int unit)
  327 {
  328     return ppp_create(ifc->ifc_name, unit) == NULL ? EEXIST : 0;
  329 }
  330 
  331 static int
  332 ppp_clone_destroy(struct ifnet *ifp)
  333 {
  334     struct ppp_softc *sc = (struct ppp_softc *)ifp->if_softc;
  335 
  336     if (sc->sc_devp != NULL)
  337         return EBUSY; /* Not removing it */
  338 
  339     simple_lock(&ppp_list_mutex);
  340     LIST_REMOVE(sc, sc_iflist);
  341     simple_unlock(&ppp_list_mutex);
  342 
  343 #if NBPFILTER > 0
  344     bpfdetach(ifp);
  345 #endif
  346     if_detach(ifp);
  347 
  348     FREE(sc, M_DEVBUF);
  349     return 0;
  350 }
  351 
  352 /*
  353  * Allocate a ppp interface unit and initialize it.
  354  */
  355 struct ppp_softc *
  356 pppalloc(pid_t pid)
  357 {
  358     struct ppp_softc *sc = NULL, *scf;
  359     int i;
  360 
  361     simple_lock(&ppp_list_mutex);
  362     for (scf = LIST_FIRST(&ppp_softc_list); scf != NULL;
  363         scf = LIST_NEXT(scf, sc_iflist)) {
  364         if (scf->sc_xfer == pid) {
  365             scf->sc_xfer = 0;
  366             simple_unlock(&ppp_list_mutex);
  367             return scf;
  368         }
  369         if (scf->sc_devp == NULL && sc == NULL)
  370             sc = scf;
  371     }
  372     simple_unlock(&ppp_list_mutex);
  373 
  374     if (sc == NULL)
  375         sc = ppp_create(ppp_cloner.ifc_name, -1);
  376 
  377     sc->sc_si = softint_establish(SOFTINT_NET, pppintr, sc);
  378     if (sc->sc_si == NULL) {
  379         printf("%s: unable to establish softintr\n", sc->sc_if.if_xname);
  380         return (NULL);
  381     }
  382     sc->sc_flags = 0;
  383     sc->sc_mru = PPP_MRU;
  384     sc->sc_relinq = NULL;
  385     (void)memset(&sc->sc_stats, 0, sizeof(sc->sc_stats));
  386 #ifdef VJC
  387     MALLOC(sc->sc_comp, struct slcompress *, sizeof(struct slcompress),
  388            M_DEVBUF, M_NOWAIT);
  389     if (sc->sc_comp)
  390         sl_compress_init(sc->sc_comp);
  391 #endif
  392 #ifdef PPP_COMPRESS
  393     sc->sc_xc_state = NULL;
  394     sc->sc_rc_state = NULL;
  395 #endif /* PPP_COMPRESS */
  396     for (i = 0; i < NUM_NP; ++i)
  397         sc->sc_npmode[i] = NPMODE_ERROR;
  398     sc->sc_npqueue = NULL;
  399     sc->sc_npqtail = &sc->sc_npqueue;
  400     sc->sc_last_sent = sc->sc_last_recv = time_second;
  401 
  402     return sc;
  403 }
  404 
  405 /*
  406  * Deallocate a ppp unit.  Must be called at splsoftnet or higher.
  407  */
  408 void
  409 pppdealloc(struct ppp_softc *sc)
  410 {
  411     struct mbuf *m;
  412 
  413     softint_disestablish(sc->sc_si);
  414     if_down(&sc->sc_if);
  415     sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
  416     sc->sc_devp = NULL;
  417     sc->sc_xfer = 0;
  418     for (;;) {
  419         IF_DEQUEUE(&sc->sc_rawq, m);
  420         if (m == NULL)
  421             break;
  422         m_freem(m);
  423     }
  424     for (;;) {
  425         IF_DEQUEUE(&sc->sc_inq, m);
  426         if (m == NULL)
  427             break;
  428         m_freem(m);
  429     }
  430     for (;;) {
  431         IF_DEQUEUE(&sc->sc_fastq, m);
  432         if (m == NULL)
  433             break;
  434         m_freem(m);
  435     }
  436     while ((m = sc->sc_npqueue) != NULL) {
  437         sc->sc_npqueue = m->m_nextpkt;
  438         m_freem(m);
  439     }
  440     if (sc->sc_togo != NULL) {
  441         m_freem(sc->sc_togo);
  442         sc->sc_togo = NULL;
  443     }
  444 #ifdef PPP_COMPRESS
  445     ppp_ccp_closed(sc);
  446     sc->sc_xc_state = NULL;
  447     sc->sc_rc_state = NULL;
  448 #endif /* PPP_COMPRESS */
  449 #ifdef PPP_FILTER
  450     if (sc->sc_pass_filt_in.bf_insns != 0) {
  451         FREE(sc->sc_pass_filt_in.bf_insns, M_DEVBUF);
  452         sc->sc_pass_filt_in.bf_insns = 0;
  453         sc->sc_pass_filt_in.bf_len = 0;
  454     }
  455     if (sc->sc_pass_filt_out.bf_insns != 0) {
  456         FREE(sc->sc_pass_filt_out.bf_insns, M_DEVBUF);
  457         sc->sc_pass_filt_out.bf_insns = 0;
  458         sc->sc_pass_filt_out.bf_len = 0;
  459     }
  460     if (sc->sc_active_filt_in.bf_insns != 0) {
  461         FREE(sc->sc_active_filt_in.bf_insns, M_DEVBUF);
  462         sc->sc_active_filt_in.bf_insns = 0;
  463         sc->sc_active_filt_in.bf_len = 0;
  464     }
  465     if (sc->sc_active_filt_out.bf_insns != 0) {
  466         FREE(sc->sc_active_filt_out.bf_insns, M_DEVBUF);
  467         sc->sc_active_filt_out.bf_insns = 0;
  468         sc->sc_active_filt_out.bf_len = 0;
  469     }
  470 #endif /* PPP_FILTER */
  471 #ifdef VJC
  472     if (sc->sc_comp != 0) {
  473         FREE(sc->sc_comp, M_DEVBUF);
  474         sc->sc_comp = 0;
  475     }
  476 #endif
  477     (void)ppp_clone_destroy(&sc->sc_if);
  478 }
  479 
  480 /*
  481  * Ioctl routine for generic ppp devices.
  482  */
  483 int
  484 pppioctl(struct ppp_softc *sc, u_long cmd, void *data, int flag,
  485     struct lwp *l)
  486 {
  487     int s, error, flags, mru, npx;
  488     u_int nb;
  489     struct ppp_option_data *odp;
  490     struct compressor **cp;
  491     struct npioctl *npi;
  492     time_t t;
  493 #ifdef PPP_FILTER
  494     struct bpf_program *bp, *nbp;
  495     struct bpf_insn *newcode, *oldcode;
  496     int newcodelen;
  497 #endif /* PPP_FILTER */
  498 #ifdef  PPP_COMPRESS
  499     u_char ccp_option[CCP_MAX_OPTION_LENGTH];
  500 #endif
  501 
  502     switch (cmd) {
  503     case PPPIOCSFLAGS:
  504     case PPPIOCSMRU:
  505     case PPPIOCSMAXCID:
  506     case PPPIOCSCOMPRESS:
  507     case PPPIOCSNPMODE:
  508         if (kauth_authorize_network(l->l_cred, KAUTH_NETWORK_INTERFACE,
  509             KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, &sc->sc_if, (void *)cmd,
  510             NULL) != 0)
  511                 return (EPERM);
  512         break;
  513     case PPPIOCXFERUNIT:
  514         /* XXX: Why is this privileged?! */
  515         if (kauth_authorize_network(l->l_cred, KAUTH_NETWORK_INTERFACE,
  516             KAUTH_REQ_NETWORK_INTERFACE_GETPRIV, &sc->sc_if, (void *)cmd,
  517             NULL) != 0)
  518                 return (EPERM);
  519         break;
  520     default:
  521         break;
  522     }
  523 
  524     switch (cmd) {
  525     case FIONREAD:
  526         *(int *)data = sc->sc_inq.ifq_len;
  527         break;
  528 
  529     case PPPIOCGUNIT:
  530         *(int *)data = sc->sc_unit;
  531         break;
  532 
  533     case PPPIOCGFLAGS:
  534         *(u_int *)data = sc->sc_flags;
  535         break;
  536 
  537     case PPPIOCGRAWIN:
  538         {
  539             struct ppp_rawin *rwin = (struct ppp_rawin *)data;
  540             u_char c, q = 0;
  541 
  542             for (c = sc->sc_rawin_start; c < sizeof(sc->sc_rawin.buf);)
  543                 rwin->buf[q++] = sc->sc_rawin.buf[c++];
  544 
  545             for (c = 0; c < sc->sc_rawin_start;)
  546                 rwin->buf[q++] = sc->sc_rawin.buf[c++];
  547 
  548             rwin->count = sc->sc_rawin.count;
  549         }
  550         break;
  551 
  552     case PPPIOCSFLAGS:
  553         flags = *(int *)data & SC_MASK;
  554         s = splsoftnet();
  555 #ifdef PPP_COMPRESS
  556         if (sc->sc_flags & SC_CCP_OPEN && !(flags & SC_CCP_OPEN))
  557             ppp_ccp_closed(sc);
  558 #endif
  559         splhigh();      /* XXX IMP ME HARDER */
  560         sc->sc_flags = (sc->sc_flags & ~SC_MASK) | flags;
  561         splx(s);
  562         break;
  563 
  564     case PPPIOCSMRU:
  565         mru = *(int *)data;
  566         if (mru >= PPP_MINMRU && mru <= PPP_MAXMRU)
  567             sc->sc_mru = mru;
  568         break;
  569 
  570     case PPPIOCGMRU:
  571         *(int *)data = sc->sc_mru;
  572         break;
  573 
  574 #ifdef VJC
  575     case PPPIOCSMAXCID:
  576         if (sc->sc_comp) {
  577             s = splsoftnet();
  578             sl_compress_setup(sc->sc_comp, *(int *)data);
  579             splx(s);
  580         }
  581         break;
  582 #endif
  583 
  584     case PPPIOCXFERUNIT:
  585         sc->sc_xfer = l->l_proc->p_pid;
  586         break;
  587 
  588 #ifdef PPP_COMPRESS
  589     case PPPIOCSCOMPRESS:
  590         odp = (struct ppp_option_data *) data;
  591         nb = odp->length;
  592         if (nb > sizeof(ccp_option))
  593             nb = sizeof(ccp_option);
  594         if ((error = copyin(odp->ptr, ccp_option, nb)) != 0)
  595             return (error);
  596         if (ccp_option[1] < 2)  /* preliminary check on the length byte */
  597             return (EINVAL);
  598         for (cp = ppp_compressors; *cp != NULL; ++cp)
  599             if ((*cp)->compress_proto == ccp_option[0]) {
  600                 /*
  601                  * Found a handler for the protocol - try to allocate
  602                  * a compressor or decompressor.
  603                  */
  604                 error = 0;
  605                 if (odp->transmit) {
  606                     s = splsoftnet();
  607                     if (sc->sc_xc_state != NULL)
  608                         (*sc->sc_xcomp->comp_free)(sc->sc_xc_state);
  609                     sc->sc_xcomp = *cp;
  610                     sc->sc_xc_state = (*cp)->comp_alloc(ccp_option, nb);
  611                     if (sc->sc_xc_state == NULL) {
  612                         if (sc->sc_flags & SC_DEBUG)
  613                             printf("%s: comp_alloc failed\n",
  614                                 sc->sc_if.if_xname);
  615                         error = ENOBUFS;
  616                     }
  617                     splhigh();  /* XXX IMP ME HARDER */
  618                     sc->sc_flags &= ~SC_COMP_RUN;
  619                     splx(s);
  620                 } else {
  621                     s = splsoftnet();
  622                     if (sc->sc_rc_state != NULL)
  623                         (*sc->sc_rcomp->decomp_free)(sc->sc_rc_state);
  624                     sc->sc_rcomp = *cp;
  625                     sc->sc_rc_state = (*cp)->decomp_alloc(ccp_option, nb);
  626                     if (sc->sc_rc_state == NULL) {
  627                         if (sc->sc_flags & SC_DEBUG)
  628                             printf("%s: decomp_alloc failed\n",
  629                                 sc->sc_if.if_xname);
  630                         error = ENOBUFS;
  631                     }
  632                     splhigh();  /* XXX IMP ME HARDER */
  633                     sc->sc_flags &= ~SC_DECOMP_RUN;
  634                     splx(s);
  635                 }
  636                 return (error);
  637             }
  638         if (sc->sc_flags & SC_DEBUG)
  639             printf("%s: no compressor for [%x %x %x], %x\n",
  640                 sc->sc_if.if_xname, ccp_option[0], ccp_option[1],
  641                 ccp_option[2], nb);
  642         return (EINVAL);        /* no handler found */
  643 #endif /* PPP_COMPRESS */
  644 
  645     case PPPIOCGNPMODE:
  646     case PPPIOCSNPMODE:
  647         npi = (struct npioctl *) data;
  648         switch (npi->protocol) {
  649         case PPP_IP:
  650             npx = NP_IP;
  651             break;
  652         case PPP_IPV6:
  653             npx = NP_IPV6;
  654             break;
  655         default:
  656             return EINVAL;
  657         }
  658         if (cmd == PPPIOCGNPMODE) {
  659             npi->mode = sc->sc_npmode[npx];
  660         } else {
  661             if (npi->mode != sc->sc_npmode[npx]) {
  662                 s = splnet();
  663                 sc->sc_npmode[npx] = npi->mode;
  664                 if (npi->mode != NPMODE_QUEUE) {
  665                     ppp_requeue(sc);
  666                     ppp_restart(sc);
  667                 }
  668                 splx(s);
  669             }
  670         }
  671         break;
  672 
  673     case PPPIOCGIDLE:
  674         s = splsoftnet();
  675         t = time_second;
  676         ((struct ppp_idle *)data)->xmit_idle = t - sc->sc_last_sent;
  677         ((struct ppp_idle *)data)->recv_idle = t - sc->sc_last_recv;
  678         splx(s);
  679         break;
  680 
  681 #ifdef PPP_FILTER
  682     case PPPIOCSPASS:
  683     case PPPIOCSACTIVE:
  684         /* These are no longer supported. */
  685         return EOPNOTSUPP;
  686 
  687     case PPPIOCSIPASS:
  688     case PPPIOCSOPASS:
  689     case PPPIOCSIACTIVE:
  690     case PPPIOCSOACTIVE:
  691         nbp = (struct bpf_program *) data;
  692         if ((unsigned) nbp->bf_len > BPF_MAXINSNS)
  693             return EINVAL;
  694         newcodelen = nbp->bf_len * sizeof(struct bpf_insn);
  695         if (newcodelen != 0) {
  696             newcode = malloc(newcodelen, M_DEVBUF, M_WAITOK);
  697             /* WAITOK -- malloc() never fails. */
  698             if ((error = copyin((void *)nbp->bf_insns, (void *)newcode,
  699                                newcodelen)) != 0) {
  700                 free(newcode, M_DEVBUF);
  701                 return error;
  702             }
  703             if (!bpf_validate(newcode, nbp->bf_len)) {
  704                 free(newcode, M_DEVBUF);
  705                 return EINVAL;
  706             }
  707         } else
  708             newcode = 0;
  709         switch (cmd) {
  710         case PPPIOCSIPASS:
  711             bp = &sc->sc_pass_filt_in;
  712             break;
  713 
  714         case PPPIOCSOPASS:
  715             bp = &sc->sc_pass_filt_out;
  716             break;
  717 
  718         case PPPIOCSIACTIVE:
  719             bp = &sc->sc_active_filt_in;
  720             break;
  721 
  722         case PPPIOCSOACTIVE:
  723             bp = &sc->sc_active_filt_out;
  724             break;
  725         default:
  726             free(newcode, M_DEVBUF);
  727             return (EPASSTHROUGH);
  728         }
  729         oldcode = bp->bf_insns;
  730         s = splnet();
  731         bp->bf_len = nbp->bf_len;
  732         bp->bf_insns = newcode;
  733         splx(s);
  734         if (oldcode != 0)
  735             free(oldcode, M_DEVBUF);
  736         break;
  737 #endif /* PPP_FILTER */
  738 
  739     default:
  740         return (EPASSTHROUGH);
  741     }
  742     return (0);
  743 }
  744 
  745 /*
  746  * Process an ioctl request to the ppp network interface.
  747  */
  748 static int
  749 pppsioctl(struct ifnet *ifp, u_long cmd, void *data)
  750 {
  751     struct lwp *l = curlwp;     /* XXX */
  752     struct ppp_softc *sc = ifp->if_softc;
  753     struct ifaddr *ifa = (struct ifaddr *)data;
  754     struct ifreq *ifr = (struct ifreq *)data;
  755     struct ppp_stats *psp;
  756 #ifdef  PPP_COMPRESS
  757     struct ppp_comp_stats *pcp;
  758 #endif
  759     int s = splnet(), error = 0;
  760 
  761     switch (cmd) {
  762     case SIOCSIFFLAGS:
  763         if ((ifp->if_flags & IFF_RUNNING) == 0)
  764             ifp->if_flags &= ~IFF_UP;
  765         break;
  766 
  767     case SIOCSIFADDR:
  768         switch (ifa->ifa_addr->sa_family) {
  769 #ifdef INET
  770         case AF_INET:
  771             break;
  772 #endif
  773 #ifdef INET6
  774         case AF_INET6:
  775             break;
  776 #endif
  777         default:
  778             error = EAFNOSUPPORT;
  779             break;
  780         }
  781         break;
  782 
  783     case SIOCSIFDSTADDR:
  784         switch (ifa->ifa_addr->sa_family) {
  785 #ifdef INET
  786         case AF_INET:
  787             break;
  788 #endif
  789 #ifdef INET6
  790         case AF_INET6:
  791             break;
  792 #endif
  793         default:
  794             error = EAFNOSUPPORT;
  795             break;
  796         }
  797         break;
  798 
  799     case SIOCSIFMTU:
  800         if ((error = kauth_authorize_network(l->l_cred,
  801             KAUTH_NETWORK_INTERFACE, KAUTH_REQ_NETWORK_INTERFACE_SETPRIV,
  802             ifp, (void *)cmd, NULL) != 0))
  803             break;
  804         /*FALLTHROUGH*/
  805     case SIOCGIFMTU:
  806         if ((error = ifioctl_common(&sc->sc_if, cmd, data)) == ENETRESET)
  807                 error = 0;
  808         break;
  809 
  810     case SIOCADDMULTI:
  811     case SIOCDELMULTI:
  812         if (ifr == NULL) {
  813             error = EAFNOSUPPORT;
  814             break;
  815         }
  816         switch (ifreq_getaddr(cmd, ifr)->sa_family) {
  817 #ifdef INET
  818         case AF_INET:
  819             break;
  820 #endif
  821 #ifdef INET6
  822         case AF_INET6:
  823             break;
  824 #endif
  825         default:
  826             error = EAFNOSUPPORT;
  827             break;
  828         }
  829         break;
  830 
  831     case SIOCGPPPSTATS:
  832         psp = &((struct ifpppstatsreq *) data)->stats;
  833         memset(psp, 0, sizeof(*psp));
  834         psp->p = sc->sc_stats;
  835 #if defined(VJC) && !defined(SL_NO_STATS)
  836         if (sc->sc_comp) {
  837             psp->vj.vjs_packets = sc->sc_comp->sls_packets;
  838             psp->vj.vjs_compressed = sc->sc_comp->sls_compressed;
  839             psp->vj.vjs_searches = sc->sc_comp->sls_searches;
  840             psp->vj.vjs_misses = sc->sc_comp->sls_misses;
  841             psp->vj.vjs_uncompressedin = sc->sc_comp->sls_uncompressedin;
  842             psp->vj.vjs_compressedin = sc->sc_comp->sls_compressedin;
  843             psp->vj.vjs_errorin = sc->sc_comp->sls_errorin;
  844             psp->vj.vjs_tossed = sc->sc_comp->sls_tossed;
  845         }
  846 #endif /* VJC */
  847         break;
  848 
  849 #ifdef PPP_COMPRESS
  850     case SIOCGPPPCSTATS:
  851         pcp = &((struct ifpppcstatsreq *) data)->stats;
  852         memset(pcp, 0, sizeof(*pcp));
  853         if (sc->sc_xc_state != NULL)
  854             (*sc->sc_xcomp->comp_stat)(sc->sc_xc_state, &pcp->c);
  855         if (sc->sc_rc_state != NULL)
  856             (*sc->sc_rcomp->decomp_stat)(sc->sc_rc_state, &pcp->d);
  857         break;
  858 #endif /* PPP_COMPRESS */
  859 
  860     default:
  861         error = EINVAL;
  862     }
  863     splx(s);
  864     return (error);
  865 }
  866 
  867 /*
  868  * Queue a packet.  Start transmission if not active.
  869  * Packet is placed in Information field of PPP frame.
  870  */
  871 int
  872 pppoutput(struct ifnet *ifp, struct mbuf *m0, const struct sockaddr *dst,
  873     struct rtentry *rtp)
  874 {
  875     struct ppp_softc *sc = ifp->if_softc;
  876     int protocol, address, control;
  877     u_char *cp;
  878     int s, error;
  879 #ifdef INET
  880     struct ip *ip;
  881 #endif
  882     struct ifqueue *ifq;
  883     enum NPmode mode;
  884     int len;
  885     ALTQ_DECL(struct altq_pktattr pktattr;)
  886 
  887     if (sc->sc_devp == NULL || (ifp->if_flags & IFF_RUNNING) == 0
  888         || ((ifp->if_flags & IFF_UP) == 0 && dst->sa_family != AF_UNSPEC)) {
  889         error = ENETDOWN;       /* sort of */
  890         goto bad;
  891     }
  892 
  893     IFQ_CLASSIFY(&ifp->if_snd, m0, dst->sa_family, &pktattr);
  894 
  895     /*
  896      * Compute PPP header.
  897      */
  898     m0->m_flags &= ~M_HIGHPRI;
  899     switch (dst->sa_family) {
  900 #ifdef INET
  901     case AF_INET:
  902         address = PPP_ALLSTATIONS;
  903         control = PPP_UI;
  904         protocol = PPP_IP;
  905         mode = sc->sc_npmode[NP_IP];
  906 
  907         /*
  908          * If this packet has the "low delay" bit set in the IP header,
  909          * put it on the fastq instead.
  910          */
  911         ip = mtod(m0, struct ip *);
  912         if (ip->ip_tos & IPTOS_LOWDELAY)
  913             m0->m_flags |= M_HIGHPRI;
  914         break;
  915 #endif
  916 #ifdef INET6
  917     case AF_INET6:
  918         address = PPP_ALLSTATIONS;      /*XXX*/
  919         control = PPP_UI;               /*XXX*/
  920         protocol = PPP_IPV6;
  921         mode = sc->sc_npmode[NP_IPV6];
  922 
  923 #if 0   /* XXX flowinfo/traffic class, maybe? */
  924         /*
  925          * If this packet has the "low delay" bit set in the IP header,
  926          * put it on the fastq instead.
  927          */
  928         ip = mtod(m0, struct ip *);
  929         if (ip->ip_tos & IPTOS_LOWDELAY)
  930             m0->m_flags |= M_HIGHPRI;
  931 #endif
  932         break;
  933 #endif
  934     case AF_UNSPEC:
  935         address = PPP_ADDRESS(dst->sa_data);
  936         control = PPP_CONTROL(dst->sa_data);
  937         protocol = PPP_PROTOCOL(dst->sa_data);
  938         mode = NPMODE_PASS;
  939         break;
  940     default:
  941         printf("%s: af%d not supported\n", ifp->if_xname, dst->sa_family);
  942         error = EAFNOSUPPORT;
  943         goto bad;
  944     }
  945 
  946     /*
  947      * Drop this packet, or return an error, if necessary.
  948      */
  949     if (mode == NPMODE_ERROR) {
  950         error = ENETDOWN;
  951         goto bad;
  952     }
  953     if (mode == NPMODE_DROP) {
  954         error = 0;
  955         goto bad;
  956     }
  957 
  958     /*
  959      * Add PPP header.
  960      */
  961     M_PREPEND(m0, PPP_HDRLEN, M_DONTWAIT);
  962     if (m0 == NULL) {
  963         error = ENOBUFS;
  964         goto bad;
  965     }
  966 
  967     cp = mtod(m0, u_char *);
  968     *cp++ = address;
  969     *cp++ = control;
  970     *cp++ = protocol >> 8;
  971     *cp++ = protocol & 0xff;
  972 
  973     len = m_length(m0);
  974 
  975     if (sc->sc_flags & SC_LOG_OUTPKT) {
  976         printf("%s output: ", ifp->if_xname);
  977         pppdumpm(m0);
  978     }
  979 
  980     if ((protocol & 0x8000) == 0) {
  981 #ifdef PPP_FILTER
  982         /*
  983          * Apply the pass and active filters to the packet,
  984          * but only if it is a data packet.
  985          */
  986         if (sc->sc_pass_filt_out.bf_insns != 0
  987             && bpf_filter(sc->sc_pass_filt_out.bf_insns, (u_char *) m0,
  988                           len, 0) == 0) {
  989             error = 0;          /* drop this packet */
  990             goto bad;
  991         }
  992 
  993         /*
  994          * Update the time we sent the most recent packet.
  995          */
  996         if (sc->sc_active_filt_out.bf_insns == 0
  997             || bpf_filter(sc->sc_active_filt_out.bf_insns, (u_char *) m0,
  998                           len, 0))
  999             sc->sc_last_sent = time_second;
 1000 #else
 1001         /*
 1002          * Update the time we sent the most recent packet.
 1003          */
 1004         sc->sc_last_sent = time_second;
 1005 #endif /* PPP_FILTER */
 1006     }
 1007 
 1008 #if NBPFILTER > 0
 1009     /*
 1010      * See if bpf wants to look at the packet.
 1011      */
 1012     if (sc->sc_if.if_bpf)
 1013         bpf_mtap(sc->sc_if.if_bpf, m0);
 1014 #endif
 1015 
 1016     /*
 1017      * Put the packet on the appropriate queue.
 1018      */
 1019     s = splnet();
 1020     if (mode == NPMODE_QUEUE) {
 1021         /* XXX we should limit the number of packets on this queue */
 1022         *sc->sc_npqtail = m0;
 1023         m0->m_nextpkt = NULL;
 1024         sc->sc_npqtail = &m0->m_nextpkt;
 1025     } else {
 1026         ifq = (m0->m_flags & M_HIGHPRI) ? &sc->sc_fastq : NULL;
 1027         if ((error = ifq_enqueue2(&sc->sc_if, ifq, m0
 1028                 ALTQ_COMMA ALTQ_DECL(&pktattr))) != 0) {
 1029             splx(s);
 1030             sc->sc_if.if_oerrors++;
 1031             sc->sc_stats.ppp_oerrors++;
 1032             return (error);
 1033         }
 1034         ppp_restart(sc);
 1035     }
 1036     ifp->if_opackets++;
 1037     ifp->if_obytes += len;
 1038 
 1039     splx(s);
 1040     return (0);
 1041 
 1042 bad:
 1043     m_freem(m0);
 1044     return (error);
 1045 }
 1046 
 1047 /*
 1048  * After a change in the NPmode for some NP, move packets from the
 1049  * npqueue to the send queue or the fast queue as appropriate.
 1050  * Should be called at splnet, since we muck with the queues.
 1051  */
 1052 static void
 1053 ppp_requeue(struct ppp_softc *sc)
 1054 {
 1055     struct mbuf *m, **mpp;
 1056     struct ifqueue *ifq;
 1057     enum NPmode mode;
 1058     int error;
 1059 
 1060     for (mpp = &sc->sc_npqueue; (m = *mpp) != NULL; ) {
 1061         switch (PPP_PROTOCOL(mtod(m, u_char *))) {
 1062         case PPP_IP:
 1063             mode = sc->sc_npmode[NP_IP];
 1064             break;
 1065         case PPP_IPV6:
 1066             mode = sc->sc_npmode[NP_IPV6];
 1067             break;
 1068         default:
 1069             mode = NPMODE_PASS;
 1070         }
 1071 
 1072         switch (mode) {
 1073         case NPMODE_PASS:
 1074             /*
 1075              * This packet can now go on one of the queues to be sent.
 1076              */
 1077             *mpp = m->m_nextpkt;
 1078             m->m_nextpkt = NULL;
 1079             ifq = (m->m_flags & M_HIGHPRI) ? &sc->sc_fastq : NULL;
 1080             if ((error = ifq_enqueue2(&sc->sc_if, ifq, m ALTQ_COMMA
 1081                 ALTQ_DECL(NULL))) != 0) {
 1082                 sc->sc_if.if_oerrors++;
 1083                 sc->sc_stats.ppp_oerrors++;
 1084             }
 1085             break;
 1086 
 1087         case NPMODE_DROP:
 1088         case NPMODE_ERROR:
 1089             *mpp = m->m_nextpkt;
 1090             m_freem(m);
 1091             break;
 1092 
 1093         case NPMODE_QUEUE:
 1094             mpp = &m->m_nextpkt;
 1095             break;
 1096         }
 1097     }
 1098     sc->sc_npqtail = mpp;
 1099 }
 1100 
 1101 /*
 1102  * Transmitter has finished outputting some stuff;
 1103  * remember to call sc->sc_start later at splsoftnet.
 1104  */
 1105 void
 1106 ppp_restart(struct ppp_softc *sc)
 1107 {
 1108     int s = splhigh();  /* XXX IMP ME HARDER */
 1109 
 1110     sc->sc_flags &= ~SC_TBUSY;
 1111     softint_schedule(sc->sc_si);
 1112     splx(s);
 1113 }
 1114 
 1115 /*
 1116  * Get a packet to send.  This procedure is intended to be called at
 1117  * splsoftnet, since it may involve time-consuming operations such as
 1118  * applying VJ compression, packet compression, address/control and/or
 1119  * protocol field compression to the packet.
 1120  */
 1121 struct mbuf *
 1122 ppp_dequeue(struct ppp_softc *sc)
 1123 {
 1124     struct mbuf *m, *mp;
 1125     u_char *cp;
 1126     int address, control, protocol;
 1127     int s;
 1128 
 1129     /*
 1130      * Grab a packet to send: first try the fast queue, then the
 1131      * normal queue.
 1132      */
 1133     s = splnet();
 1134     if (sc->sc_nfastq < sc->sc_maxfastq) {
 1135         IF_DEQUEUE(&sc->sc_fastq, m);
 1136         if (m != NULL)
 1137             sc->sc_nfastq++;
 1138         else
 1139             IFQ_DEQUEUE(&sc->sc_if.if_snd, m);
 1140     } else {
 1141         sc->sc_nfastq = 0;
 1142         IFQ_DEQUEUE(&sc->sc_if.if_snd, m);
 1143         if (m == NULL) {
 1144             IF_DEQUEUE(&sc->sc_fastq, m);
 1145             if (m != NULL)
 1146                 sc->sc_nfastq++;
 1147         }
 1148     }
 1149     splx(s);
 1150 
 1151     if (m == NULL)
 1152         return NULL;
 1153 
 1154     ++sc->sc_stats.ppp_opackets;
 1155 
 1156     /*
 1157      * Extract the ppp header of the new packet.
 1158      * The ppp header will be in one mbuf.
 1159      */
 1160     cp = mtod(m, u_char *);
 1161     address = PPP_ADDRESS(cp);
 1162     control = PPP_CONTROL(cp);
 1163     protocol = PPP_PROTOCOL(cp);
 1164 
 1165     switch (protocol) {
 1166     case PPP_IP:
 1167 #ifdef VJC
 1168         /*
 1169          * If the packet is a TCP/IP packet, see if we can compress it.
 1170          */
 1171         if ((sc->sc_flags & SC_COMP_TCP) && sc->sc_comp != NULL) {
 1172             struct ip *ip;
 1173             int type;
 1174 
 1175             mp = m;
 1176             ip = (struct ip *) (cp + PPP_HDRLEN);
 1177             if (mp->m_len <= PPP_HDRLEN) {
 1178                 mp = mp->m_next;
 1179                 if (mp == NULL)
 1180                     break;
 1181                 ip = mtod(mp, struct ip *);
 1182             }
 1183             /* this code assumes the IP/TCP header is in one non-shared mbuf */
 1184             if (ip->ip_p == IPPROTO_TCP) {
 1185                 type = sl_compress_tcp(mp, ip, sc->sc_comp,
 1186                                        !(sc->sc_flags & SC_NO_TCP_CCID));
 1187                 switch (type) {
 1188                 case TYPE_UNCOMPRESSED_TCP:
 1189                     protocol = PPP_VJC_UNCOMP;
 1190                     break;
 1191                 case TYPE_COMPRESSED_TCP:
 1192                     protocol = PPP_VJC_COMP;
 1193                     cp = mtod(m, u_char *);
 1194                     cp[0] = address;    /* header has moved */
 1195                     cp[1] = control;
 1196                     cp[2] = 0;
 1197                     break;
 1198                 }
 1199                 cp[3] = protocol;       /* update protocol in PPP header */
 1200             }
 1201         }
 1202 #endif  /* VJC */
 1203         break;
 1204 
 1205 #ifdef PPP_COMPRESS
 1206     case PPP_CCP:
 1207         ppp_ccp(sc, m, 0);
 1208         break;
 1209 #endif  /* PPP_COMPRESS */
 1210     }
 1211 
 1212 #ifdef PPP_COMPRESS
 1213     if (protocol != PPP_LCP && protocol != PPP_CCP
 1214         && sc->sc_xc_state && (sc->sc_flags & SC_COMP_RUN)) {
 1215         struct mbuf *mcomp = NULL;
 1216         int slen;
 1217 
 1218         slen = 0;
 1219         for (mp = m; mp != NULL; mp = mp->m_next)
 1220             slen += mp->m_len;
 1221         (*sc->sc_xcomp->compress)
 1222             (sc->sc_xc_state, &mcomp, m, slen, sc->sc_if.if_mtu + PPP_HDRLEN);
 1223         if (mcomp != NULL) {
 1224             if (sc->sc_flags & SC_CCP_UP) {
 1225                 /* Send the compressed packet instead of the original. */
 1226                 m_freem(m);
 1227                 m = mcomp;
 1228                 cp = mtod(m, u_char *);
 1229                 protocol = cp[3];
 1230             } else {
 1231                 /* Can't transmit compressed packets until CCP is up. */
 1232                 m_freem(mcomp);
 1233             }
 1234         }
 1235     }
 1236 #endif  /* PPP_COMPRESS */
 1237 
 1238     /*
 1239      * Compress the address/control and protocol, if possible.
 1240      */
 1241     if (sc->sc_flags & SC_COMP_AC && address == PPP_ALLSTATIONS &&
 1242         control == PPP_UI && protocol != PPP_ALLSTATIONS &&
 1243         protocol != PPP_LCP) {
 1244         /* can compress address/control */
 1245         m->m_data += 2;
 1246         m->m_len -= 2;
 1247     }
 1248     if (sc->sc_flags & SC_COMP_PROT && protocol < 0xFF) {
 1249         /* can compress protocol */
 1250         if (mtod(m, u_char *) == cp) {
 1251             cp[2] = cp[1];      /* move address/control up */
 1252             cp[1] = cp[0];
 1253         }
 1254         ++m->m_data;
 1255         --m->m_len;
 1256     }
 1257 
 1258     return m;
 1259 }
 1260 
 1261 /*
 1262  * Software interrupt routine, called at splsoftnet.
 1263  */
 1264 static void
 1265 pppintr(void *arg)
 1266 {
 1267         struct ppp_softc *sc = arg;
 1268         struct mbuf *m;
 1269         int s;
 1270 
 1271         mutex_enter(softnet_lock);
 1272         if (!(sc->sc_flags & SC_TBUSY)
 1273             && (IFQ_IS_EMPTY(&sc->sc_if.if_snd) == 0 || sc->sc_fastq.ifq_head
 1274                 || sc->sc_outm)) {
 1275                 s = splhigh();  /* XXX IMP ME HARDER */
 1276                 sc->sc_flags |= SC_TBUSY;
 1277                 splx(s);
 1278                 (*sc->sc_start)(sc);
 1279         }
 1280         for (;;) {
 1281                 s = splnet();
 1282                 IF_DEQUEUE(&sc->sc_rawq, m);
 1283                 splx(s);
 1284                 if (m == NULL)
 1285                         break;
 1286                 ppp_inproc(sc, m);
 1287         }
 1288         mutex_exit(softnet_lock);
 1289 }
 1290 
 1291 #ifdef PPP_COMPRESS
 1292 /*
 1293  * Handle a CCP packet.  `rcvd' is 1 if the packet was received,
 1294  * 0 if it is about to be transmitted.
 1295  */
 1296 static void
 1297 ppp_ccp(struct ppp_softc *sc, struct mbuf *m, int rcvd)
 1298 {
 1299     u_char *dp, *ep;
 1300     struct mbuf *mp;
 1301     int slen, s;
 1302 
 1303     /*
 1304      * Get a pointer to the data after the PPP header.
 1305      */
 1306     if (m->m_len <= PPP_HDRLEN) {
 1307         mp = m->m_next;
 1308         if (mp == NULL)
 1309             return;
 1310         dp = (mp != NULL)? mtod(mp, u_char *): NULL;
 1311     } else {
 1312         mp = m;
 1313         dp = mtod(mp, u_char *) + PPP_HDRLEN;
 1314     }
 1315 
 1316     ep = mtod(mp, u_char *) + mp->m_len;
 1317     if (dp + CCP_HDRLEN > ep)
 1318         return;
 1319     slen = CCP_LENGTH(dp);
 1320     if (dp + slen > ep) {
 1321         if (sc->sc_flags & SC_DEBUG)
 1322             printf("if_ppp/ccp: not enough data in mbuf (%p+%x > %p+%x)\n",
 1323                 dp, slen, mtod(mp, u_char *), mp->m_len);
 1324         return;
 1325     }
 1326 
 1327     switch (CCP_CODE(dp)) {
 1328     case CCP_CONFREQ:
 1329     case CCP_TERMREQ:
 1330     case CCP_TERMACK:
 1331         /* CCP must be going down - disable compression */
 1332         if (sc->sc_flags & SC_CCP_UP) {
 1333             s = splhigh();      /* XXX IMP ME HARDER */
 1334             sc->sc_flags &= ~(SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
 1335             splx(s);
 1336         }
 1337         break;
 1338 
 1339     case CCP_CONFACK:
 1340         if (sc->sc_flags & SC_CCP_OPEN && !(sc->sc_flags & SC_CCP_UP)
 1341             && slen >= CCP_HDRLEN + CCP_OPT_MINLEN
 1342             && slen >= CCP_OPT_LENGTH(dp + CCP_HDRLEN) + CCP_HDRLEN) {
 1343             if (!rcvd) {
 1344                 /* we're agreeing to send compressed packets. */
 1345                 if (sc->sc_xc_state != NULL
 1346                     && (*sc->sc_xcomp->comp_init)
 1347                         (sc->sc_xc_state, dp + CCP_HDRLEN, slen - CCP_HDRLEN,
 1348                          sc->sc_unit, 0, sc->sc_flags & SC_DEBUG)) {
 1349                     s = splhigh();      /* XXX IMP ME HARDER */
 1350                     sc->sc_flags |= SC_COMP_RUN;
 1351                     splx(s);
 1352                 }
 1353             } else {
 1354                 /* peer is agreeing to send compressed packets. */
 1355                 if (sc->sc_rc_state != NULL
 1356                     && (*sc->sc_rcomp->decomp_init)
 1357                         (sc->sc_rc_state, dp + CCP_HDRLEN, slen - CCP_HDRLEN,
 1358                          sc->sc_unit, 0, sc->sc_mru,
 1359                          sc->sc_flags & SC_DEBUG)) {
 1360                     s = splhigh();      /* XXX IMP ME HARDER */
 1361                     sc->sc_flags |= SC_DECOMP_RUN;
 1362                     sc->sc_flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
 1363                     splx(s);
 1364                 }
 1365             }
 1366         }
 1367         break;
 1368 
 1369     case CCP_RESETACK:
 1370         if (sc->sc_flags & SC_CCP_UP) {
 1371             if (!rcvd) {
 1372                 if (sc->sc_xc_state && (sc->sc_flags & SC_COMP_RUN))
 1373                     (*sc->sc_xcomp->comp_reset)(sc->sc_xc_state);
 1374             } else {
 1375                 if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)) {
 1376                     (*sc->sc_rcomp->decomp_reset)(sc->sc_rc_state);
 1377                     s = splhigh();      /* XXX IMP ME HARDER */
 1378                     sc->sc_flags &= ~SC_DC_ERROR;
 1379                     splx(s);
 1380                 }
 1381             }
 1382         }
 1383         break;
 1384     }
 1385 }
 1386 
 1387 /*
 1388  * CCP is down; free (de)compressor state if necessary.
 1389  */
 1390 static void
 1391 ppp_ccp_closed(struct ppp_softc *sc)
 1392 {
 1393     if (sc->sc_xc_state) {
 1394         (*sc->sc_xcomp->comp_free)(sc->sc_xc_state);
 1395         sc->sc_xc_state = NULL;
 1396     }
 1397     if (sc->sc_rc_state) {
 1398         (*sc->sc_rcomp->decomp_free)(sc->sc_rc_state);
 1399         sc->sc_rc_state = NULL;
 1400     }
 1401 }
 1402 #endif /* PPP_COMPRESS */
 1403 
 1404 /*
 1405  * PPP packet input routine.
 1406  * The caller has checked and removed the FCS and has inserted
 1407  * the address/control bytes and the protocol high byte if they
 1408  * were omitted.
 1409  */
 1410 void
 1411 ppppktin(struct ppp_softc *sc, struct mbuf *m, int lost)
 1412 {
 1413     int s = splhigh();  /* XXX IMP ME HARDER */
 1414 
 1415     if (lost)
 1416         m->m_flags |= M_ERRMARK;
 1417     IF_ENQUEUE(&sc->sc_rawq, m);
 1418     softint_schedule(sc->sc_si);
 1419     splx(s);
 1420 }
 1421 
 1422 /*
 1423  * Process a received PPP packet, doing decompression as necessary.
 1424  * Should be called at splsoftnet.
 1425  */
 1426 #define COMPTYPE(proto) ((proto) == PPP_VJC_COMP? TYPE_COMPRESSED_TCP: \
 1427                          TYPE_UNCOMPRESSED_TCP)
 1428 
 1429 static void
 1430 ppp_inproc(struct ppp_softc *sc, struct mbuf *m)
 1431 {
 1432     struct ifnet *ifp = &sc->sc_if;
 1433     struct ifqueue *inq;
 1434     int s, ilen, proto, rv;
 1435     u_char *cp, adrs, ctrl;
 1436     struct mbuf *mp, *dmp = NULL;
 1437 #ifdef VJC
 1438     int xlen;
 1439     u_char *iphdr;
 1440     u_int hlen;
 1441 #endif
 1442 
 1443     sc->sc_stats.ppp_ipackets++;
 1444 
 1445     if (sc->sc_flags & SC_LOG_INPKT) {
 1446         ilen = 0;
 1447         for (mp = m; mp != NULL; mp = mp->m_next)
 1448             ilen += mp->m_len;
 1449         printf("%s: got %d bytes\n", ifp->if_xname, ilen);
 1450         pppdumpm(m);
 1451     }
 1452 
 1453     cp = mtod(m, u_char *);
 1454     adrs = PPP_ADDRESS(cp);
 1455     ctrl = PPP_CONTROL(cp);
 1456     proto = PPP_PROTOCOL(cp);
 1457 
 1458     if (m->m_flags & M_ERRMARK) {
 1459         m->m_flags &= ~M_ERRMARK;
 1460         s = splhigh();  /* XXX IMP ME HARDER */
 1461         sc->sc_flags |= SC_VJ_RESET;
 1462         splx(s);
 1463     }
 1464 
 1465 #ifdef PPP_COMPRESS
 1466     /*
 1467      * Decompress this packet if necessary, update the receiver's
 1468      * dictionary, or take appropriate action on a CCP packet.
 1469      */
 1470     if (proto == PPP_COMP && sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)
 1471         && !(sc->sc_flags & SC_DC_ERROR) && !(sc->sc_flags & SC_DC_FERROR)) {
 1472         /* decompress this packet */
 1473         rv = (*sc->sc_rcomp->decompress)(sc->sc_rc_state, m, &dmp);
 1474         if (rv == DECOMP_OK) {
 1475             m_freem(m);
 1476             if (dmp == NULL) {
 1477                 /* no error, but no decompressed packet produced */
 1478                 return;
 1479             }
 1480             m = dmp;
 1481             cp = mtod(m, u_char *);
 1482             proto = PPP_PROTOCOL(cp);
 1483 
 1484         } else {
 1485             /*
 1486              * An error has occurred in decompression.
 1487              * Pass the compressed packet up to pppd, which may take
 1488              * CCP down or issue a Reset-Req.
 1489              */
 1490             if (sc->sc_flags & SC_DEBUG)
 1491                 printf("%s: decompress failed %d\n", ifp->if_xname, rv);
 1492             s = splhigh();      /* XXX IMP ME HARDER */
 1493             sc->sc_flags |= SC_VJ_RESET;
 1494             if (rv == DECOMP_ERROR)
 1495                 sc->sc_flags |= SC_DC_ERROR;
 1496             else
 1497                 sc->sc_flags |= SC_DC_FERROR;
 1498             splx(s);
 1499         }
 1500 
 1501     } else {
 1502         if (sc->sc_rc_state && (sc->sc_flags & SC_DECOMP_RUN)) {
 1503             (*sc->sc_rcomp->incomp)(sc->sc_rc_state, m);
 1504         }
 1505         if (proto == PPP_CCP) {
 1506             ppp_ccp(sc, m, 1);
 1507         }
 1508     }
 1509 #endif
 1510 
 1511     ilen = 0;
 1512     for (mp = m; mp != NULL; mp = mp->m_next)
 1513         ilen += mp->m_len;
 1514 
 1515 #ifdef VJC
 1516     if (sc->sc_flags & SC_VJ_RESET) {
 1517         /*
 1518          * If we've missed a packet, we must toss subsequent compressed
 1519          * packets which don't have an explicit connection ID.
 1520          */
 1521         if (sc->sc_comp)
 1522             sl_uncompress_tcp(NULL, 0, TYPE_ERROR, sc->sc_comp);
 1523         s = splhigh();  /* XXX IMP ME HARDER */
 1524         sc->sc_flags &= ~SC_VJ_RESET;
 1525         splx(s);
 1526     }
 1527 
 1528     /*
 1529      * See if we have a VJ-compressed packet to uncompress.
 1530      */
 1531     if (proto == PPP_VJC_COMP) {
 1532         if ((sc->sc_flags & SC_REJ_COMP_TCP) || sc->sc_comp == 0)
 1533             goto bad;
 1534 
 1535         xlen = sl_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN,
 1536                                       ilen - PPP_HDRLEN, TYPE_COMPRESSED_TCP,
 1537                                       sc->sc_comp, &iphdr, &hlen);
 1538 
 1539         if (xlen <= 0) {
 1540             if (sc->sc_flags & SC_DEBUG)
 1541                 printf("%s: VJ uncompress failed on type comp\n",
 1542                     ifp->if_xname);
 1543             goto bad;
 1544         }
 1545 
 1546         /* Copy the PPP and IP headers into a new mbuf. */
 1547         MGETHDR(mp, M_DONTWAIT, MT_DATA);
 1548         if (mp == NULL)
 1549             goto bad;
 1550         mp->m_len = 0;
 1551         mp->m_next = NULL;
 1552         if (hlen + PPP_HDRLEN > MHLEN) {
 1553             MCLGET(mp, M_DONTWAIT);
 1554             if (M_TRAILINGSPACE(mp) < hlen + PPP_HDRLEN) {
 1555                 m_freem(mp);
 1556                 goto bad;       /* lose if big headers and no clusters */
 1557             }
 1558         }
 1559         cp = mtod(mp, u_char *);
 1560         cp[0] = adrs;
 1561         cp[1] = ctrl;
 1562         cp[2] = 0;
 1563         cp[3] = PPP_IP;
 1564         proto = PPP_IP;
 1565         bcopy(iphdr, cp + PPP_HDRLEN, hlen);
 1566         mp->m_len = hlen + PPP_HDRLEN;
 1567 
 1568         /*
 1569          * Trim the PPP and VJ headers off the old mbuf
 1570          * and stick the new and old mbufs together.
 1571          */
 1572         m->m_data += PPP_HDRLEN + xlen;
 1573         m->m_len -= PPP_HDRLEN + xlen;
 1574         if (m->m_len <= M_TRAILINGSPACE(mp)) {
 1575             bcopy(mtod(m, u_char *), mtod(mp, u_char *) + mp->m_len, m->m_len);
 1576             mp->m_len += m->m_len;
 1577             MFREE(m, mp->m_next);
 1578         } else
 1579             mp->m_next = m;
 1580         m = mp;
 1581         ilen += hlen - xlen;
 1582 
 1583     } else if (proto == PPP_VJC_UNCOMP) {
 1584         if ((sc->sc_flags & SC_REJ_COMP_TCP) || sc->sc_comp == 0)
 1585             goto bad;
 1586 
 1587         xlen = sl_uncompress_tcp_core(cp + PPP_HDRLEN, m->m_len - PPP_HDRLEN,
 1588                                       ilen - PPP_HDRLEN, TYPE_UNCOMPRESSED_TCP,
 1589                                       sc->sc_comp, &iphdr, &hlen);
 1590 
 1591         if (xlen < 0) {
 1592             if (sc->sc_flags & SC_DEBUG)
 1593                 printf("%s: VJ uncompress failed on type uncomp\n",
 1594                     ifp->if_xname);
 1595             goto bad;
 1596         }
 1597 
 1598         proto = PPP_IP;
 1599         cp[3] = PPP_IP;
 1600     }
 1601 #endif /* VJC */
 1602 
 1603     /*
 1604      * If the packet will fit in a header mbuf, don't waste a
 1605      * whole cluster on it.
 1606      */
 1607     if (ilen <= MHLEN && M_IS_CLUSTER(m)) {
 1608         MGETHDR(mp, M_DONTWAIT, MT_DATA);
 1609         if (mp != NULL) {
 1610             m_copydata(m, 0, ilen, mtod(mp, void *));
 1611             m_freem(m);
 1612             m = mp;
 1613             m->m_len = ilen;
 1614         }
 1615     }
 1616     m->m_pkthdr.len = ilen;
 1617     m->m_pkthdr.rcvif = ifp;
 1618 
 1619     if ((proto & 0x8000) == 0) {
 1620 #ifdef PPP_FILTER
 1621         /*
 1622          * See whether we want to pass this packet, and
 1623          * if it counts as link activity.
 1624          */
 1625         if (sc->sc_pass_filt_in.bf_insns != 0
 1626             && bpf_filter(sc->sc_pass_filt_in.bf_insns, (u_char *) m,
 1627                           ilen, 0) == 0) {
 1628             /* drop this packet */
 1629             m_freem(m);
 1630             return;
 1631         }
 1632         if (sc->sc_active_filt_in.bf_insns == 0
 1633             || bpf_filter(sc->sc_active_filt_in.bf_insns, (u_char *) m,
 1634                           ilen, 0))
 1635             sc->sc_last_recv = time_second;
 1636 #else
 1637         /*
 1638          * Record the time that we received this packet.
 1639          */
 1640         sc->sc_last_recv = time_second;
 1641 #endif /* PPP_FILTER */
 1642     }
 1643 
 1644 #if NBPFILTER > 0
 1645     /* See if bpf wants to look at the packet. */
 1646     if (sc->sc_if.if_bpf)
 1647         bpf_mtap(sc->sc_if.if_bpf, m);
 1648 #endif
 1649 
 1650     rv = 0;
 1651     switch (proto) {
 1652 #ifdef INET
 1653     case PPP_IP:
 1654         /*
 1655          * IP packet - take off the ppp header and pass it up to IP.
 1656          */
 1657         if ((ifp->if_flags & IFF_UP) == 0
 1658             || sc->sc_npmode[NP_IP] != NPMODE_PASS) {
 1659             /* interface is down - drop the packet. */
 1660             m_freem(m);
 1661             return;
 1662         }
 1663         m->m_pkthdr.len -= PPP_HDRLEN;
 1664         m->m_data += PPP_HDRLEN;
 1665         m->m_len -= PPP_HDRLEN;
 1666 #ifdef GATEWAY
 1667         if (ipflow_fastforward(m))
 1668                 return;
 1669 #endif
 1670         schednetisr(NETISR_IP);
 1671         inq = &ipintrq;
 1672         break;
 1673 #endif
 1674 
 1675 #ifdef INET6
 1676     case PPP_IPV6:
 1677         /*
 1678          * IPv6 packet - take off the ppp header and pass it up to IPv6.
 1679          */
 1680         if ((ifp->if_flags & IFF_UP) == 0
 1681             || sc->sc_npmode[NP_IPV6] != NPMODE_PASS) {
 1682             /* interface is down - drop the packet. */
 1683             m_freem(m);
 1684             return;
 1685         }
 1686         m->m_pkthdr.len -= PPP_HDRLEN;
 1687         m->m_data += PPP_HDRLEN;
 1688         m->m_len -= PPP_HDRLEN;
 1689 #ifdef GATEWAY  
 1690         if (ip6flow_fastforward(m))
 1691                 return;
 1692 #endif
 1693         schednetisr(NETISR_IPV6);
 1694         inq = &ip6intrq;
 1695         break;
 1696 #endif
 1697 
 1698     default:
 1699         /*
 1700          * Some other protocol - place on input queue for read().
 1701          */
 1702         inq = &sc->sc_inq;
 1703         rv = 1;
 1704         break;
 1705     }
 1706 
 1707     /*
 1708      * Put the packet on the appropriate input queue.
 1709      */
 1710     s = splnet();
 1711     if (IF_QFULL(inq)) {
 1712         IF_DROP(inq);
 1713         splx(s);
 1714         if (sc->sc_flags & SC_DEBUG)
 1715             printf("%s: input queue full\n", ifp->if_xname);
 1716         ifp->if_iqdrops++;
 1717         goto bad;
 1718     }
 1719     IF_ENQUEUE(inq, m);
 1720     splx(s);
 1721     ifp->if_ipackets++;
 1722     ifp->if_ibytes += ilen;
 1723 
 1724     if (rv)
 1725         (*sc->sc_ctlp)(sc);
 1726 
 1727     return;
 1728 
 1729  bad:
 1730     m_freem(m);
 1731     sc->sc_if.if_ierrors++;
 1732     sc->sc_stats.ppp_ierrors++;
 1733 }
 1734 
 1735 #define MAX_DUMP_BYTES  128
 1736 
 1737 static void
 1738 pppdumpm(struct mbuf *m0)
 1739 {
 1740     char buf[3*MAX_DUMP_BYTES+4];
 1741     char *bp = buf;
 1742     struct mbuf *m;
 1743 
 1744     for (m = m0; m; m = m->m_next) {
 1745         int l = m->m_len;
 1746         u_char *rptr = (u_char *)m->m_data;
 1747 
 1748         while (l--) {
 1749             if (bp > buf + sizeof(buf) - 4)
 1750                 goto done;
 1751             *bp++ = hexdigits[*rptr >> 4]; /* convert byte to ascii hex */
 1752             *bp++ = hexdigits[*rptr++ & 0xf];
 1753         }
 1754 
 1755         if (m->m_next) {
 1756             if (bp > buf + sizeof(buf) - 3)
 1757                 goto done;
 1758             *bp++ = '|';
 1759         } else
 1760             *bp++ = ' ';
 1761     }
 1762 done:
 1763     if (m)
 1764         *bp++ = '>';
 1765     *bp = 0;
 1766     printf("%s\n", buf);
 1767 }
 1768 
 1769 #ifdef ALTQ
 1770 /*
 1771  * a wrapper to transmit a packet from if_start since ALTQ uses
 1772  * if_start to send a packet.
 1773  */
 1774 static void
 1775 ppp_ifstart(struct ifnet *ifp)
 1776 {
 1777         struct ppp_softc *sc;
 1778 
 1779         sc = ifp->if_softc;
 1780         (*sc->sc_start)(sc);
 1781 }
 1782 #endif

Cache object: 8d3d28fb044e09c330c931f8330800f4


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.