ether.c revision 90975
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 90975 2002-02-20 15:52:20Z brian $ 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> 5252942Sbrian#if defined(__FreeBSD__) && !defined(NOKLDLOAD) 5352942Sbrian#include <sys/linker.h> 5453241Sbrian#include <sys/module.h> 5552942Sbrian#endif 5671006Sbrian#include <sys/stat.h> 5752942Sbrian#include <sys/uio.h> 5852942Sbrian#include <termios.h> 5952942Sbrian#include <sys/time.h> 6052942Sbrian#include <unistd.h> 6152942Sbrian 6252942Sbrian#include "layer.h" 6352942Sbrian#include "defs.h" 6452942Sbrian#include "mbuf.h" 6552942Sbrian#include "log.h" 6652942Sbrian#include "timer.h" 6752942Sbrian#include "lqr.h" 6852942Sbrian#include "hdlc.h" 6952942Sbrian#include "throughput.h" 7052942Sbrian#include "fsm.h" 7152942Sbrian#include "lcp.h" 7252942Sbrian#include "ccp.h" 7352942Sbrian#include "link.h" 7452942Sbrian#include "async.h" 7552942Sbrian#include "descriptor.h" 7652942Sbrian#include "physical.h" 7752942Sbrian#include "main.h" 7852942Sbrian#include "mp.h" 7952942Sbrian#include "chat.h" 8052942Sbrian#include "auth.h" 8152942Sbrian#include "chap.h" 8252942Sbrian#include "cbcp.h" 8352942Sbrian#include "datalink.h" 8452942Sbrian#include "slcompress.h" 8552942Sbrian#include "iplist.h" 8681634Sbrian#include "ncpaddr.h" 8781634Sbrian#include "ip.h" 8852942Sbrian#include "ipcp.h" 8952942Sbrian#include "filter.h" 9052942Sbrian#ifndef NORADIUS 9152942Sbrian#include "radius.h" 9252942Sbrian#endif 9381634Sbrian#include "ipv6cp.h" 9481634Sbrian#include "ncp.h" 9552942Sbrian#include "bundle.h" 9652942Sbrian#include "id.h" 9774916Sbrian#include "iface.h" 9852942Sbrian#include "ether.h" 9952942Sbrian 10052942Sbrian 10152942Sbrian#define PPPOE_NODE_TYPE_LEN (sizeof NG_PPPOE_NODE_TYPE - 1) /* "PPPoE" */ 10252942Sbrian 10352942Sbrianstruct etherdevice { 10452942Sbrian struct device dev; /* What struct physical knows about */ 10552942Sbrian int cs; /* Control socket */ 10652942Sbrian int connected; /* Are we connected yet ? */ 10752942Sbrian int timeout; /* Seconds attempting to connect */ 10852942Sbrian char hook[sizeof TUN_NAME + 11]; /* Our socket node hook */ 10952942Sbrian}; 11052942Sbrian 11152942Sbrian#define device2ether(d) \ 11252942Sbrian ((d)->type == ETHER_DEVICE ? (struct etherdevice *)d : NULL) 11352942Sbrian 11452942Sbrianint 11552942Sbrianether_DeviceSize(void) 11652942Sbrian{ 11752942Sbrian return sizeof(struct etherdevice); 11852942Sbrian} 11952942Sbrian 12052942Sbrianstatic ssize_t 12152942Sbrianether_Write(struct physical *p, const void *v, size_t n) 12252942Sbrian{ 12352942Sbrian struct etherdevice *dev = device2ether(p->handler); 12452942Sbrian 12552942Sbrian return NgSendData(p->fd, dev->hook, v, n) == -1 ? -1 : n; 12652942Sbrian} 12752942Sbrian 12852942Sbrianstatic ssize_t 12952942Sbrianether_Read(struct physical *p, void *v, size_t n) 13052942Sbrian{ 13152942Sbrian char hook[sizeof TUN_NAME + 11]; 13252942Sbrian 13352942Sbrian return NgRecvData(p->fd, v, n, hook); 13452942Sbrian} 13552942Sbrian 13652942Sbrianstatic int 13752942Sbrianether_RemoveFromSet(struct physical *p, fd_set *r, fd_set *w, fd_set *e) 13852942Sbrian{ 13952942Sbrian struct etherdevice *dev = device2ether(p->handler); 14052942Sbrian int result; 14152942Sbrian 14252942Sbrian if (r && dev->cs >= 0 && FD_ISSET(dev->cs, r)) { 14352942Sbrian FD_CLR(dev->cs, r); 14452942Sbrian log_Printf(LogTIMER, "%s: fdunset(ctrl) %d\n", p->link.name, dev->cs); 14552942Sbrian result = 1; 14652942Sbrian } else 14752942Sbrian result = 0; 14852942Sbrian 14952942Sbrian /* Careful... physical_RemoveFromSet() called us ! */ 15052942Sbrian 15152942Sbrian p->handler->removefromset = NULL; 15252942Sbrian result += physical_RemoveFromSet(p, r, w, e); 15352942Sbrian p->handler->removefromset = ether_RemoveFromSet; 15452942Sbrian 15552942Sbrian return result; 15652942Sbrian} 15752942Sbrian 15852942Sbrianstatic void 15952942Sbrianether_Free(struct physical *p) 16052942Sbrian{ 16152942Sbrian struct etherdevice *dev = device2ether(p->handler); 16252942Sbrian 16352942Sbrian physical_SetDescriptor(p); 16452942Sbrian if (dev->cs != -1) 16552942Sbrian close(dev->cs); 16652942Sbrian free(dev); 16752942Sbrian} 16852942Sbrian 16952942Sbrianstatic const char * 17052942Sbrianether_OpenInfo(struct physical *p) 17152942Sbrian{ 17252942Sbrian struct etherdevice *dev = device2ether(p->handler); 17352942Sbrian 17452942Sbrian switch (dev->connected) { 17552942Sbrian case CARRIER_PENDING: 17652942Sbrian return "negotiating"; 17752942Sbrian case CARRIER_OK: 17852942Sbrian return "established"; 17952942Sbrian } 18052942Sbrian 18152942Sbrian return "disconnected"; 18252942Sbrian} 18352942Sbrian 18452942Sbrianstatic void 18552942Sbrianether_device2iov(struct device *d, struct iovec *iov, int *niov, 18653684Sbrian int maxiov, int *auxfd, int *nauxfd) 18752942Sbrian{ 18852942Sbrian struct etherdevice *dev = device2ether(d); 18952942Sbrian int sz = physical_MaxDeviceSize(); 19052942Sbrian 19152942Sbrian iov[*niov].iov_base = realloc(d, sz); 19252942Sbrian if (iov[*niov].iov_base == NULL) { 19352942Sbrian log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz); 19452942Sbrian AbortProgram(EX_OSERR); 19552942Sbrian } 19652942Sbrian iov[*niov].iov_len = sz; 19752942Sbrian (*niov)++; 19852942Sbrian 19952942Sbrian if (dev->cs >= 0) { 20052942Sbrian *auxfd = dev->cs; 20152942Sbrian (*nauxfd)++; 20252942Sbrian } 20352942Sbrian} 20452942Sbrian 20552942Sbrianstatic void 20652942Sbrianether_MessageIn(struct etherdevice *dev) 20752942Sbrian{ 20852942Sbrian char msgbuf[sizeof(struct ng_mesg) + sizeof(struct ngpppoe_sts)]; 20952942Sbrian struct ng_mesg *rep = (struct ng_mesg *)msgbuf; 21052942Sbrian struct ngpppoe_sts *sts = (struct ngpppoe_sts *)(msgbuf + sizeof *rep); 21152942Sbrian char unknown[14]; 21252942Sbrian const char *msg; 21352942Sbrian struct timeval t; 21466898Sbrian fd_set *r; 21566898Sbrian int ret; 21652942Sbrian 21752942Sbrian if (dev->cs < 0) 21852942Sbrian return; 21952942Sbrian 22066898Sbrian if ((r = mkfdset()) == NULL) { 22166898Sbrian log_Printf(LogERROR, "DoLoop: Cannot create fd_set\n"); 22266898Sbrian return; 22366898Sbrian } 22466898Sbrian zerofdset(r); 22566898Sbrian FD_SET(dev->cs, r); 22652942Sbrian t.tv_sec = t.tv_usec = 0; 22766898Sbrian ret = select(dev->cs + 1, r, NULL, NULL, &t); 22866898Sbrian free(r); 22966898Sbrian 23066898Sbrian if (ret <= 0) 23152942Sbrian return; 23252942Sbrian 23382277Sbrian if (NgRecvMsg(dev->cs, rep, sizeof msgbuf, NULL) <= 0) 23452942Sbrian return; 23552942Sbrian 23652942Sbrian if (rep->header.version != NG_VERSION) { 23752942Sbrian log_Printf(LogWARN, "%ld: Unexpected netgraph version, expected %ld\n", 23852942Sbrian (long)rep->header.version, (long)NG_VERSION); 23952942Sbrian return; 24052942Sbrian } 24152942Sbrian 24252942Sbrian if (rep->header.typecookie != NGM_PPPOE_COOKIE) { 24352942Sbrian log_Printf(LogWARN, "%ld: Unexpected netgraph cookie, expected %ld\n", 24452942Sbrian (long)rep->header.typecookie, (long)NGM_PPPOE_COOKIE); 24552942Sbrian return; 24652942Sbrian } 24752942Sbrian 24852942Sbrian switch (rep->header.cmd) { 24952942Sbrian case NGM_PPPOE_SET_FLAG: msg = "SET_FLAG"; break; 25052942Sbrian case NGM_PPPOE_CONNECT: msg = "CONNECT"; break; 25152942Sbrian case NGM_PPPOE_LISTEN: msg = "LISTEN"; break; 25252942Sbrian case NGM_PPPOE_OFFER: msg = "OFFER"; break; 25352942Sbrian case NGM_PPPOE_SUCCESS: msg = "SUCCESS"; break; 25452942Sbrian case NGM_PPPOE_FAIL: msg = "FAIL"; break; 25552942Sbrian case NGM_PPPOE_CLOSE: msg = "CLOSE"; break; 25652942Sbrian case NGM_PPPOE_GET_STATUS: msg = "GET_STATUS"; break; 25790975Sbrian case NGM_PPPOE_ACNAME: 25890975Sbrian msg = "ACNAME"; 25990975Sbrian if (setenv("ACNAME", sts->hook, 1) != 0) 26090975Sbrian log_Printf(LogWARN, "setenv: cannot set ACNAME=%s: %m", sts->hook); 26190975Sbrian break; 26252942Sbrian default: 26352942Sbrian snprintf(unknown, sizeof unknown, "<%d>", (int)rep->header.cmd); 26452942Sbrian msg = unknown; 26552942Sbrian break; 26652942Sbrian } 26752942Sbrian 26852942Sbrian log_Printf(LogPHASE, "Received NGM_PPPOE_%s (hook \"%s\")\n", msg, sts->hook); 26952942Sbrian 27052942Sbrian switch (rep->header.cmd) { 27152942Sbrian case NGM_PPPOE_SUCCESS: 27252942Sbrian dev->connected = CARRIER_OK; 27352942Sbrian break; 27452942Sbrian case NGM_PPPOE_FAIL: 27552942Sbrian case NGM_PPPOE_CLOSE: 27652942Sbrian dev->connected = CARRIER_LOST; 27752942Sbrian break; 27852942Sbrian } 27952942Sbrian} 28052942Sbrian 28152942Sbrianstatic int 28252942Sbrianether_AwaitCarrier(struct physical *p) 28352942Sbrian{ 28452942Sbrian struct etherdevice *dev = device2ether(p->handler); 28552942Sbrian 28653071Sbrian if (dev->connected != CARRIER_OK && !dev->timeout--) 28752942Sbrian dev->connected = CARRIER_LOST; 28852942Sbrian else if (dev->connected == CARRIER_PENDING) 28952942Sbrian ether_MessageIn(dev); 29052942Sbrian 29152942Sbrian return dev->connected; 29252942Sbrian} 29352942Sbrian 29452942Sbrianstatic const struct device baseetherdevice = { 29552942Sbrian ETHER_DEVICE, 29652942Sbrian "ether", 29778410Sbrian 1492, 29853733Sbrian { CD_REQUIRED, DEF_ETHERCDDELAY }, 29952942Sbrian ether_AwaitCarrier, 30052942Sbrian ether_RemoveFromSet, 30152942Sbrian NULL, 30252942Sbrian NULL, 30352942Sbrian NULL, 30452942Sbrian NULL, 30552942Sbrian ether_Free, 30652942Sbrian ether_Read, 30752942Sbrian ether_Write, 30852942Sbrian ether_device2iov, 30952942Sbrian NULL, 31052942Sbrian ether_OpenInfo 31152942Sbrian}; 31252942Sbrian 31352942Sbrianstruct device * 31452942Sbrianether_iov2device(int type, struct physical *p, struct iovec *iov, int *niov, 31552942Sbrian int maxiov, int *auxfd, int *nauxfd) 31652942Sbrian{ 31752942Sbrian if (type == ETHER_DEVICE) { 31852942Sbrian struct etherdevice *dev = (struct etherdevice *)iov[(*niov)++].iov_base; 31952942Sbrian 32052942Sbrian dev = realloc(dev, sizeof *dev); /* Reduce to the correct size */ 32152942Sbrian if (dev == NULL) { 32252942Sbrian log_Printf(LogALERT, "Failed to allocate memory: %d\n", 32352942Sbrian (int)(sizeof *dev)); 32452942Sbrian AbortProgram(EX_OSERR); 32552942Sbrian } 32652942Sbrian 32752942Sbrian if (*nauxfd) { 32852942Sbrian dev->cs = *auxfd; 32952942Sbrian (*nauxfd)--; 33052942Sbrian } else 33152942Sbrian dev->cs = -1; 33252942Sbrian 33352942Sbrian /* Refresh function pointers etc */ 33452942Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 33552942Sbrian 33652942Sbrian physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNCNOACF); 33752942Sbrian return &dev->dev; 33852942Sbrian } 33952942Sbrian 34052942Sbrian return NULL; 34152942Sbrian} 34252942Sbrian 34352942Sbrianstatic int 34458028Sbrianether_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 34552942Sbrian{ 34652942Sbrian struct physical *p = descriptor2physical(d); 34752942Sbrian struct etherdevice *dev = device2ether(p->handler); 34852942Sbrian int result; 34952942Sbrian 35052942Sbrian if (r && dev->cs >= 0) { 35152942Sbrian FD_SET(dev->cs, r); 35252942Sbrian log_Printf(LogTIMER, "%s(ctrl): fdset(r) %d\n", p->link.name, dev->cs); 35352942Sbrian result = 1; 35452942Sbrian } else 35552942Sbrian result = 0; 35652942Sbrian 35752942Sbrian result += physical_doUpdateSet(d, r, w, e, n, 0); 35852942Sbrian 35952942Sbrian return result; 36052942Sbrian} 36152942Sbrian 36252942Sbrianstatic int 36358028Sbrianether_IsSet(struct fdescriptor *d, const fd_set *fdset) 36452942Sbrian{ 36552942Sbrian struct physical *p = descriptor2physical(d); 36652942Sbrian struct etherdevice *dev = device2ether(p->handler); 36752942Sbrian int result; 36852942Sbrian 36952942Sbrian result = dev->cs >= 0 && FD_ISSET(dev->cs, fdset); 37052942Sbrian result += physical_IsSet(d, fdset); 37152942Sbrian 37252942Sbrian return result; 37352942Sbrian} 37452942Sbrian 37552942Sbrianstatic void 37658028Sbrianether_DescriptorRead(struct fdescriptor *d, struct bundle *bundle, 37752942Sbrian const fd_set *fdset) 37852942Sbrian{ 37952942Sbrian struct physical *p = descriptor2physical(d); 38052942Sbrian struct etherdevice *dev = device2ether(p->handler); 38152942Sbrian 38252942Sbrian if (dev->cs >= 0 && FD_ISSET(dev->cs, fdset)) { 38352942Sbrian ether_MessageIn(dev); 38452942Sbrian if (dev->connected == CARRIER_LOST) { 38552942Sbrian log_Printf(LogPHASE, "%s: Device disconnected\n", p->link.name); 38652942Sbrian datalink_Down(p->dl, CLOSE_NORMAL); 38752942Sbrian return; 38852942Sbrian } 38952942Sbrian } 39052942Sbrian 39152942Sbrian if (physical_IsSet(d, fdset)) 39252942Sbrian physical_DescriptorRead(d, bundle, fdset); 39352942Sbrian} 39452942Sbrian 39552942Sbrianstatic struct device * 39652942Sbrianether_Abandon(struct etherdevice *dev, struct physical *p) 39752942Sbrian{ 39852942Sbrian /* Abandon our node construction */ 39952942Sbrian close(dev->cs); 40052942Sbrian close(p->fd); 40152942Sbrian p->fd = -2; /* Nobody else need try.. */ 40252942Sbrian free(dev); 40352942Sbrian 40452942Sbrian return NULL; 40552942Sbrian} 40652942Sbrian 40752942Sbrianstruct device * 40852942Sbrianether_Create(struct physical *p) 40952942Sbrian{ 41052942Sbrian u_char rbuf[2048]; 41152942Sbrian struct etherdevice *dev; 41252942Sbrian struct ng_mesg *resp; 41352942Sbrian const struct hooklist *hlist; 41452942Sbrian const struct nodeinfo *ninfo; 41574916Sbrian char *path; 41674916Sbrian int ifacelen, f; 41752942Sbrian 41852942Sbrian dev = NULL; 41974916Sbrian path = NULL; 42074916Sbrian ifacelen = 0; 42152942Sbrian if (p->fd < 0 && !strncasecmp(p->name.full, NG_PPPOE_NODE_TYPE, 42252942Sbrian PPPOE_NODE_TYPE_LEN) && 42352942Sbrian p->name.full[PPPOE_NODE_TYPE_LEN] == ':') { 42452942Sbrian const struct linkinfo *nlink; 42552942Sbrian struct ngpppoe_init_data *data; 42652942Sbrian struct ngm_mkpeer mkp; 42752942Sbrian struct ngm_connect ngc; 42852942Sbrian const char *iface, *provider; 42974916Sbrian char etherid[12]; 43074916Sbrian int providerlen; 43152942Sbrian char connectpath[sizeof dev->hook + 2]; /* .:<hook> */ 43252942Sbrian 43352942Sbrian p->fd--; /* We own the device - change fd */ 43452942Sbrian 43553241Sbrian#if defined(__FreeBSD__) && !defined(NOKLDLOAD) 43675252Sbrian if (modfind("netgraph") == -1 && ID0kldload("netgraph") == -1) { 43775252Sbrian log_Printf(LogWARN, "kldload: netgraph: %s\n", strerror(errno)); 43852942Sbrian return NULL; 43952942Sbrian } 44052942Sbrian 44162209Sbrian if (modfind("ng_ether") == -1 && ID0kldload("ng_ether") == -1) 44262209Sbrian /* 44362209Sbrian * Don't treat this as an error as older kernels have this stuff 44462209Sbrian * built in as part of the netgraph node itself. 44562209Sbrian */ 44662209Sbrian log_Printf(LogWARN, "kldload: ng_ether: %s\n", strerror(errno)); 44762209Sbrian 44875376Sbrian if (modfind("ng_pppoe") == -1 && ID0kldload("ng_pppoe") == -1) { 44975376Sbrian log_Printf(LogWARN, "kldload: ng_pppoe: %s\n", strerror(errno)); 45075376Sbrian return NULL; 45175376Sbrian } 45275376Sbrian 45362209Sbrian if (modfind("ng_socket") == -1 && ID0kldload("ng_socket") == -1) { 45452942Sbrian log_Printf(LogWARN, "kldload: ng_socket: %s\n", strerror(errno)); 45552942Sbrian return NULL; 45652942Sbrian } 45752942Sbrian#endif 45852942Sbrian 45952942Sbrian if ((dev = malloc(sizeof *dev)) == NULL) 46052942Sbrian return NULL; 46152942Sbrian 46252942Sbrian iface = p->name.full + PPPOE_NODE_TYPE_LEN + 1; 46352942Sbrian 46452942Sbrian provider = strchr(iface, ':'); 46552942Sbrian if (provider) { 46652942Sbrian ifacelen = provider - iface; 46752942Sbrian provider++; 46852942Sbrian providerlen = strlen(provider); 46952942Sbrian } else { 47052942Sbrian ifacelen = strlen(iface); 47152942Sbrian provider = ""; 47252942Sbrian providerlen = 0; 47352942Sbrian } 47452942Sbrian 47552942Sbrian /* 47652942Sbrian * We're going to do this (where tunN is our tunnel device): 47752942Sbrian * 47852942Sbrian * .---------. 47952942Sbrian * | ether | 48052942Sbrian * | <iface> | dev->cs 48152942Sbrian * `---------' | 48252942Sbrian * (orphan) p->fd | 48352942Sbrian * | | | 48452942Sbrian * | | | 48552942Sbrian * (ethernet) | | 48652942Sbrian * .---------. .-----------. 48752942Sbrian * | pppoe | | socket | 48852942Sbrian * | <iface> |(tunN)<---->(tunN)| <unnamed> | 48952942Sbrian * `--------- `-----------' 49052942Sbrian * (tunX) 49152942Sbrian * ^ 49252942Sbrian * | 49352942Sbrian * `--->(tunX) 49452942Sbrian */ 49552942Sbrian 49652942Sbrian /* Create a socket node */ 49753535Sbrian if (ID0NgMkSockNode(NULL, &dev->cs, &p->fd) == -1) { 49852942Sbrian log_Printf(LogWARN, "Cannot create netgraph socket node: %s\n", 49952942Sbrian strerror(errno)); 50052942Sbrian free(dev); 50152942Sbrian return NULL; 50252942Sbrian } 50352942Sbrian 50452942Sbrian /* 50552942Sbrian * Ask for a list of hooks attached to the "ether" node. This node should 50652942Sbrian * magically exist as a way of hooking stuff onto an ethernet device 50752942Sbrian */ 50852942Sbrian path = (char *)alloca(ifacelen + 2); 50952942Sbrian sprintf(path, "%.*s:", ifacelen, iface); 51052942Sbrian if (NgSendMsg(dev->cs, path, NGM_GENERIC_COOKIE, NGM_LISTHOOKS, 51152942Sbrian NULL, 0) < 0) { 51252942Sbrian log_Printf(LogWARN, "%s Cannot send a netgraph message: %s\n", 51352942Sbrian path, strerror(errno)); 51452942Sbrian return ether_Abandon(dev, p); 51552942Sbrian } 51652942Sbrian 51752942Sbrian /* Get our list back */ 51852942Sbrian resp = (struct ng_mesg *)rbuf; 51982277Sbrian if (NgRecvMsg(dev->cs, resp, sizeof rbuf, NULL) <= 0) { 52052942Sbrian log_Printf(LogWARN, "Cannot get netgraph response: %s\n", 52152942Sbrian strerror(errno)); 52252942Sbrian return ether_Abandon(dev, p); 52352942Sbrian } 52452942Sbrian 52552942Sbrian hlist = (const struct hooklist *)resp->data; 52652942Sbrian ninfo = &hlist->nodeinfo; 52752942Sbrian 52852942Sbrian /* Make sure we've got the right type of node */ 52952942Sbrian if (strncmp(ninfo->type, NG_ETHER_NODE_TYPE, 53052942Sbrian sizeof NG_ETHER_NODE_TYPE - 1)) { 53152942Sbrian log_Printf(LogWARN, "%s Unexpected node type ``%s'' (wanted ``" 53252942Sbrian NG_ETHER_NODE_TYPE "'')\n", path, ninfo->type); 53352942Sbrian return ether_Abandon(dev, p); 53452942Sbrian } 53552942Sbrian 53652963Sbrian log_Printf(LogDEBUG, "List of netgraph node ``%s'' (id %x) hooks:\n", 53752942Sbrian path, ninfo->id); 53852942Sbrian 53952942Sbrian /* look for a hook already attached. */ 54052942Sbrian for (f = 0; f < ninfo->hooks; f++) { 54152942Sbrian nlink = &hlist->link[f]; 54252942Sbrian 54352942Sbrian log_Printf(LogDEBUG, " Found %s -> %s\n", nlink->ourhook, 54452942Sbrian nlink->peerhook); 54552942Sbrian 54652942Sbrian if (!strcmp(nlink->ourhook, NG_ETHER_HOOK_ORPHAN) || 54752942Sbrian !strcmp(nlink->ourhook, NG_ETHER_HOOK_DIVERT)) { 54852942Sbrian /* 54952942Sbrian * Something is using the data coming out of this ``ether'' node. 55052942Sbrian * If it's a PPPoE node, we use that node, otherwise we complain that 55152942Sbrian * someone else is using the node. 55252942Sbrian */ 55352942Sbrian if (!strcmp(nlink->nodeinfo.type, NG_PPPOE_NODE_TYPE)) 55452942Sbrian /* Use this PPPoE node ! */ 55552963Sbrian snprintf(ngc.path, sizeof ngc.path, "[%x]:", nlink->nodeinfo.id); 55652942Sbrian else { 55752942Sbrian log_Printf(LogWARN, "%s Node type ``%s'' is currently active\n", 55852942Sbrian path, nlink->nodeinfo.type); 55952942Sbrian return ether_Abandon(dev, p); 56052942Sbrian } 56152942Sbrian break; 56252942Sbrian } 56352942Sbrian } 56452942Sbrian 56552942Sbrian if (f == ninfo->hooks) { 56652942Sbrian /* 56752942Sbrian * Create a new ``PPPoE'' node connected to the ``ether'' node using 56852942Sbrian * the magic ``orphan'' and ``ethernet'' hooks 56952942Sbrian */ 57052942Sbrian snprintf(mkp.type, sizeof mkp.type, "%s", NG_PPPOE_NODE_TYPE); 57152942Sbrian snprintf(mkp.ourhook, sizeof mkp.ourhook, "%s", NG_ETHER_HOOK_ORPHAN); 57252942Sbrian snprintf(mkp.peerhook, sizeof mkp.peerhook, "%s", NG_PPPOE_HOOK_ETHERNET); 57352963Sbrian snprintf(etherid, sizeof etherid, "[%x]:", ninfo->id); 57452942Sbrian 57552942Sbrian log_Printf(LogDEBUG, "Creating PPPoE netgraph node %s%s -> %s\n", 57652942Sbrian etherid, mkp.ourhook, mkp.peerhook); 57752942Sbrian 57852942Sbrian if (NgSendMsg(dev->cs, etherid, NGM_GENERIC_COOKIE, 57952942Sbrian NGM_MKPEER, &mkp, sizeof mkp) < 0) { 58052942Sbrian log_Printf(LogWARN, "%s Cannot create PPPoE netgraph node: %s\n", 58152942Sbrian etherid, strerror(errno)); 58252942Sbrian return ether_Abandon(dev, p); 58352942Sbrian } 58452942Sbrian 58552942Sbrian snprintf(ngc.path, sizeof ngc.path, "%s%s", path, NG_ETHER_HOOK_ORPHAN); 58652942Sbrian } 58752942Sbrian 58852942Sbrian snprintf(dev->hook, sizeof dev->hook, "%s%d", 58952942Sbrian TUN_NAME, p->dl->bundle->unit); 59052942Sbrian 59152942Sbrian /* 59252942Sbrian * Connect the PPPoE node to our socket node. 59352942Sbrian * ngc.path has already been set up 59452942Sbrian */ 59552942Sbrian snprintf(ngc.ourhook, sizeof ngc.ourhook, "%s", dev->hook); 59652942Sbrian memcpy(ngc.peerhook, ngc.ourhook, sizeof ngc.peerhook); 59752942Sbrian 59852942Sbrian log_Printf(LogDEBUG, "Connecting netgraph socket .:%s -> %s:%s\n", 59952942Sbrian ngc.ourhook, ngc.path, ngc.peerhook); 60052942Sbrian if (NgSendMsg(dev->cs, ".:", NGM_GENERIC_COOKIE, 60152942Sbrian NGM_CONNECT, &ngc, sizeof ngc) < 0) { 60252942Sbrian log_Printf(LogWARN, "Cannot connect PPPoE and socket netgraph " 60352942Sbrian "nodes: %s\n", strerror(errno)); 60452942Sbrian return ether_Abandon(dev, p); 60552942Sbrian } 60652942Sbrian 60779854Sbrian /* Bring the Ethernet interface up */ 60879854Sbrian path[ifacelen] = '\0'; /* Remove the trailing ':' */ 60979854Sbrian if (!iface_SetFlags(path, IFF_UP)) 61079854Sbrian log_Printf(LogWARN, "%s: Failed to set the IFF_UP flag on %s\n", 61179854Sbrian p->link.name, path); 61279854Sbrian 61352942Sbrian /* And finally, request a connection to the given provider */ 61452942Sbrian 61568032Sbrian data = (struct ngpppoe_init_data *)alloca(sizeof *data + providerlen); 61652942Sbrian snprintf(data->hook, sizeof data->hook, "%s", dev->hook); 61768846Sbrian memcpy(data->data, provider, providerlen); 61868846Sbrian data->data_len = providerlen; 61952942Sbrian 62052942Sbrian snprintf(connectpath, sizeof connectpath, ".:%s", dev->hook); 62152942Sbrian log_Printf(LogDEBUG, "Sending PPPOE_CONNECT to %s\n", connectpath); 62252942Sbrian if (NgSendMsg(dev->cs, connectpath, NGM_PPPOE_COOKIE, 62352942Sbrian NGM_PPPOE_CONNECT, data, sizeof *data + providerlen) == -1) { 62452942Sbrian log_Printf(LogWARN, "``%s'': Cannot start netgraph node: %s\n", 62552942Sbrian connectpath, strerror(errno)); 62652942Sbrian return ether_Abandon(dev, p); 62752942Sbrian } 62852942Sbrian 62953062Sbrian /* Hook things up so that we monitor dev->cs */ 63053062Sbrian p->desc.UpdateSet = ether_UpdateSet; 63153062Sbrian p->desc.IsSet = ether_IsSet; 63253062Sbrian p->desc.Read = ether_DescriptorRead; 63353733Sbrian 63453733Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 63553733Sbrian switch (p->cfg.cd.necessity) { 63653733Sbrian case CD_VARIABLE: 63753733Sbrian dev->dev.cd.delay = p->cfg.cd.delay; 63853733Sbrian break; 63953733Sbrian case CD_REQUIRED: 64053733Sbrian dev->dev.cd = p->cfg.cd; 64153733Sbrian break; 64253733Sbrian case CD_NOTREQUIRED: 64353733Sbrian log_Printf(LogWARN, "%s: Carrier must be set, using ``set cd %d!''\n", 64453733Sbrian p->link.name, dev->dev.cd.delay); 64553733Sbrian case CD_DEFAULT: 64653733Sbrian break; 64753733Sbrian } 64853733Sbrian 64953733Sbrian dev->timeout = dev->dev.cd.delay; 65053733Sbrian dev->connected = CARRIER_PENDING; 65153733Sbrian 65252942Sbrian } else { 65352942Sbrian /* See if we're a netgraph socket */ 65471006Sbrian struct stat st; 65552942Sbrian 65671006Sbrian if (fstat(p->fd, &st) != -1 && (st.st_mode & S_IFSOCK)) { 65771006Sbrian struct sockaddr_storage ssock; 65871006Sbrian struct sockaddr *sock = (struct sockaddr *)&ssock; 65971006Sbrian int sz; 66052942Sbrian 66171006Sbrian sz = sizeof ssock; 66271006Sbrian if (getsockname(p->fd, sock, &sz) == -1) { 66371006Sbrian log_Printf(LogPHASE, "%s: Link is a closed socket !\n", p->link.name); 66471006Sbrian close(p->fd); 66571006Sbrian p->fd = -1; 66652942Sbrian return NULL; 66752942Sbrian } 66852942Sbrian 66971006Sbrian if (sock->sa_family == AF_NETGRAPH) { 67071006Sbrian /* 67171006Sbrian * It's a netgraph node... We can't determine hook names etc, so we 67271006Sbrian * stay pretty impartial.... 67371006Sbrian */ 67471006Sbrian log_Printf(LogPHASE, "%s: Link is a netgraph node\n", p->link.name); 67571006Sbrian 67671006Sbrian if ((dev = malloc(sizeof *dev)) == NULL) { 67771006Sbrian log_Printf(LogWARN, "%s: Cannot allocate an ether device: %s\n", 67871006Sbrian p->link.name, strerror(errno)); 67971006Sbrian return NULL; 68071006Sbrian } 68171006Sbrian 68271006Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 68371006Sbrian dev->cs = -1; 68471006Sbrian dev->timeout = 0; 68571006Sbrian dev->connected = CARRIER_OK; 68671006Sbrian *dev->hook = '\0'; 68771006Sbrian } 68852942Sbrian } 68952942Sbrian } 69052942Sbrian 69152942Sbrian if (dev) { 69252942Sbrian physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNCNOACF); 69352942Sbrian return &dev->dev; 69452942Sbrian } 69552942Sbrian 69652942Sbrian return NULL; 69752942Sbrian} 698