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