bundle.c revision 38557
136285Sbrian/*- 236285Sbrian * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org> 336285Sbrian * All rights reserved. 436285Sbrian * 536285Sbrian * Redistribution and use in source and binary forms, with or without 636285Sbrian * modification, are permitted provided that the following conditions 736285Sbrian * are met: 836285Sbrian * 1. Redistributions of source code must retain the above copyright 936285Sbrian * notice, this list of conditions and the following disclaimer. 1036285Sbrian * 2. Redistributions in binary form must reproduce the above copyright 1136285Sbrian * notice, this list of conditions and the following disclaimer in the 1236285Sbrian * documentation and/or other materials provided with the distribution. 1336285Sbrian * 1436285Sbrian * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1536285Sbrian * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1636285Sbrian * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1736285Sbrian * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1836285Sbrian * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1936285Sbrian * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2036285Sbrian * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2136285Sbrian * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2236285Sbrian * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2336285Sbrian * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2436285Sbrian * SUCH DAMAGE. 2536285Sbrian * 2638557Sbrian * $Id: bundle.c,v 1.33 1998/08/25 17:48:42 brian Exp $ 2736285Sbrian */ 2836285Sbrian 2936452Sbrian#include <sys/param.h> 3036285Sbrian#include <sys/socket.h> 3136285Sbrian#include <netinet/in.h> 3236285Sbrian#include <net/if.h> 3336285Sbrian#include <arpa/inet.h> 3436285Sbrian#include <net/route.h> 3536285Sbrian#include <net/if_dl.h> 3636285Sbrian#include <netinet/in_systm.h> 3736285Sbrian#include <netinet/ip.h> 3836285Sbrian#include <sys/un.h> 3936285Sbrian 4037191Sbrian#ifndef NOALIAS 4137191Sbrian#include <alias.h> 4237191Sbrian#endif 4336285Sbrian#include <errno.h> 4436285Sbrian#include <fcntl.h> 4536285Sbrian#include <paths.h> 4636285Sbrian#include <stdio.h> 4736285Sbrian#include <stdlib.h> 4836285Sbrian#include <string.h> 4936285Sbrian#include <sys/ioctl.h> 5036285Sbrian#include <sys/uio.h> 5136345Sbrian#include <sys/wait.h> 5236285Sbrian#include <termios.h> 5336285Sbrian#include <unistd.h> 5436285Sbrian 5537009Sbrian#include "defs.h" 5636285Sbrian#include "command.h" 5736285Sbrian#include "mbuf.h" 5836285Sbrian#include "log.h" 5936285Sbrian#include "id.h" 6036285Sbrian#include "timer.h" 6136285Sbrian#include "fsm.h" 6236285Sbrian#include "iplist.h" 6336285Sbrian#include "lqr.h" 6436285Sbrian#include "hdlc.h" 6536285Sbrian#include "throughput.h" 6636285Sbrian#include "slcompress.h" 6736285Sbrian#include "ipcp.h" 6836285Sbrian#include "filter.h" 6936285Sbrian#include "descriptor.h" 7036285Sbrian#include "route.h" 7136285Sbrian#include "lcp.h" 7236285Sbrian#include "ccp.h" 7336285Sbrian#include "link.h" 7436285Sbrian#include "mp.h" 7536285Sbrian#include "bundle.h" 7636285Sbrian#include "async.h" 7736285Sbrian#include "physical.h" 7836285Sbrian#include "modem.h" 7936285Sbrian#include "auth.h" 8036285Sbrian#include "lcpproto.h" 8136285Sbrian#include "chap.h" 8236285Sbrian#include "tun.h" 8336285Sbrian#include "prompt.h" 8436285Sbrian#include "chat.h" 8538174Sbrian#include "cbcp.h" 8636285Sbrian#include "datalink.h" 8736285Sbrian#include "ip.h" 8836285Sbrian 8936285Sbrian#define SCATTER_SEGMENTS 4 /* version, datalink, name, physical */ 9036285Sbrian#define SOCKET_OVERHEAD 100 /* additional buffer space for large */ 9136285Sbrian /* {recv,send}msg() calls */ 9236285Sbrian 9336285Sbrianstatic int bundle_RemainingIdleTime(struct bundle *); 9436285Sbrianstatic int bundle_RemainingAutoLoadTime(struct bundle *); 9536285Sbrian 9636285Sbrianstatic const char *PhaseNames[] = { 9736285Sbrian "Dead", "Establish", "Authenticate", "Network", "Terminate" 9836285Sbrian}; 9936285Sbrian 10036285Sbrianconst char * 10136285Sbrianbundle_PhaseName(struct bundle *bundle) 10236285Sbrian{ 10336285Sbrian return bundle->phase <= PHASE_TERMINATE ? 10436285Sbrian PhaseNames[bundle->phase] : "unknown"; 10536285Sbrian} 10636285Sbrian 10736285Sbrianvoid 10836285Sbrianbundle_NewPhase(struct bundle *bundle, u_int new) 10936285Sbrian{ 11036285Sbrian if (new == bundle->phase) 11136285Sbrian return; 11236285Sbrian 11336285Sbrian if (new <= PHASE_TERMINATE) 11436285Sbrian log_Printf(LogPHASE, "bundle: %s\n", PhaseNames[new]); 11536285Sbrian 11636285Sbrian switch (new) { 11736285Sbrian case PHASE_DEAD: 11836314Sbrian log_DisplayPrompts(); 11936285Sbrian bundle->phase = new; 12036285Sbrian break; 12136285Sbrian 12236285Sbrian case PHASE_ESTABLISH: 12336285Sbrian bundle->phase = new; 12436285Sbrian break; 12536285Sbrian 12636285Sbrian case PHASE_AUTHENTICATE: 12736285Sbrian bundle->phase = new; 12836314Sbrian log_DisplayPrompts(); 12936285Sbrian break; 13036285Sbrian 13136285Sbrian case PHASE_NETWORK: 13236285Sbrian ipcp_Setup(&bundle->ncp.ipcp); 13336285Sbrian fsm_Up(&bundle->ncp.ipcp.fsm); 13436285Sbrian fsm_Open(&bundle->ncp.ipcp.fsm); 13536285Sbrian bundle->phase = new; 13636314Sbrian log_DisplayPrompts(); 13736285Sbrian break; 13836285Sbrian 13936285Sbrian case PHASE_TERMINATE: 14036285Sbrian bundle->phase = new; 14136285Sbrian mp_Down(&bundle->ncp.mp); 14236314Sbrian log_DisplayPrompts(); 14336285Sbrian break; 14436285Sbrian } 14536285Sbrian} 14636285Sbrian 14736285Sbrianstatic int 14836285Sbrianbundle_CleanInterface(const struct bundle *bundle) 14936285Sbrian{ 15036285Sbrian int s; 15136285Sbrian struct ifreq ifrq; 15236285Sbrian struct ifaliasreq ifra; 15336285Sbrian 15436285Sbrian s = ID0socket(AF_INET, SOCK_DGRAM, 0); 15536285Sbrian if (s < 0) { 15636285Sbrian log_Printf(LogERROR, "bundle_CleanInterface: socket(): %s\n", 15736285Sbrian strerror(errno)); 15836285Sbrian return (-1); 15936285Sbrian } 16036285Sbrian strncpy(ifrq.ifr_name, bundle->ifp.Name, sizeof ifrq.ifr_name - 1); 16136285Sbrian ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0'; 16236285Sbrian while (ID0ioctl(s, SIOCGIFADDR, &ifrq) == 0) { 16336285Sbrian memset(&ifra.ifra_mask, '\0', sizeof ifra.ifra_mask); 16436285Sbrian strncpy(ifra.ifra_name, bundle->ifp.Name, sizeof ifra.ifra_name - 1); 16536285Sbrian ifra.ifra_name[sizeof ifra.ifra_name - 1] = '\0'; 16636285Sbrian ifra.ifra_addr = ifrq.ifr_addr; 16736285Sbrian if (ID0ioctl(s, SIOCGIFDSTADDR, &ifrq) < 0) { 16836285Sbrian if (ifra.ifra_addr.sa_family == AF_INET) 16937019Sbrian log_Printf(LogERROR, "Can't get dst for %s on %s !\n", 17036285Sbrian inet_ntoa(((struct sockaddr_in *)&ifra.ifra_addr)->sin_addr), 17136285Sbrian bundle->ifp.Name); 17236285Sbrian close(s); 17336285Sbrian return 0; 17436285Sbrian } 17536285Sbrian ifra.ifra_broadaddr = ifrq.ifr_dstaddr; 17636285Sbrian if (ID0ioctl(s, SIOCDIFADDR, &ifra) < 0) { 17736285Sbrian if (ifra.ifra_addr.sa_family == AF_INET) 17837019Sbrian log_Printf(LogERROR, "Can't delete %s address on %s !\n", 17936285Sbrian inet_ntoa(((struct sockaddr_in *)&ifra.ifra_addr)->sin_addr), 18036285Sbrian bundle->ifp.Name); 18136285Sbrian close(s); 18236285Sbrian return 0; 18336285Sbrian } 18436285Sbrian } 18536285Sbrian close(s); 18636285Sbrian 18736285Sbrian return 1; 18836285Sbrian} 18936285Sbrian 19036285Sbrianstatic void 19136285Sbrianbundle_LayerStart(void *v, struct fsm *fp) 19236285Sbrian{ 19336285Sbrian /* The given FSM is about to start up ! */ 19436285Sbrian} 19536285Sbrian 19636285Sbrian 19736285Sbrianstatic void 19836285Sbrianbundle_Notify(struct bundle *bundle, char c) 19936285Sbrian{ 20036285Sbrian if (bundle->notify.fd != -1) { 20136285Sbrian if (write(bundle->notify.fd, &c, 1) == 1) 20236285Sbrian log_Printf(LogPHASE, "Parent notified of success.\n"); 20336285Sbrian else 20436285Sbrian log_Printf(LogPHASE, "Failed to notify parent of success.\n"); 20536285Sbrian close(bundle->notify.fd); 20636285Sbrian bundle->notify.fd = -1; 20736285Sbrian } 20836285Sbrian} 20936285Sbrian 21038544Sbrianstatic void 21138544Sbrianbundle_ClearQueues(void *v) 21238544Sbrian{ 21338544Sbrian struct bundle *bundle = (struct bundle *)v; 21438544Sbrian struct datalink *dl; 21538544Sbrian 21638544Sbrian log_Printf(LogPHASE, "Clearing choked output queue\n"); 21738544Sbrian timer_Stop(&bundle->choked.timer); 21838544Sbrian 21938544Sbrian /* 22038544Sbrian * Emergency time: 22138544Sbrian * 22238544Sbrian * We've had a full queue for PACKET_DEL_SECS seconds without being 22338544Sbrian * able to get rid of any of the packets. We've probably given up 22438544Sbrian * on the redials at this point, and the queued data has almost 22538544Sbrian * definitely been timed out by the layer above. As this is preventing 22638544Sbrian * us from reading the TUN_NAME device (we don't want to buffer stuff 22738544Sbrian * indefinitely), we may as well nuke this data and start with a clean 22838544Sbrian * slate ! 22938544Sbrian * 23038544Sbrian * Unfortunately, this has the side effect of shafting any compression 23138544Sbrian * dictionaries in use (causing the relevant RESET_REQ/RESET_ACK). 23238544Sbrian */ 23338544Sbrian 23438557Sbrian ip_DeleteQueue(&bundle->ncp.ipcp); 23538544Sbrian mp_DeleteQueue(&bundle->ncp.mp); 23638544Sbrian for (dl = bundle->links; dl; dl = dl->next) 23738544Sbrian physical_DeleteQueue(dl->physical); 23838544Sbrian} 23938544Sbrian 24036285Sbrianstatic void 24136285Sbrianbundle_AutoLoadTimeout(void *v) 24236285Sbrian{ 24336285Sbrian struct bundle *bundle = (struct bundle *)v; 24436285Sbrian 24536285Sbrian if (bundle->autoload.comingup) { 24636285Sbrian log_Printf(LogPHASE, "autoload: Another link is required\n"); 24736285Sbrian /* bundle_Open() stops the timer */ 24837955Sbrian bundle_Open(bundle, NULL, PHYS_AUTO, 0); 24936285Sbrian } else { 25036285Sbrian struct datalink *dl, *last; 25136285Sbrian 25236285Sbrian timer_Stop(&bundle->autoload.timer); 25336285Sbrian for (last = NULL, dl = bundle->links; dl; dl = dl->next) 25436465Sbrian if (dl->physical->type == PHYS_AUTO && dl->state == DATALINK_OPEN) 25536285Sbrian last = dl; 25636285Sbrian 25736285Sbrian if (last) 25837007Sbrian datalink_Close(last, CLOSE_STAYDOWN); 25936285Sbrian } 26036285Sbrian} 26136285Sbrian 26236285Sbrianstatic void 26336285Sbrianbundle_StartAutoLoadTimer(struct bundle *bundle, int up) 26436285Sbrian{ 26536285Sbrian struct datalink *dl; 26636285Sbrian 26736285Sbrian timer_Stop(&bundle->autoload.timer); 26836285Sbrian 26936285Sbrian if (bundle->CleaningUp || bundle->phase != PHASE_NETWORK) { 27036285Sbrian dl = NULL; 27136285Sbrian bundle->autoload.running = 0; 27236285Sbrian } else if (up) { 27336285Sbrian for (dl = bundle->links; dl; dl = dl->next) 27436465Sbrian if (dl->state == DATALINK_CLOSED && dl->physical->type == PHYS_AUTO) { 27536285Sbrian if (bundle->cfg.autoload.max.timeout) { 27636285Sbrian bundle->autoload.timer.func = bundle_AutoLoadTimeout; 27736285Sbrian bundle->autoload.timer.name = "autoload up"; 27836285Sbrian bundle->autoload.timer.load = 27936285Sbrian bundle->cfg.autoload.max.timeout * SECTICKS; 28036285Sbrian bundle->autoload.timer.arg = bundle; 28136285Sbrian timer_Start(&bundle->autoload.timer); 28236285Sbrian bundle->autoload.done = time(NULL) + bundle->cfg.autoload.max.timeout; 28336285Sbrian } else 28436285Sbrian bundle_AutoLoadTimeout(bundle); 28536285Sbrian break; 28636285Sbrian } 28736285Sbrian bundle->autoload.running = (dl || bundle->cfg.autoload.min.timeout) ? 1 : 0; 28836285Sbrian } else { 28936285Sbrian int nlinks; 29036285Sbrian struct datalink *adl; 29136285Sbrian 29236285Sbrian for (nlinks = 0, adl = NULL, dl = bundle->links; dl; dl = dl->next) 29336285Sbrian if (dl->state == DATALINK_OPEN) { 29436465Sbrian if (dl->physical->type == PHYS_AUTO) 29536285Sbrian adl = dl; 29636285Sbrian if (++nlinks > 1 && adl) { 29736285Sbrian if (bundle->cfg.autoload.min.timeout) { 29836285Sbrian bundle->autoload.timer.func = bundle_AutoLoadTimeout; 29936285Sbrian bundle->autoload.timer.name = "autoload down"; 30036285Sbrian bundle->autoload.timer.load = 30136285Sbrian bundle->cfg.autoload.min.timeout * SECTICKS; 30236285Sbrian bundle->autoload.timer.arg = bundle; 30336285Sbrian timer_Start(&bundle->autoload.timer); 30436285Sbrian bundle->autoload.done = 30536285Sbrian time(NULL) + bundle->cfg.autoload.min.timeout; 30636285Sbrian } 30736285Sbrian break; 30836285Sbrian } 30936285Sbrian } 31036285Sbrian 31136285Sbrian bundle->autoload.running = 1; 31236285Sbrian } 31336285Sbrian 31436285Sbrian bundle->autoload.comingup = up ? 1 : 0; 31536285Sbrian} 31636285Sbrian 31736285Sbrianstatic void 31836285Sbrianbundle_StopAutoLoadTimer(struct bundle *bundle) 31936285Sbrian{ 32036285Sbrian timer_Stop(&bundle->autoload.timer); 32136285Sbrian bundle->autoload.done = 0; 32236285Sbrian} 32336285Sbrian 32436285Sbrianstatic int 32536285Sbrianbundle_RemainingAutoLoadTime(struct bundle *bundle) 32636285Sbrian{ 32736285Sbrian if (bundle->autoload.done) 32836285Sbrian return bundle->autoload.done - time(NULL); 32936285Sbrian return -1; 33036285Sbrian} 33136285Sbrian 33236928Sbrianstatic void 33336928Sbrianbundle_LinkAdded(struct bundle *bundle, struct datalink *dl) 33436928Sbrian{ 33536928Sbrian bundle->phys_type.all |= dl->physical->type; 33636928Sbrian if (dl->state == DATALINK_OPEN) 33736928Sbrian bundle->phys_type.open |= dl->physical->type; 33836285Sbrian 33936928Sbrian /* Note: We only re-add links that are DATALINK_OPEN */ 34036928Sbrian if (dl->physical->type == PHYS_AUTO && 34136928Sbrian bundle->autoload.timer.state == TIMER_STOPPED && 34236928Sbrian dl->state != DATALINK_OPEN && 34336928Sbrian bundle->phase == PHASE_NETWORK) 34436928Sbrian bundle->autoload.running = 1; 34536928Sbrian 34636928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 34736928Sbrian != bundle->phys_type.open && bundle->idle.timer.state == TIMER_STOPPED) 34836928Sbrian /* We may need to start our idle timer */ 34936928Sbrian bundle_StartIdleTimer(bundle); 35036928Sbrian} 35136928Sbrian 35238174Sbrianvoid 35336928Sbrianbundle_LinksRemoved(struct bundle *bundle) 35436928Sbrian{ 35536928Sbrian struct datalink *dl; 35636928Sbrian 35736928Sbrian bundle->phys_type.all = bundle->phys_type.open = 0; 35836928Sbrian for (dl = bundle->links; dl; dl = dl->next) 35936928Sbrian bundle_LinkAdded(bundle, dl); 36036928Sbrian 36136928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 36236928Sbrian == bundle->phys_type.open) 36336928Sbrian bundle_StopIdleTimer(bundle); 36436928Sbrian} 36536928Sbrian 36636928Sbrianstatic void 36736285Sbrianbundle_LayerUp(void *v, struct fsm *fp) 36836285Sbrian{ 36936285Sbrian /* 37036285Sbrian * The given fsm is now up 37136928Sbrian * If it's an LCP, adjust our phys_mode.open value. 37236285Sbrian * If it's an LCP set our mtu (if we're multilink, add up the link 37336285Sbrian * speeds and set the MRRU) and start our autoload timer. 37436285Sbrian * If it's an NCP, tell our -background parent to go away. 37536285Sbrian * If it's the first NCP, start the idle timer. 37636285Sbrian */ 37736285Sbrian struct bundle *bundle = (struct bundle *)v; 37836285Sbrian 37936285Sbrian if (fp->proto == PROTO_LCP) { 38036928Sbrian struct physical *p = link2physical(fp->link); 38136928Sbrian 38236928Sbrian bundle_LinkAdded(bundle, p->dl); 38336285Sbrian if (bundle->ncp.mp.active) { 38436285Sbrian struct datalink *dl; 38536285Sbrian 38636285Sbrian bundle->ifp.Speed = 0; 38736285Sbrian for (dl = bundle->links; dl; dl = dl->next) 38836285Sbrian if (dl->state == DATALINK_OPEN) 38936285Sbrian bundle->ifp.Speed += modem_Speed(dl->physical); 39036285Sbrian tun_configure(bundle, bundle->ncp.mp.peer_mrru); 39136285Sbrian bundle->autoload.running = 1; 39236285Sbrian } else { 39336928Sbrian bundle->ifp.Speed = modem_Speed(p); 39436285Sbrian tun_configure(bundle, fsm2lcp(fp)->his_mru); 39536285Sbrian } 39636285Sbrian } else if (fp->proto == PROTO_IPCP) { 39736285Sbrian bundle_StartIdleTimer(bundle); 39836285Sbrian bundle_Notify(bundle, EX_NORMAL); 39936285Sbrian } 40036285Sbrian} 40136285Sbrian 40236285Sbrianstatic void 40336285Sbrianbundle_LayerDown(void *v, struct fsm *fp) 40436285Sbrian{ 40536285Sbrian /* 40636285Sbrian * The given FSM has been told to come down. 40736285Sbrian * If it's our last NCP, stop the idle timer. 40836928Sbrian * If it's an LCP, adjust our phys_type.open value and any timers. 40936312Sbrian * If it's an LCP and we're in multilink mode, adjust our tun 41036312Sbrian * speed and make sure our minimum sequence number is adjusted. 41136285Sbrian */ 41236285Sbrian 41336285Sbrian struct bundle *bundle = (struct bundle *)v; 41436285Sbrian 41536285Sbrian if (fp->proto == PROTO_IPCP) 41636285Sbrian bundle_StopIdleTimer(bundle); 41736928Sbrian else if (fp->proto == PROTO_LCP) { 41836928Sbrian bundle_LinksRemoved(bundle); /* adjust timers & phys_type values */ 41936928Sbrian if (bundle->ncp.mp.active) { 42036928Sbrian struct datalink *dl; 42136928Sbrian struct datalink *lost; 42236285Sbrian 42336928Sbrian bundle->ifp.Speed = 0; 42436928Sbrian lost = NULL; 42536928Sbrian for (dl = bundle->links; dl; dl = dl->next) 42636928Sbrian if (fp == &dl->physical->link.lcp.fsm) 42736928Sbrian lost = dl; 42836928Sbrian else if (dl->state == DATALINK_OPEN) 42936928Sbrian bundle->ifp.Speed += modem_Speed(dl->physical); 43036312Sbrian 43136928Sbrian if (bundle->ifp.Speed) 43236928Sbrian /* Don't configure down to a speed of 0 */ 43336928Sbrian tun_configure(bundle, bundle->ncp.mp.link.lcp.his_mru); 43436312Sbrian 43536928Sbrian if (lost) 43636928Sbrian mp_LinkLost(&bundle->ncp.mp, lost); 43736928Sbrian else 43837019Sbrian log_Printf(LogALERT, "Oops, lost an unrecognised datalink (%s) !\n", 43936928Sbrian fp->link->name); 44036928Sbrian } 44136285Sbrian } 44236285Sbrian} 44336285Sbrian 44436285Sbrianstatic void 44536285Sbrianbundle_LayerFinish(void *v, struct fsm *fp) 44636285Sbrian{ 44736285Sbrian /* The given fsm is now down (fp cannot be NULL) 44836285Sbrian * 44936285Sbrian * If it's the last LCP, fsm_Down all NCPs 45036285Sbrian * If it's the last NCP, fsm_Close all LCPs 45136285Sbrian */ 45236285Sbrian 45336285Sbrian struct bundle *bundle = (struct bundle *)v; 45436285Sbrian struct datalink *dl; 45536285Sbrian 45636285Sbrian if (fp->proto == PROTO_IPCP) { 45736285Sbrian if (bundle_Phase(bundle) != PHASE_DEAD) 45836285Sbrian bundle_NewPhase(bundle, PHASE_TERMINATE); 45936285Sbrian for (dl = bundle->links; dl; dl = dl->next) 46037007Sbrian datalink_Close(dl, CLOSE_NORMAL); 46137060Sbrian fsm2initial(fp); 46236285Sbrian } else if (fp->proto == PROTO_LCP) { 46336285Sbrian int others_active; 46436285Sbrian 46536285Sbrian others_active = 0; 46636285Sbrian for (dl = bundle->links; dl; dl = dl->next) 46736285Sbrian if (fp != &dl->physical->link.lcp.fsm && 46836285Sbrian dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 46936285Sbrian others_active++; 47036285Sbrian 47137060Sbrian if (!others_active) 47237060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 47336285Sbrian } 47436285Sbrian} 47536285Sbrian 47636285Sbrianint 47736285Sbrianbundle_LinkIsUp(const struct bundle *bundle) 47836285Sbrian{ 47936285Sbrian return bundle->ncp.ipcp.fsm.state == ST_OPENED; 48036285Sbrian} 48136285Sbrian 48236285Sbrianvoid 48337007Sbrianbundle_Close(struct bundle *bundle, const char *name, int how) 48436285Sbrian{ 48536285Sbrian /* 48636285Sbrian * Please close the given datalink. 48736285Sbrian * If name == NULL or name is the last datalink, fsm_Close all NCPs 48836285Sbrian * (except our MP) 48936285Sbrian * If it isn't the last datalink, just Close that datalink. 49036285Sbrian */ 49136285Sbrian 49236285Sbrian struct datalink *dl, *this_dl; 49336285Sbrian int others_active; 49436285Sbrian 49536285Sbrian others_active = 0; 49636285Sbrian this_dl = NULL; 49736285Sbrian 49836285Sbrian for (dl = bundle->links; dl; dl = dl->next) { 49936285Sbrian if (name && !strcasecmp(name, dl->name)) 50036285Sbrian this_dl = dl; 50136285Sbrian if (name == NULL || this_dl == dl) { 50237007Sbrian switch (how) { 50337007Sbrian case CLOSE_LCP: 50437007Sbrian datalink_DontHangup(dl); 50537007Sbrian /* fall through */ 50637007Sbrian case CLOSE_STAYDOWN: 50737007Sbrian datalink_StayDown(dl); 50837007Sbrian break; 50937007Sbrian } 51036285Sbrian } else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 51136285Sbrian others_active++; 51236285Sbrian } 51336285Sbrian 51436285Sbrian if (name && this_dl == NULL) { 51536285Sbrian log_Printf(LogWARN, "%s: Invalid datalink name\n", name); 51636285Sbrian return; 51736285Sbrian } 51836285Sbrian 51936285Sbrian if (!others_active) { 52036285Sbrian bundle_StopIdleTimer(bundle); 52136285Sbrian bundle_StopAutoLoadTimer(bundle); 52236285Sbrian if (bundle->ncp.ipcp.fsm.state > ST_CLOSED || 52336285Sbrian bundle->ncp.ipcp.fsm.state == ST_STARTING) 52436285Sbrian fsm_Close(&bundle->ncp.ipcp.fsm); 52536285Sbrian else { 52637060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 52736285Sbrian for (dl = bundle->links; dl; dl = dl->next) 52837007Sbrian datalink_Close(dl, how); 52936285Sbrian } 53036285Sbrian } else if (this_dl && this_dl->state != DATALINK_CLOSED && 53136285Sbrian this_dl->state != DATALINK_HANGUP) 53237007Sbrian datalink_Close(this_dl, how); 53336285Sbrian} 53436285Sbrian 53536285Sbrianvoid 53637018Sbrianbundle_Down(struct bundle *bundle, int how) 53736285Sbrian{ 53836285Sbrian struct datalink *dl; 53936285Sbrian 54036285Sbrian for (dl = bundle->links; dl; dl = dl->next) 54137018Sbrian datalink_Down(dl, how); 54236285Sbrian} 54336285Sbrian 54436285Sbrianstatic int 54536285Sbrianbundle_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 54636285Sbrian{ 54736285Sbrian struct bundle *bundle = descriptor2bundle(d); 54836285Sbrian struct datalink *dl; 54936285Sbrian int result, want, queued, nlinks; 55036285Sbrian 55136285Sbrian result = 0; 55236285Sbrian 55336285Sbrian /* If there are aren't many packets queued, look for some more. */ 55436285Sbrian for (nlinks = 0, dl = bundle->links; dl; dl = dl->next) 55536285Sbrian nlinks++; 55636285Sbrian 55736285Sbrian if (nlinks) { 55838557Sbrian queued = r ? bundle_FillQueues(bundle) : ip_QueueLen(&bundle->ncp.ipcp); 55936285Sbrian if (bundle->autoload.running) { 56036285Sbrian if (queued < bundle->cfg.autoload.max.packets) { 56136285Sbrian if (queued > bundle->cfg.autoload.min.packets) 56236285Sbrian bundle_StopAutoLoadTimer(bundle); 56336285Sbrian else if (bundle->autoload.timer.state != TIMER_RUNNING || 56436285Sbrian bundle->autoload.comingup) 56536285Sbrian bundle_StartAutoLoadTimer(bundle, 0); 56636285Sbrian } else if (bundle->autoload.timer.state != TIMER_RUNNING || 56736285Sbrian !bundle->autoload.comingup) 56836285Sbrian bundle_StartAutoLoadTimer(bundle, 1); 56936285Sbrian } 57036285Sbrian 57136928Sbrian if (r && (bundle->phase == PHASE_NETWORK || 57236928Sbrian bundle->phys_type.all & PHYS_AUTO)) { 57336285Sbrian /* enough surplus so that we can tell if we're getting swamped */ 57436285Sbrian want = bundle->cfg.autoload.max.packets + nlinks * 2; 57536285Sbrian /* but at least 20 packets ! */ 57636285Sbrian if (want < 20) 57736285Sbrian want = 20; 57836285Sbrian if (queued < want) { 57936285Sbrian /* Not enough - select() for more */ 58038544Sbrian if (bundle->choked.timer.state == TIMER_RUNNING) 58138544Sbrian timer_Stop(&bundle->choked.timer); /* Not needed any more */ 58236285Sbrian FD_SET(bundle->dev.fd, r); 58336285Sbrian if (*n < bundle->dev.fd + 1) 58436285Sbrian *n = bundle->dev.fd + 1; 58536452Sbrian log_Printf(LogTIMER, "%s: fdset(r) %d\n", TUN_NAME, bundle->dev.fd); 58636285Sbrian result++; 58738544Sbrian } else if (bundle->choked.timer.state == TIMER_STOPPED) { 58838544Sbrian bundle->choked.timer.func = bundle_ClearQueues; 58938544Sbrian bundle->choked.timer.name = "output choke"; 59038544Sbrian bundle->choked.timer.load = bundle->cfg.choked.timeout * SECTICKS; 59138544Sbrian bundle->choked.timer.arg = bundle; 59238544Sbrian timer_Start(&bundle->choked.timer); 59336285Sbrian } 59436285Sbrian } 59536285Sbrian } 59636285Sbrian 59736714Sbrian /* Which links need a select() ? */ 59836714Sbrian for (dl = bundle->links; dl; dl = dl->next) 59936714Sbrian result += descriptor_UpdateSet(&dl->desc, r, w, e, n); 60036714Sbrian 60136285Sbrian /* 60236285Sbrian * This *MUST* be called after the datalink UpdateSet()s as it 60336285Sbrian * might be ``holding'' one of the datalinks (death-row) and 60436285Sbrian * wants to be able to de-select() it from the descriptor set. 60536285Sbrian */ 60636314Sbrian result += descriptor_UpdateSet(&bundle->ncp.mp.server.desc, r, w, e, n); 60736285Sbrian 60836285Sbrian return result; 60936285Sbrian} 61036285Sbrian 61136285Sbrianstatic int 61236285Sbrianbundle_IsSet(struct descriptor *d, const fd_set *fdset) 61336285Sbrian{ 61436285Sbrian struct bundle *bundle = descriptor2bundle(d); 61536285Sbrian struct datalink *dl; 61636285Sbrian 61736285Sbrian for (dl = bundle->links; dl; dl = dl->next) 61836285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 61936285Sbrian return 1; 62036285Sbrian 62136285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 62236285Sbrian return 1; 62336285Sbrian 62436285Sbrian return FD_ISSET(bundle->dev.fd, fdset); 62536285Sbrian} 62636285Sbrian 62736285Sbrianstatic void 62836285Sbrianbundle_DescriptorRead(struct descriptor *d, struct bundle *bundle, 62936285Sbrian const fd_set *fdset) 63036285Sbrian{ 63136285Sbrian struct datalink *dl; 63236285Sbrian 63336285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 63436285Sbrian descriptor_Read(&bundle->ncp.mp.server.desc, bundle, fdset); 63536285Sbrian 63636285Sbrian for (dl = bundle->links; dl; dl = dl->next) 63736285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 63836285Sbrian descriptor_Read(&dl->desc, bundle, fdset); 63936285Sbrian 64036285Sbrian if (FD_ISSET(bundle->dev.fd, fdset)) { 64136285Sbrian struct tun_data tun; 64236285Sbrian int n, pri; 64336285Sbrian 64436285Sbrian /* something to read from tun */ 64536285Sbrian n = read(bundle->dev.fd, &tun, sizeof tun); 64636285Sbrian if (n < 0) { 64737019Sbrian log_Printf(LogWARN, "read from %s: %s\n", TUN_NAME, strerror(errno)); 64836285Sbrian return; 64936285Sbrian } 65036285Sbrian n -= sizeof tun - sizeof tun.data; 65136285Sbrian if (n <= 0) { 65237019Sbrian log_Printf(LogERROR, "read from %s: Only %d bytes read ?\n", TUN_NAME, n); 65336285Sbrian return; 65436285Sbrian } 65536285Sbrian if (!tun_check_header(tun, AF_INET)) 65636285Sbrian return; 65736285Sbrian 65836285Sbrian if (((struct ip *)tun.data)->ip_dst.s_addr == 65936285Sbrian bundle->ncp.ipcp.my_ip.s_addr) { 66036285Sbrian /* we've been asked to send something addressed *to* us :( */ 66136285Sbrian if (Enabled(bundle, OPT_LOOPBACK)) { 66236285Sbrian pri = PacketCheck(bundle, tun.data, n, &bundle->filter.in); 66336285Sbrian if (pri >= 0) { 66436285Sbrian struct mbuf *bp; 66536285Sbrian 66636285Sbrian#ifndef NOALIAS 66737191Sbrian if (bundle->AliasEnabled) { 66837191Sbrian PacketAliasIn(tun.data, sizeof tun.data); 66936285Sbrian n = ntohs(((struct ip *)tun.data)->ip_len); 67036285Sbrian } 67136285Sbrian#endif 67236285Sbrian bp = mbuf_Alloc(n, MB_IPIN); 67336285Sbrian memcpy(MBUF_CTOP(bp), tun.data, n); 67436285Sbrian ip_Input(bundle, bp); 67536285Sbrian log_Printf(LogDEBUG, "Looped back packet addressed to myself\n"); 67636285Sbrian } 67736285Sbrian return; 67836285Sbrian } else 67936285Sbrian log_Printf(LogDEBUG, "Oops - forwarding packet addressed to myself\n"); 68036285Sbrian } 68136285Sbrian 68236285Sbrian /* 68336285Sbrian * Process on-demand dialup. Output packets are queued within tunnel 68436285Sbrian * device until IPCP is opened. 68536285Sbrian */ 68636285Sbrian 68736285Sbrian if (bundle_Phase(bundle) == PHASE_DEAD) { 68836285Sbrian /* 68936285Sbrian * Note, we must be in AUTO mode :-/ otherwise our interface should 69036285Sbrian * *not* be UP and we can't receive data 69136285Sbrian */ 69236285Sbrian if ((pri = PacketCheck(bundle, tun.data, n, &bundle->filter.dial)) >= 0) 69337955Sbrian bundle_Open(bundle, NULL, PHYS_AUTO, 0); 69436285Sbrian else 69536285Sbrian /* 69636285Sbrian * Drop the packet. If we were to queue it, we'd just end up with 69736285Sbrian * a pile of timed-out data in our output queue by the time we get 69836285Sbrian * around to actually dialing. We'd also prematurely reach the 69936285Sbrian * threshold at which we stop select()ing to read() the tun 70036285Sbrian * device - breaking auto-dial. 70136285Sbrian */ 70236285Sbrian return; 70336285Sbrian } 70436285Sbrian 70536285Sbrian pri = PacketCheck(bundle, tun.data, n, &bundle->filter.out); 70636285Sbrian if (pri >= 0) { 70736285Sbrian#ifndef NOALIAS 70837191Sbrian if (bundle->AliasEnabled) { 70937191Sbrian PacketAliasOut(tun.data, sizeof tun.data); 71036285Sbrian n = ntohs(((struct ip *)tun.data)->ip_len); 71136285Sbrian } 71236285Sbrian#endif 71338557Sbrian ip_Enqueue(&bundle->ncp.ipcp, pri, tun.data, n); 71436285Sbrian } 71536285Sbrian } 71636285Sbrian} 71736285Sbrian 71837141Sbrianstatic int 71936285Sbrianbundle_DescriptorWrite(struct descriptor *d, struct bundle *bundle, 72036285Sbrian const fd_set *fdset) 72136285Sbrian{ 72236285Sbrian struct datalink *dl; 72337141Sbrian int result = 0; 72436285Sbrian 72536285Sbrian /* This is not actually necessary as struct mpserver doesn't Write() */ 72636285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 72736285Sbrian descriptor_Write(&bundle->ncp.mp.server.desc, bundle, fdset); 72836285Sbrian 72936285Sbrian for (dl = bundle->links; dl; dl = dl->next) 73036285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 73137141Sbrian result += descriptor_Write(&dl->desc, bundle, fdset); 73237141Sbrian 73337141Sbrian return result; 73436285Sbrian} 73536285Sbrian 73636709Sbrianvoid 73736452Sbrianbundle_LockTun(struct bundle *bundle) 73836452Sbrian{ 73936452Sbrian FILE *lockfile; 74036452Sbrian char pidfile[MAXPATHLEN]; 74136285Sbrian 74236452Sbrian snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 74336452Sbrian lockfile = ID0fopen(pidfile, "w"); 74436452Sbrian if (lockfile != NULL) { 74536452Sbrian fprintf(lockfile, "%d\n", (int)getpid()); 74636452Sbrian fclose(lockfile); 74736452Sbrian } 74836452Sbrian#ifndef RELEASE_CRUNCH 74936452Sbrian else 75036452Sbrian log_Printf(LogERROR, "Warning: Can't create %s: %s\n", 75136452Sbrian pidfile, strerror(errno)); 75236452Sbrian#endif 75336452Sbrian} 75436452Sbrian 75536452Sbrianstatic void 75636452Sbrianbundle_UnlockTun(struct bundle *bundle) 75736452Sbrian{ 75836452Sbrian char pidfile[MAXPATHLEN]; 75936452Sbrian 76036452Sbrian snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 76136452Sbrian ID0unlink(pidfile); 76236452Sbrian} 76336452Sbrian 76436285Sbrianstruct bundle * 76536467Sbrianbundle_Create(const char *prefix, int type, const char **argv) 76636285Sbrian{ 76736285Sbrian int s, enoentcount, err; 76836285Sbrian struct ifreq ifrq; 76936285Sbrian static struct bundle bundle; /* there can be only one */ 77036285Sbrian 77136285Sbrian if (bundle.ifp.Name != NULL) { /* Already allocated ! */ 77237019Sbrian log_Printf(LogALERT, "bundle_Create: There's only one BUNDLE !\n"); 77336285Sbrian return NULL; 77436285Sbrian } 77536285Sbrian 77636285Sbrian err = ENOENT; 77736285Sbrian enoentcount = 0; 77836285Sbrian for (bundle.unit = 0; ; bundle.unit++) { 77936285Sbrian snprintf(bundle.dev.Name, sizeof bundle.dev.Name, "%s%d", 78036285Sbrian prefix, bundle.unit); 78136285Sbrian bundle.dev.fd = ID0open(bundle.dev.Name, O_RDWR); 78236285Sbrian if (bundle.dev.fd >= 0) 78336285Sbrian break; 78436285Sbrian else if (errno == ENXIO) { 78536285Sbrian err = errno; 78636285Sbrian break; 78736285Sbrian } else if (errno == ENOENT) { 78836285Sbrian if (++enoentcount > 2) 78936285Sbrian break; 79036285Sbrian } else 79136285Sbrian err = errno; 79236285Sbrian } 79336285Sbrian 79436285Sbrian if (bundle.dev.fd < 0) { 79536285Sbrian log_Printf(LogWARN, "No available tunnel devices found (%s).\n", 79636285Sbrian strerror(err)); 79736285Sbrian return NULL; 79836285Sbrian } 79936285Sbrian 80036285Sbrian log_SetTun(bundle.unit); 80136467Sbrian bundle.argv = argv; 80236285Sbrian 80336285Sbrian s = socket(AF_INET, SOCK_DGRAM, 0); 80436285Sbrian if (s < 0) { 80536285Sbrian log_Printf(LogERROR, "bundle_Create: socket(): %s\n", strerror(errno)); 80636285Sbrian close(bundle.dev.fd); 80736285Sbrian return NULL; 80836285Sbrian } 80936285Sbrian 81036285Sbrian bundle.ifp.Name = strrchr(bundle.dev.Name, '/'); 81136285Sbrian if (bundle.ifp.Name == NULL) 81236285Sbrian bundle.ifp.Name = bundle.dev.Name; 81336285Sbrian else 81436285Sbrian bundle.ifp.Name++; 81536285Sbrian 81636285Sbrian /* 81736285Sbrian * Now, bring up the interface. 81836285Sbrian */ 81936285Sbrian memset(&ifrq, '\0', sizeof ifrq); 82036285Sbrian strncpy(ifrq.ifr_name, bundle.ifp.Name, sizeof ifrq.ifr_name - 1); 82136285Sbrian ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0'; 82236285Sbrian if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) { 82337019Sbrian log_Printf(LogERROR, "bundle_Create: ioctl(SIOCGIFFLAGS): %s\n", 82436285Sbrian strerror(errno)); 82536285Sbrian close(s); 82636285Sbrian close(bundle.dev.fd); 82736285Sbrian bundle.ifp.Name = NULL; 82836285Sbrian return NULL; 82936285Sbrian } 83036285Sbrian ifrq.ifr_flags |= IFF_UP; 83136285Sbrian if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) { 83237019Sbrian log_Printf(LogERROR, "bundle_Create: ioctl(SIOCSIFFLAGS): %s\n", 83336285Sbrian strerror(errno)); 83436285Sbrian close(s); 83536285Sbrian close(bundle.dev.fd); 83636285Sbrian bundle.ifp.Name = NULL; 83736285Sbrian return NULL; 83836285Sbrian } 83936285Sbrian 84036285Sbrian close(s); 84136285Sbrian 84236285Sbrian if ((bundle.ifp.Index = GetIfIndex(bundle.ifp.Name)) < 0) { 84337019Sbrian log_Printf(LogERROR, "Can't find interface index.\n"); 84436285Sbrian close(bundle.dev.fd); 84536285Sbrian bundle.ifp.Name = NULL; 84636285Sbrian return NULL; 84736285Sbrian } 84836285Sbrian log_Printf(LogPHASE, "Using interface: %s\n", bundle.ifp.Name); 84936285Sbrian 85036285Sbrian bundle.ifp.Speed = 0; 85136285Sbrian 85236285Sbrian bundle.routing_seq = 0; 85336285Sbrian bundle.phase = PHASE_DEAD; 85436285Sbrian bundle.CleaningUp = 0; 85537191Sbrian bundle.AliasEnabled = 0; 85636285Sbrian 85736285Sbrian bundle.fsm.LayerStart = bundle_LayerStart; 85836285Sbrian bundle.fsm.LayerUp = bundle_LayerUp; 85936285Sbrian bundle.fsm.LayerDown = bundle_LayerDown; 86036285Sbrian bundle.fsm.LayerFinish = bundle_LayerFinish; 86136285Sbrian bundle.fsm.object = &bundle; 86236285Sbrian 86336285Sbrian bundle.cfg.idle_timeout = NCP_IDLE_TIMEOUT; 86436285Sbrian *bundle.cfg.auth.name = '\0'; 86536285Sbrian *bundle.cfg.auth.key = '\0'; 86636285Sbrian bundle.cfg.opt = OPT_SROUTES | OPT_IDCHECK | OPT_LOOPBACK | 86736285Sbrian OPT_THROUGHPUT | OPT_UTMP; 86836285Sbrian *bundle.cfg.label = '\0'; 86936285Sbrian bundle.cfg.mtu = DEF_MTU; 87036285Sbrian bundle.cfg.autoload.max.packets = 0; 87136285Sbrian bundle.cfg.autoload.max.timeout = 0; 87236285Sbrian bundle.cfg.autoload.min.packets = 0; 87336285Sbrian bundle.cfg.autoload.min.timeout = 0; 87438544Sbrian bundle.cfg.choked.timeout = CHOKED_TIMEOUT; 87536928Sbrian bundle.phys_type.all = type; 87636928Sbrian bundle.phys_type.open = 0; 87736285Sbrian 87836285Sbrian bundle.links = datalink_Create("deflink", &bundle, type); 87936285Sbrian if (bundle.links == NULL) { 88037019Sbrian log_Printf(LogALERT, "Cannot create data link: %s\n", strerror(errno)); 88136285Sbrian close(bundle.dev.fd); 88236285Sbrian bundle.ifp.Name = NULL; 88336285Sbrian return NULL; 88436285Sbrian } 88536285Sbrian 88636285Sbrian bundle.desc.type = BUNDLE_DESCRIPTOR; 88736285Sbrian bundle.desc.UpdateSet = bundle_UpdateSet; 88836285Sbrian bundle.desc.IsSet = bundle_IsSet; 88936285Sbrian bundle.desc.Read = bundle_DescriptorRead; 89036285Sbrian bundle.desc.Write = bundle_DescriptorWrite; 89136285Sbrian 89236285Sbrian mp_Init(&bundle.ncp.mp, &bundle); 89336285Sbrian 89436285Sbrian /* Send over the first physical link by default */ 89536285Sbrian ipcp_Init(&bundle.ncp.ipcp, &bundle, &bundle.links->physical->link, 89636285Sbrian &bundle.fsm); 89736285Sbrian 89836285Sbrian memset(&bundle.filter, '\0', sizeof bundle.filter); 89936285Sbrian bundle.filter.in.fragok = bundle.filter.in.logok = 1; 90036285Sbrian bundle.filter.in.name = "IN"; 90136285Sbrian bundle.filter.out.fragok = bundle.filter.out.logok = 1; 90236285Sbrian bundle.filter.out.name = "OUT"; 90336285Sbrian bundle.filter.dial.name = "DIAL"; 90436285Sbrian bundle.filter.dial.logok = 1; 90536285Sbrian bundle.filter.alive.name = "ALIVE"; 90636285Sbrian bundle.filter.alive.logok = 1; 90736285Sbrian memset(&bundle.idle.timer, '\0', sizeof bundle.idle.timer); 90836285Sbrian bundle.idle.done = 0; 90936285Sbrian bundle.notify.fd = -1; 91036285Sbrian memset(&bundle.autoload.timer, '\0', sizeof bundle.autoload.timer); 91136285Sbrian bundle.autoload.done = 0; 91236285Sbrian bundle.autoload.running = 0; 91338544Sbrian memset(&bundle.choked.timer, '\0', sizeof bundle.choked.timer); 91436285Sbrian 91536285Sbrian /* Clean out any leftover crud */ 91636285Sbrian bundle_CleanInterface(&bundle); 91736285Sbrian 91836452Sbrian bundle_LockTun(&bundle); 91936452Sbrian 92036285Sbrian return &bundle; 92136285Sbrian} 92236285Sbrian 92336285Sbrianstatic void 92436285Sbrianbundle_DownInterface(struct bundle *bundle) 92536285Sbrian{ 92636285Sbrian struct ifreq ifrq; 92736285Sbrian int s; 92836285Sbrian 92936285Sbrian route_IfDelete(bundle, 1); 93036285Sbrian 93136285Sbrian s = ID0socket(AF_INET, SOCK_DGRAM, 0); 93236285Sbrian if (s < 0) { 93336285Sbrian log_Printf(LogERROR, "bundle_DownInterface: socket: %s\n", strerror(errno)); 93436285Sbrian return; 93536285Sbrian } 93636285Sbrian 93736285Sbrian memset(&ifrq, '\0', sizeof ifrq); 93836285Sbrian strncpy(ifrq.ifr_name, bundle->ifp.Name, sizeof ifrq.ifr_name - 1); 93936285Sbrian ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0'; 94036285Sbrian if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) { 94136285Sbrian log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCGIFFLAGS): %s\n", 94236285Sbrian strerror(errno)); 94336285Sbrian close(s); 94436285Sbrian return; 94536285Sbrian } 94636285Sbrian ifrq.ifr_flags &= ~IFF_UP; 94736285Sbrian if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) { 94836285Sbrian log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCSIFFLAGS): %s\n", 94936285Sbrian strerror(errno)); 95036285Sbrian close(s); 95136285Sbrian return; 95236285Sbrian } 95336285Sbrian close(s); 95436285Sbrian} 95536285Sbrian 95636285Sbrianvoid 95736285Sbrianbundle_Destroy(struct bundle *bundle) 95836285Sbrian{ 95936285Sbrian struct datalink *dl; 96036285Sbrian 96136285Sbrian /* 96236285Sbrian * Clean up the interface. We don't need to timer_Stop()s, mp_Down(), 96336285Sbrian * ipcp_CleanInterface() and bundle_DownInterface() unless we're getting 96436285Sbrian * out under exceptional conditions such as a descriptor exception. 96536285Sbrian */ 96636285Sbrian timer_Stop(&bundle->idle.timer); 96738544Sbrian timer_Stop(&bundle->choked.timer); 96836285Sbrian timer_Stop(&bundle->autoload.timer); 96936285Sbrian mp_Down(&bundle->ncp.mp); 97036285Sbrian ipcp_CleanInterface(&bundle->ncp.ipcp); 97136285Sbrian bundle_DownInterface(bundle); 97236452Sbrian 97336285Sbrian /* Again, these are all DATALINK_CLOSED unless we're abending */ 97436285Sbrian dl = bundle->links; 97536285Sbrian while (dl) 97636285Sbrian dl = datalink_Destroy(dl); 97736285Sbrian 97836452Sbrian close(bundle->dev.fd); 97936452Sbrian bundle_UnlockTun(bundle); 98036452Sbrian 98136285Sbrian /* In case we never made PHASE_NETWORK */ 98236285Sbrian bundle_Notify(bundle, EX_ERRDEAD); 98336285Sbrian 98436285Sbrian bundle->ifp.Name = NULL; 98536285Sbrian} 98636285Sbrian 98736285Sbrianstruct rtmsg { 98836285Sbrian struct rt_msghdr m_rtm; 98936285Sbrian char m_space[64]; 99036285Sbrian}; 99136285Sbrian 99236285Sbrianint 99336285Sbrianbundle_SetRoute(struct bundle *bundle, int cmd, struct in_addr dst, 99437927Sbrian struct in_addr gateway, struct in_addr mask, int bang, int ssh) 99536285Sbrian{ 99636285Sbrian struct rtmsg rtmes; 99736285Sbrian int s, nb, wb; 99836285Sbrian char *cp; 99936285Sbrian const char *cmdstr; 100036285Sbrian struct sockaddr_in rtdata; 100136285Sbrian int result = 1; 100236285Sbrian 100336285Sbrian if (bang) 100436285Sbrian cmdstr = (cmd == RTM_ADD ? "Add!" : "Delete!"); 100536285Sbrian else 100636285Sbrian cmdstr = (cmd == RTM_ADD ? "Add" : "Delete"); 100736285Sbrian s = ID0socket(PF_ROUTE, SOCK_RAW, 0); 100836285Sbrian if (s < 0) { 100936285Sbrian log_Printf(LogERROR, "bundle_SetRoute: socket(): %s\n", strerror(errno)); 101036285Sbrian return result; 101136285Sbrian } 101236285Sbrian memset(&rtmes, '\0', sizeof rtmes); 101336285Sbrian rtmes.m_rtm.rtm_version = RTM_VERSION; 101436285Sbrian rtmes.m_rtm.rtm_type = cmd; 101536285Sbrian rtmes.m_rtm.rtm_addrs = RTA_DST; 101636285Sbrian rtmes.m_rtm.rtm_seq = ++bundle->routing_seq; 101736285Sbrian rtmes.m_rtm.rtm_pid = getpid(); 101836285Sbrian rtmes.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC; 101936285Sbrian 102036285Sbrian memset(&rtdata, '\0', sizeof rtdata); 102136285Sbrian rtdata.sin_len = sizeof rtdata; 102236285Sbrian rtdata.sin_family = AF_INET; 102336285Sbrian rtdata.sin_port = 0; 102436285Sbrian rtdata.sin_addr = dst; 102536285Sbrian 102636285Sbrian cp = rtmes.m_space; 102736285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 102836285Sbrian cp += rtdata.sin_len; 102936285Sbrian if (cmd == RTM_ADD) { 103036285Sbrian if (gateway.s_addr == INADDR_ANY) { 103136285Sbrian /* Add a route through the interface */ 103236285Sbrian struct sockaddr_dl dl; 103336285Sbrian const char *iname; 103436285Sbrian int ilen; 103536285Sbrian 103636285Sbrian iname = Index2Nam(bundle->ifp.Index); 103736285Sbrian ilen = strlen(iname); 103836285Sbrian dl.sdl_len = sizeof dl - sizeof dl.sdl_data + ilen; 103936285Sbrian dl.sdl_family = AF_LINK; 104036285Sbrian dl.sdl_index = bundle->ifp.Index; 104136285Sbrian dl.sdl_type = 0; 104236285Sbrian dl.sdl_nlen = ilen; 104336285Sbrian dl.sdl_alen = 0; 104436285Sbrian dl.sdl_slen = 0; 104536285Sbrian strncpy(dl.sdl_data, iname, sizeof dl.sdl_data); 104636285Sbrian memcpy(cp, &dl, dl.sdl_len); 104736285Sbrian cp += dl.sdl_len; 104836285Sbrian rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY; 104936285Sbrian } else { 105036285Sbrian rtdata.sin_addr = gateway; 105136285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 105236285Sbrian cp += rtdata.sin_len; 105336285Sbrian rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY; 105436285Sbrian } 105536285Sbrian } 105636285Sbrian 105736285Sbrian if (dst.s_addr == INADDR_ANY) 105836285Sbrian mask.s_addr = INADDR_ANY; 105936285Sbrian 106036285Sbrian if (cmd == RTM_ADD || dst.s_addr == INADDR_ANY) { 106136285Sbrian rtdata.sin_addr = mask; 106236285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 106336285Sbrian cp += rtdata.sin_len; 106436285Sbrian rtmes.m_rtm.rtm_addrs |= RTA_NETMASK; 106536285Sbrian } 106636285Sbrian 106736285Sbrian nb = cp - (char *) &rtmes; 106836285Sbrian rtmes.m_rtm.rtm_msglen = nb; 106936285Sbrian wb = ID0write(s, &rtmes, nb); 107036285Sbrian if (wb < 0) { 107136285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute failure:\n"); 107236285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Cmd = %s\n", cmdstr); 107336285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Dst = %s\n", inet_ntoa(dst)); 107436285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Gateway = %s\n", inet_ntoa(gateway)); 107536285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Mask = %s\n", inet_ntoa(mask)); 107636285Sbrianfailed: 107736285Sbrian if (cmd == RTM_ADD && (rtmes.m_rtm.rtm_errno == EEXIST || 107836285Sbrian (rtmes.m_rtm.rtm_errno == 0 && errno == EEXIST))) { 107936285Sbrian if (!bang) { 108036285Sbrian log_Printf(LogWARN, "Add route failed: %s already exists\n", 108136285Sbrian inet_ntoa(dst)); 108236285Sbrian result = 0; /* Don't add to our dynamic list */ 108336285Sbrian } else { 108436285Sbrian rtmes.m_rtm.rtm_type = cmd = RTM_CHANGE; 108536285Sbrian if ((wb = ID0write(s, &rtmes, nb)) < 0) 108636285Sbrian goto failed; 108736285Sbrian } 108836285Sbrian } else if (cmd == RTM_DELETE && 108936285Sbrian (rtmes.m_rtm.rtm_errno == ESRCH || 109036285Sbrian (rtmes.m_rtm.rtm_errno == 0 && errno == ESRCH))) { 109136285Sbrian if (!bang) 109236285Sbrian log_Printf(LogWARN, "Del route failed: %s: Non-existent\n", 109336285Sbrian inet_ntoa(dst)); 109437927Sbrian } else if (rtmes.m_rtm.rtm_errno == 0) { 109537927Sbrian if (!ssh || errno != ENETUNREACH) 109637927Sbrian log_Printf(LogWARN, "%s route failed: %s: errno: %s\n", cmdstr, 109737927Sbrian inet_ntoa(dst), strerror(errno)); 109837927Sbrian } else 109936285Sbrian log_Printf(LogWARN, "%s route failed: %s: %s\n", 110037927Sbrian cmdstr, inet_ntoa(dst), strerror(rtmes.m_rtm.rtm_errno)); 110136285Sbrian } 110236285Sbrian log_Printf(LogDEBUG, "wrote %d: cmd = %s, dst = %x, gateway = %x\n", 110336285Sbrian wb, cmdstr, (unsigned)dst.s_addr, (unsigned)gateway.s_addr); 110436285Sbrian close(s); 110536285Sbrian 110636285Sbrian return result; 110736285Sbrian} 110836285Sbrian 110936285Sbrianvoid 111036285Sbrianbundle_LinkClosed(struct bundle *bundle, struct datalink *dl) 111136285Sbrian{ 111236285Sbrian /* 111336285Sbrian * Our datalink has closed. 111436285Sbrian * CleanDatalinks() (called from DoLoop()) will remove closed 111536465Sbrian * BACKGROUND and DIRECT links. 111636285Sbrian * If it's the last data link, enter phase DEAD. 111736285Sbrian * 111836285Sbrian * NOTE: dl may not be in our list (bundle_SendDatalink()) ! 111936285Sbrian */ 112036285Sbrian 112136285Sbrian struct datalink *odl; 112236285Sbrian int other_links; 112336285Sbrian 112438200Sbrian log_SetTtyCommandMode(dl); 112538200Sbrian 112636285Sbrian other_links = 0; 112736285Sbrian for (odl = bundle->links; odl; odl = odl->next) 112836285Sbrian if (odl != dl && odl->state != DATALINK_CLOSED) 112936285Sbrian other_links++; 113036285Sbrian 113136285Sbrian if (!other_links) { 113236465Sbrian if (dl->physical->type != PHYS_AUTO) /* Not in -auto mode */ 113336285Sbrian bundle_DownInterface(bundle); 113437060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 113536285Sbrian bundle_NewPhase(bundle, PHASE_DEAD); 113636314Sbrian bundle_StopIdleTimer(bundle); 113736285Sbrian bundle_StopAutoLoadTimer(bundle); 113836285Sbrian bundle->autoload.running = 0; 113936285Sbrian } else 114036285Sbrian bundle->autoload.running = 1; 114136285Sbrian} 114236285Sbrian 114336285Sbrianvoid 114437955Sbrianbundle_Open(struct bundle *bundle, const char *name, int mask, int force) 114536285Sbrian{ 114636285Sbrian /* 114736285Sbrian * Please open the given datalink, or all if name == NULL 114836285Sbrian */ 114936285Sbrian struct datalink *dl; 115036285Sbrian 115136285Sbrian timer_Stop(&bundle->autoload.timer); 115236285Sbrian for (dl = bundle->links; dl; dl = dl->next) 115336285Sbrian if (name == NULL || !strcasecmp(dl->name, name)) { 115437955Sbrian if ((mask & dl->physical->type) && 115537955Sbrian (dl->state == DATALINK_CLOSED || 115637955Sbrian (force && dl->state == DATALINK_OPENING && 115737955Sbrian dl->dial_timer.state == TIMER_RUNNING))) { 115837955Sbrian if (force) 115937955Sbrian timer_Stop(&dl->dial_timer); 116036285Sbrian datalink_Up(dl, 1, 1); 116136465Sbrian if (mask == PHYS_AUTO) 116236465Sbrian /* Only one AUTO link at a time (see the AutoLoad timer) */ 116336285Sbrian break; 116436285Sbrian } 116536285Sbrian if (name != NULL) 116636285Sbrian break; 116736285Sbrian } 116836285Sbrian} 116936285Sbrian 117036285Sbrianstruct datalink * 117136285Sbrianbundle2datalink(struct bundle *bundle, const char *name) 117236285Sbrian{ 117336285Sbrian struct datalink *dl; 117436285Sbrian 117536285Sbrian if (name != NULL) { 117636285Sbrian for (dl = bundle->links; dl; dl = dl->next) 117736285Sbrian if (!strcasecmp(dl->name, name)) 117836285Sbrian return dl; 117936285Sbrian } else if (bundle->links && !bundle->links->next) 118036285Sbrian return bundle->links; 118136285Sbrian 118236285Sbrian return NULL; 118336285Sbrian} 118436285Sbrian 118536285Sbrianint 118636285Sbrianbundle_FillQueues(struct bundle *bundle) 118736285Sbrian{ 118836285Sbrian int total; 118936285Sbrian 119036285Sbrian if (bundle->ncp.mp.active) 119136285Sbrian total = mp_FillQueues(bundle); 119236285Sbrian else { 119336285Sbrian struct datalink *dl; 119436285Sbrian int add; 119536285Sbrian 119636285Sbrian for (total = 0, dl = bundle->links; dl; dl = dl->next) 119736285Sbrian if (dl->state == DATALINK_OPEN) { 119836285Sbrian add = link_QueueLen(&dl->physical->link); 119936285Sbrian if (add == 0 && dl->physical->out == NULL) 120036285Sbrian add = ip_FlushPacket(&dl->physical->link, bundle); 120136285Sbrian total += add; 120236285Sbrian } 120336285Sbrian } 120436285Sbrian 120538557Sbrian return total + ip_QueueLen(&bundle->ncp.ipcp); 120636285Sbrian} 120736285Sbrian 120836285Sbrianint 120936285Sbrianbundle_ShowLinks(struct cmdargs const *arg) 121036285Sbrian{ 121136285Sbrian struct datalink *dl; 121236285Sbrian 121336285Sbrian for (dl = arg->bundle->links; dl; dl = dl->next) { 121436316Sbrian prompt_Printf(arg->prompt, "Name: %s [%s, %s]", 121536316Sbrian dl->name, mode2Nam(dl->physical->type), datalink_State(dl)); 121636285Sbrian if (dl->physical->link.throughput.rolling && dl->state == DATALINK_OPEN) 121736316Sbrian prompt_Printf(arg->prompt, " weight %d, %d bytes/sec", 121836285Sbrian dl->mp.weight, 121936285Sbrian dl->physical->link.throughput.OctetsPerSecond); 122036285Sbrian prompt_Printf(arg->prompt, "\n"); 122136285Sbrian } 122236285Sbrian 122336285Sbrian return 0; 122436285Sbrian} 122536285Sbrian 122636285Sbrianstatic const char * 122736285Sbrianoptval(struct bundle *bundle, int bit) 122836285Sbrian{ 122936285Sbrian return (bundle->cfg.opt & bit) ? "enabled" : "disabled"; 123036285Sbrian} 123136285Sbrian 123236285Sbrianint 123336285Sbrianbundle_ShowStatus(struct cmdargs const *arg) 123436285Sbrian{ 123536285Sbrian int remaining; 123636285Sbrian 123736285Sbrian prompt_Printf(arg->prompt, "Phase %s\n", bundle_PhaseName(arg->bundle)); 123836285Sbrian prompt_Printf(arg->prompt, " Device: %s\n", arg->bundle->dev.Name); 123936285Sbrian prompt_Printf(arg->prompt, " Interface: %s @ %lubps\n", 124036285Sbrian arg->bundle->ifp.Name, arg->bundle->ifp.Speed); 124136285Sbrian 124236285Sbrian prompt_Printf(arg->prompt, "\nDefaults:\n"); 124336285Sbrian prompt_Printf(arg->prompt, " Label: %s\n", arg->bundle->cfg.label); 124436285Sbrian prompt_Printf(arg->prompt, " Auth name: %s\n", 124536285Sbrian arg->bundle->cfg.auth.name); 124636285Sbrian prompt_Printf(arg->prompt, " Auto Load: Up after %ds of >= %d packets\n", 124736285Sbrian arg->bundle->cfg.autoload.max.timeout, 124836285Sbrian arg->bundle->cfg.autoload.max.packets); 124936285Sbrian prompt_Printf(arg->prompt, " Down after %ds of <= %d" 125036285Sbrian " packets\n", arg->bundle->cfg.autoload.min.timeout, 125136285Sbrian arg->bundle->cfg.autoload.min.packets); 125236285Sbrian if (arg->bundle->autoload.timer.state == TIMER_RUNNING) 125336285Sbrian prompt_Printf(arg->prompt, " %ds remaining 'till " 125436285Sbrian "a link comes %s\n", 125536285Sbrian bundle_RemainingAutoLoadTime(arg->bundle), 125636285Sbrian arg->bundle->autoload.comingup ? "up" : "down"); 125736285Sbrian else 125836285Sbrian prompt_Printf(arg->prompt, " %srunning with %d" 125936285Sbrian " packets queued\n", arg->bundle->autoload.running ? 126038557Sbrian "" : "not ", ip_QueueLen(&arg->bundle->ncp.ipcp)); 126136285Sbrian 126238544Sbrian prompt_Printf(arg->prompt, " Choked Timer: %ds\n", 126338544Sbrian arg->bundle->cfg.choked.timeout); 126436285Sbrian prompt_Printf(arg->prompt, " Idle Timer: "); 126536285Sbrian if (arg->bundle->cfg.idle_timeout) { 126636285Sbrian prompt_Printf(arg->prompt, "%ds", arg->bundle->cfg.idle_timeout); 126736285Sbrian remaining = bundle_RemainingIdleTime(arg->bundle); 126836285Sbrian if (remaining != -1) 126936285Sbrian prompt_Printf(arg->prompt, " (%ds remaining)", remaining); 127036285Sbrian prompt_Printf(arg->prompt, "\n"); 127136285Sbrian } else 127236285Sbrian prompt_Printf(arg->prompt, "disabled\n"); 127336285Sbrian prompt_Printf(arg->prompt, " MTU: "); 127436285Sbrian if (arg->bundle->cfg.mtu) 127536285Sbrian prompt_Printf(arg->prompt, "%d\n", arg->bundle->cfg.mtu); 127636285Sbrian else 127736285Sbrian prompt_Printf(arg->prompt, "unspecified\n"); 127836285Sbrian 127936285Sbrian prompt_Printf(arg->prompt, " Sticky Routes: %s\n", 128036285Sbrian optval(arg->bundle, OPT_SROUTES)); 128136285Sbrian prompt_Printf(arg->prompt, " ID check: %s\n", 128236285Sbrian optval(arg->bundle, OPT_IDCHECK)); 128336285Sbrian prompt_Printf(arg->prompt, " Loopback: %s\n", 128436285Sbrian optval(arg->bundle, OPT_LOOPBACK)); 128536285Sbrian prompt_Printf(arg->prompt, " PasswdAuth: %s\n", 128636285Sbrian optval(arg->bundle, OPT_PASSWDAUTH)); 128736285Sbrian prompt_Printf(arg->prompt, " Proxy: %s\n", 128836285Sbrian optval(arg->bundle, OPT_PROXY)); 128936285Sbrian prompt_Printf(arg->prompt, " Throughput: %s\n", 129036285Sbrian optval(arg->bundle, OPT_THROUGHPUT)); 129136285Sbrian prompt_Printf(arg->prompt, " Utmp Logging: %s\n", 129236285Sbrian optval(arg->bundle, OPT_UTMP)); 129336285Sbrian 129436285Sbrian return 0; 129536285Sbrian} 129636285Sbrian 129736285Sbrianstatic void 129836285Sbrianbundle_IdleTimeout(void *v) 129936285Sbrian{ 130036285Sbrian struct bundle *bundle = (struct bundle *)v; 130136285Sbrian 130236285Sbrian log_Printf(LogPHASE, "Idle timer expired.\n"); 130336285Sbrian bundle_StopIdleTimer(bundle); 130437007Sbrian bundle_Close(bundle, NULL, CLOSE_STAYDOWN); 130536285Sbrian} 130636285Sbrian 130736285Sbrian/* 130836285Sbrian * Start Idle timer. If timeout is reached, we call bundle_Close() to 130936285Sbrian * close LCP and link. 131036285Sbrian */ 131136285Sbrianvoid 131236285Sbrianbundle_StartIdleTimer(struct bundle *bundle) 131336285Sbrian{ 131436285Sbrian timer_Stop(&bundle->idle.timer); 131536928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) != 131636928Sbrian bundle->phys_type.open && bundle->cfg.idle_timeout) { 131736285Sbrian bundle->idle.timer.func = bundle_IdleTimeout; 131836285Sbrian bundle->idle.timer.name = "idle"; 131936285Sbrian bundle->idle.timer.load = bundle->cfg.idle_timeout * SECTICKS; 132036285Sbrian bundle->idle.timer.arg = bundle; 132136285Sbrian timer_Start(&bundle->idle.timer); 132236285Sbrian bundle->idle.done = time(NULL) + bundle->cfg.idle_timeout; 132336285Sbrian } 132436285Sbrian} 132536285Sbrian 132636285Sbrianvoid 132736285Sbrianbundle_SetIdleTimer(struct bundle *bundle, int value) 132836285Sbrian{ 132936285Sbrian bundle->cfg.idle_timeout = value; 133036285Sbrian if (bundle_LinkIsUp(bundle)) 133136285Sbrian bundle_StartIdleTimer(bundle); 133236285Sbrian} 133336285Sbrian 133436285Sbrianvoid 133536285Sbrianbundle_StopIdleTimer(struct bundle *bundle) 133636285Sbrian{ 133736285Sbrian timer_Stop(&bundle->idle.timer); 133836285Sbrian bundle->idle.done = 0; 133936285Sbrian} 134036285Sbrian 134136285Sbrianstatic int 134236285Sbrianbundle_RemainingIdleTime(struct bundle *bundle) 134336285Sbrian{ 134436285Sbrian if (bundle->idle.done) 134536285Sbrian return bundle->idle.done - time(NULL); 134636285Sbrian return -1; 134736285Sbrian} 134836285Sbrian 134936285Sbrianint 135036285Sbrianbundle_IsDead(struct bundle *bundle) 135136285Sbrian{ 135236285Sbrian return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp); 135336285Sbrian} 135436285Sbrian 135536285Sbrianstatic struct datalink * 135636285Sbrianbundle_DatalinkLinkout(struct bundle *bundle, struct datalink *dl) 135736285Sbrian{ 135836285Sbrian struct datalink **dlp; 135936285Sbrian 136036314Sbrian for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next) 136136314Sbrian if (*dlp == dl) { 136236314Sbrian *dlp = dl->next; 136336314Sbrian dl->next = NULL; 136436314Sbrian bundle_LinksRemoved(bundle); 136536314Sbrian return dl; 136636314Sbrian } 136736285Sbrian 136836285Sbrian return NULL; 136936285Sbrian} 137036285Sbrian 137136285Sbrianstatic void 137236285Sbrianbundle_DatalinkLinkin(struct bundle *bundle, struct datalink *dl) 137336285Sbrian{ 137436285Sbrian struct datalink **dlp = &bundle->links; 137536285Sbrian 137636285Sbrian while (*dlp) 137736285Sbrian dlp = &(*dlp)->next; 137836285Sbrian 137936285Sbrian *dlp = dl; 138036285Sbrian dl->next = NULL; 138136285Sbrian 138236285Sbrian bundle_LinkAdded(bundle, dl); 138336285Sbrian} 138436285Sbrian 138536285Sbrianvoid 138636285Sbrianbundle_CleanDatalinks(struct bundle *bundle) 138736285Sbrian{ 138836285Sbrian struct datalink **dlp = &bundle->links; 138936285Sbrian int found = 0; 139036285Sbrian 139136285Sbrian while (*dlp) 139236285Sbrian if ((*dlp)->state == DATALINK_CLOSED && 139336465Sbrian (*dlp)->physical->type & (PHYS_DIRECT|PHYS_BACKGROUND)) { 139436285Sbrian *dlp = datalink_Destroy(*dlp); 139536285Sbrian found++; 139636285Sbrian } else 139736285Sbrian dlp = &(*dlp)->next; 139836285Sbrian 139936285Sbrian if (found) 140036285Sbrian bundle_LinksRemoved(bundle); 140136285Sbrian} 140236285Sbrian 140336285Sbrianint 140436285Sbrianbundle_DatalinkClone(struct bundle *bundle, struct datalink *dl, 140536285Sbrian const char *name) 140636285Sbrian{ 140736285Sbrian if (bundle2datalink(bundle, name)) { 140836285Sbrian log_Printf(LogWARN, "Clone: %s: name already exists\n", name); 140936285Sbrian return 0; 141036285Sbrian } 141136285Sbrian 141236285Sbrian bundle_DatalinkLinkin(bundle, datalink_Clone(dl, name)); 141336285Sbrian return 1; 141436285Sbrian} 141536285Sbrian 141636285Sbrianvoid 141736285Sbrianbundle_DatalinkRemove(struct bundle *bundle, struct datalink *dl) 141836285Sbrian{ 141936285Sbrian dl = bundle_DatalinkLinkout(bundle, dl); 142036285Sbrian if (dl) 142136285Sbrian datalink_Destroy(dl); 142236285Sbrian} 142336285Sbrian 142436285Sbrianvoid 142536285Sbrianbundle_SetLabel(struct bundle *bundle, const char *label) 142636285Sbrian{ 142736285Sbrian if (label) 142836285Sbrian strncpy(bundle->cfg.label, label, sizeof bundle->cfg.label - 1); 142936285Sbrian else 143036285Sbrian *bundle->cfg.label = '\0'; 143136285Sbrian} 143236285Sbrian 143336285Sbrianconst char * 143436285Sbrianbundle_GetLabel(struct bundle *bundle) 143536285Sbrian{ 143636285Sbrian return *bundle->cfg.label ? bundle->cfg.label : NULL; 143736285Sbrian} 143836285Sbrian 143936285Sbrianvoid 144036285Sbrianbundle_ReceiveDatalink(struct bundle *bundle, int s, struct sockaddr_un *sun) 144136285Sbrian{ 144236285Sbrian char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)]; 144336285Sbrian struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 144436285Sbrian struct msghdr msg; 144536285Sbrian struct iovec iov[SCATTER_SEGMENTS]; 144636285Sbrian struct datalink *dl; 144736285Sbrian int niov, link_fd, expect, f; 144836450Sbrian pid_t pid; 144936285Sbrian 145036285Sbrian log_Printf(LogPHASE, "Receiving datalink\n"); 145136285Sbrian 145236285Sbrian /* Create our scatter/gather array */ 145336285Sbrian niov = 1; 145436285Sbrian iov[0].iov_len = strlen(Version) + 1; 145536285Sbrian iov[0].iov_base = (char *)malloc(iov[0].iov_len); 145636450Sbrian if (datalink2iov(NULL, iov, &niov, sizeof iov / sizeof *iov, 0) == -1) { 145736345Sbrian close(s); 145836285Sbrian return; 145936345Sbrian } 146036285Sbrian 146136450Sbrian pid = getpid(); 146236450Sbrian write(s, &pid, sizeof pid); 146336450Sbrian 146436285Sbrian for (f = expect = 0; f < niov; f++) 146536285Sbrian expect += iov[f].iov_len; 146636285Sbrian 146736285Sbrian /* Set up our message */ 146836285Sbrian cmsg->cmsg_len = sizeof cmsgbuf; 146936285Sbrian cmsg->cmsg_level = SOL_SOCKET; 147036345Sbrian cmsg->cmsg_type = 0; 147136285Sbrian 147236285Sbrian memset(&msg, '\0', sizeof msg); 147336285Sbrian msg.msg_name = (caddr_t)sun; 147436285Sbrian msg.msg_namelen = sizeof *sun; 147536285Sbrian msg.msg_iov = iov; 147636285Sbrian msg.msg_iovlen = niov; 147736285Sbrian msg.msg_control = cmsgbuf; 147836285Sbrian msg.msg_controllen = sizeof cmsgbuf; 147936285Sbrian 148036285Sbrian log_Printf(LogDEBUG, "Expecting %d scatter/gather bytes\n", expect); 148136285Sbrian f = expect + 100; 148236285Sbrian setsockopt(s, SOL_SOCKET, SO_RCVBUF, &f, sizeof f); 148336285Sbrian if ((f = recvmsg(s, &msg, MSG_WAITALL)) != expect) { 148436285Sbrian if (f == -1) 148536285Sbrian log_Printf(LogERROR, "Failed recvmsg: %s\n", strerror(errno)); 148636285Sbrian else 148736285Sbrian log_Printf(LogERROR, "Failed recvmsg: Got %d, not %d\n", f, expect); 148836285Sbrian while (niov--) 148936285Sbrian free(iov[niov].iov_base); 149036345Sbrian close(s); 149136285Sbrian return; 149236285Sbrian } 149336285Sbrian 149436345Sbrian write(s, "!", 1); /* ACK */ 149537054Sbrian close(s); 149636285Sbrian 149737054Sbrian if (cmsg->cmsg_type != SCM_RIGHTS) { 149837054Sbrian log_Printf(LogERROR, "Recvmsg: no descriptor received !\n"); 149937054Sbrian while (niov--) 150037054Sbrian free(iov[niov].iov_base); 150137054Sbrian return; 150236345Sbrian } 150336285Sbrian 150437054Sbrian /* We've successfully received an open file descriptor through our socket */ 150537054Sbrian log_Printf(LogDEBUG, "Receiving device descriptor\n"); 150637054Sbrian link_fd = *(int *)CMSG_DATA(cmsg); 150737054Sbrian 150836285Sbrian if (strncmp(Version, iov[0].iov_base, iov[0].iov_len)) { 150936285Sbrian log_Printf(LogWARN, "Cannot receive datalink, incorrect version" 151036285Sbrian " (\"%.*s\", not \"%s\")\n", (int)iov[0].iov_len, 151137188Sbrian (char *)iov[0].iov_base, Version); 151236285Sbrian close(link_fd); 151336285Sbrian while (niov--) 151436285Sbrian free(iov[niov].iov_base); 151536285Sbrian return; 151636285Sbrian } 151736285Sbrian 151836285Sbrian niov = 1; 151936285Sbrian dl = iov2datalink(bundle, iov, &niov, sizeof iov / sizeof *iov, link_fd); 152036285Sbrian if (dl) { 152136285Sbrian bundle_DatalinkLinkin(bundle, dl); 152236285Sbrian datalink_AuthOk(dl); 152336285Sbrian } else 152436285Sbrian close(link_fd); 152536285Sbrian 152636285Sbrian free(iov[0].iov_base); 152736285Sbrian} 152836285Sbrian 152936285Sbrianvoid 153036285Sbrianbundle_SendDatalink(struct datalink *dl, int s, struct sockaddr_un *sun) 153136285Sbrian{ 153236285Sbrian char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)], ack; 153336285Sbrian struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 153436285Sbrian struct msghdr msg; 153536285Sbrian struct iovec iov[SCATTER_SEGMENTS]; 153636452Sbrian int niov, link_fd, f, expect, newsid; 153736450Sbrian pid_t newpid; 153836285Sbrian 153936285Sbrian log_Printf(LogPHASE, "Transmitting datalink %s\n", dl->name); 154036285Sbrian 154136314Sbrian bundle_LinkClosed(dl->bundle, dl); 154236285Sbrian bundle_DatalinkLinkout(dl->bundle, dl); 154336285Sbrian 154436285Sbrian /* Build our scatter/gather array */ 154536285Sbrian iov[0].iov_len = strlen(Version) + 1; 154636285Sbrian iov[0].iov_base = strdup(Version); 154736285Sbrian niov = 1; 154836285Sbrian 154936450Sbrian read(s, &newpid, sizeof newpid); 155036450Sbrian link_fd = datalink2iov(dl, iov, &niov, sizeof iov / sizeof *iov, newpid); 155136285Sbrian 155236285Sbrian if (link_fd != -1) { 155336345Sbrian memset(&msg, '\0', sizeof msg); 155436285Sbrian 155536285Sbrian msg.msg_name = (caddr_t)sun; 155636285Sbrian msg.msg_namelen = sizeof *sun; 155736285Sbrian msg.msg_iov = iov; 155836285Sbrian msg.msg_iovlen = niov; 155936285Sbrian 156036452Sbrian cmsg->cmsg_len = sizeof cmsgbuf; 156136452Sbrian cmsg->cmsg_level = SOL_SOCKET; 156236452Sbrian cmsg->cmsg_type = SCM_RIGHTS; 156336452Sbrian *(int *)CMSG_DATA(cmsg) = link_fd; 156436452Sbrian msg.msg_control = cmsgbuf; 156536452Sbrian msg.msg_controllen = sizeof cmsgbuf; 156636345Sbrian 156736285Sbrian for (f = expect = 0; f < niov; f++) 156836285Sbrian expect += iov[f].iov_len; 156936285Sbrian 157036285Sbrian log_Printf(LogDEBUG, "Sending %d bytes in scatter/gather array\n", expect); 157136285Sbrian 157236285Sbrian f = expect + SOCKET_OVERHEAD; 157336285Sbrian setsockopt(s, SOL_SOCKET, SO_SNDBUF, &f, sizeof f); 157436285Sbrian if (sendmsg(s, &msg, 0) == -1) 157536285Sbrian log_Printf(LogERROR, "Failed sendmsg: %s\n", strerror(errno)); 157636285Sbrian /* We must get the ACK before closing the descriptor ! */ 157736285Sbrian read(s, &ack, 1); 157836345Sbrian 157936452Sbrian newsid = tcgetpgrp(link_fd) == getpgrp(); 158036285Sbrian close(link_fd); 158136452Sbrian if (newsid) 158236452Sbrian bundle_setsid(dl->bundle, 1); 158336285Sbrian } 158436450Sbrian close(s); 158536285Sbrian 158636285Sbrian while (niov--) 158736285Sbrian free(iov[niov].iov_base); 158836285Sbrian} 158936285Sbrian 159036285Sbrianint 159136285Sbrianbundle_RenameDatalink(struct bundle *bundle, struct datalink *ndl, 159236285Sbrian const char *name) 159336285Sbrian{ 159436285Sbrian struct datalink *dl; 159536285Sbrian 159636285Sbrian if (!strcasecmp(ndl->name, name)) 159736285Sbrian return 1; 159836285Sbrian 159936285Sbrian for (dl = bundle->links; dl; dl = dl->next) 160036285Sbrian if (!strcasecmp(dl->name, name)) 160136285Sbrian return 0; 160236285Sbrian 160336285Sbrian datalink_Rename(ndl, name); 160436285Sbrian return 1; 160536285Sbrian} 160636285Sbrian 160736285Sbrianint 160836285Sbrianbundle_SetMode(struct bundle *bundle, struct datalink *dl, int mode) 160936285Sbrian{ 161036285Sbrian int omode; 161136285Sbrian 161236285Sbrian omode = dl->physical->type; 161336285Sbrian if (omode == mode) 161436285Sbrian return 1; 161536285Sbrian 161636928Sbrian if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO)) 161736928Sbrian /* First auto link */ 161836285Sbrian if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) { 161936928Sbrian log_Printf(LogWARN, "You must `set ifaddr' or `open' before" 162036928Sbrian " changing mode to %s\n", mode2Nam(mode)); 162136285Sbrian return 0; 162236285Sbrian } 162336285Sbrian 162436285Sbrian if (!datalink_SetMode(dl, mode)) 162536285Sbrian return 0; 162636285Sbrian 162736928Sbrian if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) && 162836928Sbrian bundle->phase != PHASE_NETWORK) 162936928Sbrian /* First auto link, we need an interface */ 163036285Sbrian ipcp_InterfaceUp(&bundle->ncp.ipcp); 163136285Sbrian 163236285Sbrian /* Regenerate phys_type and adjust autoload & idle timers */ 163336285Sbrian bundle_LinksRemoved(bundle); 163436285Sbrian 163536928Sbrian if (omode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) && 163636928Sbrian bundle->phase != PHASE_NETWORK) 163736928Sbrian /* No auto links left */ 163836285Sbrian ipcp_CleanInterface(&bundle->ncp.ipcp); 163936285Sbrian 164036285Sbrian return 1; 164136285Sbrian} 164236452Sbrian 164336452Sbrianvoid 164436452Sbrianbundle_setsid(struct bundle *bundle, int holdsession) 164536452Sbrian{ 164636452Sbrian /* 164736452Sbrian * Lose the current session. This means getting rid of our pid 164836452Sbrian * too so that the tty device will really go away, and any getty 164936452Sbrian * etc will be allowed to restart. 165036452Sbrian */ 165136452Sbrian pid_t pid, orig; 165236452Sbrian int fds[2]; 165336452Sbrian char done; 165436452Sbrian struct datalink *dl; 165536452Sbrian 165636452Sbrian orig = getpid(); 165736452Sbrian if (pipe(fds) == -1) { 165836452Sbrian log_Printf(LogERROR, "pipe: %s\n", strerror(errno)); 165936452Sbrian return; 166036452Sbrian } 166136452Sbrian switch ((pid = fork())) { 166236452Sbrian case -1: 166336452Sbrian log_Printf(LogERROR, "fork: %s\n", strerror(errno)); 166436452Sbrian close(fds[0]); 166536452Sbrian close(fds[1]); 166636452Sbrian return; 166736452Sbrian case 0: 166836452Sbrian close(fds[0]); 166936452Sbrian read(fds[1], &done, 1); /* uu_locks are mine ! */ 167036452Sbrian close(fds[1]); 167136452Sbrian if (pipe(fds) == -1) { 167236452Sbrian log_Printf(LogERROR, "pipe(2): %s\n", strerror(errno)); 167336452Sbrian return; 167436452Sbrian } 167536452Sbrian switch ((pid = fork())) { 167636452Sbrian case -1: 167737019Sbrian log_Printf(LogERROR, "fork(2): %s\n", strerror(errno)); 167836452Sbrian close(fds[0]); 167936452Sbrian close(fds[1]); 168036452Sbrian return; 168136452Sbrian case 0: 168236452Sbrian close(fds[0]); 168336452Sbrian bundle_LockTun(bundle); /* update pid */ 168436452Sbrian read(fds[1], &done, 1); /* uu_locks are mine ! */ 168536452Sbrian close(fds[1]); 168636452Sbrian setsid(); 168736452Sbrian log_Printf(LogPHASE, "%d -> %d: %s session control\n", 168836452Sbrian (int)orig, (int)getpid(), 168936452Sbrian holdsession ? "Passed" : "Dropped"); 169037061Sbrian timer_InitService(); 169136452Sbrian break; 169236452Sbrian default: 169336452Sbrian close(fds[1]); 169436452Sbrian /* Give away all our modem locks (to the final process) */ 169536452Sbrian for (dl = bundle->links; dl; dl = dl->next) 169636452Sbrian if (dl->state != DATALINK_CLOSED) 169736452Sbrian modem_ChangedPid(dl->physical, pid); 169836452Sbrian write(fds[0], "!", 1); /* done */ 169936452Sbrian close(fds[0]); 170036452Sbrian exit(0); 170136452Sbrian break; 170236452Sbrian } 170336452Sbrian break; 170436452Sbrian default: 170536452Sbrian close(fds[1]); 170636452Sbrian /* Give away all our modem locks (to the intermediate process) */ 170736452Sbrian for (dl = bundle->links; dl; dl = dl->next) 170836452Sbrian if (dl->state != DATALINK_CLOSED) 170936452Sbrian modem_ChangedPid(dl->physical, pid); 171036452Sbrian write(fds[0], "!", 1); /* done */ 171136452Sbrian close(fds[0]); 171236452Sbrian if (holdsession) { 171336452Sbrian int fd, status; 171436452Sbrian 171536452Sbrian timer_TermService(); 171636452Sbrian signal(SIGPIPE, SIG_DFL); 171736452Sbrian signal(SIGALRM, SIG_DFL); 171836452Sbrian signal(SIGHUP, SIG_DFL); 171936452Sbrian signal(SIGTERM, SIG_DFL); 172036452Sbrian signal(SIGINT, SIG_DFL); 172136452Sbrian signal(SIGQUIT, SIG_DFL); 172236452Sbrian for (fd = getdtablesize(); fd >= 0; fd--) 172336452Sbrian close(fd); 172436452Sbrian setuid(geteuid()); 172536452Sbrian /* 172636452Sbrian * Reap the intermediate process. As we're not exiting but the 172736452Sbrian * intermediate is, we don't want it to become defunct. 172836452Sbrian */ 172936452Sbrian waitpid(pid, &status, 0); 173036467Sbrian /* Tweak our process arguments.... */ 173136467Sbrian bundle->argv[0] = "session owner"; 173236467Sbrian bundle->argv[1] = NULL; 173336452Sbrian /* 173436452Sbrian * Hang around for a HUP. This should happen as soon as the 173536452Sbrian * ppp that we passed our ctty descriptor to closes it. 173636452Sbrian * NOTE: If this process dies, the passed descriptor becomes 173736452Sbrian * invalid and will give a select() error by setting one 173836452Sbrian * of the error fds, aborting the other ppp. We don't 173936452Sbrian * want that to happen ! 174036452Sbrian */ 174136452Sbrian pause(); 174236452Sbrian } 174336452Sbrian exit(0); 174436452Sbrian break; 174536452Sbrian } 174636452Sbrian} 1747