ether.c revision 53071
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 53071 1999-11-09 23:30:59Z 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> 3752942Sbrian#include <netinet/in_systm.h> 3852942Sbrian#include <netinet/ip.h> 3952942Sbrian#include <netgraph/ng_ether.h> 4052942Sbrian#include <netgraph/ng_message.h> 4152942Sbrian#include <netgraph/ng_pppoe.h> 4252942Sbrian#include <netgraph/ng_socket.h> 4352942Sbrian 4452942Sbrian#include <errno.h> 4552942Sbrian#include <stdio.h> 4652942Sbrian#include <stdlib.h> 4752942Sbrian#include <string.h> 4852942Sbrian#include <sysexits.h> 4952942Sbrian#include <sys/fcntl.h> 5052942Sbrian#if defined(__FreeBSD__) && !defined(NOKLDLOAD) 5152942Sbrian#include <sys/linker.h> 5252942Sbrian#endif 5352942Sbrian#include <sys/uio.h> 5452942Sbrian#include <termios.h> 5552942Sbrian#ifndef NONBLOCK_FIXED 5652942Sbrian#include <sys/time.h> 5752942Sbrian#endif 5852942Sbrian#include <unistd.h> 5952942Sbrian 6052942Sbrian#include "layer.h" 6152942Sbrian#include "defs.h" 6252942Sbrian#include "mbuf.h" 6352942Sbrian#include "log.h" 6452942Sbrian#include "timer.h" 6552942Sbrian#include "lqr.h" 6652942Sbrian#include "hdlc.h" 6752942Sbrian#include "throughput.h" 6852942Sbrian#include "fsm.h" 6952942Sbrian#include "lcp.h" 7052942Sbrian#include "ccp.h" 7152942Sbrian#include "link.h" 7252942Sbrian#include "async.h" 7352942Sbrian#include "descriptor.h" 7452942Sbrian#include "physical.h" 7552942Sbrian#include "main.h" 7652942Sbrian#include "mp.h" 7752942Sbrian#include "chat.h" 7852942Sbrian#include "auth.h" 7952942Sbrian#include "chap.h" 8052942Sbrian#include "cbcp.h" 8152942Sbrian#include "datalink.h" 8252942Sbrian#include "slcompress.h" 8352942Sbrian#include "iplist.h" 8452942Sbrian#include "ipcp.h" 8552942Sbrian#include "filter.h" 8652942Sbrian#ifndef NORADIUS 8752942Sbrian#include "radius.h" 8852942Sbrian#endif 8952942Sbrian#include "bundle.h" 9052942Sbrian#include "id.h" 9152942Sbrian#include "ether.h" 9252942Sbrian 9352942Sbrian 9452942Sbrian#define PPPOE_NODE_TYPE_LEN (sizeof NG_PPPOE_NODE_TYPE - 1) /* "PPPoE" */ 9552942Sbrian 9652942Sbrianstruct etherdevice { 9752942Sbrian struct device dev; /* What struct physical knows about */ 9852942Sbrian int cs; /* Control socket */ 9952942Sbrian int connected; /* Are we connected yet ? */ 10052942Sbrian int timeout; /* Seconds attempting to connect */ 10152942Sbrian char hook[sizeof TUN_NAME + 11]; /* Our socket node hook */ 10252942Sbrian}; 10352942Sbrian 10452942Sbrian#define device2ether(d) \ 10552942Sbrian ((d)->type == ETHER_DEVICE ? (struct etherdevice *)d : NULL) 10652942Sbrian 10752942Sbrianint 10852942Sbrianether_DeviceSize(void) 10952942Sbrian{ 11052942Sbrian return sizeof(struct etherdevice); 11152942Sbrian} 11252942Sbrian 11352942Sbrianstatic ssize_t 11452942Sbrianether_Write(struct physical *p, const void *v, size_t n) 11552942Sbrian{ 11652942Sbrian struct etherdevice *dev = device2ether(p->handler); 11752942Sbrian 11852942Sbrian return NgSendData(p->fd, dev->hook, v, n) == -1 ? -1 : n; 11952942Sbrian} 12052942Sbrian 12152942Sbrianstatic ssize_t 12252942Sbrianether_Read(struct physical *p, void *v, size_t n) 12352942Sbrian{ 12452942Sbrian char hook[sizeof TUN_NAME + 11]; 12552942Sbrian 12652942Sbrian return NgRecvData(p->fd, v, n, hook); 12752942Sbrian} 12852942Sbrian 12952942Sbrianstatic int 13052942Sbrianether_RemoveFromSet(struct physical *p, fd_set *r, fd_set *w, fd_set *e) 13152942Sbrian{ 13252942Sbrian struct etherdevice *dev = device2ether(p->handler); 13352942Sbrian int result; 13452942Sbrian 13552942Sbrian if (r && dev->cs >= 0 && FD_ISSET(dev->cs, r)) { 13652942Sbrian FD_CLR(dev->cs, r); 13752942Sbrian log_Printf(LogTIMER, "%s: fdunset(ctrl) %d\n", p->link.name, dev->cs); 13852942Sbrian result = 1; 13952942Sbrian } else 14052942Sbrian result = 0; 14152942Sbrian 14252942Sbrian /* Careful... physical_RemoveFromSet() called us ! */ 14352942Sbrian 14452942Sbrian p->handler->removefromset = NULL; 14552942Sbrian result += physical_RemoveFromSet(p, r, w, e); 14652942Sbrian p->handler->removefromset = ether_RemoveFromSet; 14752942Sbrian 14852942Sbrian return result; 14952942Sbrian} 15052942Sbrian 15152942Sbrianstatic void 15252942Sbrianether_Free(struct physical *p) 15352942Sbrian{ 15452942Sbrian struct etherdevice *dev = device2ether(p->handler); 15552942Sbrian 15652942Sbrian physical_SetDescriptor(p); 15752942Sbrian if (dev->cs != -1) 15852942Sbrian close(dev->cs); 15952942Sbrian free(dev); 16052942Sbrian} 16152942Sbrian 16252942Sbrianstatic const char * 16352942Sbrianether_OpenInfo(struct physical *p) 16452942Sbrian{ 16552942Sbrian struct etherdevice *dev = device2ether(p->handler); 16652942Sbrian 16752942Sbrian switch (dev->connected) { 16852942Sbrian case CARRIER_PENDING: 16952942Sbrian return "negotiating"; 17052942Sbrian case CARRIER_OK: 17152942Sbrian return "established"; 17252942Sbrian } 17352942Sbrian 17452942Sbrian return "disconnected"; 17552942Sbrian} 17652942Sbrian 17752942Sbrianstatic void 17852942Sbrianether_device2iov(struct device *d, struct iovec *iov, int *niov, 17952942Sbrian int maxiov, int *auxfd, int *nauxfd, pid_t newpid) 18052942Sbrian{ 18152942Sbrian struct etherdevice *dev = device2ether(d); 18252942Sbrian int sz = physical_MaxDeviceSize(); 18352942Sbrian 18452942Sbrian iov[*niov].iov_base = realloc(d, sz); 18552942Sbrian if (iov[*niov].iov_base == NULL) { 18652942Sbrian log_Printf(LogALERT, "Failed to allocate memory: %d\n", sz); 18752942Sbrian AbortProgram(EX_OSERR); 18852942Sbrian } 18952942Sbrian iov[*niov].iov_len = sz; 19052942Sbrian (*niov)++; 19152942Sbrian 19252942Sbrian if (dev->cs >= 0) { 19352942Sbrian *auxfd = dev->cs; 19452942Sbrian (*nauxfd)++; 19552942Sbrian } 19652942Sbrian} 19752942Sbrian 19852942Sbrianstatic void 19952942Sbrianether_MessageIn(struct etherdevice *dev) 20052942Sbrian{ 20152942Sbrian char msgbuf[sizeof(struct ng_mesg) + sizeof(struct ngpppoe_sts)]; 20252942Sbrian struct ng_mesg *rep = (struct ng_mesg *)msgbuf; 20352942Sbrian struct ngpppoe_sts *sts = (struct ngpppoe_sts *)(msgbuf + sizeof *rep); 20452942Sbrian char unknown[14]; 20552942Sbrian const char *msg; 20652942Sbrian#ifndef NONBLOCK_FIXED 20752942Sbrian struct timeval t; 20852942Sbrian fd_set r; 20952942Sbrian#endif 21052942Sbrian 21152942Sbrian if (dev->cs < 0) 21252942Sbrian return; 21352942Sbrian 21452942Sbrian#ifndef NONBLOCK_FIXED 21552942Sbrian FD_ZERO(&r); 21652942Sbrian FD_SET(dev->cs, &r); 21752942Sbrian t.tv_sec = t.tv_usec = 0; 21852942Sbrian if (select(dev->cs + 1, &r, NULL, NULL, &t) <= 0) 21952942Sbrian return; 22052942Sbrian#endif 22152942Sbrian 22252942Sbrian if (NgRecvMsg(dev->cs, rep, sizeof msgbuf, NULL) < 0) 22352942Sbrian return; 22452942Sbrian 22552942Sbrian if (rep->header.version != NG_VERSION) { 22652942Sbrian log_Printf(LogWARN, "%ld: Unexpected netgraph version, expected %ld\n", 22752942Sbrian (long)rep->header.version, (long)NG_VERSION); 22852942Sbrian return; 22952942Sbrian } 23052942Sbrian 23152942Sbrian if (rep->header.typecookie != NGM_PPPOE_COOKIE) { 23252942Sbrian log_Printf(LogWARN, "%ld: Unexpected netgraph cookie, expected %ld\n", 23352942Sbrian (long)rep->header.typecookie, (long)NGM_PPPOE_COOKIE); 23452942Sbrian return; 23552942Sbrian } 23652942Sbrian 23752942Sbrian switch (rep->header.cmd) { 23852942Sbrian case NGM_PPPOE_SET_FLAG: msg = "SET_FLAG"; break; 23952942Sbrian case NGM_PPPOE_CONNECT: msg = "CONNECT"; break; 24052942Sbrian case NGM_PPPOE_LISTEN: msg = "LISTEN"; break; 24152942Sbrian case NGM_PPPOE_OFFER: msg = "OFFER"; break; 24252942Sbrian case NGM_PPPOE_SUCCESS: msg = "SUCCESS"; break; 24352942Sbrian case NGM_PPPOE_FAIL: msg = "FAIL"; break; 24452942Sbrian case NGM_PPPOE_CLOSE: msg = "CLOSE"; break; 24552942Sbrian case NGM_PPPOE_GET_STATUS: msg = "GET_STATUS"; break; 24652942Sbrian default: 24752942Sbrian snprintf(unknown, sizeof unknown, "<%d>", (int)rep->header.cmd); 24852942Sbrian msg = unknown; 24952942Sbrian break; 25052942Sbrian } 25152942Sbrian 25252942Sbrian log_Printf(LogPHASE, "Received NGM_PPPOE_%s (hook \"%s\")\n", msg, sts->hook); 25352942Sbrian 25452942Sbrian switch (rep->header.cmd) { 25552942Sbrian case NGM_PPPOE_SUCCESS: 25652942Sbrian dev->connected = CARRIER_OK; 25752942Sbrian break; 25852942Sbrian case NGM_PPPOE_FAIL: 25952942Sbrian case NGM_PPPOE_CLOSE: 26052942Sbrian dev->connected = CARRIER_LOST; 26152942Sbrian break; 26252942Sbrian } 26352942Sbrian} 26452942Sbrian 26552942Sbrianstatic int 26652942Sbrianether_AwaitCarrier(struct physical *p) 26752942Sbrian{ 26852942Sbrian struct etherdevice *dev = device2ether(p->handler); 26952942Sbrian 27053071Sbrian if (dev->connected != CARRIER_OK && !dev->timeout--) 27152942Sbrian dev->connected = CARRIER_LOST; 27252942Sbrian else if (dev->connected == CARRIER_PENDING) 27352942Sbrian ether_MessageIn(dev); 27452942Sbrian 27552942Sbrian return dev->connected; 27652942Sbrian} 27752942Sbrian 27852942Sbrianstatic const struct device baseetherdevice = { 27952942Sbrian ETHER_DEVICE, 28052942Sbrian "ether", 28152942Sbrian ether_AwaitCarrier, 28252942Sbrian ether_RemoveFromSet, 28352942Sbrian NULL, 28452942Sbrian NULL, 28552942Sbrian NULL, 28652942Sbrian NULL, 28752942Sbrian ether_Free, 28852942Sbrian ether_Read, 28952942Sbrian ether_Write, 29052942Sbrian ether_device2iov, 29152942Sbrian NULL, 29252942Sbrian ether_OpenInfo 29352942Sbrian}; 29452942Sbrian 29552942Sbrianstruct device * 29652942Sbrianether_iov2device(int type, struct physical *p, struct iovec *iov, int *niov, 29752942Sbrian int maxiov, int *auxfd, int *nauxfd) 29852942Sbrian{ 29952942Sbrian if (type == ETHER_DEVICE) { 30052942Sbrian struct etherdevice *dev = (struct etherdevice *)iov[(*niov)++].iov_base; 30152942Sbrian 30252942Sbrian dev = realloc(dev, sizeof *dev); /* Reduce to the correct size */ 30352942Sbrian if (dev == NULL) { 30452942Sbrian log_Printf(LogALERT, "Failed to allocate memory: %d\n", 30552942Sbrian (int)(sizeof *dev)); 30652942Sbrian AbortProgram(EX_OSERR); 30752942Sbrian } 30852942Sbrian 30952942Sbrian if (*nauxfd) { 31052942Sbrian dev->cs = *auxfd; 31152942Sbrian (*nauxfd)--; 31252942Sbrian } else 31352942Sbrian dev->cs = -1; 31452942Sbrian 31552942Sbrian /* Refresh function pointers etc */ 31652942Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 31752942Sbrian 31852942Sbrian physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNCNOACF); 31952942Sbrian return &dev->dev; 32052942Sbrian } 32152942Sbrian 32252942Sbrian return NULL; 32352942Sbrian} 32452942Sbrian 32552942Sbrianstatic int 32652942Sbrianether_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 32752942Sbrian{ 32852942Sbrian struct physical *p = descriptor2physical(d); 32952942Sbrian struct etherdevice *dev = device2ether(p->handler); 33052942Sbrian int result; 33152942Sbrian 33252942Sbrian if (r && dev->cs >= 0) { 33352942Sbrian FD_SET(dev->cs, r); 33452942Sbrian log_Printf(LogTIMER, "%s(ctrl): fdset(r) %d\n", p->link.name, dev->cs); 33552942Sbrian result = 1; 33652942Sbrian } else 33752942Sbrian result = 0; 33852942Sbrian 33952942Sbrian result += physical_doUpdateSet(d, r, w, e, n, 0); 34052942Sbrian 34152942Sbrian return result; 34252942Sbrian} 34352942Sbrian 34452942Sbrianstatic int 34552942Sbrianether_IsSet(struct descriptor *d, const fd_set *fdset) 34652942Sbrian{ 34752942Sbrian struct physical *p = descriptor2physical(d); 34852942Sbrian struct etherdevice *dev = device2ether(p->handler); 34952942Sbrian int result; 35052942Sbrian 35152942Sbrian result = dev->cs >= 0 && FD_ISSET(dev->cs, fdset); 35252942Sbrian result += physical_IsSet(d, fdset); 35352942Sbrian 35452942Sbrian return result; 35552942Sbrian} 35652942Sbrian 35752942Sbrianstatic void 35852942Sbrianether_DescriptorRead(struct descriptor *d, struct bundle *bundle, 35952942Sbrian const fd_set *fdset) 36052942Sbrian{ 36152942Sbrian struct physical *p = descriptor2physical(d); 36252942Sbrian struct etherdevice *dev = device2ether(p->handler); 36352942Sbrian 36452942Sbrian if (dev->cs >= 0 && FD_ISSET(dev->cs, fdset)) { 36552942Sbrian ether_MessageIn(dev); 36652942Sbrian if (dev->connected == CARRIER_LOST) { 36752942Sbrian log_Printf(LogPHASE, "%s: Device disconnected\n", p->link.name); 36852942Sbrian datalink_Down(p->dl, CLOSE_NORMAL); 36952942Sbrian return; 37052942Sbrian } 37152942Sbrian } 37252942Sbrian 37352942Sbrian if (physical_IsSet(d, fdset)) 37452942Sbrian physical_DescriptorRead(d, bundle, fdset); 37552942Sbrian} 37652942Sbrian 37752942Sbrianstatic struct device * 37852942Sbrianether_Abandon(struct etherdevice *dev, struct physical *p) 37952942Sbrian{ 38052942Sbrian /* Abandon our node construction */ 38152942Sbrian close(dev->cs); 38252942Sbrian close(p->fd); 38352942Sbrian p->fd = -2; /* Nobody else need try.. */ 38452942Sbrian free(dev); 38552942Sbrian 38652942Sbrian return NULL; 38752942Sbrian} 38852942Sbrian 38952942Sbrianstruct device * 39052942Sbrianether_Create(struct physical *p) 39152942Sbrian{ 39252942Sbrian u_char rbuf[2048]; 39352942Sbrian struct etherdevice *dev; 39452942Sbrian struct ng_mesg *resp; 39552942Sbrian const struct hooklist *hlist; 39652942Sbrian const struct nodeinfo *ninfo; 39752942Sbrian int f; 39852942Sbrian 39952942Sbrian dev = NULL; 40052942Sbrian if (p->fd < 0 && !strncasecmp(p->name.full, NG_PPPOE_NODE_TYPE, 40152942Sbrian PPPOE_NODE_TYPE_LEN) && 40252942Sbrian p->name.full[PPPOE_NODE_TYPE_LEN] == ':') { 40352942Sbrian const struct linkinfo *nlink; 40452942Sbrian struct ngpppoe_init_data *data; 40552942Sbrian struct ngm_mkpeer mkp; 40652942Sbrian struct ngm_connect ngc; 40752942Sbrian const char *iface, *provider; 40852942Sbrian char *path, etherid[12]; 40952942Sbrian int ifacelen, providerlen, oldflag; 41052942Sbrian char connectpath[sizeof dev->hook + 2]; /* .:<hook> */ 41152942Sbrian 41252942Sbrian#ifdef KLDSYM_LOOKUP 41352942Sbrian /* First make sure we've got the right code loaded */ 41452942Sbrian char basesym[] = "ng_make_node", socksym[] = "ngdomain"; 41552942Sbrian struct kld_sym_lookup baselookup = { sizeof baselookup, basesym, 0, 0 }; 41652942Sbrian struct kld_sym_lookup socklookup = { sizeof socklookup, socksym, 0, 0 }; 41752942Sbrian#endif 41852942Sbrian 41952942Sbrian p->fd--; /* We own the device - change fd */ 42052942Sbrian 42152942Sbrian#ifdef KLDSYM_LOOKUP 42252942Sbrian if (kldsym(0, KLDSYM_LOOKUP, &baselookup) == -1) { 42352942Sbrian log_Printf(LogWARN, "Can't run without options NETGRAPH in the kernel\n"); 42452942Sbrian return NULL; 42552942Sbrian } 42652942Sbrian 42752942Sbrian if (kldsym(0, KLDSYM_LOOKUP, &socklookup) == -1 && 42852942Sbrian ID0kldload("ng_socket") == -1) { 42952942Sbrian log_Printf(LogWARN, "kldload: ng_socket: %s\n", strerror(errno)); 43052942Sbrian return NULL; 43152942Sbrian } 43252942Sbrian#endif 43352942Sbrian 43452942Sbrian if ((dev = malloc(sizeof *dev)) == NULL) 43552942Sbrian return NULL; 43652942Sbrian 43752942Sbrian iface = p->name.full + PPPOE_NODE_TYPE_LEN + 1; 43852942Sbrian 43952942Sbrian provider = strchr(iface, ':'); 44052942Sbrian if (provider) { 44152942Sbrian ifacelen = provider - iface; 44252942Sbrian provider++; 44352942Sbrian providerlen = strlen(provider); 44452942Sbrian } else { 44552942Sbrian ifacelen = strlen(iface); 44652942Sbrian provider = ""; 44752942Sbrian providerlen = 0; 44852942Sbrian } 44952942Sbrian 45052942Sbrian /* 45152942Sbrian * We're going to do this (where tunN is our tunnel device): 45252942Sbrian * 45352942Sbrian * .---------. 45452942Sbrian * | ether | 45552942Sbrian * | <iface> | dev->cs 45652942Sbrian * `---------' | 45752942Sbrian * (orphan) p->fd | 45852942Sbrian * | | | 45952942Sbrian * | | | 46052942Sbrian * (ethernet) | | 46152942Sbrian * .---------. .-----------. 46252942Sbrian * | pppoe | | socket | 46352942Sbrian * | <iface> |(tunN)<---->(tunN)| <unnamed> | 46452942Sbrian * `--------- `-----------' 46552942Sbrian * (tunX) 46652942Sbrian * ^ 46752942Sbrian * | 46852942Sbrian * `--->(tunX) 46952942Sbrian */ 47052942Sbrian 47152942Sbrian /* Create a socket node */ 47252942Sbrian if (NgMkSockNode(NULL, &dev->cs, &p->fd) == -1) { 47352942Sbrian log_Printf(LogWARN, "Cannot create netgraph socket node: %s\n", 47452942Sbrian strerror(errno)); 47552942Sbrian free(dev); 47652942Sbrian return NULL; 47752942Sbrian } 47852942Sbrian 47952942Sbrian /* 48052942Sbrian * Ask for a list of hooks attached to the "ether" node. This node should 48152942Sbrian * magically exist as a way of hooking stuff onto an ethernet device 48252942Sbrian */ 48352942Sbrian path = (char *)alloca(ifacelen + 2); 48452942Sbrian sprintf(path, "%.*s:", ifacelen, iface); 48552942Sbrian if (NgSendMsg(dev->cs, path, NGM_GENERIC_COOKIE, NGM_LISTHOOKS, 48652942Sbrian NULL, 0) < 0) { 48752942Sbrian log_Printf(LogWARN, "%s Cannot send a netgraph message: %s\n", 48852942Sbrian path, strerror(errno)); 48952942Sbrian return ether_Abandon(dev, p); 49052942Sbrian } 49152942Sbrian 49252942Sbrian /* Get our list back */ 49352942Sbrian resp = (struct ng_mesg *)rbuf; 49452942Sbrian if (NgRecvMsg(dev->cs, resp, sizeof rbuf, NULL) < 0) { 49552942Sbrian log_Printf(LogWARN, "Cannot get netgraph response: %s\n", 49652942Sbrian strerror(errno)); 49752942Sbrian return ether_Abandon(dev, p); 49852942Sbrian } 49952942Sbrian 50052942Sbrian hlist = (const struct hooklist *)resp->data; 50152942Sbrian ninfo = &hlist->nodeinfo; 50252942Sbrian 50352942Sbrian /* Make sure we've got the right type of node */ 50452942Sbrian if (strncmp(ninfo->type, NG_ETHER_NODE_TYPE, 50552942Sbrian sizeof NG_ETHER_NODE_TYPE - 1)) { 50652942Sbrian log_Printf(LogWARN, "%s Unexpected node type ``%s'' (wanted ``" 50752942Sbrian NG_ETHER_NODE_TYPE "'')\n", path, ninfo->type); 50852942Sbrian return ether_Abandon(dev, p); 50952942Sbrian } 51052942Sbrian 51152963Sbrian log_Printf(LogDEBUG, "List of netgraph node ``%s'' (id %x) hooks:\n", 51252942Sbrian path, ninfo->id); 51352942Sbrian 51452942Sbrian /* look for a hook already attached. */ 51552942Sbrian for (f = 0; f < ninfo->hooks; f++) { 51652942Sbrian nlink = &hlist->link[f]; 51752942Sbrian 51852942Sbrian log_Printf(LogDEBUG, " Found %s -> %s\n", nlink->ourhook, 51952942Sbrian nlink->peerhook); 52052942Sbrian 52152942Sbrian if (!strcmp(nlink->ourhook, NG_ETHER_HOOK_ORPHAN) || 52252942Sbrian !strcmp(nlink->ourhook, NG_ETHER_HOOK_DIVERT)) { 52352942Sbrian /* 52452942Sbrian * Something is using the data coming out of this ``ether'' node. 52552942Sbrian * If it's a PPPoE node, we use that node, otherwise we complain that 52652942Sbrian * someone else is using the node. 52752942Sbrian */ 52852942Sbrian if (!strcmp(nlink->nodeinfo.type, NG_PPPOE_NODE_TYPE)) 52952942Sbrian /* Use this PPPoE node ! */ 53052963Sbrian snprintf(ngc.path, sizeof ngc.path, "[%x]:", nlink->nodeinfo.id); 53152942Sbrian else { 53252942Sbrian log_Printf(LogWARN, "%s Node type ``%s'' is currently active\n", 53352942Sbrian path, nlink->nodeinfo.type); 53452942Sbrian return ether_Abandon(dev, p); 53552942Sbrian } 53652942Sbrian break; 53752942Sbrian } 53852942Sbrian } 53952942Sbrian 54052942Sbrian if (f == ninfo->hooks) { 54152942Sbrian /* 54252942Sbrian * Create a new ``PPPoE'' node connected to the ``ether'' node using 54352942Sbrian * the magic ``orphan'' and ``ethernet'' hooks 54452942Sbrian */ 54552942Sbrian snprintf(mkp.type, sizeof mkp.type, "%s", NG_PPPOE_NODE_TYPE); 54652942Sbrian snprintf(mkp.ourhook, sizeof mkp.ourhook, "%s", NG_ETHER_HOOK_ORPHAN); 54752942Sbrian snprintf(mkp.peerhook, sizeof mkp.peerhook, "%s", NG_PPPOE_HOOK_ETHERNET); 54852963Sbrian snprintf(etherid, sizeof etherid, "[%x]:", ninfo->id); 54952942Sbrian 55052942Sbrian log_Printf(LogDEBUG, "Creating PPPoE netgraph node %s%s -> %s\n", 55152942Sbrian etherid, mkp.ourhook, mkp.peerhook); 55252942Sbrian 55352942Sbrian if (NgSendMsg(dev->cs, etherid, NGM_GENERIC_COOKIE, 55452942Sbrian NGM_MKPEER, &mkp, sizeof mkp) < 0) { 55552942Sbrian log_Printf(LogWARN, "%s Cannot create PPPoE netgraph node: %s\n", 55652942Sbrian etherid, strerror(errno)); 55752942Sbrian return ether_Abandon(dev, p); 55852942Sbrian } 55952942Sbrian 56052942Sbrian snprintf(ngc.path, sizeof ngc.path, "%s%s", path, NG_ETHER_HOOK_ORPHAN); 56152942Sbrian } 56252942Sbrian 56352942Sbrian snprintf(dev->hook, sizeof dev->hook, "%s%d", 56452942Sbrian TUN_NAME, p->dl->bundle->unit); 56552942Sbrian 56652942Sbrian /* 56752942Sbrian * Connect the PPPoE node to our socket node. 56852942Sbrian * ngc.path has already been set up 56952942Sbrian */ 57052942Sbrian snprintf(ngc.ourhook, sizeof ngc.ourhook, "%s", dev->hook); 57152942Sbrian memcpy(ngc.peerhook, ngc.ourhook, sizeof ngc.peerhook); 57252942Sbrian 57352942Sbrian log_Printf(LogDEBUG, "Connecting netgraph socket .:%s -> %s:%s\n", 57452942Sbrian ngc.ourhook, ngc.path, ngc.peerhook); 57552942Sbrian if (NgSendMsg(dev->cs, ".:", NGM_GENERIC_COOKIE, 57652942Sbrian NGM_CONNECT, &ngc, sizeof ngc) < 0) { 57752942Sbrian log_Printf(LogWARN, "Cannot connect PPPoE and socket netgraph " 57852942Sbrian "nodes: %s\n", strerror(errno)); 57952942Sbrian return ether_Abandon(dev, p); 58052942Sbrian } 58152942Sbrian 58252942Sbrian /* And finally, request a connection to the given provider */ 58352942Sbrian 58452942Sbrian data = (struct ngpppoe_init_data *)alloca(sizeof *data + providerlen + 1); 58552942Sbrian 58652942Sbrian snprintf(data->hook, sizeof data->hook, "%s", dev->hook); 58752942Sbrian strcpy(data->data, provider); 58852942Sbrian data->data_len = providerlen; 58952942Sbrian 59052942Sbrian snprintf(connectpath, sizeof connectpath, ".:%s", dev->hook); 59152942Sbrian log_Printf(LogDEBUG, "Sending PPPOE_CONNECT to %s\n", connectpath); 59252942Sbrian if (NgSendMsg(dev->cs, connectpath, NGM_PPPOE_COOKIE, 59352942Sbrian NGM_PPPOE_CONNECT, data, sizeof *data + providerlen) == -1) { 59452942Sbrian log_Printf(LogWARN, "``%s'': Cannot start netgraph node: %s\n", 59552942Sbrian connectpath, strerror(errno)); 59652942Sbrian return ether_Abandon(dev, p); 59752942Sbrian } 59852942Sbrian 59952942Sbrian /* 60052942Sbrian * Now make our control socket non-blocking so that we can read() 60152942Sbrian * without having to select() 60252942Sbrian * 60352942Sbrian * XXX: Does this work (#define NONBLOCK_FIXED) ? 60452942Sbrian */ 60552942Sbrian oldflag = fcntl(dev->cs, F_GETFL, 0); 60652942Sbrian if (oldflag < 0) { 60752942Sbrian log_Printf(LogWARN, "%s: Open: Cannot get physical flags: %s\n", 60852942Sbrian p->link.name, strerror(errno)); 60952942Sbrian return ether_Abandon(dev, p); 61052942Sbrian } else 61152942Sbrian fcntl(dev->cs, F_SETFL, oldflag & ~O_NONBLOCK); 61252942Sbrian 61352942Sbrian dev->timeout = p->cfg.cd.delay; 61452942Sbrian dev->connected = CARRIER_PENDING; 61553062Sbrian 61653062Sbrian /* Hook things up so that we monitor dev->cs */ 61753062Sbrian p->desc.UpdateSet = ether_UpdateSet; 61853062Sbrian p->desc.IsSet = ether_IsSet; 61953062Sbrian p->desc.Read = ether_DescriptorRead; 62052942Sbrian } else { 62152942Sbrian /* See if we're a netgraph socket */ 62252942Sbrian struct sockaddr_ng ngsock; 62352942Sbrian struct sockaddr *sock = (struct sockaddr *)&ngsock; 62452942Sbrian int sz; 62552942Sbrian 62652942Sbrian sz = sizeof ngsock; 62752942Sbrian if (getsockname(p->fd, sock, &sz) != -1 && sock->sa_family == AF_NETGRAPH) { 62852942Sbrian /* 62953062Sbrian * It's a netgraph node... We can't determine hook names etc, so we 63053062Sbrian * stay pretty impartial.... 63152942Sbrian */ 63253062Sbrian log_Printf(LogPHASE, "%s: Link is a netgraph node\n", p->link.name); 63352942Sbrian 63452942Sbrian if ((dev = malloc(sizeof *dev)) == NULL) { 63552942Sbrian log_Printf(LogWARN, "%s: Cannot allocate an ether device: %s\n", 63652942Sbrian p->link.name, strerror(errno)); 63752942Sbrian return NULL; 63852942Sbrian } 63952942Sbrian 64052942Sbrian dev->cs = -1; 64152942Sbrian dev->timeout = 0; 64252942Sbrian dev->connected = CARRIER_OK; 64353062Sbrian *dev->hook = '\0'; 64452942Sbrian } 64552942Sbrian } 64652942Sbrian 64752942Sbrian if (dev) { 64852942Sbrian memcpy(&dev->dev, &baseetherdevice, sizeof dev->dev); 64952942Sbrian 65052942Sbrian physical_SetupStack(p, dev->dev.name, PHYSICAL_FORCE_SYNCNOACF); 65152942Sbrian 65252942Sbrian /* Moan about (and fix) invalid LCP configurations */ 65352942Sbrian if (p->link.lcp.cfg.mru > 1492) { 65452942Sbrian log_Printf(LogWARN, "%s: Reducing MRU to 1492\n", p->link.name); 65552942Sbrian p->link.lcp.cfg.mru = 1492; 65652942Sbrian } 65752942Sbrian if (p->dl->bundle->cfg.mtu > 1492) { 65852942Sbrian log_Printf(LogWARN, "%s: Reducing MTU to 1492\n", p->link.name); 65952942Sbrian p->dl->bundle->cfg.mtu = 1492; 66052942Sbrian } 66152942Sbrian 66252942Sbrian return &dev->dev; 66352942Sbrian } 66452942Sbrian 66552942Sbrian return NULL; 66652942Sbrian} 667