Annotation of sys/net/if_pppoe.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_pppoe.c,v 1.12 2007/05/28 06:31:01 mcbride Exp $ */
2: /* $NetBSD: if_pppoe.c,v 1.51 2003/11/28 08:56:48 keihan Exp $ */
3:
4: /*
5: * Copyright (c) 2002 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Martin Husemann <martin@NetBSD.org>.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: #include <sys/cdefs.h>
41: /*
42: __KERNEL_RCSID(0, "$NetBSD: if_pppoe.c,v 1.51 2003/11/28 08:56:48 keihan Exp $");
43: */
44:
45: #include "pppoe.h"
46: #include "bpfilter.h"
47:
48: #include <sys/param.h>
49: #include <sys/systm.h>
50: #include <sys/kernel.h>
51: #include <sys/types.h>
52: #include <sys/timeout.h>
53: #include <sys/malloc.h>
54: #include <sys/mbuf.h>
55: #include <sys/socket.h>
56: #include <sys/syslog.h>
57: #include <sys/proc.h>
58: #include <sys/ioctl.h>
59: #include <net/if.h>
60: #include <net/if_types.h>
61: #include <net/if_sppp.h>
62: #include <net/if_pppoe.h>
63: #include <net/netisr.h>
64: #include <netinet/in.h>
65: #include <netinet/if_ether.h>
66:
67: /* for arc4random() */
68: #include <dev/rndvar.h>
69:
70: #if NBPFILTER > 0
71: #include <net/bpf.h>
72: #endif
73:
74: #undef PPPOE_DEBUG /* XXX - remove this or make it an option */
75:
76: #define PPPOEDEBUG(a) ((sc->sc_sppp.pp_if.if_flags & IFF_DEBUG) ? printf a : 0)
77:
78: struct pppoehdr {
79: u_int8_t vertype;
80: u_int8_t code;
81: u_int16_t session;
82: u_int16_t plen;
83: } __packed;
84:
85: struct pppoetag {
86: u_int16_t tag;
87: u_int16_t len;
88: } __packed;
89:
90: #define PPPOE_HEADERLEN sizeof(struct pppoehdr)
91: #define PPPOE_VERTYPE 0x11 /* VER=1, TYPE = 1 */
92:
93: #define PPPOE_TAG_EOL 0x0000 /* end of list */
94: #define PPPOE_TAG_SNAME 0x0101 /* service name */
95: #define PPPOE_TAG_ACNAME 0x0102 /* access concentrator name */
96: #define PPPOE_TAG_HUNIQUE 0x0103 /* host unique */
97: #define PPPOE_TAG_ACCOOKIE 0x0104 /* AC cookie */
98: #define PPPOE_TAG_VENDOR 0x0105 /* vendor specific */
99: #define PPPOE_TAG_RELAYSID 0x0110 /* relay session id */
100: #define PPPOE_TAG_SNAME_ERR 0x0201 /* service name error */
101: #define PPPOE_TAG_ACSYS_ERR 0x0202 /* AC system error */
102: #define PPPOE_TAG_GENERIC_ERR 0x0203 /* gerneric error */
103:
104: #define PPPOE_CODE_PADI 0x09 /* Active Discovery Initiation */
105: #define PPPOE_CODE_PADO 0x07 /* Active Discovery Offer */
106: #define PPPOE_CODE_PADR 0x19 /* Active Discovery Request */
107: #define PPPOE_CODE_PADS 0x65 /* Active Discovery Session confirmation */
108: #define PPPOE_CODE_PADT 0xA7 /* Active Discovery Terminate */
109:
110: /* two byte PPP protocol discriminator, then IP data */
111: #define PPPOE_MAXMTU (ETHERMTU - PPPOE_HEADERLEN - 2)
112:
113: /* Add a 16 bit unsigned value to a buffer pointed to by PTR */
114: #define PPPOE_ADD_16(PTR, VAL) \
115: *(PTR)++ = (VAL) / 256; \
116: *(PTR)++ = (VAL) % 256
117:
118: /* Add a complete PPPoE header to the buffer pointed to by PTR */
119: #define PPPOE_ADD_HEADER(PTR, CODE, SESS, LEN) \
120: *(PTR)++ = PPPOE_VERTYPE; \
121: *(PTR)++ = (CODE); \
122: PPPOE_ADD_16(PTR, SESS); \
123: PPPOE_ADD_16(PTR, LEN)
124:
125: #define PPPOE_DISC_TIMEOUT (hz*5) /* base for quick timeout calculation */
126: #define PPPOE_SLOW_RETRY (hz*60) /* persistent retry interval */
127: #define PPPOE_DISC_MAXPADI 4 /* retry PADI four times (quickly) */
128: #define PPPOE_DISC_MAXPADR 2 /* retry PADR twice */
129:
130: #ifdef PPPOE_SERVER
131: #define IFF_PASSIVE IFF_LINK0 /* wait passively for connection */
132: #endif
133:
134: struct pppoe_softc {
135: struct sppp sc_sppp; /* contains a struct ifnet as first element */
136: LIST_ENTRY(pppoe_softc) sc_list;
137: struct ifnet *sc_eth_if; /* ethernet interface we are using */
138:
139: int sc_state; /* discovery phase or session connected */
140: struct ether_addr sc_dest; /* hardware address of concentrator */
141: u_int16_t sc_session; /* PPPoE session id */
142:
143: char *sc_service_name; /* if != NULL: requested name of service */
144: char *sc_concentrator_name; /* if != NULL: requested concentrator id */
145: u_int8_t *sc_ac_cookie; /* content of AC cookie we must echo back */
146: size_t sc_ac_cookie_len; /* length of cookie data */
147: #ifdef PPPOE_SERVER
148: u_int8_t *sc_hunique; /* content of host unique we must echo back */
149: size_t sc_hunique_len; /* length of host unique */
150: #endif
151: u_int32_t sc_unique; /* our unique id */
152: struct timeout sc_timeout; /* timeout while not in session state */
153: int sc_padi_retried; /* number of PADI retries already done */
154: int sc_padr_retried; /* number of PADR retries already done */
155:
156: struct timeval sc_session_time; /* time the session was established */
157: };
158:
159: /* incoming traffic will be queued here */
160: struct ifqueue ppoediscinq = { NULL };
161: struct ifqueue ppoeinq = { NULL };
162:
163: extern int sppp_ioctl(struct ifnet *, unsigned long, void *);
164:
165: /* input routines */
166: static void pppoe_disc_input(struct mbuf *);
167: static void pppoe_dispatch_disc_pkt(struct mbuf *, int);
168: static void pppoe_data_input(struct mbuf *);
169:
170: /* management routines */
171: void pppoeattach(int);
172: static int pppoe_connect(struct pppoe_softc *);
173: static int pppoe_disconnect(struct pppoe_softc *);
174: static void pppoe_abort_connect(struct pppoe_softc *);
175: static int pppoe_ioctl(struct ifnet *, unsigned long, caddr_t);
176: static void pppoe_tls(struct sppp *);
177: static void pppoe_tlf(struct sppp *);
178: static void pppoe_start(struct ifnet *);
179:
180: /* internal timeout handling */
181: static void pppoe_timeout(void *);
182:
183: /* sending actual protocol controll packets */
184: static int pppoe_send_padi(struct pppoe_softc *);
185: static int pppoe_send_padr(struct pppoe_softc *);
186: #ifdef PPPOE_SERVER
187: static int pppoe_send_pado(struct pppoe_softc *);
188: static int pppoe_send_pads(struct pppoe_softc *);
189: #endif
190: static int pppoe_send_padt(struct ifnet *, u_int, const u_int8_t *);
191:
192: /* raw output */
193: static int pppoe_output(struct pppoe_softc *, struct mbuf *);
194:
195: /* internal helper functions */
196: static struct pppoe_softc *pppoe_find_softc_by_session(u_int, struct ifnet *);
197: static struct pppoe_softc *pppoe_find_softc_by_hunique(u_int8_t *, size_t, struct ifnet *);
198: static struct mbuf *pppoe_get_mbuf(size_t len);
199:
200: LIST_HEAD(pppoe_softc_head, pppoe_softc) pppoe_softc_list;
201:
202: /* interface cloning */
203: int pppoe_clone_create(struct if_clone *, int);
204: int pppoe_clone_destroy(struct ifnet *);
205:
206: struct if_clone pppoe_cloner =
207: IF_CLONE_INITIALIZER("pppoe", pppoe_clone_create, pppoe_clone_destroy);
208:
209:
210: /* ARGSUSED */
211: void
212: pppoeattach(int count)
213: {
214: LIST_INIT(&pppoe_softc_list);
215: if_clone_attach(&pppoe_cloner);
216:
217: ppoediscinq.ifq_maxlen = IFQ_MAXLEN;
218: ppoeinq.ifq_maxlen = IFQ_MAXLEN;
219: }
220:
221: /* Create a new interface. */
222: int
223: pppoe_clone_create(struct if_clone *ifc, int unit)
224: {
225: struct pppoe_softc *sc;
226: int s;
227:
228: MALLOC(sc, struct pppoe_softc *, sizeof(*sc), M_DEVBUF, M_WAITOK);
229: if (sc == NULL)
230: return (ENOMEM);
231: bzero(sc, sizeof(struct pppoe_softc));
232:
233: sc->sc_unique = arc4random();
234:
235: snprintf(sc->sc_sppp.pp_if.if_xname,
236: sizeof(sc->sc_sppp.pp_if.if_xname),
237: "pppoe%d", unit);
238: sc->sc_sppp.pp_if.if_softc = sc;
239: sc->sc_sppp.pp_if.if_mtu = PPPOE_MAXMTU;
240: sc->sc_sppp.pp_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT | IFF_MULTICAST;
241: sc->sc_sppp.pp_if.if_type = IFT_PPP;
242: sc->sc_sppp.pp_if.if_hdrlen = sizeof(struct ether_header) + PPPOE_HEADERLEN;
243: sc->sc_sppp.pp_flags |= PP_KEEPALIVE | /* use LCP keepalive */
244: PP_NOFRAMING; /* no serial encapsulation */
245: sc->sc_sppp.pp_framebytes = PPPOE_HEADERLEN; /* framing added to ppp packets */
246: sc->sc_sppp.pp_if.if_ioctl = pppoe_ioctl;
247: sc->sc_sppp.pp_if.if_start = pppoe_start;
248: sc->sc_sppp.pp_tls = pppoe_tls;
249: sc->sc_sppp.pp_tlf = pppoe_tlf;
250: IFQ_SET_MAXLEN(&sc->sc_sppp.pp_if.if_snd, IFQ_MAXLEN);
251: IFQ_SET_READY(&sc->sc_sppp.pp_if.if_snd);
252:
253: /* changed to real address later */
254: memcpy(&sc->sc_dest, etherbroadcastaddr, sizeof(sc->sc_dest));
255:
256: /* init timer for interface watchdog */
257: timeout_set(&sc->sc_timeout, pppoe_timeout, sc);
258:
259: if_attach(&sc->sc_sppp.pp_if);
260: if_alloc_sadl(&sc->sc_sppp.pp_if);
261: sppp_attach(&sc->sc_sppp.pp_if);
262: #if NBPFILTER > 0
263: bpfattach(&sc->sc_sppp.pp_if.if_bpf, &sc->sc_sppp.pp_if, DLT_PPP_ETHER, 0);
264: #endif
265:
266: s = splnet();
267: LIST_INSERT_HEAD(&pppoe_softc_list, sc, sc_list);
268: splx(s);
269:
270: return (0);
271: }
272:
273: /* Destroy a given interface. */
274: int
275: pppoe_clone_destroy(struct ifnet *ifp)
276: {
277: struct pppoe_softc *sc = ifp->if_softc;
278: int s;
279:
280: s = splnet();
281: LIST_REMOVE(sc, sc_list);
282: timeout_del(&sc->sc_timeout);
283: splx(s);
284:
285: sppp_detach(&sc->sc_sppp.pp_if);
286: if_detach(ifp);
287:
288: if (sc->sc_concentrator_name)
289: free(sc->sc_concentrator_name, M_DEVBUF);
290: if (sc->sc_service_name)
291: free(sc->sc_service_name, M_DEVBUF);
292: if (sc->sc_ac_cookie)
293: free(sc->sc_ac_cookie, M_DEVBUF);
294:
295: free(sc, M_DEVBUF);
296:
297: return (0);
298: }
299:
300: /*
301: * Find the interface handling the specified session.
302: * Note: O(number of sessions open), this is a client-side only, mean
303: * and lean implementation, so number of open sessions typically should
304: * be 1.
305: */
306: static struct pppoe_softc *
307: pppoe_find_softc_by_session(u_int session, struct ifnet *rcvif)
308: {
309: struct pppoe_softc *sc;
310:
311: if (session == 0)
312: return (NULL);
313:
314: LIST_FOREACH(sc, &pppoe_softc_list, sc_list) {
315: if (sc->sc_state == PPPOE_STATE_SESSION
316: && sc->sc_session == session) {
317: if (sc->sc_eth_if == rcvif)
318: return (sc);
319: else
320: return (NULL);
321: }
322: }
323: return (NULL);
324: }
325:
326: /*
327: * Check host unique token passed and return appropriate softc pointer,
328: * or NULL if token is bogus.
329: */
330: static struct pppoe_softc *
331: pppoe_find_softc_by_hunique(u_int8_t *token, size_t len, struct ifnet *rcvif)
332: {
333: struct pppoe_softc *sc;
334: u_int32_t hunique;
335:
336: if (LIST_EMPTY(&pppoe_softc_list))
337: return (NULL);
338:
339: if (len != sizeof(hunique))
340: return (NULL);
341: memcpy(&hunique, token, len);
342:
343: LIST_FOREACH(sc, &pppoe_softc_list, sc_list)
344: if (sc->sc_unique == hunique)
345: break;
346:
347: if (sc == NULL) {
348: printf("pppoe: alien host unique tag, no session found\n");
349: return (NULL);
350: }
351:
352: /* should be safe to access *sc now */
353: if (sc->sc_state < PPPOE_STATE_PADI_SENT || sc->sc_state >= PPPOE_STATE_SESSION) {
354: printf("%s: host unique tag found, but it belongs to a connection in state %d\n",
355: sc->sc_sppp.pp_if.if_xname, sc->sc_state);
356: return (NULL);
357: }
358: if (sc->sc_eth_if != rcvif) {
359: printf("%s: wrong interface, not accepting host unique\n",
360: sc->sc_sppp.pp_if.if_xname);
361: return (NULL);
362: }
363: return (sc);
364: }
365:
366: /* Interface interrupt handler routine. */
367: void
368: pppoeintr(void)
369: {
370: struct pppoe_softc *sc;
371: struct mbuf *m;
372:
373: splassert(IPL_SOFTNET);
374:
375: LIST_FOREACH(sc, &pppoe_softc_list, sc_list) {
376: while (ppoediscinq.ifq_head) {
377: MBUFLOCK(IF_DEQUEUE(&ppoediscinq, m););
378: if (m == NULL)
379: break;
380: pppoe_disc_input(m);
381: }
382:
383: while (ppoeinq.ifq_head) {
384: MBUFLOCK(IF_DEQUEUE(&ppoeinq, m););
385: if (m == NULL)
386: break;
387: pppoe_data_input(m);
388: }
389: }
390: }
391:
392: /* Analyze and handle a single received packet while not in session state. */
393: static void pppoe_dispatch_disc_pkt(struct mbuf *m, int off)
394: {
395: struct pppoe_softc *sc;
396: struct pppoehdr *ph;
397: struct pppoetag *pt;
398: struct mbuf *n;
399: struct ether_header *eh;
400: const char *err_msg, *devname;
401: size_t ac_cookie_len;
402: int noff, err, errortag;
403: u_int16_t tag, len;
404: u_int16_t session, plen;
405: u_int8_t *ac_cookie;
406: #ifdef PPPOE_SERVER
407: u_int8_t *hunique;
408: size_t hunique_len;
409: #endif
410:
411: err_msg = NULL;
412: devname = "pppoe";
413: errortag = 0;
414:
415: if (m->m_len < sizeof(*eh)) {
416: m = m_pullup(m, sizeof(*eh));
417: if (m == NULL)
418: goto done;
419: }
420: eh = mtod(m, struct ether_header *);
421: off += sizeof(*eh);
422:
423: ac_cookie = NULL;
424: ac_cookie_len = 0;
425: #ifdef PPPOE_SERVER
426: hunique = NULL;
427: hunique_len = 0;
428: #endif
429:
430: session = 0;
431: if (m->m_pkthdr.len - off <= PPPOE_HEADERLEN) {
432: printf("pppoe: packet too short: %d\n", m->m_pkthdr.len);
433: goto done;
434: }
435:
436: n = m_pulldown(m, off, sizeof(*ph), &noff);
437: if (n == NULL) {
438: printf("pppoe: could not get PPPoE header\n");
439: m = NULL;
440: goto done;
441: }
442: ph = (struct pppoehdr *)(mtod(n, caddr_t) + noff);
443: if (ph->vertype != PPPOE_VERTYPE) {
444: printf("pppoe: unknown version/type packet: 0x%x\n",
445: ph->vertype);
446: goto done;
447: }
448:
449: session = ntohs(ph->session);
450: plen = ntohs(ph->plen);
451: off += sizeof(*ph);
452: if (plen + off > m->m_pkthdr.len) {
453: printf("pppoe: packet content does not fit: data available = %d, packet size = %u\n",
454: m->m_pkthdr.len - off, plen);
455: goto done;
456: }
457:
458: /* ignore trailing garbage */
459: m_adj(m, off + plen - m->m_pkthdr.len);
460:
461: tag = 0;
462: len = 0;
463: sc = NULL;
464: while (off + sizeof(*pt) <= m->m_pkthdr.len) {
465: n = m_pulldown(m, off, sizeof(*pt), &noff);
466: if (n == NULL) {
467: printf("%s: parse error\n", devname);
468: m = NULL;
469: goto done;
470: }
471: pt = (struct pppoetag *)(mtod(n, caddr_t) + noff);
472: tag = ntohs(pt->tag);
473: len = ntohs(pt->len);
474: if (off + len > m->m_pkthdr.len) {
475: printf("%s: tag 0x%x len 0x%x is too long\n",
476: devname, tag, len);
477: goto done;
478: }
479: switch (tag) {
480: case PPPOE_TAG_EOL:
481: goto breakbreak;
482: case PPPOE_TAG_SNAME:
483: break; /* ignored */
484: case PPPOE_TAG_ACNAME:
485: break; /* ignored */
486: case PPPOE_TAG_HUNIQUE:
487: if (sc != NULL)
488: break;
489: n = m_pulldown(m, off + sizeof(*pt), len, &noff);
490: if (n == NULL) {
491: m = NULL;
492: err_msg = "TAG HUNIQUE ERROR";
493: break;
494: }
495: #ifdef PPPOE_SERVER
496: hunique = mtod(n, caddr_t) + noff;
497: hunique_len = len;
498: #endif
499: sc = pppoe_find_softc_by_hunique(mtod(n, caddr_t) + noff,
500: len, m->m_pkthdr.rcvif);
501: if (sc != NULL)
502: devname = sc->sc_sppp.pp_if.if_xname;
503: break;
504: case PPPOE_TAG_ACCOOKIE:
505: if (ac_cookie == NULL) {
506: n = m_pulldown(m, off + sizeof(*pt), len,
507: &noff);
508: if (n == NULL) {
509: err_msg = "TAG ACCOOKIE ERROR";
510: m = NULL;
511: break;
512: }
513: ac_cookie = mtod(n, caddr_t) + noff;
514: ac_cookie_len = len;
515: }
516: break;
517: case PPPOE_TAG_SNAME_ERR:
518: err_msg = "SERVICE NAME ERROR";
519: errortag = 1;
520: break;
521: case PPPOE_TAG_ACSYS_ERR:
522: err_msg = "AC SYSTEM ERROR";
523: errortag = 1;
524: break;
525: case PPPOE_TAG_GENERIC_ERR:
526: err_msg = "GENERIC ERROR";
527: errortag = 1;
528: break;
529: }
530: if (err_msg) {
531: log(LOG_INFO, "%s: %s: ", devname, err_msg);
532: if (errortag && len) {
533: n = m_pulldown(m, off + sizeof(*pt), len,
534: &noff);
535: if (n) {
536: u_int8_t *et = mtod(n, caddr_t) + noff;
537: while (len--)
538: addlog("%c", *et++);
539: }
540: }
541: addlog("\n");
542: goto done;
543: }
544: off += sizeof(*pt) + len;
545: }
546: breakbreak:
547: switch (ph->code) {
548: case PPPOE_CODE_PADI:
549: #ifdef PPPOE_SERVER
550: /*
551: * Got service name, concentrator name, and/or host unique.
552: * Ignore if we have no interfaces with IFF_PASSIVE|IFF_UP.
553: */
554: if (LIST_EMPTY(&pppoe_softc_list))
555: goto done;
556:
557: LIST_FOREACH(sc, &pppoe_softc_list, sc_list) {
558: if (!(sc->sc_sppp.pp_if.if_flags & IFF_UP))
559: continue;
560: if (!(sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE))
561: continue;
562: if (sc->sc_state == PPPOE_STATE_INITIAL)
563: break;
564: }
565: if (sc == NULL) {
566: #ifdef PPPOE_DEBUG
567: printf("pppoe: free passive interface is not found\n");
568: #endif
569: goto done;
570: }
571: if (hunique) {
572: if (sc->sc_hunique)
573: free(sc->sc_hunique, M_DEVBUF);
574: sc->sc_hunique = malloc(hunique_len, M_DEVBUF,
575: M_DONTWAIT);
576: if (sc->sc_hunique == NULL)
577: goto done;
578: sc->sc_hunique_len = hunique_len;
579: memcpy(sc->sc_hunique, hunique, hunique_len);
580: }
581:
582: memcpy(&sc->sc_dest, eh->ether_shost, sizeof(sc->sc_dest));
583: sc->sc_state = PPPOE_STATE_PADO_SENT;
584: pppoe_send_pado(sc);
585:
586: break;
587: #endif /* PPPOE_SERVER */
588: case PPPOE_CODE_PADR:
589: #ifdef PPPOE_SERVER
590: /*
591: * Get sc from ac_cookie if IFF_PASSIVE.
592: */
593: if (ac_cookie == NULL) {
594: /* be quiet if there is not a single pppoe instance */
595: printf("pppoe: received PADR but not includes ac_cookie\n");
596: goto done;
597: }
598:
599: sc = pppoe_find_softc_by_hunique(ac_cookie,
600: ac_cookie_len,
601: m->m_pkthdr.rcvif);
602: if (sc == NULL) {
603: /* be quiet if there is not a single pppoe instance */
604: if (!LIST_EMPTY(&pppoe_softc_list))
605: printf("pppoe: received PADR but could not find request for it\n");
606: goto done;
607: }
608: if (sc->sc_state != PPPOE_STATE_PADO_SENT) {
609: printf("%s: received unexpected PADR\n",
610: sc->sc_sppp.pp_if.if_xname);
611: goto done;
612: }
613: if (hunique) {
614: if (sc->sc_hunique)
615: free(sc->sc_hunique, M_DEVBUF);
616: sc->sc_hunique = malloc(hunique_len, M_DEVBUF,
617: M_DONTWAIT);
618: if (sc->sc_hunique == NULL)
619: goto done;
620: sc->sc_hunique_len = hunique_len;
621: memcpy(sc->sc_hunique, hunique, hunique_len);
622: }
623:
624: pppoe_send_pads(sc);
625: sc->sc_state = PPPOE_STATE_SESSION;
626: sc->sc_sppp.pp_up(&sc->sc_sppp);
627:
628: break;
629: #else
630: /* ignore, we are no access concentrator */
631: goto done;
632: #endif /* PPPOE_SERVER */
633: case PPPOE_CODE_PADO:
634: if (sc == NULL) {
635: /* be quiet if there is not a single pppoe instance */
636: if (!LIST_EMPTY(&pppoe_softc_list))
637: printf("pppoe: received PADO but could not find request for it\n");
638: goto done;
639: }
640: if (sc->sc_state != PPPOE_STATE_PADI_SENT) {
641: printf("%s: received unexpected PADO\n",
642: sc->sc_sppp.pp_if.if_xname);
643: goto done;
644: }
645: if (ac_cookie) {
646: if (sc->sc_ac_cookie)
647: free(sc->sc_ac_cookie, M_DEVBUF);
648: sc->sc_ac_cookie = malloc(ac_cookie_len, M_DEVBUF,
649: M_DONTWAIT);
650: if (sc->sc_ac_cookie == NULL)
651: goto done;
652: sc->sc_ac_cookie_len = ac_cookie_len;
653: memcpy(sc->sc_ac_cookie, ac_cookie, ac_cookie_len);
654: }
655:
656: memcpy(&sc->sc_dest, eh->ether_shost, sizeof(sc->sc_dest));
657: timeout_del(&sc->sc_timeout);
658: sc->sc_padr_retried = 0;
659: sc->sc_state = PPPOE_STATE_PADR_SENT;
660: if ((err = pppoe_send_padr(sc)) != 0) {
661: PPPOEDEBUG(("%s: failed to send PADR, error=%d\n",
662: sc->sc_sppp.pp_if.if_xname, err));
663: }
664: timeout_add(&sc->sc_timeout,
665: PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried));
666:
667: break;
668: case PPPOE_CODE_PADS:
669: if (sc == NULL)
670: goto done;
671:
672: sc->sc_session = session;
673: timeout_del(&sc->sc_timeout);
674: PPPOEDEBUG(("%s: session 0x%x connected\n",
675: sc->sc_sppp.pp_if.if_xname, session));
676: sc->sc_state = PPPOE_STATE_SESSION;
677: microtime(&sc->sc_session_time);
678: sc->sc_sppp.pp_up(&sc->sc_sppp); /* notify upper layers */
679:
680: break;
681: case PPPOE_CODE_PADT:
682: if (sc == NULL)
683: goto done;
684:
685: /* stop timer (we might be about to transmit a PADT ourself) */
686: timeout_del(&sc->sc_timeout);
687: PPPOEDEBUG(("%s: session 0x%x terminated, received PADT\n",
688: sc->sc_sppp.pp_if.if_xname, session));
689:
690: /* clean up softc */
691: sc->sc_state = PPPOE_STATE_INITIAL;
692: memcpy(&sc->sc_dest, etherbroadcastaddr, sizeof(sc->sc_dest));
693: if (sc->sc_ac_cookie) {
694: free(sc->sc_ac_cookie, M_DEVBUF);
695: sc->sc_ac_cookie = NULL;
696: }
697: sc->sc_ac_cookie_len = 0;
698: sc->sc_session = 0;
699: sc->sc_session_time.tv_sec = 0;
700: sc->sc_session_time.tv_usec = 0;
701: sc->sc_sppp.pp_down(&sc->sc_sppp); /* signal upper layer */
702:
703: break;
704: default:
705: printf("%s: unknown code (0x%04x) session = 0x%04x\n",
706: sc ? sc->sc_sppp.pp_if.if_xname : "pppoe",
707: ph->code, session);
708: break;
709: }
710:
711: done:
712: m_freem(m);
713: }
714:
715: /* Input function for discovery packets. */
716: static void
717: pppoe_disc_input(struct mbuf *m)
718: {
719: /* avoid error messages if there is not a single pppoe instance */
720: if (!LIST_EMPTY(&pppoe_softc_list)) {
721: KASSERT(m->m_flags & M_PKTHDR);
722: pppoe_dispatch_disc_pkt(m, 0);
723: } else
724: m_freem(m);
725: }
726:
727: /* Input function for data packets */
728: static void
729: pppoe_data_input(struct mbuf *m)
730: {
731: struct pppoe_softc *sc;
732: struct pppoehdr *ph;
733: u_int16_t session, plen;
734: #ifdef PPPOE_TERM_UNKNOWN_SESSIONS
735: u_int8_t shost[ETHER_ADDR_LEN];
736: #endif
737:
738: KASSERT(m->m_flags & M_PKTHDR);
739:
740: #ifdef PPPOE_TERM_UNKNOWN_SESSIONS
741: memcpy(shost, mtod(m, struct ether_header*)->ether_shost, ETHER_ADDR_LEN);
742: #endif
743: m_adj(m, sizeof(struct ether_header));
744: if (m->m_pkthdr.len <= PPPOE_HEADERLEN) {
745: printf("pppoe (data): dropping too short packet: %d bytes\n",
746: m->m_pkthdr.len);
747: goto drop;
748: }
749: if (m->m_len < sizeof(*ph)) {
750: m = m_pullup(m, sizeof(*ph));
751: if (m == NULL) {
752: printf("pppoe (data): could not get PPPoE header\n");
753: return;
754: }
755: }
756: ph = mtod(m, struct pppoehdr *);
757: if (ph->vertype != PPPOE_VERTYPE) {
758: printf("pppoe (data): unknown version/type packet: 0x%x\n",
759: ph->vertype);
760: goto drop;
761: }
762: if (ph->code != 0)
763: goto drop;
764:
765: session = ntohs(ph->session);
766: sc = pppoe_find_softc_by_session(session, m->m_pkthdr.rcvif);
767: if (sc == NULL) {
768: #ifdef PPPOE_TERM_UNKNOWN_SESSIONS
769: printf("pppoe (data): input for unknown session 0x%x, sending PADT\n",
770: session);
771: pppoe_send_padt(m->m_pkthdr.rcvif, session, shost);
772: #endif
773: goto drop;
774: }
775:
776: plen = ntohs(ph->plen);
777:
778: #if NBPFILTER > 0
779: if(sc->sc_sppp.pp_if.if_bpf)
780: bpf_mtap(sc->sc_sppp.pp_if.if_bpf, m, BPF_DIRECTION_IN);
781: #endif
782:
783: m_adj(m, PPPOE_HEADERLEN);
784:
785: #ifdef PPPOE_DEBUG
786: {
787: struct mbuf *p;
788:
789: printf("%s: pkthdr.len=%d, pppoe.len=%d",
790: sc->sc_sppp.pp_if.if_xname,
791: m->m_pkthdr.len, plen);
792: p = m;
793: while (p) {
794: printf(" l=%d", p->m_len);
795: p = p->m_next;
796: }
797: printf("\n");
798: }
799: #endif
800:
801: if (m->m_pkthdr.len < plen)
802: goto drop;
803:
804: /* fix incoming interface pointer (not the raw ethernet interface anymore) */
805: m->m_pkthdr.rcvif = &sc->sc_sppp.pp_if;
806:
807: /* pass packet up and account for it */
808: sc->sc_sppp.pp_if.if_ipackets++;
809: sppp_input(&sc->sc_sppp.pp_if, m);
810: return;
811:
812: drop:
813: m_freem(m);
814: }
815:
816: static int
817: pppoe_output(struct pppoe_softc *sc, struct mbuf *m)
818: {
819: struct sockaddr dst;
820: struct ether_header *eh;
821: u_int16_t etype;
822:
823: if (sc->sc_eth_if == NULL) {
824: m_freem(m);
825: return (EIO);
826: }
827:
828: if ((sc->sc_eth_if->if_flags & (IFF_UP|IFF_RUNNING))
829: != (IFF_UP|IFF_RUNNING)) {
830: m_freem(m);
831: return (ENETDOWN);
832: }
833:
834: memset(&dst, 0, sizeof dst);
835: dst.sa_family = AF_UNSPEC;
836: eh = (struct ether_header*)&dst.sa_data;
837: etype = sc->sc_state == PPPOE_STATE_SESSION ? ETHERTYPE_PPPOE : ETHERTYPE_PPPOEDISC;
838: eh->ether_type = htons(etype);
839: memcpy(&eh->ether_dhost, &sc->sc_dest, sizeof sc->sc_dest);
840:
841: PPPOEDEBUG(("%s (%x) state=%d, session=0x%x output -> %s, len=%d\n",
842: sc->sc_sppp.pp_if.if_xname, etype,
843: sc->sc_state, sc->sc_session,
844: ether_sprintf((unsigned char *)&sc->sc_dest), m->m_pkthdr.len));
845:
846: m->m_flags &= ~(M_BCAST|M_MCAST);
847: sc->sc_sppp.pp_if.if_opackets++;
848: return (sc->sc_eth_if->if_output(sc->sc_eth_if, m, &dst, NULL));
849: }
850:
851: /* The ioctl routine. */
852: static int
853: pppoe_ioctl(struct ifnet *ifp, unsigned long cmd, caddr_t data)
854: {
855: struct proc *p = curproc; /* XXX */
856: struct pppoe_softc *sc = (struct pppoe_softc *)ifp;
857: int error = 0;
858:
859: switch (cmd) {
860: case PPPOESETPARMS:
861: {
862: struct pppoediscparms *parms = (struct pppoediscparms *)data;
863: int len;
864:
865: if ((error = suser(p, p->p_acflag)) != 0)
866: return (error);
867: if (parms->eth_ifname[0] != '\0') {
868: sc->sc_eth_if = ifunit(parms->eth_ifname);
869: if (sc->sc_eth_if == NULL)
870: return (ENXIO);
871: }
872:
873: if (sc->sc_concentrator_name)
874: free(sc->sc_concentrator_name, M_DEVBUF);
875: sc->sc_concentrator_name = NULL;
876:
877: len = strlen(parms->ac_name);
878: if (len > 0 && len < sizeof(parms->ac_name)) {
879: char *p = malloc(len + 1, M_DEVBUF, M_WAITOK);
880: if (p == NULL)
881: return (ENOMEM);
882: strlcpy(p, parms->ac_name, len + 1);
883: sc->sc_concentrator_name = p;
884: }
885:
886: if (sc->sc_service_name)
887: free(sc->sc_service_name, M_DEVBUF);
888: sc->sc_service_name = NULL;
889:
890: len = strlen(parms->service_name);
891: if (len > 0 && len < sizeof(parms->service_name)) {
892: char *p = malloc(len + 1, M_DEVBUF, M_WAITOK);
893: if (p == NULL)
894: return (ENOMEM);
895: strlcpy(p, parms->service_name, len + 1);
896: sc->sc_service_name = p;
897: }
898: return (0);
899: }
900: break;
901: case PPPOEGETPARMS:
902: {
903: struct pppoediscparms *parms = (struct pppoediscparms *)data;
904:
905: if (sc->sc_eth_if)
906: strlcpy(parms->eth_ifname, sc->sc_eth_if->if_xname,
907: IFNAMSIZ);
908: else
909: parms->eth_ifname[0] = '\0';
910:
911: if (sc->sc_concentrator_name)
912: strlcpy(parms->ac_name, sc->sc_concentrator_name,
913: sizeof(parms->ac_name));
914: else
915: parms->ac_name[0] = '\0';
916:
917: if (sc->sc_service_name)
918: strlcpy(parms->service_name, sc->sc_service_name,
919: sizeof(parms->service_name));
920: else
921: parms->service_name[0] = '\0';
922:
923: return (0);
924: }
925: break;
926: case PPPOEGETSESSION:
927: {
928: struct pppoeconnectionstate *state =
929: (struct pppoeconnectionstate *)data;
930: state->state = sc->sc_state;
931: state->session_id = sc->sc_session;
932: state->padi_retry_no = sc->sc_padi_retried;
933: state->padr_retry_no = sc->sc_padr_retried;
934: state->session_time.tv_sec = sc->sc_session_time.tv_sec;
935: state->session_time.tv_usec = sc->sc_session_time.tv_usec;
936: return (0);
937: }
938: break;
939: case SIOCSIFFLAGS:
940: {
941: struct ifreq *ifr = (struct ifreq *)data;
942: /*
943: * Prevent running re-establishment timers overriding
944: * administrators choice.
945: */
946: if ((ifr->ifr_flags & IFF_UP) == 0
947: && sc->sc_state >= PPPOE_STATE_PADI_SENT
948: && sc->sc_state < PPPOE_STATE_SESSION) {
949: timeout_del(&sc->sc_timeout);
950: sc->sc_state = PPPOE_STATE_INITIAL;
951: sc->sc_padi_retried = 0;
952: sc->sc_padr_retried = 0;
953: memcpy(&sc->sc_dest, etherbroadcastaddr,
954: sizeof(sc->sc_dest));
955: }
956: return (sppp_ioctl(ifp, cmd, data));
957: }
958: case SIOCSIFMTU:
959: {
960: struct ifreq *ifr = (struct ifreq *)data;
961:
962: if (ifr->ifr_mtu > PPPOE_MAXMTU)
963: return (EINVAL);
964: return (sppp_ioctl(ifp, cmd, data));
965: }
966: default:
967: return (sppp_ioctl(ifp, cmd, data));
968: }
969: return (0);
970: }
971:
972: /*
973: * Allocate a mbuf/cluster with space to store the given data length
974: * of payload, leaving space for prepending an ethernet header
975: * in front.
976: */
977: static struct mbuf *
978: pppoe_get_mbuf(size_t len)
979: {
980: struct mbuf *m;
981:
982: MGETHDR(m, M_DONTWAIT, MT_DATA);
983: if (m == NULL)
984: return (NULL);
985: if (len + sizeof(struct ether_header) > MHLEN) {
986: MCLGET(m, M_DONTWAIT);
987: if ((m->m_flags & M_EXT) == 0) {
988: struct mbuf *n;
989:
990: MFREE(m, n);
991: return (NULL);
992: }
993: }
994: m->m_data += sizeof(struct ether_header);
995: m->m_len = len;
996: m->m_pkthdr.len = len;
997: m->m_pkthdr.rcvif = NULL;
998:
999: return (m);
1000: }
1001:
1002: /* Send PADI. */
1003: static int
1004: pppoe_send_padi(struct pppoe_softc *sc)
1005: {
1006: struct mbuf *m0;
1007: int len, l1 = 0, l2 = 0; /* XXX: gcc */
1008: u_int8_t *p;
1009:
1010: if (sc->sc_state > PPPOE_STATE_PADI_SENT)
1011: panic("pppoe_send_padi in state %d", sc->sc_state);
1012:
1013: /* calculate length of frame (excluding ethernet header + pppoe header) */
1014: len = 2 + 2 + 2 + 2 + sizeof(sc->sc_unique); /* service name tag is required, host unique is send too */
1015: if (sc->sc_service_name != NULL) {
1016: l1 = strlen(sc->sc_service_name);
1017: len += l1;
1018: }
1019: if (sc->sc_concentrator_name != NULL) {
1020: l2 = strlen(sc->sc_concentrator_name);
1021: len += 2 + 2 + l2;
1022: }
1023:
1024: /* allocate a buffer */
1025: m0 = pppoe_get_mbuf(len + PPPOE_HEADERLEN); /* header len + payload len */
1026: if (m0 == NULL)
1027: return (ENOBUFS);
1028:
1029: /* fill in pkt */
1030: p = mtod(m0, u_int8_t *);
1031: PPPOE_ADD_HEADER(p, PPPOE_CODE_PADI, 0, len);
1032: PPPOE_ADD_16(p, PPPOE_TAG_SNAME);
1033: if (sc->sc_service_name != NULL) {
1034: PPPOE_ADD_16(p, l1);
1035: memcpy(p, sc->sc_service_name, l1);
1036: p += l1;
1037: } else {
1038: PPPOE_ADD_16(p, 0);
1039: }
1040: if (sc->sc_concentrator_name != NULL) {
1041: PPPOE_ADD_16(p, PPPOE_TAG_ACNAME);
1042: PPPOE_ADD_16(p, l2);
1043: memcpy(p, sc->sc_concentrator_name, l2);
1044: p += l2;
1045: }
1046: PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
1047: PPPOE_ADD_16(p, sizeof(sc->sc_unique));
1048: memcpy(p, &sc->sc_unique, sizeof(sc->sc_unique));
1049:
1050: #ifdef PPPOE_DEBUG
1051: p += sizeof(sc->sc_unique);
1052: if (p - mtod(m0, u_int8_t *) != len + PPPOE_HEADERLEN)
1053: panic("pppoe_send_padi: garbled output len, should be %ld, is %ld",
1054: (long)(len + PPPOE_HEADERLEN), (long)(p - mtod(m0, u_int8_t *)));
1055: #endif
1056:
1057: /* send pkt */
1058: return (pppoe_output(sc, m0));
1059: }
1060:
1061: /* Watchdog function. */
1062: static void
1063: pppoe_timeout(void *arg)
1064: {
1065: struct pppoe_softc *sc = (struct pppoe_softc *)arg;
1066: int x, retry_wait, err;
1067:
1068: PPPOEDEBUG(("%s: timeout\n", sc->sc_sppp.pp_if.if_xname));
1069:
1070: switch (sc->sc_state) {
1071: case PPPOE_STATE_PADI_SENT:
1072: /*
1073: * We have two basic ways of retrying:
1074: * - Quick retry mode: try a few times in short sequence
1075: * - Slow retry mode: we already had a connection successfully
1076: * established and will try infinitely (without user
1077: * intervention)
1078: * We only enter slow retry mode if IFF_LINK1 (aka autodial)
1079: * is not set.
1080: */
1081:
1082: /* initialize for quick retry mode */
1083: retry_wait = PPPOE_DISC_TIMEOUT * (1 + sc->sc_padi_retried);
1084:
1085: x = splnet();
1086: sc->sc_padi_retried++;
1087: if (sc->sc_padi_retried >= PPPOE_DISC_MAXPADI) {
1088: if ((sc->sc_sppp.pp_if.if_flags & IFF_LINK1) == 0) {
1089: /* slow retry mode */
1090: retry_wait = PPPOE_SLOW_RETRY;
1091: } else {
1092: pppoe_abort_connect(sc);
1093: splx(x);
1094: return;
1095: }
1096: }
1097: if ((err = pppoe_send_padi(sc)) != 0) {
1098: sc->sc_padi_retried--;
1099: PPPOEDEBUG(("%s: failed to transmit PADI, error=%d\n",
1100: sc->sc_sppp.pp_if.if_xname, err));
1101: }
1102: timeout_add(&sc->sc_timeout, retry_wait);
1103: splx(x);
1104:
1105: break;
1106: case PPPOE_STATE_PADR_SENT:
1107: x = splnet();
1108: sc->sc_padr_retried++;
1109: if (sc->sc_padr_retried >= PPPOE_DISC_MAXPADR) {
1110: memcpy(&sc->sc_dest, etherbroadcastaddr,
1111: sizeof(sc->sc_dest));
1112: sc->sc_state = PPPOE_STATE_PADI_SENT;
1113: sc->sc_padr_retried = 0;
1114: if ((err = pppoe_send_padi(sc)) != 0) {
1115: PPPOEDEBUG(("%s: failed to send PADI, error=%d\n",
1116: sc->sc_sppp.pp_if.if_xname, err));
1117: }
1118: timeout_add(&sc->sc_timeout,
1119: PPPOE_DISC_TIMEOUT * (1 + sc->sc_padi_retried));
1120: splx(x);
1121: return;
1122: }
1123: if ((err = pppoe_send_padr(sc)) != 0) {
1124: sc->sc_padr_retried--;
1125: PPPOEDEBUG(("%s: failed to send PADR, error=%d\n",
1126: sc->sc_sppp.pp_if.if_xname, err));
1127: }
1128: timeout_add(&sc->sc_timeout,
1129: PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried));
1130: splx(x);
1131:
1132: break;
1133: case PPPOE_STATE_CLOSING:
1134: pppoe_disconnect(sc);
1135: break;
1136: default:
1137: return; /* all done, work in peace */
1138: }
1139: }
1140:
1141: /* Start a connection (i.e. initiate discovery phase). */
1142: static int
1143: pppoe_connect(struct pppoe_softc *sc)
1144: {
1145: int x, err;
1146:
1147: if (sc->sc_state != PPPOE_STATE_INITIAL)
1148: return (EBUSY);
1149:
1150: #ifdef PPPOE_SERVER
1151: /* wait for PADI if IFF_PASSIVE */
1152: if ((sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE))
1153: return (0);
1154: #endif
1155: x = splnet();
1156:
1157: /* save state, in case we fail to send PADI */
1158: sc->sc_state = PPPOE_STATE_PADI_SENT;
1159: sc->sc_padr_retried = 0;
1160: err = pppoe_send_padi(sc);
1161: if (err != 0)
1162: PPPOEDEBUG(("%s: failed to send PADI, error=%d\n",
1163: sc->sc_sppp.pp_if.if_xname, err));
1164:
1165: timeout_add(&sc->sc_timeout, PPPOE_DISC_TIMEOUT);
1166: splx(x);
1167:
1168: return (err);
1169: }
1170:
1171: /* disconnect */
1172: static int
1173: pppoe_disconnect(struct pppoe_softc *sc)
1174: {
1175: int err, x;
1176:
1177: x = splnet();
1178:
1179: if (sc->sc_state < PPPOE_STATE_SESSION)
1180: err = EBUSY;
1181: else {
1182: PPPOEDEBUG(("%s: disconnecting\n",
1183: sc->sc_sppp.pp_if.if_xname));
1184: err = pppoe_send_padt(sc->sc_eth_if, sc->sc_session, (const u_int8_t *)&sc->sc_dest);
1185: }
1186:
1187: /* cleanup softc */
1188: sc->sc_state = PPPOE_STATE_INITIAL;
1189: memcpy(&sc->sc_dest, etherbroadcastaddr, sizeof(sc->sc_dest));
1190: if (sc->sc_ac_cookie) {
1191: free(sc->sc_ac_cookie, M_DEVBUF);
1192: sc->sc_ac_cookie = NULL;
1193: }
1194: sc->sc_ac_cookie_len = 0;
1195: #ifdef PPPOE_SERVER
1196: if (sc->sc_hunique) {
1197: free(sc->sc_hunique, M_DEVBUF);
1198: sc->sc_hunique = NULL;
1199: }
1200: sc->sc_hunique_len = 0;
1201: #endif
1202: sc->sc_session = 0;
1203:
1204: /* notify upper layer */
1205: sc->sc_sppp.pp_down(&sc->sc_sppp);
1206:
1207: splx(x);
1208:
1209: return (err);
1210: }
1211:
1212: /* Connection attempt aborted. */
1213: static void
1214: pppoe_abort_connect(struct pppoe_softc *sc)
1215: {
1216: printf("%s: could not establish connection\n",
1217: sc->sc_sppp.pp_if.if_xname);
1218: sc->sc_state = PPPOE_STATE_CLOSING;
1219:
1220: /* notify upper layer */
1221: sc->sc_sppp.pp_down(&sc->sc_sppp);
1222:
1223: /* clear connection state */
1224: memcpy(&sc->sc_dest, etherbroadcastaddr, sizeof(sc->sc_dest));
1225: sc->sc_state = PPPOE_STATE_INITIAL;
1226: }
1227:
1228: /* Send a PADR packet */
1229: static int
1230: pppoe_send_padr(struct pppoe_softc *sc)
1231: {
1232: struct mbuf *m0;
1233: u_int8_t *p;
1234: size_t len, l1 = 0; /* XXX: gcc */
1235:
1236: if (sc->sc_state != PPPOE_STATE_PADR_SENT)
1237: return (EIO);
1238:
1239: len = 2 + 2 + 2 + 2 + sizeof(sc->sc_unique); /* service name, host unique */
1240: if (sc->sc_service_name != NULL) { /* service name tag maybe empty */
1241: l1 = strlen(sc->sc_service_name);
1242: len += l1;
1243: }
1244: if (sc->sc_ac_cookie_len > 0)
1245: len += 2 + 2 + sc->sc_ac_cookie_len; /* AC cookie */
1246:
1247: m0 = pppoe_get_mbuf(len + PPPOE_HEADERLEN);
1248: if (m0 == NULL)
1249: return (ENOBUFS);
1250:
1251: p = mtod(m0, u_int8_t *);
1252: PPPOE_ADD_HEADER(p, PPPOE_CODE_PADR, 0, len);
1253: PPPOE_ADD_16(p, PPPOE_TAG_SNAME);
1254:
1255: if (sc->sc_service_name != NULL) {
1256: PPPOE_ADD_16(p, l1);
1257: memcpy(p, sc->sc_service_name, l1);
1258: p += l1;
1259: } else {
1260: PPPOE_ADD_16(p, 0);
1261: }
1262: if (sc->sc_ac_cookie_len > 0) {
1263: PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE);
1264: PPPOE_ADD_16(p, sc->sc_ac_cookie_len);
1265: memcpy(p, sc->sc_ac_cookie, sc->sc_ac_cookie_len);
1266: p += sc->sc_ac_cookie_len;
1267: }
1268: PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
1269: PPPOE_ADD_16(p, sizeof(sc->sc_unique));
1270: memcpy(p, &sc->sc_unique, sizeof(sc->sc_unique));
1271:
1272: #ifdef PPPOE_DEBUG
1273: p += sizeof(sc->sc_unique);
1274: if (p - mtod(m0, u_int8_t *) != len + PPPOE_HEADERLEN)
1275: panic("pppoe_send_padr: garbled output len, should be %ld, is %ld",
1276: (long)(len + PPPOE_HEADERLEN), (long)(p - mtod(m0, u_int8_t *)));
1277: #endif
1278:
1279: return (pppoe_output(sc, m0));
1280: }
1281:
1282: /* Send a PADT packet. */
1283: static int
1284: pppoe_send_padt(struct ifnet *outgoing_if, u_int session, const u_int8_t *dest)
1285: {
1286: struct ether_header *eh;
1287: struct sockaddr dst;
1288: struct mbuf *m0;
1289: u_int8_t *p;
1290:
1291: m0 = pppoe_get_mbuf(PPPOE_HEADERLEN);
1292: if (m0 == NULL)
1293: return (ENOBUFS);
1294:
1295: p = mtod(m0, u_int8_t *);
1296: PPPOE_ADD_HEADER(p, PPPOE_CODE_PADT, session, 0);
1297:
1298: memset(&dst, 0, sizeof(dst));
1299: dst.sa_family = AF_UNSPEC;
1300: eh = (struct ether_header *)&dst.sa_data;
1301: eh->ether_type = htons(ETHERTYPE_PPPOEDISC);
1302: memcpy(&eh->ether_dhost, dest, ETHER_ADDR_LEN);
1303:
1304: m0->m_flags &= ~(M_BCAST|M_MCAST);
1305: return (outgoing_if->if_output(outgoing_if, m0, &dst, NULL));
1306: }
1307:
1308: #ifdef PPPOE_SERVER
1309: /* Send a PADO packet. */
1310: static int
1311: pppoe_send_pado(struct pppoe_softc *sc)
1312: {
1313: struct mbuf *m0;
1314: size_t len;
1315: u_int8_t *p;
1316:
1317: if (sc->sc_state != PPPOE_STATE_PADO_SENT)
1318: return (EIO);
1319:
1320: /* calc length */
1321: len = 0;
1322: /* include ac_cookie */
1323: len += 2 + 2 + sizeof(sc->sc_unique);
1324: /* include hunique */
1325: len += 2 + 2 + sc->sc_hunique_len;
1326:
1327: m0 = pppoe_get_mbuf(len + PPPOE_HEADERLEN);
1328: if (m0 == NULL)
1329: return (ENOBUFS);
1330:
1331: p = mtod(m0, u_int8_t *);
1332: PPPOE_ADD_HEADER(p, PPPOE_CODE_PADO, 0, len);
1333: PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE);
1334: PPPOE_ADD_16(p, sizeof(sc->sc_unique));
1335: memcpy(p, &sc, sizeof(sc->sc_unique));
1336: p += sizeof(sc->sc_unique);
1337: PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
1338: PPPOE_ADD_16(p, sc->sc_hunique_len);
1339: memcpy(p, sc->sc_hunique, sc->sc_hunique_len);
1340:
1341: return (pppoe_output(sc, m0));
1342: }
1343:
1344: /* Send a PADS packet. */
1345: static int
1346: pppoe_send_pads(struct pppoe_softc *sc)
1347: {
1348: struct mbuf *m0;
1349: size_t len, l1;
1350: u_int8_t *p;
1351:
1352: if (sc->sc_state != PPPOE_STATE_PADO_SENT)
1353: return (EIO);
1354:
1355: sc->sc_session = mono_time.tv_sec % 0xff + 1;
1356:
1357: /* calc length */
1358: len = 0;
1359: /* include hunique */
1360: len += 2 + 2 + 2 + 2 + sc->sc_hunique_len; /* service name, host unique */
1361: if (sc->sc_service_name != NULL) { /* service name tag maybe empty */
1362: l1 = strlen(sc->sc_service_name);
1363: len += l1;
1364: }
1365:
1366: m0 = pppoe_get_mbuf(len + PPPOE_HEADERLEN);
1367: if (m0 == NULL)
1368: return (ENOBUFS);
1369:
1370: p = mtod(m0, u_int8_t *);
1371: PPPOE_ADD_HEADER(p, PPPOE_CODE_PADS, sc->sc_session, len);
1372: PPPOE_ADD_16(p, PPPOE_TAG_SNAME);
1373: if (sc->sc_service_name != NULL) {
1374: PPPOE_ADD_16(p, l1);
1375: memcpy(p, sc->sc_service_name, l1);
1376: p += l1;
1377: } else {
1378: PPPOE_ADD_16(p, 0);
1379: }
1380: PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
1381: PPPOE_ADD_16(p, sc->sc_hunique_len);
1382: memcpy(p, sc->sc_hunique, sc->sc_hunique_len);
1383:
1384: return (pppoe_output(sc, m0));
1385: }
1386: #endif
1387:
1388: /* this-layer-start function */
1389: static void
1390: pppoe_tls(struct sppp *sp)
1391: {
1392: struct pppoe_softc *sc = (void *)sp;
1393:
1394: if (sc->sc_state != PPPOE_STATE_INITIAL)
1395: return;
1396: pppoe_connect(sc);
1397: }
1398:
1399: /* this-layer-finish function */
1400: static void
1401: pppoe_tlf(struct sppp *sp)
1402: {
1403: struct pppoe_softc *sc = (void *)sp;
1404:
1405: if (sc->sc_state < PPPOE_STATE_SESSION)
1406: return;
1407: /*
1408: * Do not call pppoe_disconnect here, the upper layer state
1409: * machine gets confused by this. We must return from this
1410: * function and defer disconnecting to the timeout handler.
1411: */
1412: sc->sc_state = PPPOE_STATE_CLOSING;
1413: timeout_add(&sc->sc_timeout, hz / 50);
1414: }
1415:
1416: static void
1417: pppoe_start(struct ifnet *ifp)
1418: {
1419: struct pppoe_softc *sc = (void *)ifp;
1420: struct mbuf *m;
1421: size_t len;
1422: u_int8_t *p;
1423:
1424: if (sppp_isempty(ifp))
1425: return;
1426:
1427: /* are we ready to process data yet? */
1428: if (sc->sc_state < PPPOE_STATE_SESSION) {
1429: sppp_flush(&sc->sc_sppp.pp_if);
1430: return;
1431: }
1432:
1433: while ((m = sppp_dequeue(ifp)) != NULL) {
1434: len = m->m_pkthdr.len;
1435: M_PREPEND(m, PPPOE_HEADERLEN, M_DONTWAIT);
1436: if (m == NULL) {
1437: ifp->if_oerrors++;
1438: continue;
1439: }
1440: p = mtod(m, u_int8_t *);
1441: PPPOE_ADD_HEADER(p, 0, sc->sc_session, len);
1442:
1443: #if NBPFILTER > 0
1444: if(sc->sc_sppp.pp_if.if_bpf)
1445: bpf_mtap(sc->sc_sppp.pp_if.if_bpf, m,
1446: BPF_DIRECTION_OUT);
1447: #endif
1448:
1449: pppoe_output(sc, m);
1450: }
1451: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_pppoe.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net