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