Annotation of embedaddon/mpd/src/pppoe.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * pppoe.c
! 4: *
! 5: * Written by Archie Cobbs <archie@freebsd.org>
! 6: * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
! 7: * See ``COPYRIGHT.whistle''
! 8: */
! 9:
! 10: #include "ppp.h"
! 11: #include "pppoe.h"
! 12: #include "ngfunc.h"
! 13: #include "log.h"
! 14: #include "util.h"
! 15:
! 16: #include <net/ethernet.h>
! 17: #include <netgraph/ng_message.h>
! 18: #include <netgraph/ng_pppoe.h>
! 19: #include <netgraph/ng_ether.h>
! 20: #include <netgraph/ng_tee.h>
! 21: #include <netgraph.h>
! 22:
! 23: #include <sys/param.h>
! 24: #include <sys/linker.h>
! 25:
! 26: /*
! 27: * DEFINITIONS
! 28: */
! 29:
! 30: #define PPPOE_MTU 1492 /* allow room for PPPoE overhead */
! 31: #define PPPOE_MRU 1492
! 32:
! 33: #define PPPOE_CONNECT_TIMEOUT 9
! 34:
! 35: #define ETHER_DEFAULT_HOOK NG_ETHER_HOOK_ORPHAN
! 36:
! 37: #define PPPOE_MAXPARENTIFS 1024
! 38:
! 39: #define MAX_PATH 64 /* XXX should be NG_PATHSIZ */
! 40: #define MAX_SESSION 64 /* max length of PPPoE session name */
! 41:
! 42: /* Per link private info */
! 43: struct pppoeinfo {
! 44: char path[MAX_PATH]; /* PPPoE node path */
! 45: char hook[NG_HOOKSIZ]; /* hook on that node */
! 46: char session[MAX_SESSION]; /* session name */
! 47: char acname[PPPOE_SERVICE_NAME_SIZE]; /* AC name */
! 48: u_char peeraddr[6]; /* Peer MAC address */
! 49: char real_session[MAX_SESSION]; /* real session name */
! 50: char agent_cid[64]; /* Agent Circuit ID */
! 51: char agent_rid[64]; /* Agent Remote ID */
! 52: u_char incoming; /* incoming vs. outgoing */
! 53: u_char opened; /* PPPoE opened by phys */
! 54: struct optinfo options;
! 55: struct PppoeIf *PIf; /* pointer on parent ng_pppoe info */
! 56: struct PppoeList *list;
! 57: struct pppTimer connectTimer; /* connection timeout timer */
! 58: };
! 59: typedef struct pppoeinfo *PppoeInfo;
! 60:
! 61: static u_char gNgEtherLoaded = FALSE;
! 62:
! 63: /* Set menu options */
! 64: enum {
! 65: SET_IFACE,
! 66: SET_SESSION,
! 67: SET_ACNAME
! 68: };
! 69:
! 70: /*
! 71: Invariants:
! 72: ----------
! 73:
! 74: PPPOE_DOWN
! 75: - ng_pppoe(4) node does not exist
! 76: - pe->csock == -1
! 77: - Connect timeout timer is not running
! 78:
! 79: PPPOE_CONNECTING
! 80: - ng_pppoe(4) node exists and is connected to ether and ppp nodes
! 81: - pe->csock != -1
! 82: - Listening for control messages rec'd on pe->csock
! 83: - Connect timeout timer is running
! 84: - NGM_PPPOE_CONNECT has been sent to the ng_pppoe(4) node, and
! 85: no response has been received yet
! 86:
! 87: PPPOE_UP
! 88: - ng_pppoe(4) node exists and is connected to ether and ppp nodes
! 89: - pe->csock != -1
! 90: - Listening for control messages rec'd on pe->csock
! 91: - Connect timeout timer is not running
! 92: - NGM_PPPOE_CONNECT has been sent to the ng_pppoe(4) node, and
! 93: a NGM_PPPOE_SUCCESS has been received
! 94: */
! 95:
! 96: /*
! 97: * INTERNAL FUNCTIONS
! 98: */
! 99:
! 100: static int PppoeInit(Link l);
! 101: static int PppoeInst(Link l, Link lt);
! 102: static void PppoeOpen(Link l);
! 103: static void PppoeClose(Link l);
! 104: static void PppoeShutdown(Link l);
! 105: static int PppoePeerMacAddr(Link l, void *buf, size_t buf_len);
! 106: static int PppoePeerIface(Link l, void *buf, size_t buf_len);
! 107: static int PppoeCallingNum(Link l, void *buf, size_t buf_len);
! 108: static int PppoeCalledNum(Link l, void *buf, size_t buf_len);
! 109: static int PppoeSelfName(Link l, void *buf, size_t buf_len);
! 110: static int PppoePeerName(Link l, void *buf, size_t buf_len);
! 111: static void PppoeCtrlReadEvent(int type, void *arg);
! 112: static void PppoeConnectTimeout(void *arg);
! 113: static void PppoeStat(Context ctx);
! 114: static int PppoeSetCommand(Context ctx, int ac, char *av[], void *arg);
! 115: static int PppoeOriginated(Link l);
! 116: static int PppoeIsSync(Link l);
! 117: static void PppoeGetNode(Link l);
! 118: static void PppoeReleaseNode(Link l);
! 119: static int PppoeListen(Link l);
! 120: static int PppoeUnListen(Link l);
! 121: static void PppoeNodeUpdate(Link l);
! 122: static void PppoeListenEvent(int type, void *arg);
! 123: static int CreatePppoeNode(struct PppoeIf *PIf, const char *path, const char *hook);
! 124:
! 125: static void PppoeDoClose(Link l);
! 126:
! 127: /*
! 128: * GLOBAL VARIABLES
! 129: */
! 130:
! 131: const struct phystype gPppoePhysType = {
! 132: .name = "pppoe",
! 133: .descr = "PPP over Ethernet",
! 134: .mtu = PPPOE_MTU,
! 135: .mru = PPPOE_MRU,
! 136: .tmpl = 1,
! 137: .init = PppoeInit,
! 138: .inst = PppoeInst,
! 139: .open = PppoeOpen,
! 140: .close = PppoeClose,
! 141: .update = PppoeNodeUpdate,
! 142: .shutdown = PppoeShutdown,
! 143: .showstat = PppoeStat,
! 144: .originate = PppoeOriginated,
! 145: .issync = PppoeIsSync,
! 146: .peeraddr = PppoePeerMacAddr,
! 147: .peermacaddr = PppoePeerMacAddr,
! 148: .peeriface = PppoePeerIface,
! 149: .callingnum = PppoeCallingNum,
! 150: .callednum = PppoeCalledNum,
! 151: .selfname = PppoeSelfName,
! 152: .peername = PppoePeerName,
! 153: };
! 154:
! 155: const struct cmdtab PppoeSetCmds[] = {
! 156: { "iface {name}", "Set ethernet interface to use",
! 157: PppoeSetCommand, NULL, 2, (void *)SET_IFACE },
! 158: { "service {name}", "Set PPPoE session name",
! 159: PppoeSetCommand, NULL, 2, (void *)SET_SESSION },
! 160: { "acname {name}", "Set PPPoE access concentrator name",
! 161: PppoeSetCommand, NULL, 2, (void *)SET_ACNAME },
! 162: { NULL },
! 163: };
! 164:
! 165: /*
! 166: * INTERNAL VARIABLES
! 167: */
! 168:
! 169: struct PppoeList {
! 170: char session[MAX_SESSION];
! 171: int refs;
! 172: SLIST_ENTRY(PppoeList) next;
! 173: };
! 174:
! 175: struct PppoeIf {
! 176: char ifnodepath[MAX_PATH];
! 177: ng_ID_t node_id; /* pppoe node id */
! 178: int refs;
! 179: int csock; /* netgraph Control socket */
! 180: int dsock; /* netgraph Data socket */
! 181: EventRef ctrlEvent; /* listen for ctrl messages */
! 182: EventRef dataEvent; /* listen for data messages */
! 183: SLIST_HEAD(, PppoeList) list;
! 184: };
! 185:
! 186: int PppoeIfCount=0;
! 187: struct PppoeIf PppoeIfs[PPPOE_MAXPARENTIFS];
! 188:
! 189: /*
! 190: * PppoeInit()
! 191: *
! 192: * Initialize device-specific data in physical layer info
! 193: */
! 194: static int
! 195: PppoeInit(Link l)
! 196: {
! 197: PppoeInfo pe;
! 198:
! 199: /* Allocate private struct */
! 200: pe = (PppoeInfo)(l->info = Malloc(MB_PHYS, sizeof(*pe)));
! 201: pe->incoming = 0;
! 202: pe->opened = 0;
! 203: snprintf(pe->path, sizeof(pe->path), "undefined:");
! 204: snprintf(pe->hook, sizeof(pe->hook), "undefined");
! 205: snprintf(pe->session, sizeof(pe->session), "*");
! 206: memset(pe->peeraddr, 0x00, ETHER_ADDR_LEN);
! 207: strlcpy(pe->real_session, pe->session, sizeof(pe->real_session));
! 208: pe->agent_cid[0] = 0;
! 209: pe->agent_rid[0] = 0;
! 210: pe->PIf = NULL;
! 211:
! 212: /* Done */
! 213: return(0);
! 214: }
! 215:
! 216: /*
! 217: * PppoeInst()
! 218: *
! 219: * Instantiate device
! 220: */
! 221: static int
! 222: PppoeInst(Link l, Link lt)
! 223: {
! 224: PppoeInfo pi;
! 225: l->info = Mdup(MB_PHYS, lt->info, sizeof(struct pppoeinfo));
! 226: pi = (PppoeInfo)l->info;
! 227: if (pi->PIf)
! 228: pi->PIf->refs++;
! 229: if (pi->list)
! 230: pi->list->refs++;
! 231:
! 232: /* Done */
! 233: return(0);
! 234: }
! 235:
! 236: /*
! 237: * PppoeOpen()
! 238: */
! 239: static void
! 240: PppoeOpen(Link l)
! 241: {
! 242: PppoeInfo pe = (PppoeInfo)l->info;
! 243: struct ngm_connect cn;
! 244: union {
! 245: u_char buf[sizeof(struct ngpppoe_init_data) + MAX_SESSION];
! 246: struct ngpppoe_init_data poeid;
! 247: } u;
! 248: struct ngpppoe_init_data *const idata = &u.poeid;
! 249: char path[NG_PATHSIZ];
! 250: char session_hook[NG_HOOKSIZ];
! 251:
! 252: pe->opened=1;
! 253:
! 254: Disable(&l->conf.options, LINK_CONF_ACFCOMP); /* RFC 2516 */
! 255: Deny(&l->conf.options, LINK_CONF_ACFCOMP); /* RFC 2516 */
! 256:
! 257: snprintf(session_hook, sizeof(session_hook), "mpd%d-%d",
! 258: gPid, l->id);
! 259:
! 260: if (pe->incoming == 1) {
! 261: Log(LG_PHYS2, ("[%s] PppoeOpen() on incoming call", l->name));
! 262:
! 263: /* Path to the ng_tee node */
! 264: snprintf(path, sizeof(path), "[%x]:%s",
! 265: pe->PIf->node_id, session_hook);
! 266:
! 267: /* Connect ng_tee(4) node to the ng_ppp(4) node. */
! 268: memset(&cn, 0, sizeof(cn));
! 269: if (!PhysGetUpperHook(l, cn.path, cn.peerhook)) {
! 270: Log(LG_PHYS, ("[%s] PPPoE: can't get upper hook", l->name));
! 271: goto fail3;
! 272: }
! 273: snprintf(cn.ourhook, sizeof(cn.ourhook), "right");
! 274: if (NgSendMsg(pe->PIf->csock, path, NGM_GENERIC_COOKIE, NGM_CONNECT,
! 275: &cn, sizeof(cn)) < 0) {
! 276: Perror("[%s] PPPoE: can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\"",
! 277: l->name, path, cn.ourhook, cn.path, cn.peerhook);
! 278: goto fail3;
! 279: }
! 280:
! 281: /* Shutdown ng_tee node */
! 282: if (NgFuncShutdownNode(pe->PIf->csock, l->name, path) < 0) {
! 283: Perror("[%s] PPPoE: Shutdown ng_tee node %s error",
! 284: l->name, path);
! 285: }
! 286:
! 287: if (l->state==PHYS_STATE_READY) {
! 288: TimerStop(&pe->connectTimer);
! 289: l->state = PHYS_STATE_UP;
! 290: PhysUp(l);
! 291: }
! 292: return;
! 293: }
! 294:
! 295: /* Sanity check. */
! 296: if (l->state != PHYS_STATE_DOWN) {
! 297: Log(LG_PHYS, ("[%s] PPPoE allready active", l->name));
! 298: return;
! 299: };
! 300:
! 301: /* Create PPPoE node if necessary. */
! 302: PppoeGetNode(l);
! 303:
! 304: if (!pe->PIf) {
! 305: Log(LG_ERR, ("[%s] PPPoE node for link is not initialized",
! 306: l->name));
! 307: goto fail;
! 308: }
! 309:
! 310: /* Connect our ng_ppp(4) node link hook to the ng_pppoe(4) node. */
! 311: strlcpy(cn.ourhook, session_hook, sizeof(cn.ourhook));
! 312: snprintf(path, sizeof(path), "[%x]:", pe->PIf->node_id);
! 313:
! 314: if (!PhysGetUpperHook(l, cn.path, cn.peerhook)) {
! 315: Log(LG_PHYS, ("[%s] PPPoE: can't get upper hook", l->name));
! 316: goto fail2;
! 317: }
! 318:
! 319: if (NgSendMsg(pe->PIf->csock, path, NGM_GENERIC_COOKIE, NGM_CONNECT,
! 320: &cn, sizeof(cn)) < 0) {
! 321: Perror("[%s] PPPoE: can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\"",
! 322: l->name, path, cn.ourhook, cn.path, cn.peerhook);
! 323: goto fail2;
! 324: }
! 325:
! 326: Log(LG_PHYS, ("[%s] PPPoE: Connecting to '%s'", l->name, pe->session));
! 327:
! 328: /* Tell the PPPoE node to try to connect to a server. */
! 329: memset(idata, 0, sizeof(idata));
! 330: strlcpy(idata->hook, session_hook, sizeof(idata->hook));
! 331: idata->data_len = strlen(pe->session);
! 332: strncpy(idata->data, pe->session, MAX_SESSION);
! 333: if (NgSendMsg(pe->PIf->csock, path, NGM_PPPOE_COOKIE, NGM_PPPOE_CONNECT,
! 334: idata, sizeof(*idata) + idata->data_len) < 0) {
! 335: Perror("[%s] PPPoE can't request connection to server", l->name);
! 336: goto fail2;
! 337: }
! 338:
! 339: /* Set a timer to limit connection time. */
! 340: TimerInit(&pe->connectTimer, "PPPoE-connect",
! 341: PPPOE_CONNECT_TIMEOUT * SECONDS, PppoeConnectTimeout, l);
! 342: TimerStart(&pe->connectTimer);
! 343:
! 344: /* OK */
! 345: l->state = PHYS_STATE_CONNECTING;
! 346: strlcpy(pe->real_session, pe->session, sizeof(pe->real_session));
! 347: pe->agent_cid[0] = 0;
! 348: pe->agent_rid[0] = 0;
! 349: return;
! 350:
! 351: fail3:
! 352: snprintf(path, sizeof(path), "[%x]:", pe->PIf->node_id);
! 353: fail2:
! 354: NgFuncDisconnect(pe->PIf->csock, l->name, path, session_hook);
! 355: fail:
! 356: PhysDown(l, STR_ERROR, NULL);
! 357: return;
! 358: }
! 359:
! 360: /*
! 361: * PppoeConnectTimeout()
! 362: */
! 363: static void
! 364: PppoeConnectTimeout(void *arg)
! 365: {
! 366: const Link l = (Link)arg;
! 367:
! 368: /* Cancel connection. */
! 369: Log(LG_PHYS, ("[%s] PPPoE connection timeout after %d seconds",
! 370: l->name, PPPOE_CONNECT_TIMEOUT));
! 371: PppoeDoClose(l);
! 372: PhysDown(l, STR_CON_FAILED0, NULL);
! 373: }
! 374:
! 375: /*
! 376: * PppoeClose()
! 377: */
! 378: static void
! 379: PppoeClose(Link l)
! 380: {
! 381: const PppoeInfo pe = (PppoeInfo)l->info;
! 382:
! 383: pe->opened = 0;
! 384: if (l->state == PHYS_STATE_DOWN)
! 385: return;
! 386: PppoeDoClose(l);
! 387: PhysDown(l, STR_MANUALLY, NULL);
! 388: }
! 389:
! 390: /*
! 391: * PppoeShutdown()
! 392: *
! 393: * Shut everything down and go to the PHYS_STATE_DOWN state.
! 394: */
! 395: static void
! 396: PppoeShutdown(Link l)
! 397: {
! 398: PppoeDoClose(l);
! 399: PppoeUnListen(l);
! 400: PppoeReleaseNode(l);
! 401: Freee(l->info);
! 402: }
! 403:
! 404: /*
! 405: * PppoeDoClose()
! 406: *
! 407: * Shut everything down and go to the PHYS_STATE_DOWN state.
! 408: */
! 409: static void
! 410: PppoeDoClose(Link l)
! 411: {
! 412: const PppoeInfo pi = (PppoeInfo)l->info;
! 413: char path[NG_PATHSIZ];
! 414: char session_hook[NG_HOOKSIZ];
! 415:
! 416: if (l->state == PHYS_STATE_DOWN)
! 417: return;
! 418:
! 419: snprintf(path, sizeof(path), "[%x]:", pi->PIf->node_id);
! 420: snprintf(session_hook, sizeof(session_hook), "mpd%d-%d",
! 421: gPid, l->id);
! 422: NgFuncDisconnect(pi->PIf->csock, l->name, path, session_hook);
! 423:
! 424: TimerStop(&pi->connectTimer);
! 425: l->state = PHYS_STATE_DOWN;
! 426: pi->incoming = 0;
! 427: memset(pi->peeraddr, 0x00, ETHER_ADDR_LEN);
! 428: pi->real_session[0] = 0;
! 429: pi->agent_cid[0] = 0;
! 430: pi->agent_rid[0] = 0;
! 431: }
! 432:
! 433: /*
! 434: * PppoeCtrlReadEvent()
! 435: *
! 436: * Receive an incoming control message from the PPPoE node
! 437: */
! 438: static void
! 439: PppoeCtrlReadEvent(int type, void *arg)
! 440: {
! 441: union {
! 442: u_char buf[sizeof(struct ng_mesg) + sizeof(struct ngpppoe_sts)];
! 443: struct ng_mesg resp;
! 444: } u;
! 445: char path[NG_PATHSIZ];
! 446: Link l = NULL;
! 447: PppoeInfo pi = NULL;
! 448:
! 449: struct PppoeIf *PIf = (struct PppoeIf*)arg;
! 450:
! 451: /* Read control message. */
! 452: if (NgRecvMsg(PIf->csock, &u.resp, sizeof(u), path) < 0) {
! 453: Perror("PPPoE: error reading message from \"%s\"", path);
! 454: return;
! 455: }
! 456: if (u.resp.header.typecookie != NGM_PPPOE_COOKIE) {
! 457: Log(LG_ERR, ("PPPoE: rec'd cookie %lu from \"%s\"",
! 458: (u_long)u.resp.header.typecookie, path));
! 459: return;
! 460: }
! 461:
! 462: switch (u.resp.header.cmd) {
! 463: case NGM_PPPOE_SUCCESS:
! 464: case NGM_PPPOE_FAIL:
! 465: case NGM_PPPOE_CLOSE:
! 466: {
! 467: char ppphook[NG_HOOKSIZ];
! 468: char *linkname, *rest;
! 469: int id;
! 470:
! 471: /* Check hook name prefix */
! 472: linkname = ((struct ngpppoe_sts *)u.resp.data)->hook;
! 473: if (strncmp(linkname, "listen-", 7) == 0)
! 474: return; /* We do not need them */
! 475: snprintf(ppphook, NG_HOOKSIZ, "mpd%d-", gPid);
! 476: if (strncmp(linkname, ppphook, strlen(ppphook))) {
! 477: Log(LG_ERR, ("PPPoE: message %d from unknown hook \"%s\"",
! 478: u.resp.header.cmd, ((struct ngpppoe_sts *)u.resp.data)->hook));
! 479: return;
! 480: }
! 481: linkname += strlen(ppphook);
! 482: id = strtol(linkname, &rest, 10);
! 483: if (rest[0] != 0 ||
! 484: !gLinks[id] ||
! 485: gLinks[id]->type != &gPppoePhysType ||
! 486: PIf != ((PppoeInfo)gLinks[id]->info)->PIf) {
! 487: Log((u.resp.header.cmd == NGM_PPPOE_SUCCESS)?LG_ERR:LG_PHYS,
! 488: ("PPPoE: message %d from unexisting link \"%s\"",
! 489: u.resp.header.cmd, linkname));
! 490: return;
! 491: }
! 492:
! 493: l = gLinks[id];
! 494: pi = (PppoeInfo)l->info;
! 495:
! 496: if (l->state == PHYS_STATE_DOWN) {
! 497: if (u.resp.header.cmd != NGM_PPPOE_CLOSE)
! 498: Log(LG_PHYS, ("[%s] PPPoE: message %d in DOWN state",
! 499: l->name, u.resp.header.cmd));
! 500: return;
! 501: }
! 502: }
! 503: }
! 504:
! 505: /* Decode message. */
! 506: switch (u.resp.header.cmd) {
! 507: case NGM_PPPOE_SESSIONID: /* XXX: I do not know what to do with this? */
! 508: break;
! 509: case NGM_PPPOE_SUCCESS:
! 510: Log(LG_PHYS, ("[%s] PPPoE: connection successful", l->name));
! 511: if (pi->opened) {
! 512: TimerStop(&pi->connectTimer);
! 513: l->state = PHYS_STATE_UP;
! 514: PhysUp(l);
! 515: } else {
! 516: l->state = PHYS_STATE_READY;
! 517: }
! 518: break;
! 519: case NGM_PPPOE_FAIL:
! 520: Log(LG_PHYS, ("[%s] PPPoE: connection failed", l->name));
! 521: PppoeDoClose(l);
! 522: PhysDown(l, STR_CON_FAILED0, NULL);
! 523: break;
! 524: case NGM_PPPOE_CLOSE:
! 525: Log(LG_PHYS, ("[%s] PPPoE: connection closed", l->name));
! 526: PppoeDoClose(l);
! 527: PhysDown(l, STR_DROPPED, NULL);
! 528: break;
! 529: case NGM_PPPOE_ACNAME:
! 530: Log(LG_PHYS, ("PPPoE: rec'd ACNAME \"%s\"",
! 531: ((struct ngpppoe_sts *)u.resp.data)->hook));
! 532: break;
! 533: default:
! 534: Log(LG_PHYS, ("PPPoE: rec'd command %lu from \"%s\"",
! 535: (u_long)u.resp.header.cmd, path));
! 536: break;
! 537: }
! 538: }
! 539:
! 540: /*
! 541: * PppoeStat()
! 542: */
! 543: void
! 544: PppoeStat(Context ctx)
! 545: {
! 546: const PppoeInfo pe = (PppoeInfo)ctx->lnk->info;
! 547: char buf[32];
! 548:
! 549: Printf("PPPoE configuration:\r\n");
! 550: Printf("\tIface Node : %s\r\n", pe->path);
! 551: Printf("\tIface Hook : %s\r\n", pe->hook);
! 552: Printf("\tSession : %s\r\n", pe->session);
! 553: Printf("PPPoE status:\r\n");
! 554: if (ctx->lnk->state != PHYS_STATE_DOWN) {
! 555: Printf("\tOpened : %s\r\n", (pe->opened?"YES":"NO"));
! 556: Printf("\tIncoming : %s\r\n", (pe->incoming?"YES":"NO"));
! 557: PppoePeerMacAddr(ctx->lnk, buf, sizeof(buf));
! 558: Printf("\tCurrent peer : %s\r\n", buf);
! 559: Printf("\tSession : %s\r\n", pe->real_session);
! 560: Printf("\tCircuit-ID : %s\r\n", pe->agent_cid);
! 561: Printf("\tRemote-ID : %s\r\n", pe->agent_rid);
! 562: }
! 563: }
! 564:
! 565: /*
! 566: * PppoeOriginated()
! 567: */
! 568: static int
! 569: PppoeOriginated(Link l)
! 570: {
! 571: PppoeInfo const pppoe = (PppoeInfo)l->info;
! 572:
! 573: return (pppoe->incoming ? LINK_ORIGINATE_REMOTE : LINK_ORIGINATE_LOCAL);
! 574: }
! 575:
! 576: /*
! 577: * PppoeIsSync()
! 578: */
! 579: static int
! 580: PppoeIsSync(Link l)
! 581: {
! 582: return (1);
! 583: }
! 584:
! 585: static int
! 586: PppoePeerMacAddr(Link l, void *buf, size_t buf_len)
! 587: {
! 588: PppoeInfo const pppoe = (PppoeInfo)l->info;
! 589:
! 590: snprintf(buf, buf_len, "%02x:%02x:%02x:%02x:%02x:%02x",
! 591: pppoe->peeraddr[0], pppoe->peeraddr[1], pppoe->peeraddr[2],
! 592: pppoe->peeraddr[3], pppoe->peeraddr[4], pppoe->peeraddr[5]);
! 593:
! 594: return (0);
! 595: }
! 596:
! 597: static int
! 598: PppoePeerIface(Link l, void *buf, size_t buf_len)
! 599: {
! 600: PppoeInfo const pppoe = (PppoeInfo)l->info;
! 601: char iface[IFNAMSIZ];
! 602:
! 603: strlcpy(iface, pppoe->path, sizeof(iface));
! 604: if (iface[strlen(iface) - 1] == ':')
! 605: iface[strlen(iface) - 1] = '\0';
! 606: strlcpy(buf, iface, buf_len);
! 607: return (0);
! 608: }
! 609:
! 610: static int
! 611: PppoeCallingNum(Link l, void *buf, size_t buf_len)
! 612: {
! 613: PppoeInfo const pppoe = (PppoeInfo)l->info;
! 614:
! 615: if (pppoe->incoming) {
! 616: snprintf(buf, buf_len, "%02x%02x%02x%02x%02x%02x",
! 617: pppoe->peeraddr[0], pppoe->peeraddr[1], pppoe->peeraddr[2],
! 618: pppoe->peeraddr[3], pppoe->peeraddr[4], pppoe->peeraddr[5]);
! 619: } else {
! 620: strlcpy(buf, pppoe->real_session, buf_len);
! 621: }
! 622:
! 623: return (0);
! 624: }
! 625:
! 626: static int
! 627: PppoeCalledNum(Link l, void *buf, size_t buf_len)
! 628: {
! 629: PppoeInfo const pppoe = (PppoeInfo)l->info;
! 630:
! 631: if (!pppoe->incoming) {
! 632: snprintf(buf, buf_len, "%02x%02x%02x%02x%02x%02x",
! 633: pppoe->peeraddr[0], pppoe->peeraddr[1], pppoe->peeraddr[2],
! 634: pppoe->peeraddr[3], pppoe->peeraddr[4], pppoe->peeraddr[5]);
! 635: } else {
! 636: strlcpy(buf, pppoe->real_session, buf_len);
! 637: }
! 638:
! 639: return (0);
! 640: }
! 641:
! 642: static int
! 643: PppoeSelfName(Link l, void *buf, size_t buf_len)
! 644: {
! 645: PppoeInfo const pppoe = (PppoeInfo)l->info;
! 646:
! 647: strlcpy(buf, pppoe->agent_cid, buf_len);
! 648:
! 649: return (0);
! 650: }
! 651:
! 652: static int
! 653: PppoePeerName(Link l, void *buf, size_t buf_len)
! 654: {
! 655: PppoeInfo const pppoe = (PppoeInfo)l->info;
! 656:
! 657: strlcpy(buf, pppoe->agent_rid, buf_len);
! 658:
! 659: return (0);
! 660: }
! 661:
! 662: static int
! 663: CreatePppoeNode(struct PppoeIf *PIf, const char *path, const char *hook)
! 664: {
! 665: union {
! 666: u_char buf[sizeof(struct ng_mesg) + 2048];
! 667: struct ng_mesg reply;
! 668: } u;
! 669: struct ng_mesg *resp;
! 670: const struct hooklist *hlist;
! 671: const struct nodeinfo *ninfo;
! 672: int f;
! 673:
! 674: /* Make sure interface is up. */
! 675: char iface[IFNAMSIZ];
! 676:
! 677: strlcpy(iface, path, sizeof(iface));
! 678: if (iface[strlen(iface) - 1] == ':')
! 679: iface[strlen(iface) - 1] = '\0';
! 680: if (ExecCmdNosh(LG_PHYS2, iface, "%s %s up", PATH_IFCONFIG, iface) != 0) {
! 681: Log(LG_ERR, ("PPPoE: can't bring up interface %s",
! 682: iface));
! 683: return (0);
! 684: }
! 685:
! 686: /* Create a new netgraph node */
! 687: if (NgMkSockNode(NULL, &PIf->csock, &PIf->dsock) < 0) {
! 688: Perror("[%s] PPPoE: can't create ctrl socket", iface);
! 689: return(0);
! 690: }
! 691: (void)fcntl(PIf->csock, F_SETFD, 1);
! 692: (void)fcntl(PIf->dsock, F_SETFD, 1);
! 693:
! 694: /* Check if NG_ETHER_NODE_TYPE is available. */
! 695: if (gNgEtherLoaded == FALSE) {
! 696: const struct typelist *tlist;
! 697:
! 698: /* Ask for a list of available node types. */
! 699: if (NgSendMsg(PIf->csock, "", NGM_GENERIC_COOKIE, NGM_LISTTYPES,
! 700: NULL, 0) < 0) {
! 701: Perror("[%s] PPPoE: Cannot send a netgraph message",
! 702: iface);
! 703: close(PIf->csock);
! 704: close(PIf->dsock);
! 705: return (0);
! 706: }
! 707:
! 708: /* Get response. */
! 709: resp = &u.reply;
! 710: if (NgRecvMsg(PIf->csock, resp, sizeof(u.buf), NULL) <= 0) {
! 711: Perror("[%s] PPPoE: Cannot get netgraph response",
! 712: iface);
! 713: close(PIf->csock);
! 714: close(PIf->dsock);
! 715: return (0);
! 716: }
! 717:
! 718: /* Look for NG_ETHER_NODE_TYPE. */
! 719: tlist = (const struct typelist*) resp->data;
! 720: for (f = 0; f < tlist->numtypes; f++)
! 721: if (strncmp(tlist->typeinfo[f].type_name,
! 722: NG_ETHER_NODE_TYPE,
! 723: sizeof(NG_ETHER_NODE_TYPE) - 1) == 0)
! 724: gNgEtherLoaded = TRUE;
! 725:
! 726: /* If not found try to load ng_ether and repeat the check. */
! 727: if (gNgEtherLoaded == FALSE && (kldload("ng_ether") < 0)) {
! 728: Perror("PPPoE: Cannot load ng_ether");
! 729: close(PIf->csock);
! 730: close(PIf->dsock);
! 731: assert (0);
! 732: }
! 733: gNgEtherLoaded = TRUE;
! 734: }
! 735:
! 736: /*
! 737: * Ask for a list of hooks attached to the "ether" node. This node
! 738: * should magically exist as a way of hooking stuff onto an ethernet
! 739: * device.
! 740: */
! 741: if (NgSendMsg(PIf->csock, path, NGM_GENERIC_COOKIE, NGM_LISTHOOKS,
! 742: NULL, 0) < 0) {
! 743: Perror("[%s] Cannot send a netgraph message: %s", iface, path);
! 744: close(PIf->csock);
! 745: close(PIf->dsock);
! 746: return (0);
! 747: }
! 748:
! 749: /* Get our list back. */
! 750: resp = &u.reply;
! 751: if (NgRecvMsg(PIf->csock, resp, sizeof(u.buf), NULL) <= 0) {
! 752: Perror("[%s] Cannot get netgraph response", iface);
! 753: close(PIf->csock);
! 754: close(PIf->dsock);
! 755: return (0);
! 756: }
! 757:
! 758: hlist = (const struct hooklist *)resp->data;
! 759: ninfo = &hlist->nodeinfo;
! 760:
! 761: /* Make sure we've got the right type of node. */
! 762: if (strncmp(ninfo->type, NG_ETHER_NODE_TYPE,
! 763: sizeof(NG_ETHER_NODE_TYPE) - 1)) {
! 764: Log(LG_ERR, ("[%s] Unexpected node type ``%s'' (wanted ``"
! 765: NG_ETHER_NODE_TYPE "'') on %s",
! 766: iface, ninfo->type, path));
! 767: close(PIf->csock);
! 768: close(PIf->dsock);
! 769: return (0);
! 770: }
! 771:
! 772: /* Look for a hook already attached. */
! 773: for (f = 0; f < ninfo->hooks; f++) {
! 774: const struct linkinfo *nlink = &hlist->link[f];
! 775:
! 776: /* Search for "orphans" hook. */
! 777: if (strcmp(nlink->ourhook, NG_ETHER_HOOK_ORPHAN) &&
! 778: strcmp(nlink->ourhook, NG_ETHER_HOOK_DIVERT))
! 779: continue;
! 780:
! 781: /*
! 782: * Something is using the data coming out of this ``ether''
! 783: * node. If it's a PPPoE node, we use that node, otherwise
! 784: * we complain that someone else is using the node.
! 785: */
! 786: if (strcmp(nlink->nodeinfo.type, NG_PPPOE_NODE_TYPE)) {
! 787: Log(LG_ERR, ("%s Node type ``%s'' is currently "
! 788: " using orphan hook\n",
! 789: path, nlink->nodeinfo.type));
! 790: close(PIf->csock);
! 791: close(PIf->dsock);
! 792: return (0);
! 793: }
! 794: PIf->node_id = nlink->nodeinfo.id;
! 795: break;
! 796: }
! 797:
! 798: if (f == ninfo->hooks) {
! 799: struct ngm_mkpeer mp;
! 800: char path2[NG_PATHSIZ];
! 801:
! 802: /* Create new PPPoE node. */
! 803: memset(&mp, 0, sizeof(mp));
! 804: strcpy(mp.type, NG_PPPOE_NODE_TYPE);
! 805: strlcpy(mp.ourhook, hook, sizeof(mp.ourhook));
! 806: strcpy(mp.peerhook, NG_PPPOE_HOOK_ETHERNET);
! 807: if (NgSendMsg(PIf->csock, path, NGM_GENERIC_COOKIE, NGM_MKPEER, &mp,
! 808: sizeof(mp)) < 0) {
! 809: Perror("[%s] can't create %s peer to %s,%s",
! 810: iface, NG_PPPOE_NODE_TYPE, path, hook);
! 811: close(PIf->csock);
! 812: close(PIf->dsock);
! 813: return (0);
! 814: }
! 815:
! 816: snprintf(path2, sizeof(path2), "%s%s", path, hook);
! 817: /* Get pppoe node ID */
! 818: if ((PIf->node_id = NgGetNodeID(PIf->csock, path2)) == 0) {
! 819: Perror("[%s] Cannot get pppoe node id", iface);
! 820: close(PIf->csock);
! 821: close(PIf->dsock);
! 822: return (0);
! 823: };
! 824: };
! 825:
! 826: /* Register an event listening to the control and data sockets. */
! 827: EventRegister(&(PIf->ctrlEvent), EVENT_READ, PIf->csock,
! 828: EVENT_RECURRING, PppoeCtrlReadEvent, PIf);
! 829: EventRegister(&(PIf->dataEvent), EVENT_READ, PIf->dsock,
! 830: EVENT_RECURRING, PppoeListenEvent, PIf);
! 831:
! 832: return (1);
! 833: }
! 834:
! 835: /*
! 836: * Look for a tag of a specific type.
! 837: * Don't trust any length the other end says,
! 838: * but assume we already sanity checked ph->length.
! 839: */
! 840: static const struct pppoe_tag*
! 841: get_tag(const struct pppoe_hdr* ph, uint16_t idx)
! 842: {
! 843: const char *const end = ((const char *)(ph + 1))
! 844: + ntohs(ph->length);
! 845: const struct pppoe_tag *pt = (const void *)(ph + 1);
! 846: const char *ptn;
! 847:
! 848: /*
! 849: * Keep processing tags while a tag header will still fit.
! 850: */
! 851: while((const char*)(pt + 1) <= end) {
! 852: /*
! 853: * If the tag data would go past the end of the packet, abort.
! 854: */
! 855: ptn = (((const char *)(pt + 1)) + ntohs(pt->tag_len));
! 856: if (ptn > end)
! 857: return (NULL);
! 858: if (pt->tag_type == idx)
! 859: return (pt);
! 860:
! 861: pt = (const struct pppoe_tag*)ptn;
! 862: }
! 863:
! 864: return (NULL);
! 865: }
! 866:
! 867: static const struct pppoe_tag*
! 868: get_vs_tag(const struct pppoe_hdr* ph, uint32_t idx)
! 869: {
! 870: const char *const end = ((const char *)(ph + 1))
! 871: + ntohs(ph->length);
! 872: const struct pppoe_tag *pt = (const void *)(ph + 1);
! 873: const char *ptn;
! 874:
! 875: /*
! 876: * Keep processing tags while a tag header will still fit.
! 877: */
! 878: while((const char*)(pt + 1) <= end) {
! 879: /*
! 880: * If the tag data would go past the end of the packet, abort.
! 881: */
! 882: ptn = (((const char *)(pt + 1)) + ntohs(pt->tag_len));
! 883: if (ptn > end)
! 884: return (NULL);
! 885: if (pt->tag_type == PTT_VENDOR &&
! 886: ntohs(pt->tag_len) >= 4 &&
! 887: *(const uint32_t*)(pt + 1) == idx)
! 888: return (pt);
! 889:
! 890: pt = (const struct pppoe_tag*)ptn;
! 891: }
! 892:
! 893: return (NULL);
! 894: }
! 895:
! 896: static void
! 897: PppoeListenEvent(int type, void *arg)
! 898: {
! 899: int k, sz;
! 900: struct PppoeIf *PIf = (struct PppoeIf *)(arg);
! 901: char rhook[NG_HOOKSIZ];
! 902: unsigned char response[1024];
! 903:
! 904: char path[NG_PATHSIZ];
! 905: char path1[NG_PATHSIZ];
! 906: char session_hook[NG_HOOKSIZ];
! 907: char *session;
! 908: char real_session[MAX_SESSION];
! 909: char agent_cid[64];
! 910: char agent_rid[64];
! 911: struct ngm_connect cn;
! 912: struct ngm_mkpeer mp;
! 913: Link l = NULL;
! 914: PppoeInfo pi = NULL;
! 915: const struct pppoe_full_hdr *wh;
! 916: const struct pppoe_hdr *ph;
! 917: const struct pppoe_tag *tag;
! 918:
! 919: union {
! 920: u_char buf[sizeof(struct ngpppoe_init_data) + MAX_SESSION];
! 921: struct ngpppoe_init_data poeid;
! 922: } u;
! 923: struct ngpppoe_init_data *const idata = &u.poeid;
! 924:
! 925: switch (sz = NgRecvData(PIf->dsock, response, sizeof(response), rhook)) {
! 926: case -1:
! 927: Log(LG_ERR, ("NgRecvData: %d", sz));
! 928: return;
! 929: case 0:
! 930: Log(LG_ERR, ("NgRecvData: socket closed"));
! 931: return;
! 932: }
! 933:
! 934: if (strncmp(rhook, "listen-", 7)) {
! 935: Log(LG_ERR, ("PPPoE: data from unknown hook \"%s\"", rhook));
! 936: return;
! 937: }
! 938:
! 939: session = rhook + 7;
! 940:
! 941: if (sz < sizeof(struct pppoe_full_hdr)) {
! 942: Log(LG_PHYS, ("Incoming truncated PPPoE connection request via %s for "
! 943: "service \"%s\"", PIf->ifnodepath, session));
! 944: return;
! 945: }
! 946:
! 947: wh = (struct pppoe_full_hdr *)response;
! 948: ph = &wh->ph;
! 949: if ((tag = get_tag(ph, PTT_SRV_NAME))) {
! 950: int len = ntohs(tag->tag_len);
! 951: if (len >= sizeof(real_session))
! 952: len = sizeof(real_session)-1;
! 953: memcpy(real_session, tag + 1, len);
! 954: real_session[len] = 0;
! 955: } else {
! 956: strlcpy(real_session, session, sizeof(real_session));
! 957: }
! 958: bzero(agent_cid, sizeof(agent_cid));
! 959: bzero(agent_rid, sizeof(agent_rid));
! 960: if ((tag = get_vs_tag(ph, htonl(0x00000DE9)))) {
! 961: int len = ntohs(tag->tag_len) - 4, pos = 0;
! 962: const char *b = (const char *)(tag + 1) + 4;
! 963: while (pos + 1 <= len) {
! 964: int len1 = b[pos + 1];
! 965: if (len1 > len - pos - 2)
! 966: break;
! 967: if (len1 >= sizeof(agent_rid))
! 968: len1 = sizeof(agent_rid) - 1;
! 969: switch (b[pos]) {
! 970: case 1:
! 971: strncpy(agent_cid, &b[pos + 2], len1);
! 972: break;
! 973: case 2:
! 974: strncpy(agent_rid, &b[pos + 2], len1);
! 975: break;
! 976: }
! 977: pos += 2 + len1;
! 978: }
! 979: }
! 980: Log(LG_PHYS, ("Incoming PPPoE connection request via %s for "
! 981: "service \"%s\" from %s", PIf->ifnodepath, real_session,
! 982: ether_ntoa((struct ether_addr *)&wh->eh.ether_shost)));
! 983:
! 984: if (gShutdownInProgress) {
! 985: Log(LG_PHYS, ("Shutdown sequence in progress, ignoring request."));
! 986: return;
! 987: }
! 988:
! 989: if (OVERLOAD()) {
! 990: Log(LG_PHYS, ("Daemon overloaded, ignoring request."));
! 991: return;
! 992: }
! 993:
! 994: /* Examine all PPPoE links. */
! 995: for (k = 0; k < gNumLinks; k++) {
! 996: Link l2;
! 997: PppoeInfo pi2;
! 998:
! 999: if (!gLinks[k] || gLinks[k]->type != &gPppoePhysType)
! 1000: continue;
! 1001:
! 1002: l2 = gLinks[k];
! 1003: pi2 = (PppoeInfo)l2->info;
! 1004:
! 1005: if ((!PhysIsBusy(l2)) &&
! 1006: (pi2->PIf == PIf) &&
! 1007: (strcmp(pi2->session, session) == 0) &&
! 1008: Enabled(&l2->conf.options, LINK_CONF_INCOMING)) {
! 1009: l = l2;
! 1010: break;
! 1011: }
! 1012: }
! 1013:
! 1014: if (l != NULL && l->tmpl)
! 1015: l = LinkInst(l, NULL, 0, 0);
! 1016:
! 1017: if (l == NULL) {
! 1018: Log(LG_PHYS, ("No free PPPoE link with requested parameters "
! 1019: "was found"));
! 1020: return;
! 1021: }
! 1022: pi = (PppoeInfo)l->info;
! 1023:
! 1024: Log(LG_PHYS, ("[%s] Accepting PPPoE connection", l->name));
! 1025:
! 1026: /* Path to the ng_pppoe */
! 1027: snprintf(path, sizeof(path), "[%x]:", PIf->node_id);
! 1028:
! 1029: /* Name of ng_pppoe session hook */
! 1030: snprintf(session_hook, sizeof(session_hook), "mpd%d-%d",
! 1031: gPid, l->id);
! 1032:
! 1033: /* Create ng_tee(4) node and connect it to ng_pppoe(4). */
! 1034: memset(&mp, 0, sizeof(mp));
! 1035: strcpy(mp.type, NG_TEE_NODE_TYPE);
! 1036: strlcpy(mp.ourhook, session_hook, sizeof(mp.ourhook));
! 1037: snprintf(mp.peerhook, sizeof(mp.peerhook), "left");
! 1038: if (NgSendMsg(pi->PIf->csock, path, NGM_GENERIC_COOKIE, NGM_MKPEER,
! 1039: &mp, sizeof(mp)) < 0) {
! 1040: Perror("[%s] PPPoE: can't create %s peer to %s,%s",
! 1041: l->name, NG_TEE_NODE_TYPE, path, "left");
! 1042: goto close_socket;
! 1043: }
! 1044:
! 1045: /* Path to the ng_tee */
! 1046: snprintf(path1, sizeof(path), "%s%s", path, session_hook);
! 1047:
! 1048: /* Connect our socket node link hook to the ng_tee(4) node. */
! 1049: memset(&cn, 0, sizeof(cn));
! 1050: strlcpy(cn.ourhook, l->name, sizeof(cn.ourhook));
! 1051: strlcpy(cn.path, path1, sizeof(cn.path));
! 1052: strcpy(cn.peerhook, "left2right");
! 1053: if (NgSendMsg(pi->PIf->csock, ".:", NGM_GENERIC_COOKIE, NGM_CONNECT,
! 1054: &cn, sizeof(cn)) < 0) {
! 1055: Perror("[%s] PPPoE: can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\"",
! 1056: l->name, ".:", cn.ourhook, cn.path, cn.peerhook);
! 1057: goto shutdown_tee;
! 1058: }
! 1059:
! 1060: /* Put the PPPoE node into OFFER mode. */
! 1061: memset(idata, 0, sizeof(*idata));
! 1062: strlcpy(idata->hook, session_hook, sizeof(idata->hook));
! 1063: if (pi->acname[0] != 0) {
! 1064: strlcpy(idata->data, pi->acname, MAX_SESSION);
! 1065: } else {
! 1066: if (gethostname(idata->data, MAX_SESSION) == -1) {
! 1067: Log(LG_ERR, ("[%s] PPPoE: gethostname() failed",
! 1068: l->name));
! 1069: idata->data[0] = 0;
! 1070: }
! 1071: if (idata->data[0] == 0)
! 1072: strlcpy(idata->data, "NONAME", MAX_SESSION);
! 1073: }
! 1074: idata->data_len=strlen(idata->data);
! 1075:
! 1076: if (NgSendMsg(pi->PIf->csock, path, NGM_PPPOE_COOKIE, NGM_PPPOE_OFFER,
! 1077: idata, sizeof(*idata) + idata->data_len) < 0) {
! 1078: Perror("[%s] PPPoE: can't send NGM_PPPOE_OFFER to %s,%s ",
! 1079: l->name, path, idata->hook);
! 1080: goto shutdown_tee;
! 1081: }
! 1082:
! 1083: memset(idata, 0, sizeof(*idata));
! 1084: strlcpy(idata->hook, session_hook, sizeof(idata->hook));
! 1085: idata->data_len = strlen(pi->session);
! 1086: strncpy(idata->data, pi->session, MAX_SESSION);
! 1087:
! 1088: if (NgSendMsg(pi->PIf->csock, path, NGM_PPPOE_COOKIE,
! 1089: NGM_PPPOE_SERVICE, idata,
! 1090: sizeof(*idata) + idata->data_len) < 0) {
! 1091: Perror("[%s] PPPoE: can't send NGM_PPPOE_SERVICE to %s,%s",
! 1092: l->name, path, idata->hook);
! 1093: goto shutdown_tee;
! 1094: }
! 1095:
! 1096: /* And send our request data to the waiting node. */
! 1097: if (NgSendData(pi->PIf->dsock, l->name, response, sz) == -1) {
! 1098: Perror("[%s] PPPoE: Cannot send original request", l->name);
! 1099: goto shutdown_tee;
! 1100: }
! 1101:
! 1102: if (NgFuncDisconnect(pi->PIf->csock, l->name, ".:", l->name) < 0) {
! 1103: Perror("[%s] PPPoE: can't remove hook %s", l->name, l->name);
! 1104: goto shutdown_tee;
! 1105: }
! 1106: l->state = PHYS_STATE_CONNECTING;
! 1107: pi->incoming = 1;
! 1108: /* Record the peer's MAC address */
! 1109: memcpy(pi->peeraddr, wh->eh.ether_shost, 6);
! 1110: strlcpy(pi->real_session, real_session, sizeof(pi->real_session));
! 1111: strlcpy(pi->agent_cid, agent_cid, sizeof(pi->agent_cid));
! 1112: strlcpy(pi->agent_rid, agent_rid, sizeof(pi->agent_rid));
! 1113:
! 1114: Log(LG_PHYS2, ("[%s] PPPoE response sent", l->name));
! 1115:
! 1116: /* Set a timer to limit connection time. */
! 1117: TimerInit(&pi->connectTimer, "PPPoE-connect",
! 1118: PPPOE_CONNECT_TIMEOUT * SECONDS, PppoeConnectTimeout, l);
! 1119: TimerStart(&pi->connectTimer);
! 1120:
! 1121: PhysIncoming(l);
! 1122: return;
! 1123:
! 1124: shutdown_tee:
! 1125: if (NgFuncShutdownNode(pi->PIf->csock, l->name, path1) < 0) {
! 1126: Perror("[%s] Shutdown ng_tee node %s error", l->name, path1);
! 1127: };
! 1128:
! 1129: close_socket:
! 1130: Log(LG_PHYS, ("[%s] PPPoE connection not accepted due to error",
! 1131: l->name));
! 1132:
! 1133: /* If link is not static - shutdown it. */
! 1134: if (!l->stay)
! 1135: LinkShutdown(l);
! 1136: }
! 1137:
! 1138: /*
! 1139: * PppoeGetNode()
! 1140: */
! 1141:
! 1142: static void
! 1143: PppoeGetNode(Link l)
! 1144: {
! 1145: int i, j = -1, free = -1;
! 1146: PppoeInfo pi = (PppoeInfo)l->info;
! 1147:
! 1148: if (pi->PIf) // Do this only once for interface
! 1149: return;
! 1150:
! 1151: if (!strcmp(pi->path, "undefined:")) {
! 1152: Log(LG_ERR, ("[%s] PPPoE: Skipping link \"%s\" with undefined "
! 1153: "interface", l->name, l->name));
! 1154: return;
! 1155: }
! 1156:
! 1157: for (i = 0; i < PPPOE_MAXPARENTIFS; i++) {
! 1158: if (PppoeIfs[i].ifnodepath[0] == 0) {
! 1159: free = i;
! 1160: } else if (strcmp(PppoeIfs[i].ifnodepath, pi->path) == 0) {
! 1161: j = i;
! 1162: break;
! 1163: }
! 1164: }
! 1165: if (j == -1) {
! 1166: if (free == -1) {
! 1167: Log(LG_ERR, ("[%s] PPPoE: Too many different parent interfaces! ",
! 1168: l->name));
! 1169: return;
! 1170: }
! 1171: if (CreatePppoeNode(&PppoeIfs[free], pi->path, pi->hook)) {
! 1172: strlcpy(PppoeIfs[free].ifnodepath,
! 1173: pi->path,
! 1174: sizeof(PppoeIfs[free].ifnodepath));
! 1175: PppoeIfs[free].refs = 1;
! 1176: pi->PIf = &PppoeIfs[free];
! 1177: } else {
! 1178: Log(LG_ERR, ("[%s] PPPoE: Error creating ng_pppoe "
! 1179: "node on %s", l->name, pi->path));
! 1180: return;
! 1181: }
! 1182: } else {
! 1183: PppoeIfs[j].refs++;
! 1184: pi->PIf = &PppoeIfs[j];
! 1185: }
! 1186: }
! 1187:
! 1188: /*
! 1189: * PppoeReleaseNode()
! 1190: */
! 1191:
! 1192: static void
! 1193: PppoeReleaseNode(Link l)
! 1194: {
! 1195: PppoeInfo pi = (PppoeInfo)l->info;
! 1196:
! 1197: if (!pi->PIf) // Do this only once for interface
! 1198: return;
! 1199:
! 1200: pi->PIf->refs--;
! 1201: if (pi->PIf->refs == 0) {
! 1202: pi->PIf->ifnodepath[0] = 0;
! 1203: pi->PIf->node_id = 0;
! 1204: EventUnRegister(&pi->PIf->ctrlEvent);
! 1205: EventUnRegister(&pi->PIf->dataEvent);
! 1206: close(pi->PIf->csock);
! 1207: pi->PIf->csock = -1;
! 1208: close(pi->PIf->dsock);
! 1209: pi->PIf->dsock = -1;
! 1210: }
! 1211:
! 1212: pi->PIf = NULL;
! 1213: }
! 1214:
! 1215: static int
! 1216: PppoeListen(Link l)
! 1217: {
! 1218: PppoeInfo pi = (PppoeInfo)l->info;
! 1219: struct PppoeIf *PIf = pi->PIf;
! 1220: struct PppoeList *pl;
! 1221: union {
! 1222: u_char buf[sizeof(struct ngpppoe_init_data) + MAX_SESSION];
! 1223: struct ngpppoe_init_data poeid;
! 1224: } u;
! 1225: struct ngpppoe_init_data *const idata = &u.poeid;
! 1226: char path[NG_PATHSIZ];
! 1227: struct ngm_connect cn;
! 1228:
! 1229: if (pi->list || !pi->PIf)
! 1230: return(1); /* Do this only once */
! 1231:
! 1232: SLIST_FOREACH(pl, &pi->PIf->list, next) {
! 1233: if (strcmp(pl->session, pi->session) == 0)
! 1234: break;
! 1235: }
! 1236: if (pl) {
! 1237: pl->refs++;
! 1238: pi->list = pl;
! 1239: return (1);
! 1240: }
! 1241:
! 1242: pl = Malloc(MB_PHYS, sizeof(*pl));
! 1243: strlcpy(pl->session, pi->session, sizeof(pl->session));
! 1244: pl->refs = 1;
! 1245: pi->list = pl;
! 1246: SLIST_INSERT_HEAD(&pi->PIf->list, pl, next);
! 1247:
! 1248: snprintf(path, sizeof(path), "[%x]:", PIf->node_id);
! 1249:
! 1250: /* Connect our socket node link hook to the ng_pppoe(4) node. */
! 1251: memset(&cn, 0, sizeof(cn));
! 1252: strcpy(cn.path, path);
! 1253: snprintf(cn.ourhook, sizeof(cn.peerhook), "listen-%s", pi->session);
! 1254: strcpy(cn.peerhook, cn.ourhook);
! 1255:
! 1256: if (NgSendMsg(PIf->csock, ".:", NGM_GENERIC_COOKIE, NGM_CONNECT, &cn,
! 1257: sizeof(cn)) < 0) {
! 1258: Log(LG_ERR, ("PPPoE: Can't connect \"%s\"->\"%s\" and \"%s\"->\"%s\": %s",
! 1259: ".:", cn.ourhook, cn.path, cn.peerhook,
! 1260: strerror(errno)));
! 1261: return(0);
! 1262: }
! 1263:
! 1264: /* Tell the PPPoE node to be a server. */
! 1265: memset(idata, 0, sizeof(*idata));
! 1266: snprintf(idata->hook, sizeof(idata->hook), "listen-%s", pi->session);
! 1267: idata->data_len = strlen(pi->session);
! 1268: strncpy(idata->data, pi->session, MAX_SESSION);
! 1269:
! 1270: if (NgSendMsg(PIf->csock, path, NGM_PPPOE_COOKIE, NGM_PPPOE_LISTEN,
! 1271: idata, sizeof(*idata) + idata->data_len) < 0) {
! 1272: Perror("PPPoE: Can't send NGM_PPPOE_LISTEN to %s hook %s",
! 1273: path, idata->hook);
! 1274: return (0);
! 1275: }
! 1276:
! 1277: Log(LG_PHYS, ("PPPoE: waiting for connection on %s, service \"%s\"",
! 1278: PIf->ifnodepath, idata->data));
! 1279:
! 1280: return (1);
! 1281: }
! 1282:
! 1283: static int
! 1284: PppoeUnListen(Link l)
! 1285: {
! 1286: PppoeInfo pi = (PppoeInfo)l->info;
! 1287: struct PppoeIf *PIf = pi->PIf;
! 1288: char path[NG_PATHSIZ];
! 1289: char session_hook[NG_HOOKSIZ];
! 1290:
! 1291: if (!pi->list)
! 1292: return(1); /* Do this only once */
! 1293:
! 1294: pi->list->refs--;
! 1295:
! 1296: if (pi->list->refs == 0) {
! 1297:
! 1298: snprintf(path, sizeof(path), "[%x]:", pi->PIf->node_id);
! 1299: snprintf(session_hook, sizeof(session_hook), "listen-%s", pi->list->session);
! 1300: NgFuncDisconnect(pi->PIf->csock, l->name, path, session_hook);
! 1301:
! 1302: Log(LG_PHYS, ("PPPoE: stop waiting for connection on %s, service \"%s\"",
! 1303: PIf->ifnodepath, pi->list->session));
! 1304:
! 1305: SLIST_REMOVE(&PIf->list, pi->list, PppoeList, next);
! 1306: Freee(pi->list);
! 1307: }
! 1308:
! 1309: pi->list = NULL;
! 1310: return (1);
! 1311: }
! 1312:
! 1313: /*
! 1314: * PppoeNodeUpdate()
! 1315: */
! 1316:
! 1317: static void
! 1318: PppoeNodeUpdate(Link l)
! 1319: {
! 1320: PppoeInfo pi = (PppoeInfo)l->info;
! 1321: if (!pi->list) {
! 1322: if (Enabled(&l->conf.options, LINK_CONF_INCOMING)) {
! 1323: PppoeGetNode(l);
! 1324: PppoeListen(l);
! 1325: }
! 1326: } else {
! 1327: if (!Enabled(&l->conf.options, LINK_CONF_INCOMING)) {
! 1328: PppoeUnListen(l);
! 1329: if (l->state == PHYS_STATE_DOWN)
! 1330: PppoeReleaseNode(l);
! 1331: }
! 1332: }
! 1333: }
! 1334:
! 1335: /*
! 1336: * PppoeSetCommand()
! 1337: */
! 1338:
! 1339: static int
! 1340: PppoeSetCommand(Context ctx, int ac, char *av[], void *arg)
! 1341: {
! 1342: const PppoeInfo pi = (PppoeInfo) ctx->lnk->info;
! 1343: const char *hookname = ETHER_DEFAULT_HOOK;
! 1344: const char *colon;
! 1345:
! 1346: switch ((intptr_t)arg) {
! 1347: case SET_IFACE:
! 1348: switch (ac) {
! 1349: case 2:
! 1350: hookname = av[1];
! 1351: /* fall through */
! 1352: case 1:
! 1353: colon = (av[0][strlen(av[0]) - 1] == ':') ? "" : ":";
! 1354: snprintf(pi->path, sizeof(pi->path),
! 1355: "%s%s", av[0], colon);
! 1356: strlcpy(pi->hook, hookname, sizeof(pi->hook));
! 1357: break;
! 1358: default:
! 1359: return(-1);
! 1360: }
! 1361: if (pi->list) {
! 1362: PppoeUnListen(ctx->lnk);
! 1363: PppoeReleaseNode(ctx->lnk);
! 1364: PppoeGetNode(ctx->lnk);
! 1365: PppoeListen(ctx->lnk);
! 1366: }
! 1367: break;
! 1368: case SET_SESSION:
! 1369: if (ac != 1)
! 1370: return(-1);
! 1371: strlcpy(pi->session, av[0], sizeof(pi->session));
! 1372: if (pi->list) {
! 1373: PppoeUnListen(ctx->lnk);
! 1374: PppoeListen(ctx->lnk);
! 1375: }
! 1376: break;
! 1377: case SET_ACNAME:
! 1378: if (ac != 1)
! 1379: return(-1);
! 1380: strlcpy(pi->acname, av[0], sizeof(pi->acname));
! 1381: break;
! 1382: default:
! 1383: assert(0);
! 1384: }
! 1385: return(0);
! 1386: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pppoe.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src