bundle.c revision 46686
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 * 2646686Sbrian * $Id: bundle.c,v 1.51 1999/04/26 08:54:33 brian Exp $ 2736285Sbrian */ 2836285Sbrian 2936452Sbrian#include <sys/param.h> 3036285Sbrian#include <sys/socket.h> 3136285Sbrian#include <netinet/in.h> 3236285Sbrian#include <net/if.h> 3345032Sbrian#include <net/if_tun.h> 3436285Sbrian#include <arpa/inet.h> 3536285Sbrian#include <net/route.h> 3636285Sbrian#include <netinet/in_systm.h> 3736285Sbrian#include <netinet/ip.h> 3836285Sbrian#include <sys/un.h> 3936285Sbrian 4036285Sbrian#include <errno.h> 4136285Sbrian#include <fcntl.h> 4236285Sbrian#include <paths.h> 4336285Sbrian#include <stdio.h> 4436285Sbrian#include <stdlib.h> 4536285Sbrian#include <string.h> 4636285Sbrian#include <sys/ioctl.h> 4736285Sbrian#include <sys/uio.h> 4836345Sbrian#include <sys/wait.h> 4936285Sbrian#include <termios.h> 5036285Sbrian#include <unistd.h> 5136285Sbrian 5246686Sbrian#include "layer.h" 5337009Sbrian#include "defs.h" 5436285Sbrian#include "command.h" 5536285Sbrian#include "mbuf.h" 5636285Sbrian#include "log.h" 5736285Sbrian#include "id.h" 5836285Sbrian#include "timer.h" 5936285Sbrian#include "fsm.h" 6036285Sbrian#include "iplist.h" 6136285Sbrian#include "lqr.h" 6236285Sbrian#include "hdlc.h" 6336285Sbrian#include "throughput.h" 6436285Sbrian#include "slcompress.h" 6536285Sbrian#include "ipcp.h" 6636285Sbrian#include "filter.h" 6736285Sbrian#include "descriptor.h" 6836285Sbrian#include "route.h" 6936285Sbrian#include "lcp.h" 7036285Sbrian#include "ccp.h" 7136285Sbrian#include "link.h" 7236285Sbrian#include "mp.h" 7343313Sbrian#ifndef NORADIUS 7443313Sbrian#include "radius.h" 7543313Sbrian#endif 7636285Sbrian#include "bundle.h" 7736285Sbrian#include "async.h" 7836285Sbrian#include "physical.h" 7936285Sbrian#include "auth.h" 8046686Sbrian#include "proto.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" 8840561Sbrian#include "iface.h" 8936285Sbrian 9036285Sbrian#define SCATTER_SEGMENTS 4 /* version, datalink, name, physical */ 9136285Sbrian#define SOCKET_OVERHEAD 100 /* additional buffer space for large */ 9236285Sbrian /* {recv,send}msg() calls */ 9336285Sbrian 9436285Sbrianstatic int bundle_RemainingIdleTime(struct bundle *); 9536285Sbrianstatic int bundle_RemainingAutoLoadTime(struct bundle *); 9636285Sbrian 9736285Sbrianstatic const char *PhaseNames[] = { 9836285Sbrian "Dead", "Establish", "Authenticate", "Network", "Terminate" 9936285Sbrian}; 10036285Sbrian 10136285Sbrianconst char * 10236285Sbrianbundle_PhaseName(struct bundle *bundle) 10336285Sbrian{ 10436285Sbrian return bundle->phase <= PHASE_TERMINATE ? 10536285Sbrian PhaseNames[bundle->phase] : "unknown"; 10636285Sbrian} 10736285Sbrian 10836285Sbrianvoid 10936285Sbrianbundle_NewPhase(struct bundle *bundle, u_int new) 11036285Sbrian{ 11136285Sbrian if (new == bundle->phase) 11236285Sbrian return; 11336285Sbrian 11436285Sbrian if (new <= PHASE_TERMINATE) 11536285Sbrian log_Printf(LogPHASE, "bundle: %s\n", PhaseNames[new]); 11636285Sbrian 11736285Sbrian switch (new) { 11836285Sbrian case PHASE_DEAD: 11936314Sbrian log_DisplayPrompts(); 12036285Sbrian bundle->phase = new; 12136285Sbrian break; 12236285Sbrian 12336285Sbrian case PHASE_ESTABLISH: 12436285Sbrian bundle->phase = new; 12536285Sbrian break; 12636285Sbrian 12736285Sbrian case PHASE_AUTHENTICATE: 12836285Sbrian bundle->phase = new; 12936314Sbrian log_DisplayPrompts(); 13036285Sbrian break; 13136285Sbrian 13236285Sbrian case PHASE_NETWORK: 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 void 14836285Sbrianbundle_LayerStart(void *v, struct fsm *fp) 14936285Sbrian{ 15036285Sbrian /* The given FSM is about to start up ! */ 15136285Sbrian} 15236285Sbrian 15336285Sbrian 15436285Sbrianstatic void 15536285Sbrianbundle_Notify(struct bundle *bundle, char c) 15636285Sbrian{ 15736285Sbrian if (bundle->notify.fd != -1) { 15836285Sbrian if (write(bundle->notify.fd, &c, 1) == 1) 15936285Sbrian log_Printf(LogPHASE, "Parent notified of success.\n"); 16036285Sbrian else 16136285Sbrian log_Printf(LogPHASE, "Failed to notify parent of success.\n"); 16236285Sbrian close(bundle->notify.fd); 16336285Sbrian bundle->notify.fd = -1; 16436285Sbrian } 16536285Sbrian} 16636285Sbrian 16738544Sbrianstatic void 16838544Sbrianbundle_ClearQueues(void *v) 16938544Sbrian{ 17038544Sbrian struct bundle *bundle = (struct bundle *)v; 17138544Sbrian struct datalink *dl; 17238544Sbrian 17338544Sbrian log_Printf(LogPHASE, "Clearing choked output queue\n"); 17438544Sbrian timer_Stop(&bundle->choked.timer); 17538544Sbrian 17638544Sbrian /* 17738544Sbrian * Emergency time: 17838544Sbrian * 17938544Sbrian * We've had a full queue for PACKET_DEL_SECS seconds without being 18038544Sbrian * able to get rid of any of the packets. We've probably given up 18138544Sbrian * on the redials at this point, and the queued data has almost 18238544Sbrian * definitely been timed out by the layer above. As this is preventing 18338544Sbrian * us from reading the TUN_NAME device (we don't want to buffer stuff 18438544Sbrian * indefinitely), we may as well nuke this data and start with a clean 18538544Sbrian * slate ! 18638544Sbrian * 18738544Sbrian * Unfortunately, this has the side effect of shafting any compression 18838544Sbrian * dictionaries in use (causing the relevant RESET_REQ/RESET_ACK). 18938544Sbrian */ 19038544Sbrian 19138557Sbrian ip_DeleteQueue(&bundle->ncp.ipcp); 19238544Sbrian mp_DeleteQueue(&bundle->ncp.mp); 19338544Sbrian for (dl = bundle->links; dl; dl = dl->next) 19438544Sbrian physical_DeleteQueue(dl->physical); 19538544Sbrian} 19638544Sbrian 19736285Sbrianstatic void 19836285Sbrianbundle_AutoLoadTimeout(void *v) 19936285Sbrian{ 20036285Sbrian struct bundle *bundle = (struct bundle *)v; 20136285Sbrian 20236285Sbrian if (bundle->autoload.comingup) { 20336285Sbrian log_Printf(LogPHASE, "autoload: Another link is required\n"); 20436285Sbrian /* bundle_Open() stops the timer */ 20537955Sbrian bundle_Open(bundle, NULL, PHYS_AUTO, 0); 20636285Sbrian } else { 20736285Sbrian struct datalink *dl, *last; 20836285Sbrian 20936285Sbrian timer_Stop(&bundle->autoload.timer); 21036285Sbrian for (last = NULL, dl = bundle->links; dl; dl = dl->next) 21136465Sbrian if (dl->physical->type == PHYS_AUTO && dl->state == DATALINK_OPEN) 21236285Sbrian last = dl; 21336285Sbrian 21436285Sbrian if (last) 21537007Sbrian datalink_Close(last, CLOSE_STAYDOWN); 21636285Sbrian } 21736285Sbrian} 21836285Sbrian 21936285Sbrianstatic void 22036285Sbrianbundle_StartAutoLoadTimer(struct bundle *bundle, int up) 22136285Sbrian{ 22236285Sbrian struct datalink *dl; 22336285Sbrian 22436285Sbrian timer_Stop(&bundle->autoload.timer); 22544352Sbrian bundle->autoload.comingup = up ? 1 : 0; 22636285Sbrian 22736285Sbrian if (bundle->CleaningUp || bundle->phase != PHASE_NETWORK) { 22836285Sbrian dl = NULL; 22936285Sbrian bundle->autoload.running = 0; 23036285Sbrian } else if (up) { 23136285Sbrian for (dl = bundle->links; dl; dl = dl->next) 23236465Sbrian if (dl->state == DATALINK_CLOSED && dl->physical->type == PHYS_AUTO) { 23336285Sbrian if (bundle->cfg.autoload.max.timeout) { 23436285Sbrian bundle->autoload.timer.func = bundle_AutoLoadTimeout; 23536285Sbrian bundle->autoload.timer.name = "autoload up"; 23636285Sbrian bundle->autoload.timer.load = 23736285Sbrian bundle->cfg.autoload.max.timeout * SECTICKS; 23836285Sbrian bundle->autoload.timer.arg = bundle; 23936285Sbrian timer_Start(&bundle->autoload.timer); 24036285Sbrian bundle->autoload.done = time(NULL) + bundle->cfg.autoload.max.timeout; 24136285Sbrian } else 24236285Sbrian bundle_AutoLoadTimeout(bundle); 24336285Sbrian break; 24436285Sbrian } 24536285Sbrian bundle->autoload.running = (dl || bundle->cfg.autoload.min.timeout) ? 1 : 0; 24636285Sbrian } else { 24736285Sbrian int nlinks; 24836285Sbrian struct datalink *adl; 24936285Sbrian 25036285Sbrian for (nlinks = 0, adl = NULL, dl = bundle->links; dl; dl = dl->next) 25136285Sbrian if (dl->state == DATALINK_OPEN) { 25236465Sbrian if (dl->physical->type == PHYS_AUTO) 25336285Sbrian adl = dl; 25436285Sbrian if (++nlinks > 1 && adl) { 25536285Sbrian if (bundle->cfg.autoload.min.timeout) { 25636285Sbrian bundle->autoload.timer.func = bundle_AutoLoadTimeout; 25736285Sbrian bundle->autoload.timer.name = "autoload down"; 25836285Sbrian bundle->autoload.timer.load = 25936285Sbrian bundle->cfg.autoload.min.timeout * SECTICKS; 26036285Sbrian bundle->autoload.timer.arg = bundle; 26136285Sbrian timer_Start(&bundle->autoload.timer); 26236285Sbrian bundle->autoload.done = 26336285Sbrian time(NULL) + bundle->cfg.autoload.min.timeout; 26436285Sbrian } 26536285Sbrian break; 26636285Sbrian } 26736285Sbrian } 26836285Sbrian 26936285Sbrian bundle->autoload.running = 1; 27036285Sbrian } 27136285Sbrian} 27236285Sbrian 27336285Sbrianstatic void 27436285Sbrianbundle_StopAutoLoadTimer(struct bundle *bundle) 27536285Sbrian{ 27636285Sbrian timer_Stop(&bundle->autoload.timer); 27736285Sbrian bundle->autoload.done = 0; 27836285Sbrian} 27936285Sbrian 28036285Sbrianstatic int 28136285Sbrianbundle_RemainingAutoLoadTime(struct bundle *bundle) 28236285Sbrian{ 28336285Sbrian if (bundle->autoload.done) 28436285Sbrian return bundle->autoload.done - time(NULL); 28536285Sbrian return -1; 28636285Sbrian} 28736285Sbrian 28836928Sbrianstatic void 28936928Sbrianbundle_LinkAdded(struct bundle *bundle, struct datalink *dl) 29036928Sbrian{ 29136928Sbrian bundle->phys_type.all |= dl->physical->type; 29236928Sbrian if (dl->state == DATALINK_OPEN) 29336928Sbrian bundle->phys_type.open |= dl->physical->type; 29436285Sbrian 29536928Sbrian /* Note: We only re-add links that are DATALINK_OPEN */ 29636928Sbrian if (dl->physical->type == PHYS_AUTO && 29736928Sbrian bundle->autoload.timer.state == TIMER_STOPPED && 29836928Sbrian dl->state != DATALINK_OPEN && 29936928Sbrian bundle->phase == PHASE_NETWORK) 30036928Sbrian bundle->autoload.running = 1; 30136928Sbrian 30236928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 30336928Sbrian != bundle->phys_type.open && bundle->idle.timer.state == TIMER_STOPPED) 30436928Sbrian /* We may need to start our idle timer */ 30536928Sbrian bundle_StartIdleTimer(bundle); 30636928Sbrian} 30736928Sbrian 30838174Sbrianvoid 30936928Sbrianbundle_LinksRemoved(struct bundle *bundle) 31036928Sbrian{ 31136928Sbrian struct datalink *dl; 31236928Sbrian 31336928Sbrian bundle->phys_type.all = bundle->phys_type.open = 0; 31436928Sbrian for (dl = bundle->links; dl; dl = dl->next) 31536928Sbrian bundle_LinkAdded(bundle, dl); 31636928Sbrian 31736928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 31836928Sbrian == bundle->phys_type.open) 31936928Sbrian bundle_StopIdleTimer(bundle); 32036928Sbrian} 32136928Sbrian 32236928Sbrianstatic void 32336285Sbrianbundle_LayerUp(void *v, struct fsm *fp) 32436285Sbrian{ 32536285Sbrian /* 32636285Sbrian * The given fsm is now up 32736928Sbrian * If it's an LCP, adjust our phys_mode.open value. 32836285Sbrian * If it's an LCP set our mtu (if we're multilink, add up the link 32936285Sbrian * speeds and set the MRRU) and start our autoload timer. 33036285Sbrian * If it's an NCP, tell our -background parent to go away. 33136285Sbrian * If it's the first NCP, start the idle timer. 33236285Sbrian */ 33336285Sbrian struct bundle *bundle = (struct bundle *)v; 33436285Sbrian 33536285Sbrian if (fp->proto == PROTO_LCP) { 33636928Sbrian struct physical *p = link2physical(fp->link); 33736928Sbrian 33836928Sbrian bundle_LinkAdded(bundle, p->dl); 33936285Sbrian if (bundle->ncp.mp.active) { 34036285Sbrian struct datalink *dl; 34136285Sbrian 34240561Sbrian bundle->ifSpeed = 0; 34336285Sbrian for (dl = bundle->links; dl; dl = dl->next) 34436285Sbrian if (dl->state == DATALINK_OPEN) 34546686Sbrian bundle->ifSpeed += physical_GetSpeed(dl->physical); 34636285Sbrian tun_configure(bundle, bundle->ncp.mp.peer_mrru); 34736285Sbrian bundle->autoload.running = 1; 34836285Sbrian } else { 34946686Sbrian bundle->ifSpeed = physical_GetSpeed(p); 35036285Sbrian tun_configure(bundle, fsm2lcp(fp)->his_mru); 35136285Sbrian } 35236285Sbrian } else if (fp->proto == PROTO_IPCP) { 35336285Sbrian bundle_StartIdleTimer(bundle); 35436285Sbrian bundle_Notify(bundle, EX_NORMAL); 35536285Sbrian } 35636285Sbrian} 35736285Sbrian 35836285Sbrianstatic void 35936285Sbrianbundle_LayerDown(void *v, struct fsm *fp) 36036285Sbrian{ 36136285Sbrian /* 36236285Sbrian * The given FSM has been told to come down. 36336285Sbrian * If it's our last NCP, stop the idle timer. 36436928Sbrian * If it's an LCP, adjust our phys_type.open value and any timers. 36536312Sbrian * If it's an LCP and we're in multilink mode, adjust our tun 36636312Sbrian * speed and make sure our minimum sequence number is adjusted. 36736285Sbrian */ 36836285Sbrian 36936285Sbrian struct bundle *bundle = (struct bundle *)v; 37036285Sbrian 37136285Sbrian if (fp->proto == PROTO_IPCP) 37236285Sbrian bundle_StopIdleTimer(bundle); 37336928Sbrian else if (fp->proto == PROTO_LCP) { 37436928Sbrian bundle_LinksRemoved(bundle); /* adjust timers & phys_type values */ 37536928Sbrian if (bundle->ncp.mp.active) { 37636928Sbrian struct datalink *dl; 37736928Sbrian struct datalink *lost; 37836285Sbrian 37940561Sbrian bundle->ifSpeed = 0; 38036928Sbrian lost = NULL; 38136928Sbrian for (dl = bundle->links; dl; dl = dl->next) 38236928Sbrian if (fp == &dl->physical->link.lcp.fsm) 38336928Sbrian lost = dl; 38436928Sbrian else if (dl->state == DATALINK_OPEN) 38546686Sbrian bundle->ifSpeed += physical_GetSpeed(dl->physical); 38636312Sbrian 38740561Sbrian if (bundle->ifSpeed) 38836928Sbrian /* Don't configure down to a speed of 0 */ 38936928Sbrian tun_configure(bundle, bundle->ncp.mp.link.lcp.his_mru); 39036312Sbrian 39136928Sbrian if (lost) 39236928Sbrian mp_LinkLost(&bundle->ncp.mp, lost); 39336928Sbrian else 39437019Sbrian log_Printf(LogALERT, "Oops, lost an unrecognised datalink (%s) !\n", 39536928Sbrian fp->link->name); 39636928Sbrian } 39736285Sbrian } 39836285Sbrian} 39936285Sbrian 40036285Sbrianstatic void 40136285Sbrianbundle_LayerFinish(void *v, struct fsm *fp) 40236285Sbrian{ 40336285Sbrian /* The given fsm is now down (fp cannot be NULL) 40436285Sbrian * 40536285Sbrian * If it's the last LCP, fsm_Down all NCPs 40636285Sbrian * If it's the last NCP, fsm_Close all LCPs 40736285Sbrian */ 40836285Sbrian 40936285Sbrian struct bundle *bundle = (struct bundle *)v; 41036285Sbrian struct datalink *dl; 41136285Sbrian 41236285Sbrian if (fp->proto == PROTO_IPCP) { 41336285Sbrian if (bundle_Phase(bundle) != PHASE_DEAD) 41436285Sbrian bundle_NewPhase(bundle, PHASE_TERMINATE); 41536285Sbrian for (dl = bundle->links; dl; dl = dl->next) 41637007Sbrian datalink_Close(dl, CLOSE_NORMAL); 41737060Sbrian fsm2initial(fp); 41836285Sbrian } else if (fp->proto == PROTO_LCP) { 41936285Sbrian int others_active; 42036285Sbrian 42136285Sbrian others_active = 0; 42236285Sbrian for (dl = bundle->links; dl; dl = dl->next) 42336285Sbrian if (fp != &dl->physical->link.lcp.fsm && 42436285Sbrian dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 42536285Sbrian others_active++; 42636285Sbrian 42737060Sbrian if (!others_active) 42837060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 42936285Sbrian } 43036285Sbrian} 43136285Sbrian 43236285Sbrianint 43336285Sbrianbundle_LinkIsUp(const struct bundle *bundle) 43436285Sbrian{ 43536285Sbrian return bundle->ncp.ipcp.fsm.state == ST_OPENED; 43636285Sbrian} 43736285Sbrian 43836285Sbrianvoid 43937007Sbrianbundle_Close(struct bundle *bundle, const char *name, int how) 44036285Sbrian{ 44136285Sbrian /* 44236285Sbrian * Please close the given datalink. 44336285Sbrian * If name == NULL or name is the last datalink, fsm_Close all NCPs 44436285Sbrian * (except our MP) 44536285Sbrian * If it isn't the last datalink, just Close that datalink. 44636285Sbrian */ 44736285Sbrian 44836285Sbrian struct datalink *dl, *this_dl; 44936285Sbrian int others_active; 45036285Sbrian 45136285Sbrian others_active = 0; 45236285Sbrian this_dl = NULL; 45336285Sbrian 45436285Sbrian for (dl = bundle->links; dl; dl = dl->next) { 45536285Sbrian if (name && !strcasecmp(name, dl->name)) 45636285Sbrian this_dl = dl; 45736285Sbrian if (name == NULL || this_dl == dl) { 45837007Sbrian switch (how) { 45937007Sbrian case CLOSE_LCP: 46037007Sbrian datalink_DontHangup(dl); 46137007Sbrian /* fall through */ 46237007Sbrian case CLOSE_STAYDOWN: 46337007Sbrian datalink_StayDown(dl); 46437007Sbrian break; 46537007Sbrian } 46636285Sbrian } else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 46736285Sbrian others_active++; 46836285Sbrian } 46936285Sbrian 47036285Sbrian if (name && this_dl == NULL) { 47136285Sbrian log_Printf(LogWARN, "%s: Invalid datalink name\n", name); 47236285Sbrian return; 47336285Sbrian } 47436285Sbrian 47536285Sbrian if (!others_active) { 47636285Sbrian bundle_StopIdleTimer(bundle); 47736285Sbrian bundle_StopAutoLoadTimer(bundle); 47836285Sbrian if (bundle->ncp.ipcp.fsm.state > ST_CLOSED || 47936285Sbrian bundle->ncp.ipcp.fsm.state == ST_STARTING) 48036285Sbrian fsm_Close(&bundle->ncp.ipcp.fsm); 48136285Sbrian else { 48237060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 48336285Sbrian for (dl = bundle->links; dl; dl = dl->next) 48437007Sbrian datalink_Close(dl, how); 48536285Sbrian } 48636285Sbrian } else if (this_dl && this_dl->state != DATALINK_CLOSED && 48736285Sbrian this_dl->state != DATALINK_HANGUP) 48837007Sbrian datalink_Close(this_dl, how); 48936285Sbrian} 49036285Sbrian 49136285Sbrianvoid 49237018Sbrianbundle_Down(struct bundle *bundle, int how) 49336285Sbrian{ 49436285Sbrian struct datalink *dl; 49536285Sbrian 49636285Sbrian for (dl = bundle->links; dl; dl = dl->next) 49737018Sbrian datalink_Down(dl, how); 49836285Sbrian} 49936285Sbrian 50036285Sbrianstatic int 50136285Sbrianbundle_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 50236285Sbrian{ 50336285Sbrian struct bundle *bundle = descriptor2bundle(d); 50436285Sbrian struct datalink *dl; 50536285Sbrian int result, want, queued, nlinks; 50636285Sbrian 50736285Sbrian result = 0; 50836285Sbrian 50936285Sbrian /* If there are aren't many packets queued, look for some more. */ 51036285Sbrian for (nlinks = 0, dl = bundle->links; dl; dl = dl->next) 51136285Sbrian nlinks++; 51236285Sbrian 51336285Sbrian if (nlinks) { 51438557Sbrian queued = r ? bundle_FillQueues(bundle) : ip_QueueLen(&bundle->ncp.ipcp); 51536285Sbrian if (bundle->autoload.running) { 51636285Sbrian if (queued < bundle->cfg.autoload.max.packets) { 51736285Sbrian if (queued > bundle->cfg.autoload.min.packets) 51836285Sbrian bundle_StopAutoLoadTimer(bundle); 51936285Sbrian else if (bundle->autoload.timer.state != TIMER_RUNNING || 52036285Sbrian bundle->autoload.comingup) 52136285Sbrian bundle_StartAutoLoadTimer(bundle, 0); 52244352Sbrian } else if ((bundle_Phase(bundle) == PHASE_NETWORK || queued) && 52344352Sbrian (bundle->autoload.timer.state != TIMER_RUNNING || 52444352Sbrian !bundle->autoload.comingup)) 52536285Sbrian bundle_StartAutoLoadTimer(bundle, 1); 52636285Sbrian } 52736285Sbrian 52836928Sbrian if (r && (bundle->phase == PHASE_NETWORK || 52936928Sbrian bundle->phys_type.all & PHYS_AUTO)) { 53036285Sbrian /* enough surplus so that we can tell if we're getting swamped */ 53136285Sbrian want = bundle->cfg.autoload.max.packets + nlinks * 2; 53236285Sbrian /* but at least 20 packets ! */ 53336285Sbrian if (want < 20) 53436285Sbrian want = 20; 53536285Sbrian if (queued < want) { 53636285Sbrian /* Not enough - select() for more */ 53738544Sbrian if (bundle->choked.timer.state == TIMER_RUNNING) 53838544Sbrian timer_Stop(&bundle->choked.timer); /* Not needed any more */ 53936285Sbrian FD_SET(bundle->dev.fd, r); 54036285Sbrian if (*n < bundle->dev.fd + 1) 54136285Sbrian *n = bundle->dev.fd + 1; 54236452Sbrian log_Printf(LogTIMER, "%s: fdset(r) %d\n", TUN_NAME, bundle->dev.fd); 54336285Sbrian result++; 54438544Sbrian } else if (bundle->choked.timer.state == TIMER_STOPPED) { 54538544Sbrian bundle->choked.timer.func = bundle_ClearQueues; 54638544Sbrian bundle->choked.timer.name = "output choke"; 54738544Sbrian bundle->choked.timer.load = bundle->cfg.choked.timeout * SECTICKS; 54838544Sbrian bundle->choked.timer.arg = bundle; 54938544Sbrian timer_Start(&bundle->choked.timer); 55036285Sbrian } 55136285Sbrian } 55236285Sbrian } 55336285Sbrian 55443693Sbrian#ifndef NORADIUS 55543693Sbrian result += descriptor_UpdateSet(&bundle->radius.desc, r, w, e, n); 55643693Sbrian#endif 55743693Sbrian 55836714Sbrian /* Which links need a select() ? */ 55936714Sbrian for (dl = bundle->links; dl; dl = dl->next) 56036714Sbrian result += descriptor_UpdateSet(&dl->desc, r, w, e, n); 56136714Sbrian 56236285Sbrian /* 56336285Sbrian * This *MUST* be called after the datalink UpdateSet()s as it 56436285Sbrian * might be ``holding'' one of the datalinks (death-row) and 56536285Sbrian * wants to be able to de-select() it from the descriptor set. 56636285Sbrian */ 56736314Sbrian result += descriptor_UpdateSet(&bundle->ncp.mp.server.desc, r, w, e, n); 56836285Sbrian 56936285Sbrian return result; 57036285Sbrian} 57136285Sbrian 57236285Sbrianstatic int 57336285Sbrianbundle_IsSet(struct descriptor *d, const fd_set *fdset) 57436285Sbrian{ 57536285Sbrian struct bundle *bundle = descriptor2bundle(d); 57636285Sbrian struct datalink *dl; 57736285Sbrian 57836285Sbrian for (dl = bundle->links; dl; dl = dl->next) 57936285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 58036285Sbrian return 1; 58136285Sbrian 58243693Sbrian#ifndef NORADIUS 58343693Sbrian if (descriptor_IsSet(&bundle->radius.desc, fdset)) 58443693Sbrian return 1; 58543693Sbrian#endif 58643693Sbrian 58736285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 58836285Sbrian return 1; 58936285Sbrian 59036285Sbrian return FD_ISSET(bundle->dev.fd, fdset); 59136285Sbrian} 59236285Sbrian 59336285Sbrianstatic void 59436285Sbrianbundle_DescriptorRead(struct descriptor *d, struct bundle *bundle, 59536285Sbrian const fd_set *fdset) 59636285Sbrian{ 59736285Sbrian struct datalink *dl; 59836285Sbrian 59936285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 60036285Sbrian descriptor_Read(&bundle->ncp.mp.server.desc, bundle, fdset); 60136285Sbrian 60236285Sbrian for (dl = bundle->links; dl; dl = dl->next) 60336285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 60436285Sbrian descriptor_Read(&dl->desc, bundle, fdset); 60536285Sbrian 60643693Sbrian#ifndef NORADIUS 60743693Sbrian if (descriptor_IsSet(&bundle->radius.desc, fdset)) 60843693Sbrian descriptor_Read(&bundle->radius.desc, bundle, fdset); 60943693Sbrian#endif 61043693Sbrian 61136285Sbrian if (FD_ISSET(bundle->dev.fd, fdset)) { 61236285Sbrian struct tun_data tun; 61336285Sbrian int n, pri; 61436285Sbrian 61536285Sbrian /* something to read from tun */ 61636285Sbrian n = read(bundle->dev.fd, &tun, sizeof tun); 61736285Sbrian if (n < 0) { 61837019Sbrian log_Printf(LogWARN, "read from %s: %s\n", TUN_NAME, strerror(errno)); 61936285Sbrian return; 62036285Sbrian } 62136285Sbrian n -= sizeof tun - sizeof tun.data; 62236285Sbrian if (n <= 0) { 62337019Sbrian log_Printf(LogERROR, "read from %s: Only %d bytes read ?\n", TUN_NAME, n); 62436285Sbrian return; 62536285Sbrian } 62636285Sbrian if (!tun_check_header(tun, AF_INET)) 62736285Sbrian return; 62836285Sbrian 62936285Sbrian if (((struct ip *)tun.data)->ip_dst.s_addr == 63036285Sbrian bundle->ncp.ipcp.my_ip.s_addr) { 63136285Sbrian /* we've been asked to send something addressed *to* us :( */ 63236285Sbrian if (Enabled(bundle, OPT_LOOPBACK)) { 63336285Sbrian pri = PacketCheck(bundle, tun.data, n, &bundle->filter.in); 63436285Sbrian if (pri >= 0) { 63546686Sbrian n += sizeof tun - sizeof tun.data; 63646686Sbrian write(bundle->dev.fd, &tun, n); 63736285Sbrian log_Printf(LogDEBUG, "Looped back packet addressed to myself\n"); 63836285Sbrian } 63936285Sbrian return; 64036285Sbrian } else 64136285Sbrian log_Printf(LogDEBUG, "Oops - forwarding packet addressed to myself\n"); 64236285Sbrian } 64336285Sbrian 64436285Sbrian /* 64536285Sbrian * Process on-demand dialup. Output packets are queued within tunnel 64636285Sbrian * device until IPCP is opened. 64736285Sbrian */ 64836285Sbrian 64936285Sbrian if (bundle_Phase(bundle) == PHASE_DEAD) { 65036285Sbrian /* 65136285Sbrian * Note, we must be in AUTO mode :-/ otherwise our interface should 65236285Sbrian * *not* be UP and we can't receive data 65336285Sbrian */ 65436285Sbrian if ((pri = PacketCheck(bundle, tun.data, n, &bundle->filter.dial)) >= 0) 65537955Sbrian bundle_Open(bundle, NULL, PHYS_AUTO, 0); 65636285Sbrian else 65736285Sbrian /* 65836285Sbrian * Drop the packet. If we were to queue it, we'd just end up with 65936285Sbrian * a pile of timed-out data in our output queue by the time we get 66036285Sbrian * around to actually dialing. We'd also prematurely reach the 66136285Sbrian * threshold at which we stop select()ing to read() the tun 66236285Sbrian * device - breaking auto-dial. 66336285Sbrian */ 66436285Sbrian return; 66536285Sbrian } 66636285Sbrian 66736285Sbrian pri = PacketCheck(bundle, tun.data, n, &bundle->filter.out); 66846686Sbrian if (pri >= 0) 66938557Sbrian ip_Enqueue(&bundle->ncp.ipcp, pri, tun.data, n); 67036285Sbrian } 67136285Sbrian} 67236285Sbrian 67337141Sbrianstatic int 67436285Sbrianbundle_DescriptorWrite(struct descriptor *d, struct bundle *bundle, 67536285Sbrian const fd_set *fdset) 67636285Sbrian{ 67736285Sbrian struct datalink *dl; 67837141Sbrian int result = 0; 67936285Sbrian 68036285Sbrian /* This is not actually necessary as struct mpserver doesn't Write() */ 68136285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 68236285Sbrian descriptor_Write(&bundle->ncp.mp.server.desc, bundle, fdset); 68336285Sbrian 68436285Sbrian for (dl = bundle->links; dl; dl = dl->next) 68536285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 68637141Sbrian result += descriptor_Write(&dl->desc, bundle, fdset); 68737141Sbrian 68837141Sbrian return result; 68936285Sbrian} 69036285Sbrian 69136709Sbrianvoid 69236452Sbrianbundle_LockTun(struct bundle *bundle) 69336452Sbrian{ 69436452Sbrian FILE *lockfile; 69536452Sbrian char pidfile[MAXPATHLEN]; 69636285Sbrian 69736452Sbrian snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 69836452Sbrian lockfile = ID0fopen(pidfile, "w"); 69936452Sbrian if (lockfile != NULL) { 70036452Sbrian fprintf(lockfile, "%d\n", (int)getpid()); 70136452Sbrian fclose(lockfile); 70236452Sbrian } 70336452Sbrian#ifndef RELEASE_CRUNCH 70436452Sbrian else 70536452Sbrian log_Printf(LogERROR, "Warning: Can't create %s: %s\n", 70636452Sbrian pidfile, strerror(errno)); 70736452Sbrian#endif 70836452Sbrian} 70936452Sbrian 71036452Sbrianstatic void 71136452Sbrianbundle_UnlockTun(struct bundle *bundle) 71236452Sbrian{ 71336452Sbrian char pidfile[MAXPATHLEN]; 71436452Sbrian 71536452Sbrian snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 71636452Sbrian ID0unlink(pidfile); 71736452Sbrian} 71836452Sbrian 71936285Sbrianstruct bundle * 72036467Sbrianbundle_Create(const char *prefix, int type, const char **argv) 72136285Sbrian{ 72236285Sbrian int s, enoentcount, err; 72340561Sbrian const char *ifname; 72436285Sbrian struct ifreq ifrq; 72536285Sbrian static struct bundle bundle; /* there can be only one */ 72645032Sbrian#ifdef TUNSIFMODE 72745032Sbrian int iff; 72845032Sbrian#endif 72936285Sbrian 73040561Sbrian if (bundle.iface != NULL) { /* Already allocated ! */ 73137019Sbrian log_Printf(LogALERT, "bundle_Create: There's only one BUNDLE !\n"); 73236285Sbrian return NULL; 73336285Sbrian } 73436285Sbrian 73536285Sbrian err = ENOENT; 73636285Sbrian enoentcount = 0; 73736285Sbrian for (bundle.unit = 0; ; bundle.unit++) { 73836285Sbrian snprintf(bundle.dev.Name, sizeof bundle.dev.Name, "%s%d", 73936285Sbrian prefix, bundle.unit); 74036285Sbrian bundle.dev.fd = ID0open(bundle.dev.Name, O_RDWR); 74136285Sbrian if (bundle.dev.fd >= 0) 74236285Sbrian break; 74336285Sbrian else if (errno == ENXIO) { 74436285Sbrian err = errno; 74536285Sbrian break; 74636285Sbrian } else if (errno == ENOENT) { 74736285Sbrian if (++enoentcount > 2) 74836285Sbrian break; 74936285Sbrian } else 75036285Sbrian err = errno; 75136285Sbrian } 75236285Sbrian 75336285Sbrian if (bundle.dev.fd < 0) { 75436285Sbrian log_Printf(LogWARN, "No available tunnel devices found (%s).\n", 75536285Sbrian strerror(err)); 75636285Sbrian return NULL; 75736285Sbrian } 75836285Sbrian 75936285Sbrian log_SetTun(bundle.unit); 76036467Sbrian bundle.argv = argv; 76140679Sbrian bundle.argv0 = argv[0]; 76240679Sbrian bundle.argv1 = argv[1]; 76336285Sbrian 76436285Sbrian s = socket(AF_INET, SOCK_DGRAM, 0); 76536285Sbrian if (s < 0) { 76636285Sbrian log_Printf(LogERROR, "bundle_Create: socket(): %s\n", strerror(errno)); 76736285Sbrian close(bundle.dev.fd); 76836285Sbrian return NULL; 76936285Sbrian } 77036285Sbrian 77140561Sbrian ifname = strrchr(bundle.dev.Name, '/'); 77240561Sbrian if (ifname == NULL) 77340561Sbrian ifname = bundle.dev.Name; 77436285Sbrian else 77540561Sbrian ifname++; 77636285Sbrian 77740561Sbrian bundle.iface = iface_Create(ifname); 77840561Sbrian if (bundle.iface == NULL) { 77940561Sbrian close(s); 78040561Sbrian close(bundle.dev.fd); 78140561Sbrian return NULL; 78240561Sbrian } 78340561Sbrian 78445032Sbrian#ifdef TUNSIFMODE 78545032Sbrian /* Make sure we're POINTOPOINT */ 78645032Sbrian iff = IFF_POINTOPOINT; 78745032Sbrian if (ID0ioctl(bundle.dev.fd, TUNSIFMODE, &iff) < 0) 78845032Sbrian log_Printf(LogERROR, "bundle_Create: ioctl(TUNSIFMODE): %s\n", 78945032Sbrian strerror(errno)); 79045032Sbrian#endif 79145032Sbrian 79236285Sbrian /* 79336285Sbrian * Now, bring up the interface. 79436285Sbrian */ 79536285Sbrian memset(&ifrq, '\0', sizeof ifrq); 79640561Sbrian strncpy(ifrq.ifr_name, ifname, sizeof ifrq.ifr_name - 1); 79736285Sbrian ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0'; 79836285Sbrian if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) { 79937019Sbrian log_Printf(LogERROR, "bundle_Create: ioctl(SIOCGIFFLAGS): %s\n", 80036285Sbrian strerror(errno)); 80136285Sbrian close(s); 80240561Sbrian iface_Destroy(bundle.iface); 80340561Sbrian bundle.iface = NULL; 80436285Sbrian close(bundle.dev.fd); 80536285Sbrian return NULL; 80636285Sbrian } 80736285Sbrian ifrq.ifr_flags |= IFF_UP; 80836285Sbrian if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) { 80937019Sbrian log_Printf(LogERROR, "bundle_Create: ioctl(SIOCSIFFLAGS): %s\n", 81036285Sbrian strerror(errno)); 81136285Sbrian close(s); 81240561Sbrian iface_Destroy(bundle.iface); 81340561Sbrian bundle.iface = NULL; 81436285Sbrian close(bundle.dev.fd); 81536285Sbrian return NULL; 81636285Sbrian } 81736285Sbrian 81836285Sbrian close(s); 81936285Sbrian 82040561Sbrian log_Printf(LogPHASE, "Using interface: %s\n", ifname); 82136285Sbrian 82240561Sbrian bundle.ifSpeed = 0; 82336285Sbrian 82436285Sbrian bundle.routing_seq = 0; 82536285Sbrian bundle.phase = PHASE_DEAD; 82636285Sbrian bundle.CleaningUp = 0; 82737191Sbrian bundle.AliasEnabled = 0; 82836285Sbrian 82936285Sbrian bundle.fsm.LayerStart = bundle_LayerStart; 83036285Sbrian bundle.fsm.LayerUp = bundle_LayerUp; 83136285Sbrian bundle.fsm.LayerDown = bundle_LayerDown; 83236285Sbrian bundle.fsm.LayerFinish = bundle_LayerFinish; 83336285Sbrian bundle.fsm.object = &bundle; 83436285Sbrian 83536285Sbrian bundle.cfg.idle_timeout = NCP_IDLE_TIMEOUT; 83636285Sbrian *bundle.cfg.auth.name = '\0'; 83736285Sbrian *bundle.cfg.auth.key = '\0'; 83836285Sbrian bundle.cfg.opt = OPT_SROUTES | OPT_IDCHECK | OPT_LOOPBACK | 83936285Sbrian OPT_THROUGHPUT | OPT_UTMP; 84036285Sbrian *bundle.cfg.label = '\0'; 84136285Sbrian bundle.cfg.mtu = DEF_MTU; 84236285Sbrian bundle.cfg.autoload.max.packets = 0; 84336285Sbrian bundle.cfg.autoload.max.timeout = 0; 84436285Sbrian bundle.cfg.autoload.min.packets = 0; 84536285Sbrian bundle.cfg.autoload.min.timeout = 0; 84638544Sbrian bundle.cfg.choked.timeout = CHOKED_TIMEOUT; 84736928Sbrian bundle.phys_type.all = type; 84836928Sbrian bundle.phys_type.open = 0; 84936285Sbrian 85036285Sbrian bundle.links = datalink_Create("deflink", &bundle, type); 85136285Sbrian if (bundle.links == NULL) { 85237019Sbrian log_Printf(LogALERT, "Cannot create data link: %s\n", strerror(errno)); 85340561Sbrian iface_Destroy(bundle.iface); 85440561Sbrian bundle.iface = NULL; 85536285Sbrian close(bundle.dev.fd); 85636285Sbrian return NULL; 85736285Sbrian } 85836285Sbrian 85936285Sbrian bundle.desc.type = BUNDLE_DESCRIPTOR; 86036285Sbrian bundle.desc.UpdateSet = bundle_UpdateSet; 86136285Sbrian bundle.desc.IsSet = bundle_IsSet; 86236285Sbrian bundle.desc.Read = bundle_DescriptorRead; 86336285Sbrian bundle.desc.Write = bundle_DescriptorWrite; 86436285Sbrian 86536285Sbrian mp_Init(&bundle.ncp.mp, &bundle); 86636285Sbrian 86736285Sbrian /* Send over the first physical link by default */ 86836285Sbrian ipcp_Init(&bundle.ncp.ipcp, &bundle, &bundle.links->physical->link, 86936285Sbrian &bundle.fsm); 87036285Sbrian 87136285Sbrian memset(&bundle.filter, '\0', sizeof bundle.filter); 87236285Sbrian bundle.filter.in.fragok = bundle.filter.in.logok = 1; 87336285Sbrian bundle.filter.in.name = "IN"; 87436285Sbrian bundle.filter.out.fragok = bundle.filter.out.logok = 1; 87536285Sbrian bundle.filter.out.name = "OUT"; 87636285Sbrian bundle.filter.dial.name = "DIAL"; 87736285Sbrian bundle.filter.dial.logok = 1; 87836285Sbrian bundle.filter.alive.name = "ALIVE"; 87936285Sbrian bundle.filter.alive.logok = 1; 88036285Sbrian memset(&bundle.idle.timer, '\0', sizeof bundle.idle.timer); 88136285Sbrian bundle.idle.done = 0; 88236285Sbrian bundle.notify.fd = -1; 88336285Sbrian memset(&bundle.autoload.timer, '\0', sizeof bundle.autoload.timer); 88436285Sbrian bundle.autoload.done = 0; 88536285Sbrian bundle.autoload.running = 0; 88638544Sbrian memset(&bundle.choked.timer, '\0', sizeof bundle.choked.timer); 88743313Sbrian#ifndef NORADIUS 88843313Sbrian radius_Init(&bundle.radius); 88943313Sbrian#endif 89036285Sbrian 89136285Sbrian /* Clean out any leftover crud */ 89240561Sbrian iface_Clear(bundle.iface, IFACE_CLEAR_ALL); 89336285Sbrian 89436452Sbrian bundle_LockTun(&bundle); 89536452Sbrian 89636285Sbrian return &bundle; 89736285Sbrian} 89836285Sbrian 89936285Sbrianstatic void 90036285Sbrianbundle_DownInterface(struct bundle *bundle) 90136285Sbrian{ 90236285Sbrian struct ifreq ifrq; 90336285Sbrian int s; 90436285Sbrian 90536285Sbrian route_IfDelete(bundle, 1); 90636285Sbrian 90736285Sbrian s = ID0socket(AF_INET, SOCK_DGRAM, 0); 90836285Sbrian if (s < 0) { 90936285Sbrian log_Printf(LogERROR, "bundle_DownInterface: socket: %s\n", strerror(errno)); 91036285Sbrian return; 91136285Sbrian } 91236285Sbrian 91336285Sbrian memset(&ifrq, '\0', sizeof ifrq); 91440561Sbrian strncpy(ifrq.ifr_name, bundle->iface->name, sizeof ifrq.ifr_name - 1); 91536285Sbrian ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0'; 91636285Sbrian if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) { 91736285Sbrian log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCGIFFLAGS): %s\n", 91836285Sbrian strerror(errno)); 91936285Sbrian close(s); 92036285Sbrian return; 92136285Sbrian } 92236285Sbrian ifrq.ifr_flags &= ~IFF_UP; 92336285Sbrian if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) { 92436285Sbrian log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCSIFFLAGS): %s\n", 92536285Sbrian strerror(errno)); 92636285Sbrian close(s); 92736285Sbrian return; 92836285Sbrian } 92936285Sbrian close(s); 93036285Sbrian} 93136285Sbrian 93236285Sbrianvoid 93336285Sbrianbundle_Destroy(struct bundle *bundle) 93436285Sbrian{ 93536285Sbrian struct datalink *dl; 93636285Sbrian 93736285Sbrian /* 93836285Sbrian * Clean up the interface. We don't need to timer_Stop()s, mp_Down(), 93936285Sbrian * ipcp_CleanInterface() and bundle_DownInterface() unless we're getting 94036285Sbrian * out under exceptional conditions such as a descriptor exception. 94136285Sbrian */ 94236285Sbrian timer_Stop(&bundle->idle.timer); 94338544Sbrian timer_Stop(&bundle->choked.timer); 94436285Sbrian timer_Stop(&bundle->autoload.timer); 94536285Sbrian mp_Down(&bundle->ncp.mp); 94636285Sbrian ipcp_CleanInterface(&bundle->ncp.ipcp); 94736285Sbrian bundle_DownInterface(bundle); 94836452Sbrian 94943313Sbrian#ifndef NORADIUS 95043313Sbrian /* Tell the radius server the bad news */ 95143313Sbrian radius_Destroy(&bundle->radius); 95243313Sbrian#endif 95343313Sbrian 95436285Sbrian /* Again, these are all DATALINK_CLOSED unless we're abending */ 95536285Sbrian dl = bundle->links; 95636285Sbrian while (dl) 95736285Sbrian dl = datalink_Destroy(dl); 95836285Sbrian 95936452Sbrian close(bundle->dev.fd); 96036452Sbrian bundle_UnlockTun(bundle); 96136452Sbrian 96236285Sbrian /* In case we never made PHASE_NETWORK */ 96336285Sbrian bundle_Notify(bundle, EX_ERRDEAD); 96436285Sbrian 96540561Sbrian iface_Destroy(bundle->iface); 96640561Sbrian bundle->iface = NULL; 96736285Sbrian} 96836285Sbrian 96936285Sbrianstruct rtmsg { 97036285Sbrian struct rt_msghdr m_rtm; 97136285Sbrian char m_space[64]; 97236285Sbrian}; 97336285Sbrian 97436285Sbrianint 97536285Sbrianbundle_SetRoute(struct bundle *bundle, int cmd, struct in_addr dst, 97637927Sbrian struct in_addr gateway, struct in_addr mask, int bang, int ssh) 97736285Sbrian{ 97836285Sbrian struct rtmsg rtmes; 97936285Sbrian int s, nb, wb; 98036285Sbrian char *cp; 98136285Sbrian const char *cmdstr; 98236285Sbrian struct sockaddr_in rtdata; 98336285Sbrian int result = 1; 98436285Sbrian 98536285Sbrian if (bang) 98636285Sbrian cmdstr = (cmd == RTM_ADD ? "Add!" : "Delete!"); 98736285Sbrian else 98836285Sbrian cmdstr = (cmd == RTM_ADD ? "Add" : "Delete"); 98936285Sbrian s = ID0socket(PF_ROUTE, SOCK_RAW, 0); 99036285Sbrian if (s < 0) { 99136285Sbrian log_Printf(LogERROR, "bundle_SetRoute: socket(): %s\n", strerror(errno)); 99236285Sbrian return result; 99336285Sbrian } 99436285Sbrian memset(&rtmes, '\0', sizeof rtmes); 99536285Sbrian rtmes.m_rtm.rtm_version = RTM_VERSION; 99636285Sbrian rtmes.m_rtm.rtm_type = cmd; 99736285Sbrian rtmes.m_rtm.rtm_addrs = RTA_DST; 99836285Sbrian rtmes.m_rtm.rtm_seq = ++bundle->routing_seq; 99936285Sbrian rtmes.m_rtm.rtm_pid = getpid(); 100036285Sbrian rtmes.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC; 100136285Sbrian 100240665Sbrian if (cmd == RTM_ADD || cmd == RTM_CHANGE) { 100340665Sbrian if (bundle->ncp.ipcp.cfg.sendpipe > 0) { 100440665Sbrian rtmes.m_rtm.rtm_rmx.rmx_sendpipe = bundle->ncp.ipcp.cfg.sendpipe; 100540665Sbrian rtmes.m_rtm.rtm_inits |= RTV_SPIPE; 100640665Sbrian } 100740665Sbrian if (bundle->ncp.ipcp.cfg.recvpipe > 0) { 100840665Sbrian rtmes.m_rtm.rtm_rmx.rmx_recvpipe = bundle->ncp.ipcp.cfg.recvpipe; 100940665Sbrian rtmes.m_rtm.rtm_inits |= RTV_RPIPE; 101040665Sbrian } 101140665Sbrian } 101240665Sbrian 101336285Sbrian memset(&rtdata, '\0', sizeof rtdata); 101436285Sbrian rtdata.sin_len = sizeof rtdata; 101536285Sbrian rtdata.sin_family = AF_INET; 101636285Sbrian rtdata.sin_port = 0; 101736285Sbrian rtdata.sin_addr = dst; 101836285Sbrian 101936285Sbrian cp = rtmes.m_space; 102036285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 102136285Sbrian cp += rtdata.sin_len; 102236285Sbrian if (cmd == RTM_ADD) { 102336285Sbrian if (gateway.s_addr == INADDR_ANY) { 102442321Sbrian if (!ssh) 102542321Sbrian log_Printf(LogERROR, "bundle_SetRoute: Cannot add a route with" 102642321Sbrian " destination 0.0.0.0\n"); 102740561Sbrian close(s); 102840561Sbrian return result; 102936285Sbrian } else { 103036285Sbrian rtdata.sin_addr = gateway; 103136285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 103236285Sbrian cp += rtdata.sin_len; 103336285Sbrian rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY; 103436285Sbrian } 103536285Sbrian } 103636285Sbrian 103736285Sbrian if (dst.s_addr == INADDR_ANY) 103836285Sbrian mask.s_addr = INADDR_ANY; 103936285Sbrian 104036285Sbrian if (cmd == RTM_ADD || dst.s_addr == INADDR_ANY) { 104136285Sbrian rtdata.sin_addr = mask; 104236285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 104336285Sbrian cp += rtdata.sin_len; 104436285Sbrian rtmes.m_rtm.rtm_addrs |= RTA_NETMASK; 104536285Sbrian } 104636285Sbrian 104736285Sbrian nb = cp - (char *) &rtmes; 104836285Sbrian rtmes.m_rtm.rtm_msglen = nb; 104936285Sbrian wb = ID0write(s, &rtmes, nb); 105036285Sbrian if (wb < 0) { 105136285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute failure:\n"); 105236285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Cmd = %s\n", cmdstr); 105336285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Dst = %s\n", inet_ntoa(dst)); 105436285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Gateway = %s\n", inet_ntoa(gateway)); 105536285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Mask = %s\n", inet_ntoa(mask)); 105636285Sbrianfailed: 105736285Sbrian if (cmd == RTM_ADD && (rtmes.m_rtm.rtm_errno == EEXIST || 105836285Sbrian (rtmes.m_rtm.rtm_errno == 0 && errno == EEXIST))) { 105936285Sbrian if (!bang) { 106036285Sbrian log_Printf(LogWARN, "Add route failed: %s already exists\n", 106140665Sbrian dst.s_addr == 0 ? "default" : inet_ntoa(dst)); 106236285Sbrian result = 0; /* Don't add to our dynamic list */ 106336285Sbrian } else { 106436285Sbrian rtmes.m_rtm.rtm_type = cmd = RTM_CHANGE; 106536285Sbrian if ((wb = ID0write(s, &rtmes, nb)) < 0) 106636285Sbrian goto failed; 106736285Sbrian } 106836285Sbrian } else if (cmd == RTM_DELETE && 106936285Sbrian (rtmes.m_rtm.rtm_errno == ESRCH || 107036285Sbrian (rtmes.m_rtm.rtm_errno == 0 && errno == ESRCH))) { 107136285Sbrian if (!bang) 107236285Sbrian log_Printf(LogWARN, "Del route failed: %s: Non-existent\n", 107336285Sbrian inet_ntoa(dst)); 107437927Sbrian } else if (rtmes.m_rtm.rtm_errno == 0) { 107537927Sbrian if (!ssh || errno != ENETUNREACH) 107637927Sbrian log_Printf(LogWARN, "%s route failed: %s: errno: %s\n", cmdstr, 107737927Sbrian inet_ntoa(dst), strerror(errno)); 107837927Sbrian } else 107936285Sbrian log_Printf(LogWARN, "%s route failed: %s: %s\n", 108037927Sbrian cmdstr, inet_ntoa(dst), strerror(rtmes.m_rtm.rtm_errno)); 108136285Sbrian } 108236285Sbrian log_Printf(LogDEBUG, "wrote %d: cmd = %s, dst = %x, gateway = %x\n", 108336285Sbrian wb, cmdstr, (unsigned)dst.s_addr, (unsigned)gateway.s_addr); 108436285Sbrian close(s); 108536285Sbrian 108636285Sbrian return result; 108736285Sbrian} 108836285Sbrian 108936285Sbrianvoid 109036285Sbrianbundle_LinkClosed(struct bundle *bundle, struct datalink *dl) 109136285Sbrian{ 109236285Sbrian /* 109336285Sbrian * Our datalink has closed. 109436285Sbrian * CleanDatalinks() (called from DoLoop()) will remove closed 109536465Sbrian * BACKGROUND and DIRECT links. 109636285Sbrian * If it's the last data link, enter phase DEAD. 109736285Sbrian * 109836285Sbrian * NOTE: dl may not be in our list (bundle_SendDatalink()) ! 109936285Sbrian */ 110036285Sbrian 110136285Sbrian struct datalink *odl; 110236285Sbrian int other_links; 110336285Sbrian 110438200Sbrian log_SetTtyCommandMode(dl); 110538200Sbrian 110636285Sbrian other_links = 0; 110736285Sbrian for (odl = bundle->links; odl; odl = odl->next) 110836285Sbrian if (odl != dl && odl->state != DATALINK_CLOSED) 110936285Sbrian other_links++; 111036285Sbrian 111136285Sbrian if (!other_links) { 111236465Sbrian if (dl->physical->type != PHYS_AUTO) /* Not in -auto mode */ 111336285Sbrian bundle_DownInterface(bundle); 111437060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 111536285Sbrian bundle_NewPhase(bundle, PHASE_DEAD); 111636314Sbrian bundle_StopIdleTimer(bundle); 111736285Sbrian bundle_StopAutoLoadTimer(bundle); 111836285Sbrian bundle->autoload.running = 0; 111936285Sbrian } else 112036285Sbrian bundle->autoload.running = 1; 112136285Sbrian} 112236285Sbrian 112336285Sbrianvoid 112437955Sbrianbundle_Open(struct bundle *bundle, const char *name, int mask, int force) 112536285Sbrian{ 112636285Sbrian /* 112736285Sbrian * Please open the given datalink, or all if name == NULL 112836285Sbrian */ 112936285Sbrian struct datalink *dl; 113036285Sbrian 113136285Sbrian timer_Stop(&bundle->autoload.timer); 113236285Sbrian for (dl = bundle->links; dl; dl = dl->next) 113336285Sbrian if (name == NULL || !strcasecmp(dl->name, name)) { 113437955Sbrian if ((mask & dl->physical->type) && 113537955Sbrian (dl->state == DATALINK_CLOSED || 113637955Sbrian (force && dl->state == DATALINK_OPENING && 113744468Sbrian dl->dial.timer.state == TIMER_RUNNING))) { 113844468Sbrian if (force) /* Ignore redial timeout ? */ 113944468Sbrian timer_Stop(&dl->dial.timer); 114036285Sbrian datalink_Up(dl, 1, 1); 114136465Sbrian if (mask == PHYS_AUTO) 114236465Sbrian /* Only one AUTO link at a time (see the AutoLoad timer) */ 114336285Sbrian break; 114436285Sbrian } 114536285Sbrian if (name != NULL) 114636285Sbrian break; 114736285Sbrian } 114836285Sbrian} 114936285Sbrian 115036285Sbrianstruct datalink * 115136285Sbrianbundle2datalink(struct bundle *bundle, const char *name) 115236285Sbrian{ 115336285Sbrian struct datalink *dl; 115436285Sbrian 115536285Sbrian if (name != NULL) { 115636285Sbrian for (dl = bundle->links; dl; dl = dl->next) 115736285Sbrian if (!strcasecmp(dl->name, name)) 115836285Sbrian return dl; 115936285Sbrian } else if (bundle->links && !bundle->links->next) 116036285Sbrian return bundle->links; 116136285Sbrian 116236285Sbrian return NULL; 116336285Sbrian} 116436285Sbrian 116536285Sbrianint 116636285Sbrianbundle_FillQueues(struct bundle *bundle) 116736285Sbrian{ 116836285Sbrian int total; 116936285Sbrian 117036285Sbrian if (bundle->ncp.mp.active) 117136285Sbrian total = mp_FillQueues(bundle); 117236285Sbrian else { 117336285Sbrian struct datalink *dl; 117436285Sbrian int add; 117536285Sbrian 117636285Sbrian for (total = 0, dl = bundle->links; dl; dl = dl->next) 117736285Sbrian if (dl->state == DATALINK_OPEN) { 117836285Sbrian add = link_QueueLen(&dl->physical->link); 117936285Sbrian if (add == 0 && dl->physical->out == NULL) 118046686Sbrian add = ip_PushPacket(&dl->physical->link, bundle); 118136285Sbrian total += add; 118236285Sbrian } 118336285Sbrian } 118436285Sbrian 118538557Sbrian return total + ip_QueueLen(&bundle->ncp.ipcp); 118636285Sbrian} 118736285Sbrian 118836285Sbrianint 118936285Sbrianbundle_ShowLinks(struct cmdargs const *arg) 119036285Sbrian{ 119136285Sbrian struct datalink *dl; 119236285Sbrian 119336285Sbrian for (dl = arg->bundle->links; dl; dl = dl->next) { 119436316Sbrian prompt_Printf(arg->prompt, "Name: %s [%s, %s]", 119536316Sbrian dl->name, mode2Nam(dl->physical->type), datalink_State(dl)); 119636285Sbrian if (dl->physical->link.throughput.rolling && dl->state == DATALINK_OPEN) 119746686Sbrian prompt_Printf(arg->prompt, " weight %d, %Ld bytes/sec", 119836285Sbrian dl->mp.weight, 119936285Sbrian dl->physical->link.throughput.OctetsPerSecond); 120036285Sbrian prompt_Printf(arg->prompt, "\n"); 120136285Sbrian } 120236285Sbrian 120336285Sbrian return 0; 120436285Sbrian} 120536285Sbrian 120636285Sbrianstatic const char * 120736285Sbrianoptval(struct bundle *bundle, int bit) 120836285Sbrian{ 120936285Sbrian return (bundle->cfg.opt & bit) ? "enabled" : "disabled"; 121036285Sbrian} 121136285Sbrian 121236285Sbrianint 121336285Sbrianbundle_ShowStatus(struct cmdargs const *arg) 121436285Sbrian{ 121536285Sbrian int remaining; 121636285Sbrian 121736285Sbrian prompt_Printf(arg->prompt, "Phase %s\n", bundle_PhaseName(arg->bundle)); 121840679Sbrian prompt_Printf(arg->prompt, " Title: %s\n", arg->bundle->argv[0]); 121936285Sbrian prompt_Printf(arg->prompt, " Device: %s\n", arg->bundle->dev.Name); 122036285Sbrian prompt_Printf(arg->prompt, " Interface: %s @ %lubps\n", 122140561Sbrian arg->bundle->iface->name, arg->bundle->ifSpeed); 122236285Sbrian 122336285Sbrian prompt_Printf(arg->prompt, "\nDefaults:\n"); 122436285Sbrian prompt_Printf(arg->prompt, " Label: %s\n", arg->bundle->cfg.label); 122536285Sbrian prompt_Printf(arg->prompt, " Auth name: %s\n", 122636285Sbrian arg->bundle->cfg.auth.name); 122736285Sbrian prompt_Printf(arg->prompt, " Auto Load: Up after %ds of >= %d packets\n", 122836285Sbrian arg->bundle->cfg.autoload.max.timeout, 122936285Sbrian arg->bundle->cfg.autoload.max.packets); 123036285Sbrian prompt_Printf(arg->prompt, " Down after %ds of <= %d" 123136285Sbrian " packets\n", arg->bundle->cfg.autoload.min.timeout, 123236285Sbrian arg->bundle->cfg.autoload.min.packets); 123336285Sbrian if (arg->bundle->autoload.timer.state == TIMER_RUNNING) 123436285Sbrian prompt_Printf(arg->prompt, " %ds remaining 'till " 123536285Sbrian "a link comes %s\n", 123636285Sbrian bundle_RemainingAutoLoadTime(arg->bundle), 123736285Sbrian arg->bundle->autoload.comingup ? "up" : "down"); 123836285Sbrian else 123936285Sbrian prompt_Printf(arg->prompt, " %srunning with %d" 124036285Sbrian " packets queued\n", arg->bundle->autoload.running ? 124138557Sbrian "" : "not ", ip_QueueLen(&arg->bundle->ncp.ipcp)); 124236285Sbrian 124338544Sbrian prompt_Printf(arg->prompt, " Choked Timer: %ds\n", 124438544Sbrian arg->bundle->cfg.choked.timeout); 124543313Sbrian 124643313Sbrian#ifndef NORADIUS 124743313Sbrian radius_Show(&arg->bundle->radius, arg->prompt); 124843313Sbrian#endif 124943313Sbrian 125036285Sbrian prompt_Printf(arg->prompt, " Idle Timer: "); 125136285Sbrian if (arg->bundle->cfg.idle_timeout) { 125236285Sbrian prompt_Printf(arg->prompt, "%ds", arg->bundle->cfg.idle_timeout); 125336285Sbrian remaining = bundle_RemainingIdleTime(arg->bundle); 125436285Sbrian if (remaining != -1) 125536285Sbrian prompt_Printf(arg->prompt, " (%ds remaining)", remaining); 125636285Sbrian prompt_Printf(arg->prompt, "\n"); 125736285Sbrian } else 125836285Sbrian prompt_Printf(arg->prompt, "disabled\n"); 125936285Sbrian prompt_Printf(arg->prompt, " MTU: "); 126036285Sbrian if (arg->bundle->cfg.mtu) 126136285Sbrian prompt_Printf(arg->prompt, "%d\n", arg->bundle->cfg.mtu); 126236285Sbrian else 126336285Sbrian prompt_Printf(arg->prompt, "unspecified\n"); 126436285Sbrian 126540665Sbrian prompt_Printf(arg->prompt, " sendpipe: "); 126640665Sbrian if (arg->bundle->ncp.ipcp.cfg.sendpipe > 0) 126740665Sbrian prompt_Printf(arg->prompt, "%ld\n", arg->bundle->ncp.ipcp.cfg.sendpipe); 126840665Sbrian else 126940665Sbrian prompt_Printf(arg->prompt, "unspecified\n"); 127040665Sbrian prompt_Printf(arg->prompt, " recvpipe: "); 127140665Sbrian if (arg->bundle->ncp.ipcp.cfg.recvpipe > 0) 127240665Sbrian prompt_Printf(arg->prompt, "%ld\n", arg->bundle->ncp.ipcp.cfg.recvpipe); 127340665Sbrian else 127440665Sbrian prompt_Printf(arg->prompt, "unspecified\n"); 127540665Sbrian 127636285Sbrian prompt_Printf(arg->prompt, " Sticky Routes: %s\n", 127736285Sbrian optval(arg->bundle, OPT_SROUTES)); 127836285Sbrian prompt_Printf(arg->prompt, " ID check: %s\n", 127936285Sbrian optval(arg->bundle, OPT_IDCHECK)); 128036285Sbrian prompt_Printf(arg->prompt, " Loopback: %s\n", 128136285Sbrian optval(arg->bundle, OPT_LOOPBACK)); 128236285Sbrian prompt_Printf(arg->prompt, " PasswdAuth: %s\n", 128336285Sbrian optval(arg->bundle, OPT_PASSWDAUTH)); 128436285Sbrian prompt_Printf(arg->prompt, " Proxy: %s\n", 128536285Sbrian optval(arg->bundle, OPT_PROXY)); 128640665Sbrian prompt_Printf(arg->prompt, " Proxyall: %s\n", 128740665Sbrian optval(arg->bundle, OPT_PROXYALL)); 128836285Sbrian prompt_Printf(arg->prompt, " Throughput: %s\n", 128936285Sbrian optval(arg->bundle, OPT_THROUGHPUT)); 129036285Sbrian prompt_Printf(arg->prompt, " Utmp Logging: %s\n", 129136285Sbrian optval(arg->bundle, OPT_UTMP)); 129240561Sbrian prompt_Printf(arg->prompt, " Iface-Alias: %s\n", 129340561Sbrian optval(arg->bundle, OPT_IFACEALIAS)); 129436285Sbrian 129536285Sbrian return 0; 129636285Sbrian} 129736285Sbrian 129836285Sbrianstatic void 129936285Sbrianbundle_IdleTimeout(void *v) 130036285Sbrian{ 130136285Sbrian struct bundle *bundle = (struct bundle *)v; 130236285Sbrian 130336285Sbrian log_Printf(LogPHASE, "Idle timer expired.\n"); 130436285Sbrian bundle_StopIdleTimer(bundle); 130537007Sbrian bundle_Close(bundle, NULL, CLOSE_STAYDOWN); 130636285Sbrian} 130736285Sbrian 130836285Sbrian/* 130936285Sbrian * Start Idle timer. If timeout is reached, we call bundle_Close() to 131036285Sbrian * close LCP and link. 131136285Sbrian */ 131236285Sbrianvoid 131336285Sbrianbundle_StartIdleTimer(struct bundle *bundle) 131436285Sbrian{ 131536285Sbrian timer_Stop(&bundle->idle.timer); 131636928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) != 131736928Sbrian bundle->phys_type.open && bundle->cfg.idle_timeout) { 131836285Sbrian bundle->idle.timer.func = bundle_IdleTimeout; 131936285Sbrian bundle->idle.timer.name = "idle"; 132036285Sbrian bundle->idle.timer.load = bundle->cfg.idle_timeout * SECTICKS; 132136285Sbrian bundle->idle.timer.arg = bundle; 132236285Sbrian timer_Start(&bundle->idle.timer); 132336285Sbrian bundle->idle.done = time(NULL) + bundle->cfg.idle_timeout; 132436285Sbrian } 132536285Sbrian} 132636285Sbrian 132736285Sbrianvoid 132836285Sbrianbundle_SetIdleTimer(struct bundle *bundle, int value) 132936285Sbrian{ 133036285Sbrian bundle->cfg.idle_timeout = value; 133136285Sbrian if (bundle_LinkIsUp(bundle)) 133236285Sbrian bundle_StartIdleTimer(bundle); 133336285Sbrian} 133436285Sbrian 133536285Sbrianvoid 133636285Sbrianbundle_StopIdleTimer(struct bundle *bundle) 133736285Sbrian{ 133836285Sbrian timer_Stop(&bundle->idle.timer); 133936285Sbrian bundle->idle.done = 0; 134036285Sbrian} 134136285Sbrian 134236285Sbrianstatic int 134336285Sbrianbundle_RemainingIdleTime(struct bundle *bundle) 134436285Sbrian{ 134536285Sbrian if (bundle->idle.done) 134636285Sbrian return bundle->idle.done - time(NULL); 134736285Sbrian return -1; 134836285Sbrian} 134936285Sbrian 135036285Sbrianint 135136285Sbrianbundle_IsDead(struct bundle *bundle) 135236285Sbrian{ 135336285Sbrian return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp); 135436285Sbrian} 135536285Sbrian 135636285Sbrianstatic struct datalink * 135736285Sbrianbundle_DatalinkLinkout(struct bundle *bundle, struct datalink *dl) 135836285Sbrian{ 135936285Sbrian struct datalink **dlp; 136036285Sbrian 136136314Sbrian for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next) 136236314Sbrian if (*dlp == dl) { 136336314Sbrian *dlp = dl->next; 136436314Sbrian dl->next = NULL; 136536314Sbrian bundle_LinksRemoved(bundle); 136636314Sbrian return dl; 136736314Sbrian } 136836285Sbrian 136936285Sbrian return NULL; 137036285Sbrian} 137136285Sbrian 137236285Sbrianstatic void 137336285Sbrianbundle_DatalinkLinkin(struct bundle *bundle, struct datalink *dl) 137436285Sbrian{ 137536285Sbrian struct datalink **dlp = &bundle->links; 137636285Sbrian 137736285Sbrian while (*dlp) 137836285Sbrian dlp = &(*dlp)->next; 137936285Sbrian 138036285Sbrian *dlp = dl; 138136285Sbrian dl->next = NULL; 138236285Sbrian 138336285Sbrian bundle_LinkAdded(bundle, dl); 138436285Sbrian} 138536285Sbrian 138636285Sbrianvoid 138736285Sbrianbundle_CleanDatalinks(struct bundle *bundle) 138836285Sbrian{ 138936285Sbrian struct datalink **dlp = &bundle->links; 139036285Sbrian int found = 0; 139136285Sbrian 139236285Sbrian while (*dlp) 139336285Sbrian if ((*dlp)->state == DATALINK_CLOSED && 139436465Sbrian (*dlp)->physical->type & (PHYS_DIRECT|PHYS_BACKGROUND)) { 139536285Sbrian *dlp = datalink_Destroy(*dlp); 139636285Sbrian found++; 139736285Sbrian } else 139836285Sbrian dlp = &(*dlp)->next; 139936285Sbrian 140036285Sbrian if (found) 140136285Sbrian bundle_LinksRemoved(bundle); 140236285Sbrian} 140336285Sbrian 140436285Sbrianint 140536285Sbrianbundle_DatalinkClone(struct bundle *bundle, struct datalink *dl, 140636285Sbrian const char *name) 140736285Sbrian{ 140836285Sbrian if (bundle2datalink(bundle, name)) { 140936285Sbrian log_Printf(LogWARN, "Clone: %s: name already exists\n", name); 141036285Sbrian return 0; 141136285Sbrian } 141236285Sbrian 141336285Sbrian bundle_DatalinkLinkin(bundle, datalink_Clone(dl, name)); 141436285Sbrian return 1; 141536285Sbrian} 141636285Sbrian 141736285Sbrianvoid 141836285Sbrianbundle_DatalinkRemove(struct bundle *bundle, struct datalink *dl) 141936285Sbrian{ 142036285Sbrian dl = bundle_DatalinkLinkout(bundle, dl); 142136285Sbrian if (dl) 142236285Sbrian datalink_Destroy(dl); 142336285Sbrian} 142436285Sbrian 142536285Sbrianvoid 142636285Sbrianbundle_SetLabel(struct bundle *bundle, const char *label) 142736285Sbrian{ 142836285Sbrian if (label) 142936285Sbrian strncpy(bundle->cfg.label, label, sizeof bundle->cfg.label - 1); 143036285Sbrian else 143136285Sbrian *bundle->cfg.label = '\0'; 143236285Sbrian} 143336285Sbrian 143436285Sbrianconst char * 143536285Sbrianbundle_GetLabel(struct bundle *bundle) 143636285Sbrian{ 143736285Sbrian return *bundle->cfg.label ? bundle->cfg.label : NULL; 143836285Sbrian} 143936285Sbrian 144036285Sbrianvoid 144136285Sbrianbundle_ReceiveDatalink(struct bundle *bundle, int s, struct sockaddr_un *sun) 144236285Sbrian{ 144336285Sbrian char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)]; 144436285Sbrian struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 144536285Sbrian struct msghdr msg; 144636285Sbrian struct iovec iov[SCATTER_SEGMENTS]; 144736285Sbrian struct datalink *dl; 144836285Sbrian int niov, link_fd, expect, f; 144936450Sbrian pid_t pid; 145036285Sbrian 145136285Sbrian log_Printf(LogPHASE, "Receiving datalink\n"); 145236285Sbrian 145336285Sbrian /* Create our scatter/gather array */ 145436285Sbrian niov = 1; 145536285Sbrian iov[0].iov_len = strlen(Version) + 1; 145636285Sbrian iov[0].iov_base = (char *)malloc(iov[0].iov_len); 145736450Sbrian if (datalink2iov(NULL, iov, &niov, sizeof iov / sizeof *iov, 0) == -1) { 145836345Sbrian close(s); 145936285Sbrian return; 146036345Sbrian } 146136285Sbrian 146236450Sbrian pid = getpid(); 146336450Sbrian write(s, &pid, sizeof pid); 146436450Sbrian 146536285Sbrian for (f = expect = 0; f < niov; f++) 146636285Sbrian expect += iov[f].iov_len; 146736285Sbrian 146836285Sbrian /* Set up our message */ 146936285Sbrian cmsg->cmsg_len = sizeof cmsgbuf; 147036285Sbrian cmsg->cmsg_level = SOL_SOCKET; 147136345Sbrian cmsg->cmsg_type = 0; 147236285Sbrian 147336285Sbrian memset(&msg, '\0', sizeof msg); 147436285Sbrian msg.msg_name = (caddr_t)sun; 147536285Sbrian msg.msg_namelen = sizeof *sun; 147636285Sbrian msg.msg_iov = iov; 147736285Sbrian msg.msg_iovlen = niov; 147836285Sbrian msg.msg_control = cmsgbuf; 147936285Sbrian msg.msg_controllen = sizeof cmsgbuf; 148036285Sbrian 148136285Sbrian log_Printf(LogDEBUG, "Expecting %d scatter/gather bytes\n", expect); 148236285Sbrian f = expect + 100; 148336285Sbrian setsockopt(s, SOL_SOCKET, SO_RCVBUF, &f, sizeof f); 148436285Sbrian if ((f = recvmsg(s, &msg, MSG_WAITALL)) != expect) { 148536285Sbrian if (f == -1) 148636285Sbrian log_Printf(LogERROR, "Failed recvmsg: %s\n", strerror(errno)); 148736285Sbrian else 148836285Sbrian log_Printf(LogERROR, "Failed recvmsg: Got %d, not %d\n", f, expect); 148936285Sbrian while (niov--) 149036285Sbrian free(iov[niov].iov_base); 149136345Sbrian close(s); 149236285Sbrian return; 149336285Sbrian } 149436285Sbrian 149536345Sbrian write(s, "!", 1); /* ACK */ 149637054Sbrian close(s); 149736285Sbrian 149837054Sbrian if (cmsg->cmsg_type != SCM_RIGHTS) { 149937054Sbrian log_Printf(LogERROR, "Recvmsg: no descriptor received !\n"); 150037054Sbrian while (niov--) 150137054Sbrian free(iov[niov].iov_base); 150237054Sbrian return; 150336345Sbrian } 150436285Sbrian 150537054Sbrian /* We've successfully received an open file descriptor through our socket */ 150637054Sbrian log_Printf(LogDEBUG, "Receiving device descriptor\n"); 150737054Sbrian link_fd = *(int *)CMSG_DATA(cmsg); 150837054Sbrian 150936285Sbrian if (strncmp(Version, iov[0].iov_base, iov[0].iov_len)) { 151036285Sbrian log_Printf(LogWARN, "Cannot receive datalink, incorrect version" 151136285Sbrian " (\"%.*s\", not \"%s\")\n", (int)iov[0].iov_len, 151237188Sbrian (char *)iov[0].iov_base, Version); 151336285Sbrian close(link_fd); 151436285Sbrian while (niov--) 151536285Sbrian free(iov[niov].iov_base); 151636285Sbrian return; 151736285Sbrian } 151836285Sbrian 151936285Sbrian niov = 1; 152036285Sbrian dl = iov2datalink(bundle, iov, &niov, sizeof iov / sizeof *iov, link_fd); 152136285Sbrian if (dl) { 152236285Sbrian bundle_DatalinkLinkin(bundle, dl); 152336285Sbrian datalink_AuthOk(dl); 152436285Sbrian } else 152536285Sbrian close(link_fd); 152636285Sbrian 152736285Sbrian free(iov[0].iov_base); 152836285Sbrian} 152936285Sbrian 153036285Sbrianvoid 153136285Sbrianbundle_SendDatalink(struct datalink *dl, int s, struct sockaddr_un *sun) 153236285Sbrian{ 153336285Sbrian char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)], ack; 153436285Sbrian struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 153536285Sbrian struct msghdr msg; 153636285Sbrian struct iovec iov[SCATTER_SEGMENTS]; 153736452Sbrian int niov, link_fd, f, expect, newsid; 153836450Sbrian pid_t newpid; 153936285Sbrian 154036285Sbrian log_Printf(LogPHASE, "Transmitting datalink %s\n", dl->name); 154136285Sbrian 154236314Sbrian bundle_LinkClosed(dl->bundle, dl); 154336285Sbrian bundle_DatalinkLinkout(dl->bundle, dl); 154436285Sbrian 154536285Sbrian /* Build our scatter/gather array */ 154636285Sbrian iov[0].iov_len = strlen(Version) + 1; 154736285Sbrian iov[0].iov_base = strdup(Version); 154836285Sbrian niov = 1; 154936285Sbrian 155036450Sbrian read(s, &newpid, sizeof newpid); 155136450Sbrian link_fd = datalink2iov(dl, iov, &niov, sizeof iov / sizeof *iov, newpid); 155236285Sbrian 155336285Sbrian if (link_fd != -1) { 155436345Sbrian memset(&msg, '\0', sizeof msg); 155536285Sbrian 155636285Sbrian msg.msg_name = (caddr_t)sun; 155736285Sbrian msg.msg_namelen = sizeof *sun; 155836285Sbrian msg.msg_iov = iov; 155936285Sbrian msg.msg_iovlen = niov; 156036285Sbrian 156136452Sbrian cmsg->cmsg_len = sizeof cmsgbuf; 156236452Sbrian cmsg->cmsg_level = SOL_SOCKET; 156336452Sbrian cmsg->cmsg_type = SCM_RIGHTS; 156436452Sbrian *(int *)CMSG_DATA(cmsg) = link_fd; 156536452Sbrian msg.msg_control = cmsgbuf; 156636452Sbrian msg.msg_controllen = sizeof cmsgbuf; 156736345Sbrian 156836285Sbrian for (f = expect = 0; f < niov; f++) 156936285Sbrian expect += iov[f].iov_len; 157036285Sbrian 157136285Sbrian log_Printf(LogDEBUG, "Sending %d bytes in scatter/gather array\n", expect); 157236285Sbrian 157336285Sbrian f = expect + SOCKET_OVERHEAD; 157436285Sbrian setsockopt(s, SOL_SOCKET, SO_SNDBUF, &f, sizeof f); 157536285Sbrian if (sendmsg(s, &msg, 0) == -1) 157636285Sbrian log_Printf(LogERROR, "Failed sendmsg: %s\n", strerror(errno)); 157736285Sbrian /* We must get the ACK before closing the descriptor ! */ 157836285Sbrian read(s, &ack, 1); 157936345Sbrian 158036452Sbrian newsid = tcgetpgrp(link_fd) == getpgrp(); 158136285Sbrian close(link_fd); 158236452Sbrian if (newsid) 158336452Sbrian bundle_setsid(dl->bundle, 1); 158436285Sbrian } 158536450Sbrian close(s); 158636285Sbrian 158736285Sbrian while (niov--) 158836285Sbrian free(iov[niov].iov_base); 158936285Sbrian} 159036285Sbrian 159136285Sbrianint 159236285Sbrianbundle_RenameDatalink(struct bundle *bundle, struct datalink *ndl, 159336285Sbrian const char *name) 159436285Sbrian{ 159536285Sbrian struct datalink *dl; 159636285Sbrian 159736285Sbrian if (!strcasecmp(ndl->name, name)) 159836285Sbrian return 1; 159936285Sbrian 160036285Sbrian for (dl = bundle->links; dl; dl = dl->next) 160136285Sbrian if (!strcasecmp(dl->name, name)) 160236285Sbrian return 0; 160336285Sbrian 160436285Sbrian datalink_Rename(ndl, name); 160536285Sbrian return 1; 160636285Sbrian} 160736285Sbrian 160836285Sbrianint 160936285Sbrianbundle_SetMode(struct bundle *bundle, struct datalink *dl, int mode) 161036285Sbrian{ 161136285Sbrian int omode; 161236285Sbrian 161336285Sbrian omode = dl->physical->type; 161436285Sbrian if (omode == mode) 161536285Sbrian return 1; 161636285Sbrian 161736928Sbrian if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO)) 161836928Sbrian /* First auto link */ 161936285Sbrian if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) { 162036928Sbrian log_Printf(LogWARN, "You must `set ifaddr' or `open' before" 162136928Sbrian " changing mode to %s\n", mode2Nam(mode)); 162236285Sbrian return 0; 162336285Sbrian } 162436285Sbrian 162536285Sbrian if (!datalink_SetMode(dl, mode)) 162636285Sbrian return 0; 162736285Sbrian 162836928Sbrian if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) && 162936928Sbrian bundle->phase != PHASE_NETWORK) 163036928Sbrian /* First auto link, we need an interface */ 163136285Sbrian ipcp_InterfaceUp(&bundle->ncp.ipcp); 163236285Sbrian 163336285Sbrian /* Regenerate phys_type and adjust autoload & idle timers */ 163436285Sbrian bundle_LinksRemoved(bundle); 163536285Sbrian 163636285Sbrian return 1; 163736285Sbrian} 163836452Sbrian 163936452Sbrianvoid 164036452Sbrianbundle_setsid(struct bundle *bundle, int holdsession) 164136452Sbrian{ 164236452Sbrian /* 164336452Sbrian * Lose the current session. This means getting rid of our pid 164436452Sbrian * too so that the tty device will really go away, and any getty 164536452Sbrian * etc will be allowed to restart. 164636452Sbrian */ 164736452Sbrian pid_t pid, orig; 164836452Sbrian int fds[2]; 164936452Sbrian char done; 165036452Sbrian struct datalink *dl; 165136452Sbrian 165236452Sbrian orig = getpid(); 165336452Sbrian if (pipe(fds) == -1) { 165436452Sbrian log_Printf(LogERROR, "pipe: %s\n", strerror(errno)); 165536452Sbrian return; 165636452Sbrian } 165736452Sbrian switch ((pid = fork())) { 165836452Sbrian case -1: 165936452Sbrian log_Printf(LogERROR, "fork: %s\n", strerror(errno)); 166036452Sbrian close(fds[0]); 166136452Sbrian close(fds[1]); 166236452Sbrian return; 166336452Sbrian case 0: 166444541Sbrian close(fds[1]); 166544541Sbrian read(fds[0], &done, 1); /* uu_locks are mine ! */ 166636452Sbrian close(fds[0]); 166736452Sbrian if (pipe(fds) == -1) { 166836452Sbrian log_Printf(LogERROR, "pipe(2): %s\n", strerror(errno)); 166936452Sbrian return; 167036452Sbrian } 167136452Sbrian switch ((pid = fork())) { 167236452Sbrian case -1: 167337019Sbrian log_Printf(LogERROR, "fork(2): %s\n", strerror(errno)); 167436452Sbrian close(fds[0]); 167536452Sbrian close(fds[1]); 167636452Sbrian return; 167736452Sbrian case 0: 167844541Sbrian close(fds[1]); 167944541Sbrian bundle_LockTun(bundle); /* update pid */ 168044541Sbrian read(fds[0], &done, 1); /* uu_locks are mine ! */ 168136452Sbrian close(fds[0]); 168236452Sbrian setsid(); 168336452Sbrian log_Printf(LogPHASE, "%d -> %d: %s session control\n", 168436452Sbrian (int)orig, (int)getpid(), 168536452Sbrian holdsession ? "Passed" : "Dropped"); 168641799Sbrian timer_InitService(0); /* Start the Timer Service */ 168736452Sbrian break; 168836452Sbrian default: 168944541Sbrian close(fds[0]); 169046686Sbrian /* Give away all our physical locks (to the final process) */ 169136452Sbrian for (dl = bundle->links; dl; dl = dl->next) 169236452Sbrian if (dl->state != DATALINK_CLOSED) 169346686Sbrian physical_ChangedPid(dl->physical, pid); 169444541Sbrian write(fds[1], "!", 1); /* done */ 169544541Sbrian close(fds[1]); 169636452Sbrian exit(0); 169736452Sbrian break; 169836452Sbrian } 169936452Sbrian break; 170036452Sbrian default: 170144541Sbrian close(fds[0]); 170246686Sbrian /* Give away all our physical locks (to the intermediate process) */ 170336452Sbrian for (dl = bundle->links; dl; dl = dl->next) 170436452Sbrian if (dl->state != DATALINK_CLOSED) 170546686Sbrian physical_ChangedPid(dl->physical, pid); 170644541Sbrian write(fds[1], "!", 1); /* done */ 170744541Sbrian close(fds[1]); 170836452Sbrian if (holdsession) { 170936452Sbrian int fd, status; 171036452Sbrian 171136452Sbrian timer_TermService(); 171236452Sbrian signal(SIGPIPE, SIG_DFL); 171336452Sbrian signal(SIGALRM, SIG_DFL); 171436452Sbrian signal(SIGHUP, SIG_DFL); 171536452Sbrian signal(SIGTERM, SIG_DFL); 171636452Sbrian signal(SIGINT, SIG_DFL); 171736452Sbrian signal(SIGQUIT, SIG_DFL); 171836452Sbrian for (fd = getdtablesize(); fd >= 0; fd--) 171936452Sbrian close(fd); 172036452Sbrian setuid(geteuid()); 172136452Sbrian /* 172236452Sbrian * Reap the intermediate process. As we're not exiting but the 172336452Sbrian * intermediate is, we don't want it to become defunct. 172436452Sbrian */ 172536452Sbrian waitpid(pid, &status, 0); 172636467Sbrian /* Tweak our process arguments.... */ 172736467Sbrian bundle->argv[0] = "session owner"; 172836467Sbrian bundle->argv[1] = NULL; 172936452Sbrian /* 173036452Sbrian * Hang around for a HUP. This should happen as soon as the 173136452Sbrian * ppp that we passed our ctty descriptor to closes it. 173236452Sbrian * NOTE: If this process dies, the passed descriptor becomes 173336452Sbrian * invalid and will give a select() error by setting one 173436452Sbrian * of the error fds, aborting the other ppp. We don't 173536452Sbrian * want that to happen ! 173636452Sbrian */ 173736452Sbrian pause(); 173836452Sbrian } 173936452Sbrian exit(0); 174036452Sbrian break; 174136452Sbrian } 174236452Sbrian} 174340622Sbrian 174440622Sbrianint 174540622Sbrianbundle_HighestState(struct bundle *bundle) 174640622Sbrian{ 174740622Sbrian struct datalink *dl; 174840622Sbrian int result = DATALINK_CLOSED; 174940622Sbrian 175040622Sbrian for (dl = bundle->links; dl; dl = dl->next) 175140622Sbrian if (result < dl->state) 175240622Sbrian result = dl->state; 175340622Sbrian 175440622Sbrian return result; 175540622Sbrian} 175641654Sbrian 175741654Sbrianint 175841654Sbrianbundle_Exception(struct bundle *bundle, int fd) 175941654Sbrian{ 176041654Sbrian struct datalink *dl; 176141654Sbrian 176241654Sbrian for (dl = bundle->links; dl; dl = dl->next) 176341654Sbrian if (dl->physical->fd == fd) { 176441654Sbrian datalink_Down(dl, CLOSE_NORMAL); 176541654Sbrian return 1; 176641654Sbrian } 176741654Sbrian 176841654Sbrian return 0; 176941654Sbrian} 1770