ether.c revision 134833
152942Sbrian/*- 252942Sbrian * Copyright (c) 1999 Brian Somers <brian@Awfulhak.org> 352942Sbrian * All rights reserved. 452942Sbrian * 552942Sbrian * Redistribution and use in source and binary forms, with or without 652942Sbrian * modification, are permitted provided that the following conditions 752942Sbrian * are met: 852942Sbrian * 1. Redistributions of source code must retain the above copyright 952942Sbrian * notice, this list of conditions and the following disclaimer. 1052942Sbrian * 2. Redistributions in binary form must reproduce the above copyright 1152942Sbrian * notice, this list of conditions and the following disclaimer in the 1252942Sbrian * documentation and/or other materials provided with the distribution. 1352942Sbrian * 1452942Sbrian * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1552942Sbrian * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1652942Sbrian * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1752942Sbrian * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1852942Sbrian * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1952942Sbrian * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2052942Sbrian * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2152942Sbrian * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2252942Sbrian * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2352942Sbrian * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2452942Sbrian * SUCH DAMAGE. 2552942Sbrian * 2652942Sbrian * $FreeBSD: head/usr.sbin/ppp/ether.c 134833 2004-09-06 00:07:58Z marcel $ 2752942Sbrian */ 2852942Sbrian 2952942Sbrian#include <sys/param.h> 3052942Sbrian#include <sys/socket.h> 3152942Sbrian#include <sys/un.h> 3252942Sbrian#include <netinet/in.h> 3352942Sbrian#include <arpa/inet.h> 3452942Sbrian#include <netdb.h> 3552942Sbrian#include <netgraph.h> 3652942Sbrian#include <net/ethernet.h> 3774916Sbrian#include <net/if.h> 3874916Sbrian#include <net/route.h> 3952942Sbrian#include <netinet/in_systm.h> 4052942Sbrian#include <netinet/ip.h> 4152942Sbrian#include <netgraph/ng_ether.h> 4252942Sbrian#include <netgraph/ng_message.h> 4352942Sbrian#include <netgraph/ng_pppoe.h> 4452942Sbrian#include <netgraph/ng_socket.h> 4552942Sbrian 4652942Sbrian#include <errno.h> 4752942Sbrian#include <stdio.h> 4852942Sbrian#include <stdlib.h> 4952942Sbrian#include <string.h> 5052942Sbrian#include <sysexits.h> 5152942Sbrian#include <sys/fcntl.h> 5271006Sbrian#include <sys/stat.h> 5352942Sbrian#include <sys/uio.h> 5452942Sbrian#include <termios.h> 5552942Sbrian#include <sys/time.h> 5696582Sbrian#include <syslog.h> 5752942Sbrian#include <unistd.h> 5852942Sbrian 5952942Sbrian#include "layer.h" 6052942Sbrian#include "defs.h" 6152942Sbrian#include "mbuf.h" 6252942Sbrian#include "log.h" 6352942Sbrian#include "timer.h" 6452942Sbrian#include "lqr.h" 6552942Sbrian#include "hdlc.h" 6652942Sbrian#include "throughput.h" 6752942Sbrian#include "fsm.h" 6852942Sbrian#include "lcp.h" 6952942Sbrian#include "ccp.h" 7052942Sbrian#include "link.h" 7152942Sbrian#include "async.h" 7252942Sbrian#include "descriptor.h" 7352942Sbrian#include "physical.h" 7452942Sbrian#include "main.h" 7552942Sbrian#include "mp.h" 7652942Sbrian#include "chat.h" 7752942Sbrian#include "auth.h" 7852942Sbrian#include "chap.h" 7952942Sbrian#include "cbcp.h" 8052942Sbrian#include "datalink.h" 8152942Sbrian#include "slcompress.h" 8252942Sbrian#include "iplist.h" 8381634Sbrian#include "ncpaddr.h" 8481634Sbrian#include "ip.h" 8552942Sbrian#include "ipcp.h" 8652942Sbrian#include "filter.h" 8752942Sbrian#ifndef NORADIUS 8852942Sbrian#include "radius.h" 8952942Sbrian#endif 9081634Sbrian#include "ipv6cp.h" 9181634Sbrian#include "ncp.h" 9252942Sbrian#include "bundle.h" 9352942Sbrian#include "id.h" 9474916Sbrian#include "iface.h" 9596582Sbrian#include "route.h" 9652942Sbrian#include "ether.h" 9752942Sbrian 9852942Sbrian 9952942Sbrian#define PPPOE_NODE_TYPE_LEN (sizeof NG_PPPOE_NODE_TYPE - 1) /* "PPPoE" */ 10052942Sbrian 10152942Sbrianstruct etherdevice { 10252942Sbrian struct device dev; /* What struct physical knows about */ 10352942Sbrian int cs; /* Control socket */ 10452942Sbrian int connected; /* Are we connected yet ? */ 10552942Sbrian int timeout; /* Seconds attempting to connect */ 10652942Sbrian char hook[sizeof TUN_NAME + 11]; /* Our socket node hook */ 10796582Sbrian u_int32_t slot; /* ifindex << 24 | unit */ 10852942Sbrian}; 10952942Sbrian 11052942Sbrian#define device2ether(d) \ 11152942Sbrian ((d)->type == ETHER_DEVICE ? (struct etherdevice *)d : NULL) 11252942Sbrian 113134789Sbrianunsigned 11452942Sbrianether_DeviceSize(void) 11552942Sbrian{ 11652942Sbrian return sizeof(struct etherdevice); 11752942Sbrian} 11852942Sbrian 11952942Sbrianstatic ssize_t 12052942Sbrianether_Write(struct physical *p, const void *v, size_t n) 12152942Sbrian{ 12252942Sbrian struct etherdevice *dev = device2ether(p->handler); 12352942Sbrian 124134789Sbrian return NgSendData(p->fd, dev->hook, v, n) == -1 ? -1 : (ssize_t)n; 12552942Sbrian} 12652942Sbrian 12752942Sbrianstatic ssize_t 12852942Sbrianether_Read(struct physical *p, void *v, size_t n) 12952942Sbrian{ 13052942Sbrian char hook[sizeof TUN_NAME + 11]; 13152942Sbrian 13252942Sbrian return NgRecvData(p->fd, v, n, hook); 13352942Sbrian} 13452942Sbrian 13552942Sbrianstatic int 13652942Sbrianether_RemoveFromSet(struct physical *p, fd_set *r, fd_set *w, fd_set *e) 13752942Sbrian{ 13852942Sbrian struct etherdevice *dev = device2ether(p->handler); 13952942Sbrian int result; 14052942Sbrian 14152942Sbrian if (r && dev->cs >= 0 && FD_ISSET(dev->cs, r)) { 14252942Sbrian FD_CLR(dev->cs, r); 14352942Sbrian log_Printf(LogTIMER, "%s: fdunset(ctrl) %d\n", p->link.name, dev->cs); 14452942Sbrian result = 1; 14552942Sbrian } else 14652942Sbrian result = 0; 14752942Sbrian 14852942Sbrian /* Careful... physical_RemoveFromSet() called us ! */ 14952942Sbrian 15052942Sbrian p->handler->removefromset = NULL; 15152942Sbrian result += physical_RemoveFromSet(p, r, w, e); 15252942Sbrian p->handler->removefromset = ether_RemoveFromSet; 15352942Sbrian 15452942Sbrian return result; 15552942Sbrian} 15652942Sbrian 15752942Sbrianstatic void 15852942Sbrianether_Free(struct physical *p) 15952942Sbrian{ 16052942Sbrian struct etherdevice *dev = device2ether(p->handler); 16152942Sbrian 16252942Sbrian physical_SetDescriptor(p); 16352942Sbrian if (dev->cs != -1) 16452942Sbrian close(dev->cs); 16552942Sbrian free(dev); 16652942Sbrian} 16752942Sbrian 16852942Sbrianstatic const char * 16952942Sbrianether_OpenInfo(struct physical *p) 17052942Sbrian{ 17152942Sbrian struct etherdevice *dev = device2ether(p->handler); 17252942Sbrian 17352942Sbrian switch (dev->connected) { 17452942Sbrian case CARRIER_PENDING: 17552942Sbrian return "negotiating"; 17652942Sbrian case CARRIER_OK: 17752942Sbrian return "established"; 17852942Sbrian } 17952942Sbrian 18052942Sbrian return "disconnected"; 18152942Sbrian} 18252942Sbrian 18396582Sbrianstatic int 18496582Sbrianether_Slot(struct physical *p) 18596582Sbrian{ 18696582Sbrian struct etherdevice *dev = device2ether(p->handler); 18796582Sbrian 18896582Sbrian return dev->slot; 18996582Sbrian} 19096582Sbrian 19196582Sbrian 19252942Sbrianstatic void 19352942Sbrianether_device2iov(struct device *d, struct iovec *iov, int *niov, 194134789Sbrian int maxiov __unused, int *auxfd, int *nauxfd) 19552942Sbrian{ 19652942Sbrian struct etherdevice *dev = device2ether(d); 19752942Sbrian int sz = physical_MaxDeviceSize(); 19852942Sbrian 19952942Sbrian iov[*niov].iov_base = realloc(d, sz); 20052942Sbrian if (iov[*niov].iov_base == NULL) { 20152942Sbrian log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz); 20252942Sbrian AbortProgram(EX_OSERR); 20352942Sbrian } 20452942Sbrian iov[*niov].iov_len = sz; 20552942Sbrian (*niov)++; 20652942Sbrian 20752942Sbrian if (dev->cs >= 0) { 20852942Sbrian *auxfd = dev->cs; 20952942Sbrian (*nauxfd)++; 21052942Sbrian } 21152942Sbrian} 21252942Sbrian 21352942Sbrianstatic void 21452942Sbrianether_MessageIn(struct etherdevice *dev) 21552942Sbrian{ 21652942Sbrian char msgbuf[sizeof(struct ng_mesg) + sizeof(struct ngpppoe_sts)]; 21752942Sbrian struct ng_mesg *rep = (struct ng_mesg *)msgbuf; 21852942Sbrian struct ngpppoe_sts *sts = (struct ngpppoe_sts *)(msgbuf + sizeof *rep); 21996582Sbrian char *end, unknown[14], sessionid[5]; 22052942Sbrian const char *msg; 22152942Sbrian struct timeval t; 22266898Sbrian fd_set *r; 22396582Sbrian u_long slot; 22498638Sbrian int asciilen, ret; 22552942Sbrian 22652942Sbrian if (dev->cs < 0) 22752942Sbrian return; 22852942Sbrian 22966898Sbrian if ((r = mkfdset()) == NULL) { 23066898Sbrian log_Printf(LogERROR, "DoLoop: Cannot create fd_set\n"); 23166898Sbrian return; 23266898Sbrian } 23366898Sbrian 23499086Sbrian while (1) { 23599086Sbrian zerofdset(r); 23699086Sbrian FD_SET(dev->cs, r); 23799086Sbrian t.tv_sec = t.tv_usec = 0; 23899086Sbrian ret = select(dev->cs + 1, r, NULL, NULL, &t); 23952942Sbrian 24099086Sbrian if (ret <= 0) 24199086Sbrian break; 24252942Sbrian 24399086Sbrian if (NgRecvMsg(dev->cs, rep, sizeof msgbuf, NULL) <= 0) 24499086Sbrian break; 24552942Sbrian 24699086Sbrian if (rep->header.version != NG_VERSION) { 24799086Sbrian log_Printf(LogWARN, "%ld: Unexpected netgraph version, expected %ld\n", 24899086Sbrian (long)rep->header.version, (long)NG_VERSION); 24999086Sbrian break; 25099086Sbrian } 25152942Sbrian 25299086Sbrian if (rep->header.typecookie != NGM_PPPOE_COOKIE) { 25399086Sbrian log_Printf(LogWARN, "%ld: Unexpected netgraph cookie, expected %ld\n", 25499086Sbrian (long)rep->header.typecookie, (long)NGM_PPPOE_COOKIE); 25590975Sbrian break; 25699086Sbrian } 25752942Sbrian 25899086Sbrian asciilen = 0; 25999086Sbrian switch (rep->header.cmd) { 26099086Sbrian case NGM_PPPOE_SET_FLAG: msg = "SET_FLAG"; break; 26199086Sbrian case NGM_PPPOE_CONNECT: msg = "CONNECT"; break; 26299086Sbrian case NGM_PPPOE_LISTEN: msg = "LISTEN"; break; 26399086Sbrian case NGM_PPPOE_OFFER: msg = "OFFER"; break; 26499086Sbrian case NGM_PPPOE_SUCCESS: msg = "SUCCESS"; break; 26599086Sbrian case NGM_PPPOE_FAIL: msg = "FAIL"; break; 26699086Sbrian case NGM_PPPOE_CLOSE: msg = "CLOSE"; break; 26799086Sbrian case NGM_PPPOE_GET_STATUS: msg = "GET_STATUS"; break; 26899086Sbrian case NGM_PPPOE_ACNAME: 26999086Sbrian msg = "ACNAME"; 27099086Sbrian if (setenv("ACNAME", sts->hook, 1) != 0) 27199086Sbrian log_Printf(LogWARN, "setenv: cannot set ACNAME=%s: %m", sts->hook); 27299086Sbrian asciilen = rep->header.arglen; 27399086Sbrian break; 27499086Sbrian case NGM_PPPOE_SESSIONID: 27599086Sbrian msg = "SESSIONID"; 27699086Sbrian snprintf(sessionid, sizeof sessionid, "%04x", *(u_int16_t *)sts); 27799086Sbrian if (setenv("SESSIONID", sessionid, 1) != 0) 27899086Sbrian syslog(LOG_WARNING, "setenv: cannot set SESSIONID=%s: %m", 27999086Sbrian sessionid); 28099086Sbrian /* Use this in preference to our interface index */ 28199086Sbrian slot = strtoul(sessionid, &end, 16); 28299086Sbrian if (end != sessionid && *end == '\0') 28399086Sbrian dev->slot = slot; 28499086Sbrian break; 28599086Sbrian default: 28699086Sbrian snprintf(unknown, sizeof unknown, "<%d>", (int)rep->header.cmd); 28799086Sbrian msg = unknown; 28899086Sbrian break; 28999086Sbrian } 29052942Sbrian 29199086Sbrian if (asciilen) 29299086Sbrian log_Printf(LogPHASE, "Received NGM_PPPOE_%s (hook \"%.*s\")\n", 29399086Sbrian msg, asciilen, sts->hook); 29499086Sbrian else 29599086Sbrian log_Printf(LogPHASE, "Received NGM_PPPOE_%s\n", msg); 29699086Sbrian 29799086Sbrian switch (rep->header.cmd) { 29899086Sbrian case NGM_PPPOE_SUCCESS: 29999086Sbrian dev->connected = CARRIER_OK; 30099086Sbrian break; 30199086Sbrian case NGM_PPPOE_FAIL: 30299086Sbrian case NGM_PPPOE_CLOSE: 30399086Sbrian dev->connected = CARRIER_LOST; 30499086Sbrian break; 30599086Sbrian } 30652942Sbrian } 30799086Sbrian free(r); 30852942Sbrian} 30952942Sbrian 31052942Sbrianstatic int 31152942Sbrianether_AwaitCarrier(struct physical *p) 31252942Sbrian{ 31352942Sbrian struct etherdevice *dev = device2ether(p->handler); 31452942Sbrian 31553071Sbrian if (dev->connected != CARRIER_OK && !dev->timeout--) 31652942Sbrian dev->connected = CARRIER_LOST; 31752942Sbrian else if (dev->connected == CARRIER_PENDING) 31852942Sbrian ether_MessageIn(dev); 31952942Sbrian 32052942Sbrian return dev->connected; 32152942Sbrian} 32252942Sbrian 32352942Sbrianstatic const struct device baseetherdevice = { 32452942Sbrian ETHER_DEVICE, 32552942Sbrian "ether", 32678410Sbrian 1492, 32753733Sbrian { CD_REQUIRED, DEF_ETHERCDDELAY }, 32852942Sbrian ether_AwaitCarrier, 32952942Sbrian ether_RemoveFromSet, 33052942Sbrian NULL, 33152942Sbrian NULL, 33252942Sbrian NULL, 33352942Sbrian NULL, 33493418Sbrian NULL, 33552942Sbrian ether_Free, 33652942Sbrian ether_Read, 33752942Sbrian ether_Write, 33852942Sbrian ether_device2iov, 33952942Sbrian NULL, 34096582Sbrian ether_OpenInfo, 34196582Sbrian ether_Slot 34252942Sbrian}; 34352942Sbrian 34452942Sbrianstruct device * 34552942Sbrianether_iov2device(int type, struct physical *p, struct iovec *iov, int *niov, 346134789Sbrian int maxiov __unused, int *auxfd, int *nauxfd) 34752942Sbrian{ 34852942Sbrian if (type == ETHER_DEVICE) { 34952942Sbrian struct etherdevice *dev = (struct etherdevice *)iov[(*niov)++].iov_base; 35052942Sbrian 35152942Sbrian dev = realloc(dev, sizeof *dev); /* Reduce to the correct size */ 35252942Sbrian if (dev == NULL) { 35352942Sbrian log_Printf(LogALERT, "Failed to allocate memory: %d\n", 35452942Sbrian (int)(sizeof *dev)); 35552942Sbrian AbortProgram(EX_OSERR); 35652942Sbrian } 35752942Sbrian 35852942Sbrian if (*nauxfd) { 35952942Sbrian dev->cs = *auxfd; 36052942Sbrian (*nauxfd)--; 36152942Sbrian } else 36252942Sbrian dev->cs = -1; 36352942Sbrian 36452942Sbrian /* Refresh function pointers etc */ 36552942Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 36652942Sbrian 36752942Sbrian physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNCNOACF); 36852942Sbrian return &dev->dev; 36952942Sbrian } 37052942Sbrian 37152942Sbrian return NULL; 37252942Sbrian} 37352942Sbrian 37452942Sbrianstatic int 37558028Sbrianether_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 37652942Sbrian{ 37752942Sbrian struct physical *p = descriptor2physical(d); 37852942Sbrian struct etherdevice *dev = device2ether(p->handler); 37952942Sbrian int result; 38052942Sbrian 38152942Sbrian if (r && dev->cs >= 0) { 38252942Sbrian FD_SET(dev->cs, r); 38352942Sbrian log_Printf(LogTIMER, "%s(ctrl): fdset(r) %d\n", p->link.name, dev->cs); 38452942Sbrian result = 1; 38552942Sbrian } else 38652942Sbrian result = 0; 38752942Sbrian 38852942Sbrian result += physical_doUpdateSet(d, r, w, e, n, 0); 38952942Sbrian 39052942Sbrian return result; 39152942Sbrian} 39252942Sbrian 39352942Sbrianstatic int 39458028Sbrianether_IsSet(struct fdescriptor *d, const fd_set *fdset) 39552942Sbrian{ 39652942Sbrian struct physical *p = descriptor2physical(d); 39752942Sbrian struct etherdevice *dev = device2ether(p->handler); 39852942Sbrian int result; 39952942Sbrian 40052942Sbrian result = dev->cs >= 0 && FD_ISSET(dev->cs, fdset); 40152942Sbrian result += physical_IsSet(d, fdset); 40252942Sbrian 40352942Sbrian return result; 40452942Sbrian} 40552942Sbrian 40652942Sbrianstatic void 40758028Sbrianether_DescriptorRead(struct fdescriptor *d, struct bundle *bundle, 40852942Sbrian const fd_set *fdset) 40952942Sbrian{ 41052942Sbrian struct physical *p = descriptor2physical(d); 41152942Sbrian struct etherdevice *dev = device2ether(p->handler); 41252942Sbrian 41352942Sbrian if (dev->cs >= 0 && FD_ISSET(dev->cs, fdset)) { 41452942Sbrian ether_MessageIn(dev); 41552942Sbrian if (dev->connected == CARRIER_LOST) { 41652942Sbrian log_Printf(LogPHASE, "%s: Device disconnected\n", p->link.name); 41752942Sbrian datalink_Down(p->dl, CLOSE_NORMAL); 41852942Sbrian return; 41952942Sbrian } 42052942Sbrian } 42152942Sbrian 42252942Sbrian if (physical_IsSet(d, fdset)) 42352942Sbrian physical_DescriptorRead(d, bundle, fdset); 42452942Sbrian} 42552942Sbrian 42652942Sbrianstatic struct device * 42752942Sbrianether_Abandon(struct etherdevice *dev, struct physical *p) 42852942Sbrian{ 42952942Sbrian /* Abandon our node construction */ 43052942Sbrian close(dev->cs); 43152942Sbrian close(p->fd); 43252942Sbrian p->fd = -2; /* Nobody else need try.. */ 43352942Sbrian free(dev); 43452942Sbrian 43552942Sbrian return NULL; 43652942Sbrian} 43752942Sbrian 43852942Sbrianstruct device * 43952942Sbrianether_Create(struct physical *p) 44052942Sbrian{ 44152942Sbrian u_char rbuf[2048]; 44252942Sbrian struct etherdevice *dev; 44352942Sbrian struct ng_mesg *resp; 44452942Sbrian const struct hooklist *hlist; 44552942Sbrian const struct nodeinfo *ninfo; 446134789Sbrian char *path, *sessionid; 447134789Sbrian const char *mode; 448134789Sbrian size_t ifacelen; 449134789Sbrian unsigned f; 45052942Sbrian 45152942Sbrian dev = NULL; 45274916Sbrian path = NULL; 45374916Sbrian ifacelen = 0; 45452942Sbrian if (p->fd < 0 && !strncasecmp(p->name.full, NG_PPPOE_NODE_TYPE, 45552942Sbrian PPPOE_NODE_TYPE_LEN) && 45652942Sbrian p->name.full[PPPOE_NODE_TYPE_LEN] == ':') { 45752942Sbrian const struct linkinfo *nlink; 45852942Sbrian struct ngpppoe_init_data *data; 45952942Sbrian struct ngm_mkpeer mkp; 46052942Sbrian struct ngm_connect ngc; 46152942Sbrian const char *iface, *provider; 46274916Sbrian char etherid[12]; 46374916Sbrian int providerlen; 46452942Sbrian char connectpath[sizeof dev->hook + 2]; /* .:<hook> */ 46552942Sbrian 46652942Sbrian p->fd--; /* We own the device - change fd */ 46752942Sbrian 46893418Sbrian loadmodules(LOAD_VERBOSLY, "netgraph", "ng_ether", "ng_pppoe", "ng_socket", 46993418Sbrian NULL); 47052942Sbrian 47152942Sbrian if ((dev = malloc(sizeof *dev)) == NULL) 47252942Sbrian return NULL; 47352942Sbrian 47452942Sbrian iface = p->name.full + PPPOE_NODE_TYPE_LEN + 1; 47552942Sbrian 47652942Sbrian provider = strchr(iface, ':'); 47752942Sbrian if (provider) { 47852942Sbrian ifacelen = provider - iface; 47952942Sbrian provider++; 48052942Sbrian providerlen = strlen(provider); 48152942Sbrian } else { 48252942Sbrian ifacelen = strlen(iface); 48352942Sbrian provider = ""; 48452942Sbrian providerlen = 0; 48552942Sbrian } 48652942Sbrian 48752942Sbrian /* 48852942Sbrian * We're going to do this (where tunN is our tunnel device): 48952942Sbrian * 49052942Sbrian * .---------. 49152942Sbrian * | ether | 49252942Sbrian * | <iface> | dev->cs 49352942Sbrian * `---------' | 49452942Sbrian * (orphan) p->fd | 49552942Sbrian * | | | 49652942Sbrian * | | | 49752942Sbrian * (ethernet) | | 49852942Sbrian * .---------. .-----------. 49952942Sbrian * | pppoe | | socket | 50052942Sbrian * | <iface> |(tunN)<---->(tunN)| <unnamed> | 50152942Sbrian * `--------- `-----------' 50252942Sbrian * (tunX) 50352942Sbrian * ^ 50452942Sbrian * | 50552942Sbrian * `--->(tunX) 50652942Sbrian */ 50752942Sbrian 50852942Sbrian /* Create a socket node */ 50953535Sbrian if (ID0NgMkSockNode(NULL, &dev->cs, &p->fd) == -1) { 51052942Sbrian log_Printf(LogWARN, "Cannot create netgraph socket node: %s\n", 51152942Sbrian strerror(errno)); 51252942Sbrian free(dev); 51393418Sbrian p->fd = -2; 51452942Sbrian return NULL; 51552942Sbrian } 51652942Sbrian 51752942Sbrian /* 51852942Sbrian * Ask for a list of hooks attached to the "ether" node. This node should 51952942Sbrian * magically exist as a way of hooking stuff onto an ethernet device 52052942Sbrian */ 52152942Sbrian path = (char *)alloca(ifacelen + 2); 522134833Smarcel sprintf(path, "%.*s:", (int)ifacelen, iface); 52352942Sbrian if (NgSendMsg(dev->cs, path, NGM_GENERIC_COOKIE, NGM_LISTHOOKS, 52452942Sbrian NULL, 0) < 0) { 52552942Sbrian log_Printf(LogWARN, "%s Cannot send a netgraph message: %s\n", 52652942Sbrian path, strerror(errno)); 52752942Sbrian return ether_Abandon(dev, p); 52852942Sbrian } 52952942Sbrian 53052942Sbrian /* Get our list back */ 53152942Sbrian resp = (struct ng_mesg *)rbuf; 53282277Sbrian if (NgRecvMsg(dev->cs, resp, sizeof rbuf, NULL) <= 0) { 53352942Sbrian log_Printf(LogWARN, "Cannot get netgraph response: %s\n", 53452942Sbrian strerror(errno)); 53552942Sbrian return ether_Abandon(dev, p); 53652942Sbrian } 53752942Sbrian 53852942Sbrian hlist = (const struct hooklist *)resp->data; 53952942Sbrian ninfo = &hlist->nodeinfo; 54052942Sbrian 54152942Sbrian /* Make sure we've got the right type of node */ 54252942Sbrian if (strncmp(ninfo->type, NG_ETHER_NODE_TYPE, 54352942Sbrian sizeof NG_ETHER_NODE_TYPE - 1)) { 54452942Sbrian log_Printf(LogWARN, "%s Unexpected node type ``%s'' (wanted ``" 54552942Sbrian NG_ETHER_NODE_TYPE "'')\n", path, ninfo->type); 54652942Sbrian return ether_Abandon(dev, p); 54752942Sbrian } 54852942Sbrian 54952963Sbrian log_Printf(LogDEBUG, "List of netgraph node ``%s'' (id %x) hooks:\n", 55052942Sbrian path, ninfo->id); 55152942Sbrian 55252942Sbrian /* look for a hook already attached. */ 55352942Sbrian for (f = 0; f < ninfo->hooks; f++) { 55452942Sbrian nlink = &hlist->link[f]; 55552942Sbrian 55652942Sbrian log_Printf(LogDEBUG, " Found %s -> %s\n", nlink->ourhook, 55752942Sbrian nlink->peerhook); 55852942Sbrian 55952942Sbrian if (!strcmp(nlink->ourhook, NG_ETHER_HOOK_ORPHAN) || 56052942Sbrian !strcmp(nlink->ourhook, NG_ETHER_HOOK_DIVERT)) { 56152942Sbrian /* 56252942Sbrian * Something is using the data coming out of this ``ether'' node. 56352942Sbrian * If it's a PPPoE node, we use that node, otherwise we complain that 56452942Sbrian * someone else is using the node. 56552942Sbrian */ 56652942Sbrian if (!strcmp(nlink->nodeinfo.type, NG_PPPOE_NODE_TYPE)) 56752942Sbrian /* Use this PPPoE node ! */ 56852963Sbrian snprintf(ngc.path, sizeof ngc.path, "[%x]:", nlink->nodeinfo.id); 56952942Sbrian else { 57052942Sbrian log_Printf(LogWARN, "%s Node type ``%s'' is currently active\n", 57152942Sbrian path, nlink->nodeinfo.type); 57252942Sbrian return ether_Abandon(dev, p); 57352942Sbrian } 57452942Sbrian break; 57552942Sbrian } 57652942Sbrian } 57752942Sbrian 57852942Sbrian if (f == ninfo->hooks) { 57952942Sbrian /* 58052942Sbrian * Create a new ``PPPoE'' node connected to the ``ether'' node using 58193418Sbrian * the ``orphan'' and ``ethernet'' hooks 58252942Sbrian */ 58352942Sbrian snprintf(mkp.type, sizeof mkp.type, "%s", NG_PPPOE_NODE_TYPE); 58452942Sbrian snprintf(mkp.ourhook, sizeof mkp.ourhook, "%s", NG_ETHER_HOOK_ORPHAN); 58552942Sbrian snprintf(mkp.peerhook, sizeof mkp.peerhook, "%s", NG_PPPOE_HOOK_ETHERNET); 58652963Sbrian snprintf(etherid, sizeof etherid, "[%x]:", ninfo->id); 58752942Sbrian 58852942Sbrian log_Printf(LogDEBUG, "Creating PPPoE netgraph node %s%s -> %s\n", 58952942Sbrian etherid, mkp.ourhook, mkp.peerhook); 59052942Sbrian 59152942Sbrian if (NgSendMsg(dev->cs, etherid, NGM_GENERIC_COOKIE, 59252942Sbrian NGM_MKPEER, &mkp, sizeof mkp) < 0) { 59352942Sbrian log_Printf(LogWARN, "%s Cannot create PPPoE netgraph node: %s\n", 59452942Sbrian etherid, strerror(errno)); 59552942Sbrian return ether_Abandon(dev, p); 59652942Sbrian } 59752942Sbrian 59852942Sbrian snprintf(ngc.path, sizeof ngc.path, "%s%s", path, NG_ETHER_HOOK_ORPHAN); 59952942Sbrian } 60052942Sbrian 60152942Sbrian snprintf(dev->hook, sizeof dev->hook, "%s%d", 60252942Sbrian TUN_NAME, p->dl->bundle->unit); 60352942Sbrian 60452942Sbrian /* 60552942Sbrian * Connect the PPPoE node to our socket node. 60652942Sbrian * ngc.path has already been set up 60752942Sbrian */ 60852942Sbrian snprintf(ngc.ourhook, sizeof ngc.ourhook, "%s", dev->hook); 60952942Sbrian memcpy(ngc.peerhook, ngc.ourhook, sizeof ngc.peerhook); 61052942Sbrian 61152942Sbrian log_Printf(LogDEBUG, "Connecting netgraph socket .:%s -> %s:%s\n", 61252942Sbrian ngc.ourhook, ngc.path, ngc.peerhook); 61352942Sbrian if (NgSendMsg(dev->cs, ".:", NGM_GENERIC_COOKIE, 61452942Sbrian NGM_CONNECT, &ngc, sizeof ngc) < 0) { 61552942Sbrian log_Printf(LogWARN, "Cannot connect PPPoE and socket netgraph " 61652942Sbrian "nodes: %s\n", strerror(errno)); 61752942Sbrian return ether_Abandon(dev, p); 61852942Sbrian } 61952942Sbrian 62079854Sbrian /* Bring the Ethernet interface up */ 62179854Sbrian path[ifacelen] = '\0'; /* Remove the trailing ':' */ 62279854Sbrian if (!iface_SetFlags(path, IFF_UP)) 62379854Sbrian log_Printf(LogWARN, "%s: Failed to set the IFF_UP flag on %s\n", 62479854Sbrian p->link.name, path); 62579854Sbrian 626132818Sglebius snprintf(connectpath, sizeof connectpath, ".:%s", dev->hook); 627132818Sglebius 628132818Sglebius /* Configure node to 3Com mode if needed */ 629132818Sglebius if (p->cfg.pppoe_configured) { 630132818Sglebius mode = p->cfg.nonstandard_pppoe ? NG_PPPOE_NONSTANDARD : NG_PPPOE_STANDARD; 631132818Sglebius if (NgSendMsg(dev->cs, connectpath, NGM_PPPOE_COOKIE, 632132818Sglebius NGM_PPPOE_SETMODE, mode, strlen(mode) + 1) == -1) { 633132818Sglebius log_Printf(LogWARN, "``%s'': Cannot configure netgraph node: %s\n", 634132818Sglebius connectpath, strerror(errno)); 635132818Sglebius return ether_Abandon(dev, p); 636132818Sglebius } 637132818Sglebius } 638132818Sglebius 63952942Sbrian /* And finally, request a connection to the given provider */ 64052942Sbrian 64168032Sbrian data = (struct ngpppoe_init_data *)alloca(sizeof *data + providerlen); 64252942Sbrian snprintf(data->hook, sizeof data->hook, "%s", dev->hook); 64368846Sbrian memcpy(data->data, provider, providerlen); 64468846Sbrian data->data_len = providerlen; 64552942Sbrian 64652942Sbrian log_Printf(LogDEBUG, "Sending PPPOE_CONNECT to %s\n", connectpath); 64752942Sbrian if (NgSendMsg(dev->cs, connectpath, NGM_PPPOE_COOKIE, 64852942Sbrian NGM_PPPOE_CONNECT, data, sizeof *data + providerlen) == -1) { 64952942Sbrian log_Printf(LogWARN, "``%s'': Cannot start netgraph node: %s\n", 65052942Sbrian connectpath, strerror(errno)); 65152942Sbrian return ether_Abandon(dev, p); 65252942Sbrian } 65352942Sbrian 65453062Sbrian /* Hook things up so that we monitor dev->cs */ 65553062Sbrian p->desc.UpdateSet = ether_UpdateSet; 65653062Sbrian p->desc.IsSet = ether_IsSet; 65753062Sbrian p->desc.Read = ether_DescriptorRead; 65853733Sbrian 65953733Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 66053733Sbrian switch (p->cfg.cd.necessity) { 66153733Sbrian case CD_VARIABLE: 66253733Sbrian dev->dev.cd.delay = p->cfg.cd.delay; 66353733Sbrian break; 66453733Sbrian case CD_REQUIRED: 66553733Sbrian dev->dev.cd = p->cfg.cd; 66653733Sbrian break; 66753733Sbrian case CD_NOTREQUIRED: 66853733Sbrian log_Printf(LogWARN, "%s: Carrier must be set, using ``set cd %d!''\n", 66953733Sbrian p->link.name, dev->dev.cd.delay); 67053733Sbrian case CD_DEFAULT: 67153733Sbrian break; 67253733Sbrian } 67353733Sbrian 67453733Sbrian dev->timeout = dev->dev.cd.delay; 67553733Sbrian dev->connected = CARRIER_PENDING; 67696582Sbrian /* This will be overridden by our session id - if provided by netgraph */ 67796582Sbrian dev->slot = GetIfIndex(path); 67852942Sbrian } else { 67952942Sbrian /* See if we're a netgraph socket */ 68071006Sbrian struct stat st; 68152942Sbrian 68271006Sbrian if (fstat(p->fd, &st) != -1 && (st.st_mode & S_IFSOCK)) { 68371006Sbrian struct sockaddr_storage ssock; 68471006Sbrian struct sockaddr *sock = (struct sockaddr *)&ssock; 68571006Sbrian int sz; 68652942Sbrian 68771006Sbrian sz = sizeof ssock; 68871006Sbrian if (getsockname(p->fd, sock, &sz) == -1) { 68971006Sbrian log_Printf(LogPHASE, "%s: Link is a closed socket !\n", p->link.name); 69071006Sbrian close(p->fd); 69171006Sbrian p->fd = -1; 69252942Sbrian return NULL; 69352942Sbrian } 69452942Sbrian 69571006Sbrian if (sock->sa_family == AF_NETGRAPH) { 69671006Sbrian /* 69771006Sbrian * It's a netgraph node... We can't determine hook names etc, so we 69871006Sbrian * stay pretty impartial.... 69971006Sbrian */ 70071006Sbrian log_Printf(LogPHASE, "%s: Link is a netgraph node\n", p->link.name); 70171006Sbrian 70271006Sbrian if ((dev = malloc(sizeof *dev)) == NULL) { 70371006Sbrian log_Printf(LogWARN, "%s: Cannot allocate an ether device: %s\n", 70471006Sbrian p->link.name, strerror(errno)); 70571006Sbrian return NULL; 70671006Sbrian } 70771006Sbrian 70871006Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 70971006Sbrian dev->cs = -1; 71071006Sbrian dev->timeout = 0; 71171006Sbrian dev->connected = CARRIER_OK; 71271006Sbrian *dev->hook = '\0'; 71396582Sbrian 71496582Sbrian /* 71596582Sbrian * If we're being envoked from pppoed(8), we may have a SESSIONID 71696582Sbrian * set in the environment. If so, use it as the slot 71796582Sbrian */ 71896582Sbrian if ((sessionid = getenv("SESSIONID")) != NULL) { 71996582Sbrian char *end; 72096582Sbrian u_long slot; 72196582Sbrian 72296582Sbrian slot = strtoul(sessionid, &end, 16); 72396582Sbrian dev->slot = end != sessionid && *end == '\0' ? slot : 0; 72496582Sbrian } else 72596582Sbrian dev->slot = 0; 72671006Sbrian } 72752942Sbrian } 72852942Sbrian } 72952942Sbrian 73052942Sbrian if (dev) { 73152942Sbrian physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNCNOACF); 73252942Sbrian return &dev->dev; 73352942Sbrian } 73452942Sbrian 73552942Sbrian return NULL; 73652942Sbrian} 737