bundle.c revision 44541
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 * 2644541Sbrian * $Id: bundle.c,v 1.48 1999/03/04 17:42:14 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 <netinet/in_systm.h> 3636285Sbrian#include <netinet/ip.h> 3736285Sbrian#include <sys/un.h> 3836285Sbrian 3936285Sbrian#include <errno.h> 4036285Sbrian#include <fcntl.h> 4136285Sbrian#include <paths.h> 4236285Sbrian#include <stdio.h> 4336285Sbrian#include <stdlib.h> 4436285Sbrian#include <string.h> 4536285Sbrian#include <sys/ioctl.h> 4636285Sbrian#include <sys/uio.h> 4736345Sbrian#include <sys/wait.h> 4836285Sbrian#include <termios.h> 4936285Sbrian#include <unistd.h> 5036285Sbrian 5139395Sbrian#ifndef NOALIAS 5239395Sbrian#ifdef __OpenBSD__ 5339395Sbrian#include "alias.h" 5439395Sbrian#else 5539395Sbrian#include <alias.h> 5639395Sbrian#endif 5739395Sbrian#endif 5837009Sbrian#include "defs.h" 5936285Sbrian#include "command.h" 6036285Sbrian#include "mbuf.h" 6136285Sbrian#include "log.h" 6236285Sbrian#include "id.h" 6336285Sbrian#include "timer.h" 6436285Sbrian#include "fsm.h" 6536285Sbrian#include "iplist.h" 6636285Sbrian#include "lqr.h" 6736285Sbrian#include "hdlc.h" 6836285Sbrian#include "throughput.h" 6936285Sbrian#include "slcompress.h" 7036285Sbrian#include "ipcp.h" 7136285Sbrian#include "filter.h" 7236285Sbrian#include "descriptor.h" 7336285Sbrian#include "route.h" 7436285Sbrian#include "lcp.h" 7536285Sbrian#include "ccp.h" 7636285Sbrian#include "link.h" 7736285Sbrian#include "mp.h" 7843313Sbrian#ifndef NORADIUS 7943313Sbrian#include "radius.h" 8043313Sbrian#endif 8136285Sbrian#include "bundle.h" 8236285Sbrian#include "async.h" 8336285Sbrian#include "physical.h" 8436285Sbrian#include "modem.h" 8536285Sbrian#include "auth.h" 8636285Sbrian#include "lcpproto.h" 8736285Sbrian#include "chap.h" 8836285Sbrian#include "tun.h" 8936285Sbrian#include "prompt.h" 9036285Sbrian#include "chat.h" 9138174Sbrian#include "cbcp.h" 9236285Sbrian#include "datalink.h" 9336285Sbrian#include "ip.h" 9440561Sbrian#include "iface.h" 9536285Sbrian 9636285Sbrian#define SCATTER_SEGMENTS 4 /* version, datalink, name, physical */ 9736285Sbrian#define SOCKET_OVERHEAD 100 /* additional buffer space for large */ 9836285Sbrian /* {recv,send}msg() calls */ 9936285Sbrian 10036285Sbrianstatic int bundle_RemainingIdleTime(struct bundle *); 10136285Sbrianstatic int bundle_RemainingAutoLoadTime(struct bundle *); 10236285Sbrian 10336285Sbrianstatic const char *PhaseNames[] = { 10436285Sbrian "Dead", "Establish", "Authenticate", "Network", "Terminate" 10536285Sbrian}; 10636285Sbrian 10736285Sbrianconst char * 10836285Sbrianbundle_PhaseName(struct bundle *bundle) 10936285Sbrian{ 11036285Sbrian return bundle->phase <= PHASE_TERMINATE ? 11136285Sbrian PhaseNames[bundle->phase] : "unknown"; 11236285Sbrian} 11336285Sbrian 11436285Sbrianvoid 11536285Sbrianbundle_NewPhase(struct bundle *bundle, u_int new) 11636285Sbrian{ 11736285Sbrian if (new == bundle->phase) 11836285Sbrian return; 11936285Sbrian 12036285Sbrian if (new <= PHASE_TERMINATE) 12136285Sbrian log_Printf(LogPHASE, "bundle: %s\n", PhaseNames[new]); 12236285Sbrian 12336285Sbrian switch (new) { 12436285Sbrian case PHASE_DEAD: 12536314Sbrian log_DisplayPrompts(); 12636285Sbrian bundle->phase = new; 12736285Sbrian break; 12836285Sbrian 12936285Sbrian case PHASE_ESTABLISH: 13036285Sbrian bundle->phase = new; 13136285Sbrian break; 13236285Sbrian 13336285Sbrian case PHASE_AUTHENTICATE: 13436285Sbrian bundle->phase = new; 13536314Sbrian log_DisplayPrompts(); 13636285Sbrian break; 13736285Sbrian 13836285Sbrian case PHASE_NETWORK: 13936285Sbrian fsm_Up(&bundle->ncp.ipcp.fsm); 14036285Sbrian fsm_Open(&bundle->ncp.ipcp.fsm); 14136285Sbrian bundle->phase = new; 14236314Sbrian log_DisplayPrompts(); 14336285Sbrian break; 14436285Sbrian 14536285Sbrian case PHASE_TERMINATE: 14636285Sbrian bundle->phase = new; 14736285Sbrian mp_Down(&bundle->ncp.mp); 14836314Sbrian log_DisplayPrompts(); 14936285Sbrian break; 15036285Sbrian } 15136285Sbrian} 15236285Sbrian 15336285Sbrianstatic void 15436285Sbrianbundle_LayerStart(void *v, struct fsm *fp) 15536285Sbrian{ 15636285Sbrian /* The given FSM is about to start up ! */ 15736285Sbrian} 15836285Sbrian 15936285Sbrian 16036285Sbrianstatic void 16136285Sbrianbundle_Notify(struct bundle *bundle, char c) 16236285Sbrian{ 16336285Sbrian if (bundle->notify.fd != -1) { 16436285Sbrian if (write(bundle->notify.fd, &c, 1) == 1) 16536285Sbrian log_Printf(LogPHASE, "Parent notified of success.\n"); 16636285Sbrian else 16736285Sbrian log_Printf(LogPHASE, "Failed to notify parent of success.\n"); 16836285Sbrian close(bundle->notify.fd); 16936285Sbrian bundle->notify.fd = -1; 17036285Sbrian } 17136285Sbrian} 17236285Sbrian 17338544Sbrianstatic void 17438544Sbrianbundle_ClearQueues(void *v) 17538544Sbrian{ 17638544Sbrian struct bundle *bundle = (struct bundle *)v; 17738544Sbrian struct datalink *dl; 17838544Sbrian 17938544Sbrian log_Printf(LogPHASE, "Clearing choked output queue\n"); 18038544Sbrian timer_Stop(&bundle->choked.timer); 18138544Sbrian 18238544Sbrian /* 18338544Sbrian * Emergency time: 18438544Sbrian * 18538544Sbrian * We've had a full queue for PACKET_DEL_SECS seconds without being 18638544Sbrian * able to get rid of any of the packets. We've probably given up 18738544Sbrian * on the redials at this point, and the queued data has almost 18838544Sbrian * definitely been timed out by the layer above. As this is preventing 18938544Sbrian * us from reading the TUN_NAME device (we don't want to buffer stuff 19038544Sbrian * indefinitely), we may as well nuke this data and start with a clean 19138544Sbrian * slate ! 19238544Sbrian * 19338544Sbrian * Unfortunately, this has the side effect of shafting any compression 19438544Sbrian * dictionaries in use (causing the relevant RESET_REQ/RESET_ACK). 19538544Sbrian */ 19638544Sbrian 19738557Sbrian ip_DeleteQueue(&bundle->ncp.ipcp); 19838544Sbrian mp_DeleteQueue(&bundle->ncp.mp); 19938544Sbrian for (dl = bundle->links; dl; dl = dl->next) 20038544Sbrian physical_DeleteQueue(dl->physical); 20138544Sbrian} 20238544Sbrian 20336285Sbrianstatic void 20436285Sbrianbundle_AutoLoadTimeout(void *v) 20536285Sbrian{ 20636285Sbrian struct bundle *bundle = (struct bundle *)v; 20736285Sbrian 20836285Sbrian if (bundle->autoload.comingup) { 20936285Sbrian log_Printf(LogPHASE, "autoload: Another link is required\n"); 21036285Sbrian /* bundle_Open() stops the timer */ 21137955Sbrian bundle_Open(bundle, NULL, PHYS_AUTO, 0); 21236285Sbrian } else { 21336285Sbrian struct datalink *dl, *last; 21436285Sbrian 21536285Sbrian timer_Stop(&bundle->autoload.timer); 21636285Sbrian for (last = NULL, dl = bundle->links; dl; dl = dl->next) 21736465Sbrian if (dl->physical->type == PHYS_AUTO && dl->state == DATALINK_OPEN) 21836285Sbrian last = dl; 21936285Sbrian 22036285Sbrian if (last) 22137007Sbrian datalink_Close(last, CLOSE_STAYDOWN); 22236285Sbrian } 22336285Sbrian} 22436285Sbrian 22536285Sbrianstatic void 22636285Sbrianbundle_StartAutoLoadTimer(struct bundle *bundle, int up) 22736285Sbrian{ 22836285Sbrian struct datalink *dl; 22936285Sbrian 23036285Sbrian timer_Stop(&bundle->autoload.timer); 23144352Sbrian bundle->autoload.comingup = up ? 1 : 0; 23236285Sbrian 23336285Sbrian if (bundle->CleaningUp || bundle->phase != PHASE_NETWORK) { 23436285Sbrian dl = NULL; 23536285Sbrian bundle->autoload.running = 0; 23636285Sbrian } else if (up) { 23736285Sbrian for (dl = bundle->links; dl; dl = dl->next) 23836465Sbrian if (dl->state == DATALINK_CLOSED && dl->physical->type == PHYS_AUTO) { 23936285Sbrian if (bundle->cfg.autoload.max.timeout) { 24036285Sbrian bundle->autoload.timer.func = bundle_AutoLoadTimeout; 24136285Sbrian bundle->autoload.timer.name = "autoload up"; 24236285Sbrian bundle->autoload.timer.load = 24336285Sbrian bundle->cfg.autoload.max.timeout * SECTICKS; 24436285Sbrian bundle->autoload.timer.arg = bundle; 24536285Sbrian timer_Start(&bundle->autoload.timer); 24636285Sbrian bundle->autoload.done = time(NULL) + bundle->cfg.autoload.max.timeout; 24736285Sbrian } else 24836285Sbrian bundle_AutoLoadTimeout(bundle); 24936285Sbrian break; 25036285Sbrian } 25136285Sbrian bundle->autoload.running = (dl || bundle->cfg.autoload.min.timeout) ? 1 : 0; 25236285Sbrian } else { 25336285Sbrian int nlinks; 25436285Sbrian struct datalink *adl; 25536285Sbrian 25636285Sbrian for (nlinks = 0, adl = NULL, dl = bundle->links; dl; dl = dl->next) 25736285Sbrian if (dl->state == DATALINK_OPEN) { 25836465Sbrian if (dl->physical->type == PHYS_AUTO) 25936285Sbrian adl = dl; 26036285Sbrian if (++nlinks > 1 && adl) { 26136285Sbrian if (bundle->cfg.autoload.min.timeout) { 26236285Sbrian bundle->autoload.timer.func = bundle_AutoLoadTimeout; 26336285Sbrian bundle->autoload.timer.name = "autoload down"; 26436285Sbrian bundle->autoload.timer.load = 26536285Sbrian bundle->cfg.autoload.min.timeout * SECTICKS; 26636285Sbrian bundle->autoload.timer.arg = bundle; 26736285Sbrian timer_Start(&bundle->autoload.timer); 26836285Sbrian bundle->autoload.done = 26936285Sbrian time(NULL) + bundle->cfg.autoload.min.timeout; 27036285Sbrian } 27136285Sbrian break; 27236285Sbrian } 27336285Sbrian } 27436285Sbrian 27536285Sbrian bundle->autoload.running = 1; 27636285Sbrian } 27736285Sbrian} 27836285Sbrian 27936285Sbrianstatic void 28036285Sbrianbundle_StopAutoLoadTimer(struct bundle *bundle) 28136285Sbrian{ 28236285Sbrian timer_Stop(&bundle->autoload.timer); 28336285Sbrian bundle->autoload.done = 0; 28436285Sbrian} 28536285Sbrian 28636285Sbrianstatic int 28736285Sbrianbundle_RemainingAutoLoadTime(struct bundle *bundle) 28836285Sbrian{ 28936285Sbrian if (bundle->autoload.done) 29036285Sbrian return bundle->autoload.done - time(NULL); 29136285Sbrian return -1; 29236285Sbrian} 29336285Sbrian 29436928Sbrianstatic void 29536928Sbrianbundle_LinkAdded(struct bundle *bundle, struct datalink *dl) 29636928Sbrian{ 29736928Sbrian bundle->phys_type.all |= dl->physical->type; 29836928Sbrian if (dl->state == DATALINK_OPEN) 29936928Sbrian bundle->phys_type.open |= dl->physical->type; 30036285Sbrian 30136928Sbrian /* Note: We only re-add links that are DATALINK_OPEN */ 30236928Sbrian if (dl->physical->type == PHYS_AUTO && 30336928Sbrian bundle->autoload.timer.state == TIMER_STOPPED && 30436928Sbrian dl->state != DATALINK_OPEN && 30536928Sbrian bundle->phase == PHASE_NETWORK) 30636928Sbrian bundle->autoload.running = 1; 30736928Sbrian 30836928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 30936928Sbrian != bundle->phys_type.open && bundle->idle.timer.state == TIMER_STOPPED) 31036928Sbrian /* We may need to start our idle timer */ 31136928Sbrian bundle_StartIdleTimer(bundle); 31236928Sbrian} 31336928Sbrian 31438174Sbrianvoid 31536928Sbrianbundle_LinksRemoved(struct bundle *bundle) 31636928Sbrian{ 31736928Sbrian struct datalink *dl; 31836928Sbrian 31936928Sbrian bundle->phys_type.all = bundle->phys_type.open = 0; 32036928Sbrian for (dl = bundle->links; dl; dl = dl->next) 32136928Sbrian bundle_LinkAdded(bundle, dl); 32236928Sbrian 32336928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 32436928Sbrian == bundle->phys_type.open) 32536928Sbrian bundle_StopIdleTimer(bundle); 32636928Sbrian} 32736928Sbrian 32836928Sbrianstatic void 32936285Sbrianbundle_LayerUp(void *v, struct fsm *fp) 33036285Sbrian{ 33136285Sbrian /* 33236285Sbrian * The given fsm is now up 33336928Sbrian * If it's an LCP, adjust our phys_mode.open value. 33436285Sbrian * If it's an LCP set our mtu (if we're multilink, add up the link 33536285Sbrian * speeds and set the MRRU) and start our autoload timer. 33636285Sbrian * If it's an NCP, tell our -background parent to go away. 33736285Sbrian * If it's the first NCP, start the idle timer. 33836285Sbrian */ 33936285Sbrian struct bundle *bundle = (struct bundle *)v; 34036285Sbrian 34136285Sbrian if (fp->proto == PROTO_LCP) { 34236928Sbrian struct physical *p = link2physical(fp->link); 34336928Sbrian 34436928Sbrian bundle_LinkAdded(bundle, p->dl); 34536285Sbrian if (bundle->ncp.mp.active) { 34636285Sbrian struct datalink *dl; 34736285Sbrian 34840561Sbrian bundle->ifSpeed = 0; 34936285Sbrian for (dl = bundle->links; dl; dl = dl->next) 35036285Sbrian if (dl->state == DATALINK_OPEN) 35140561Sbrian bundle->ifSpeed += modem_Speed(dl->physical); 35236285Sbrian tun_configure(bundle, bundle->ncp.mp.peer_mrru); 35336285Sbrian bundle->autoload.running = 1; 35436285Sbrian } else { 35540561Sbrian bundle->ifSpeed = modem_Speed(p); 35636285Sbrian tun_configure(bundle, fsm2lcp(fp)->his_mru); 35736285Sbrian } 35836285Sbrian } else if (fp->proto == PROTO_IPCP) { 35936285Sbrian bundle_StartIdleTimer(bundle); 36036285Sbrian bundle_Notify(bundle, EX_NORMAL); 36136285Sbrian } 36236285Sbrian} 36336285Sbrian 36436285Sbrianstatic void 36536285Sbrianbundle_LayerDown(void *v, struct fsm *fp) 36636285Sbrian{ 36736285Sbrian /* 36836285Sbrian * The given FSM has been told to come down. 36936285Sbrian * If it's our last NCP, stop the idle timer. 37036928Sbrian * If it's an LCP, adjust our phys_type.open value and any timers. 37136312Sbrian * If it's an LCP and we're in multilink mode, adjust our tun 37236312Sbrian * speed and make sure our minimum sequence number is adjusted. 37336285Sbrian */ 37436285Sbrian 37536285Sbrian struct bundle *bundle = (struct bundle *)v; 37636285Sbrian 37736285Sbrian if (fp->proto == PROTO_IPCP) 37836285Sbrian bundle_StopIdleTimer(bundle); 37936928Sbrian else if (fp->proto == PROTO_LCP) { 38036928Sbrian bundle_LinksRemoved(bundle); /* adjust timers & phys_type values */ 38136928Sbrian if (bundle->ncp.mp.active) { 38236928Sbrian struct datalink *dl; 38336928Sbrian struct datalink *lost; 38436285Sbrian 38540561Sbrian bundle->ifSpeed = 0; 38636928Sbrian lost = NULL; 38736928Sbrian for (dl = bundle->links; dl; dl = dl->next) 38836928Sbrian if (fp == &dl->physical->link.lcp.fsm) 38936928Sbrian lost = dl; 39036928Sbrian else if (dl->state == DATALINK_OPEN) 39140561Sbrian bundle->ifSpeed += modem_Speed(dl->physical); 39236312Sbrian 39340561Sbrian if (bundle->ifSpeed) 39436928Sbrian /* Don't configure down to a speed of 0 */ 39536928Sbrian tun_configure(bundle, bundle->ncp.mp.link.lcp.his_mru); 39636312Sbrian 39736928Sbrian if (lost) 39836928Sbrian mp_LinkLost(&bundle->ncp.mp, lost); 39936928Sbrian else 40037019Sbrian log_Printf(LogALERT, "Oops, lost an unrecognised datalink (%s) !\n", 40136928Sbrian fp->link->name); 40236928Sbrian } 40336285Sbrian } 40436285Sbrian} 40536285Sbrian 40636285Sbrianstatic void 40736285Sbrianbundle_LayerFinish(void *v, struct fsm *fp) 40836285Sbrian{ 40936285Sbrian /* The given fsm is now down (fp cannot be NULL) 41036285Sbrian * 41136285Sbrian * If it's the last LCP, fsm_Down all NCPs 41236285Sbrian * If it's the last NCP, fsm_Close all LCPs 41336285Sbrian */ 41436285Sbrian 41536285Sbrian struct bundle *bundle = (struct bundle *)v; 41636285Sbrian struct datalink *dl; 41736285Sbrian 41836285Sbrian if (fp->proto == PROTO_IPCP) { 41936285Sbrian if (bundle_Phase(bundle) != PHASE_DEAD) 42036285Sbrian bundle_NewPhase(bundle, PHASE_TERMINATE); 42136285Sbrian for (dl = bundle->links; dl; dl = dl->next) 42237007Sbrian datalink_Close(dl, CLOSE_NORMAL); 42337060Sbrian fsm2initial(fp); 42436285Sbrian } else if (fp->proto == PROTO_LCP) { 42536285Sbrian int others_active; 42636285Sbrian 42736285Sbrian others_active = 0; 42836285Sbrian for (dl = bundle->links; dl; dl = dl->next) 42936285Sbrian if (fp != &dl->physical->link.lcp.fsm && 43036285Sbrian dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 43136285Sbrian others_active++; 43236285Sbrian 43337060Sbrian if (!others_active) 43437060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 43536285Sbrian } 43636285Sbrian} 43736285Sbrian 43836285Sbrianint 43936285Sbrianbundle_LinkIsUp(const struct bundle *bundle) 44036285Sbrian{ 44136285Sbrian return bundle->ncp.ipcp.fsm.state == ST_OPENED; 44236285Sbrian} 44336285Sbrian 44436285Sbrianvoid 44537007Sbrianbundle_Close(struct bundle *bundle, const char *name, int how) 44636285Sbrian{ 44736285Sbrian /* 44836285Sbrian * Please close the given datalink. 44936285Sbrian * If name == NULL or name is the last datalink, fsm_Close all NCPs 45036285Sbrian * (except our MP) 45136285Sbrian * If it isn't the last datalink, just Close that datalink. 45236285Sbrian */ 45336285Sbrian 45436285Sbrian struct datalink *dl, *this_dl; 45536285Sbrian int others_active; 45636285Sbrian 45736285Sbrian others_active = 0; 45836285Sbrian this_dl = NULL; 45936285Sbrian 46036285Sbrian for (dl = bundle->links; dl; dl = dl->next) { 46136285Sbrian if (name && !strcasecmp(name, dl->name)) 46236285Sbrian this_dl = dl; 46336285Sbrian if (name == NULL || this_dl == dl) { 46437007Sbrian switch (how) { 46537007Sbrian case CLOSE_LCP: 46637007Sbrian datalink_DontHangup(dl); 46737007Sbrian /* fall through */ 46837007Sbrian case CLOSE_STAYDOWN: 46937007Sbrian datalink_StayDown(dl); 47037007Sbrian break; 47137007Sbrian } 47236285Sbrian } else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 47336285Sbrian others_active++; 47436285Sbrian } 47536285Sbrian 47636285Sbrian if (name && this_dl == NULL) { 47736285Sbrian log_Printf(LogWARN, "%s: Invalid datalink name\n", name); 47836285Sbrian return; 47936285Sbrian } 48036285Sbrian 48136285Sbrian if (!others_active) { 48236285Sbrian bundle_StopIdleTimer(bundle); 48336285Sbrian bundle_StopAutoLoadTimer(bundle); 48436285Sbrian if (bundle->ncp.ipcp.fsm.state > ST_CLOSED || 48536285Sbrian bundle->ncp.ipcp.fsm.state == ST_STARTING) 48636285Sbrian fsm_Close(&bundle->ncp.ipcp.fsm); 48736285Sbrian else { 48837060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 48936285Sbrian for (dl = bundle->links; dl; dl = dl->next) 49037007Sbrian datalink_Close(dl, how); 49136285Sbrian } 49236285Sbrian } else if (this_dl && this_dl->state != DATALINK_CLOSED && 49336285Sbrian this_dl->state != DATALINK_HANGUP) 49437007Sbrian datalink_Close(this_dl, how); 49536285Sbrian} 49636285Sbrian 49736285Sbrianvoid 49837018Sbrianbundle_Down(struct bundle *bundle, int how) 49936285Sbrian{ 50036285Sbrian struct datalink *dl; 50136285Sbrian 50236285Sbrian for (dl = bundle->links; dl; dl = dl->next) 50337018Sbrian datalink_Down(dl, how); 50436285Sbrian} 50536285Sbrian 50636285Sbrianstatic int 50736285Sbrianbundle_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 50836285Sbrian{ 50936285Sbrian struct bundle *bundle = descriptor2bundle(d); 51036285Sbrian struct datalink *dl; 51136285Sbrian int result, want, queued, nlinks; 51236285Sbrian 51336285Sbrian result = 0; 51436285Sbrian 51536285Sbrian /* If there are aren't many packets queued, look for some more. */ 51636285Sbrian for (nlinks = 0, dl = bundle->links; dl; dl = dl->next) 51736285Sbrian nlinks++; 51836285Sbrian 51936285Sbrian if (nlinks) { 52038557Sbrian queued = r ? bundle_FillQueues(bundle) : ip_QueueLen(&bundle->ncp.ipcp); 52136285Sbrian if (bundle->autoload.running) { 52236285Sbrian if (queued < bundle->cfg.autoload.max.packets) { 52336285Sbrian if (queued > bundle->cfg.autoload.min.packets) 52436285Sbrian bundle_StopAutoLoadTimer(bundle); 52536285Sbrian else if (bundle->autoload.timer.state != TIMER_RUNNING || 52636285Sbrian bundle->autoload.comingup) 52736285Sbrian bundle_StartAutoLoadTimer(bundle, 0); 52844352Sbrian } else if ((bundle_Phase(bundle) == PHASE_NETWORK || queued) && 52944352Sbrian (bundle->autoload.timer.state != TIMER_RUNNING || 53044352Sbrian !bundle->autoload.comingup)) 53136285Sbrian bundle_StartAutoLoadTimer(bundle, 1); 53236285Sbrian } 53336285Sbrian 53436928Sbrian if (r && (bundle->phase == PHASE_NETWORK || 53536928Sbrian bundle->phys_type.all & PHYS_AUTO)) { 53636285Sbrian /* enough surplus so that we can tell if we're getting swamped */ 53736285Sbrian want = bundle->cfg.autoload.max.packets + nlinks * 2; 53836285Sbrian /* but at least 20 packets ! */ 53936285Sbrian if (want < 20) 54036285Sbrian want = 20; 54136285Sbrian if (queued < want) { 54236285Sbrian /* Not enough - select() for more */ 54338544Sbrian if (bundle->choked.timer.state == TIMER_RUNNING) 54438544Sbrian timer_Stop(&bundle->choked.timer); /* Not needed any more */ 54536285Sbrian FD_SET(bundle->dev.fd, r); 54636285Sbrian if (*n < bundle->dev.fd + 1) 54736285Sbrian *n = bundle->dev.fd + 1; 54836452Sbrian log_Printf(LogTIMER, "%s: fdset(r) %d\n", TUN_NAME, bundle->dev.fd); 54936285Sbrian result++; 55038544Sbrian } else if (bundle->choked.timer.state == TIMER_STOPPED) { 55138544Sbrian bundle->choked.timer.func = bundle_ClearQueues; 55238544Sbrian bundle->choked.timer.name = "output choke"; 55338544Sbrian bundle->choked.timer.load = bundle->cfg.choked.timeout * SECTICKS; 55438544Sbrian bundle->choked.timer.arg = bundle; 55538544Sbrian timer_Start(&bundle->choked.timer); 55636285Sbrian } 55736285Sbrian } 55836285Sbrian } 55936285Sbrian 56043693Sbrian#ifndef NORADIUS 56143693Sbrian result += descriptor_UpdateSet(&bundle->radius.desc, r, w, e, n); 56243693Sbrian#endif 56343693Sbrian 56436714Sbrian /* Which links need a select() ? */ 56536714Sbrian for (dl = bundle->links; dl; dl = dl->next) 56636714Sbrian result += descriptor_UpdateSet(&dl->desc, r, w, e, n); 56736714Sbrian 56836285Sbrian /* 56936285Sbrian * This *MUST* be called after the datalink UpdateSet()s as it 57036285Sbrian * might be ``holding'' one of the datalinks (death-row) and 57136285Sbrian * wants to be able to de-select() it from the descriptor set. 57236285Sbrian */ 57336314Sbrian result += descriptor_UpdateSet(&bundle->ncp.mp.server.desc, r, w, e, n); 57436285Sbrian 57536285Sbrian return result; 57636285Sbrian} 57736285Sbrian 57836285Sbrianstatic int 57936285Sbrianbundle_IsSet(struct descriptor *d, const fd_set *fdset) 58036285Sbrian{ 58136285Sbrian struct bundle *bundle = descriptor2bundle(d); 58236285Sbrian struct datalink *dl; 58336285Sbrian 58436285Sbrian for (dl = bundle->links; dl; dl = dl->next) 58536285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 58636285Sbrian return 1; 58736285Sbrian 58843693Sbrian#ifndef NORADIUS 58943693Sbrian if (descriptor_IsSet(&bundle->radius.desc, fdset)) 59043693Sbrian return 1; 59143693Sbrian#endif 59243693Sbrian 59336285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 59436285Sbrian return 1; 59536285Sbrian 59636285Sbrian return FD_ISSET(bundle->dev.fd, fdset); 59736285Sbrian} 59836285Sbrian 59936285Sbrianstatic void 60036285Sbrianbundle_DescriptorRead(struct descriptor *d, struct bundle *bundle, 60136285Sbrian const fd_set *fdset) 60236285Sbrian{ 60336285Sbrian struct datalink *dl; 60436285Sbrian 60536285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 60636285Sbrian descriptor_Read(&bundle->ncp.mp.server.desc, bundle, fdset); 60736285Sbrian 60836285Sbrian for (dl = bundle->links; dl; dl = dl->next) 60936285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 61036285Sbrian descriptor_Read(&dl->desc, bundle, fdset); 61136285Sbrian 61243693Sbrian#ifndef NORADIUS 61343693Sbrian if (descriptor_IsSet(&bundle->radius.desc, fdset)) 61443693Sbrian descriptor_Read(&bundle->radius.desc, bundle, fdset); 61543693Sbrian#endif 61643693Sbrian 61736285Sbrian if (FD_ISSET(bundle->dev.fd, fdset)) { 61836285Sbrian struct tun_data tun; 61936285Sbrian int n, pri; 62036285Sbrian 62136285Sbrian /* something to read from tun */ 62236285Sbrian n = read(bundle->dev.fd, &tun, sizeof tun); 62336285Sbrian if (n < 0) { 62437019Sbrian log_Printf(LogWARN, "read from %s: %s\n", TUN_NAME, strerror(errno)); 62536285Sbrian return; 62636285Sbrian } 62736285Sbrian n -= sizeof tun - sizeof tun.data; 62836285Sbrian if (n <= 0) { 62937019Sbrian log_Printf(LogERROR, "read from %s: Only %d bytes read ?\n", TUN_NAME, n); 63036285Sbrian return; 63136285Sbrian } 63236285Sbrian if (!tun_check_header(tun, AF_INET)) 63336285Sbrian return; 63436285Sbrian 63536285Sbrian if (((struct ip *)tun.data)->ip_dst.s_addr == 63636285Sbrian bundle->ncp.ipcp.my_ip.s_addr) { 63736285Sbrian /* we've been asked to send something addressed *to* us :( */ 63836285Sbrian if (Enabled(bundle, OPT_LOOPBACK)) { 63936285Sbrian pri = PacketCheck(bundle, tun.data, n, &bundle->filter.in); 64036285Sbrian if (pri >= 0) { 64136285Sbrian struct mbuf *bp; 64236285Sbrian 64336285Sbrian bp = mbuf_Alloc(n, MB_IPIN); 64436285Sbrian memcpy(MBUF_CTOP(bp), tun.data, n); 64536285Sbrian ip_Input(bundle, bp); 64636285Sbrian log_Printf(LogDEBUG, "Looped back packet addressed to myself\n"); 64736285Sbrian } 64836285Sbrian return; 64936285Sbrian } else 65036285Sbrian log_Printf(LogDEBUG, "Oops - forwarding packet addressed to myself\n"); 65136285Sbrian } 65236285Sbrian 65336285Sbrian /* 65436285Sbrian * Process on-demand dialup. Output packets are queued within tunnel 65536285Sbrian * device until IPCP is opened. 65636285Sbrian */ 65736285Sbrian 65836285Sbrian if (bundle_Phase(bundle) == PHASE_DEAD) { 65936285Sbrian /* 66036285Sbrian * Note, we must be in AUTO mode :-/ otherwise our interface should 66136285Sbrian * *not* be UP and we can't receive data 66236285Sbrian */ 66336285Sbrian if ((pri = PacketCheck(bundle, tun.data, n, &bundle->filter.dial)) >= 0) 66437955Sbrian bundle_Open(bundle, NULL, PHYS_AUTO, 0); 66536285Sbrian else 66636285Sbrian /* 66736285Sbrian * Drop the packet. If we were to queue it, we'd just end up with 66836285Sbrian * a pile of timed-out data in our output queue by the time we get 66936285Sbrian * around to actually dialing. We'd also prematurely reach the 67036285Sbrian * threshold at which we stop select()ing to read() the tun 67136285Sbrian * device - breaking auto-dial. 67236285Sbrian */ 67336285Sbrian return; 67436285Sbrian } 67536285Sbrian 67636285Sbrian pri = PacketCheck(bundle, tun.data, n, &bundle->filter.out); 67736285Sbrian if (pri >= 0) { 67836285Sbrian#ifndef NOALIAS 67937191Sbrian if (bundle->AliasEnabled) { 68037191Sbrian PacketAliasOut(tun.data, sizeof tun.data); 68136285Sbrian n = ntohs(((struct ip *)tun.data)->ip_len); 68236285Sbrian } 68336285Sbrian#endif 68438557Sbrian ip_Enqueue(&bundle->ncp.ipcp, pri, tun.data, n); 68536285Sbrian } 68636285Sbrian } 68736285Sbrian} 68836285Sbrian 68937141Sbrianstatic int 69036285Sbrianbundle_DescriptorWrite(struct descriptor *d, struct bundle *bundle, 69136285Sbrian const fd_set *fdset) 69236285Sbrian{ 69336285Sbrian struct datalink *dl; 69437141Sbrian int result = 0; 69536285Sbrian 69636285Sbrian /* This is not actually necessary as struct mpserver doesn't Write() */ 69736285Sbrian if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 69836285Sbrian descriptor_Write(&bundle->ncp.mp.server.desc, bundle, fdset); 69936285Sbrian 70036285Sbrian for (dl = bundle->links; dl; dl = dl->next) 70136285Sbrian if (descriptor_IsSet(&dl->desc, fdset)) 70237141Sbrian result += descriptor_Write(&dl->desc, bundle, fdset); 70337141Sbrian 70437141Sbrian return result; 70536285Sbrian} 70636285Sbrian 70736709Sbrianvoid 70836452Sbrianbundle_LockTun(struct bundle *bundle) 70936452Sbrian{ 71036452Sbrian FILE *lockfile; 71136452Sbrian char pidfile[MAXPATHLEN]; 71236285Sbrian 71336452Sbrian snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 71436452Sbrian lockfile = ID0fopen(pidfile, "w"); 71536452Sbrian if (lockfile != NULL) { 71636452Sbrian fprintf(lockfile, "%d\n", (int)getpid()); 71736452Sbrian fclose(lockfile); 71836452Sbrian } 71936452Sbrian#ifndef RELEASE_CRUNCH 72036452Sbrian else 72136452Sbrian log_Printf(LogERROR, "Warning: Can't create %s: %s\n", 72236452Sbrian pidfile, strerror(errno)); 72336452Sbrian#endif 72436452Sbrian} 72536452Sbrian 72636452Sbrianstatic void 72736452Sbrianbundle_UnlockTun(struct bundle *bundle) 72836452Sbrian{ 72936452Sbrian char pidfile[MAXPATHLEN]; 73036452Sbrian 73136452Sbrian snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 73236452Sbrian ID0unlink(pidfile); 73336452Sbrian} 73436452Sbrian 73536285Sbrianstruct bundle * 73636467Sbrianbundle_Create(const char *prefix, int type, const char **argv) 73736285Sbrian{ 73836285Sbrian int s, enoentcount, err; 73940561Sbrian const char *ifname; 74036285Sbrian struct ifreq ifrq; 74136285Sbrian static struct bundle bundle; /* there can be only one */ 74236285Sbrian 74340561Sbrian if (bundle.iface != NULL) { /* Already allocated ! */ 74437019Sbrian log_Printf(LogALERT, "bundle_Create: There's only one BUNDLE !\n"); 74536285Sbrian return NULL; 74636285Sbrian } 74736285Sbrian 74836285Sbrian err = ENOENT; 74936285Sbrian enoentcount = 0; 75036285Sbrian for (bundle.unit = 0; ; bundle.unit++) { 75136285Sbrian snprintf(bundle.dev.Name, sizeof bundle.dev.Name, "%s%d", 75236285Sbrian prefix, bundle.unit); 75336285Sbrian bundle.dev.fd = ID0open(bundle.dev.Name, O_RDWR); 75436285Sbrian if (bundle.dev.fd >= 0) 75536285Sbrian break; 75636285Sbrian else if (errno == ENXIO) { 75736285Sbrian err = errno; 75836285Sbrian break; 75936285Sbrian } else if (errno == ENOENT) { 76036285Sbrian if (++enoentcount > 2) 76136285Sbrian break; 76236285Sbrian } else 76336285Sbrian err = errno; 76436285Sbrian } 76536285Sbrian 76636285Sbrian if (bundle.dev.fd < 0) { 76736285Sbrian log_Printf(LogWARN, "No available tunnel devices found (%s).\n", 76836285Sbrian strerror(err)); 76936285Sbrian return NULL; 77036285Sbrian } 77136285Sbrian 77236285Sbrian log_SetTun(bundle.unit); 77336467Sbrian bundle.argv = argv; 77440679Sbrian bundle.argv0 = argv[0]; 77540679Sbrian bundle.argv1 = argv[1]; 77636285Sbrian 77736285Sbrian s = socket(AF_INET, SOCK_DGRAM, 0); 77836285Sbrian if (s < 0) { 77936285Sbrian log_Printf(LogERROR, "bundle_Create: socket(): %s\n", strerror(errno)); 78036285Sbrian close(bundle.dev.fd); 78136285Sbrian return NULL; 78236285Sbrian } 78336285Sbrian 78440561Sbrian ifname = strrchr(bundle.dev.Name, '/'); 78540561Sbrian if (ifname == NULL) 78640561Sbrian ifname = bundle.dev.Name; 78736285Sbrian else 78840561Sbrian ifname++; 78936285Sbrian 79040561Sbrian bundle.iface = iface_Create(ifname); 79140561Sbrian if (bundle.iface == NULL) { 79240561Sbrian close(s); 79340561Sbrian close(bundle.dev.fd); 79440561Sbrian return NULL; 79540561Sbrian } 79640561Sbrian 79736285Sbrian /* 79836285Sbrian * Now, bring up the interface. 79936285Sbrian */ 80036285Sbrian memset(&ifrq, '\0', sizeof ifrq); 80140561Sbrian strncpy(ifrq.ifr_name, ifname, sizeof ifrq.ifr_name - 1); 80236285Sbrian ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0'; 80336285Sbrian if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) { 80437019Sbrian log_Printf(LogERROR, "bundle_Create: ioctl(SIOCGIFFLAGS): %s\n", 80536285Sbrian strerror(errno)); 80636285Sbrian close(s); 80740561Sbrian iface_Destroy(bundle.iface); 80840561Sbrian bundle.iface = NULL; 80936285Sbrian close(bundle.dev.fd); 81036285Sbrian return NULL; 81136285Sbrian } 81236285Sbrian ifrq.ifr_flags |= IFF_UP; 81336285Sbrian if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) { 81437019Sbrian log_Printf(LogERROR, "bundle_Create: ioctl(SIOCSIFFLAGS): %s\n", 81536285Sbrian strerror(errno)); 81636285Sbrian close(s); 81740561Sbrian iface_Destroy(bundle.iface); 81840561Sbrian bundle.iface = NULL; 81936285Sbrian close(bundle.dev.fd); 82036285Sbrian return NULL; 82136285Sbrian } 82236285Sbrian 82336285Sbrian close(s); 82436285Sbrian 82540561Sbrian log_Printf(LogPHASE, "Using interface: %s\n", ifname); 82636285Sbrian 82740561Sbrian bundle.ifSpeed = 0; 82836285Sbrian 82936285Sbrian bundle.routing_seq = 0; 83036285Sbrian bundle.phase = PHASE_DEAD; 83136285Sbrian bundle.CleaningUp = 0; 83237191Sbrian bundle.AliasEnabled = 0; 83336285Sbrian 83436285Sbrian bundle.fsm.LayerStart = bundle_LayerStart; 83536285Sbrian bundle.fsm.LayerUp = bundle_LayerUp; 83636285Sbrian bundle.fsm.LayerDown = bundle_LayerDown; 83736285Sbrian bundle.fsm.LayerFinish = bundle_LayerFinish; 83836285Sbrian bundle.fsm.object = &bundle; 83936285Sbrian 84036285Sbrian bundle.cfg.idle_timeout = NCP_IDLE_TIMEOUT; 84136285Sbrian *bundle.cfg.auth.name = '\0'; 84236285Sbrian *bundle.cfg.auth.key = '\0'; 84336285Sbrian bundle.cfg.opt = OPT_SROUTES | OPT_IDCHECK | OPT_LOOPBACK | 84436285Sbrian OPT_THROUGHPUT | OPT_UTMP; 84536285Sbrian *bundle.cfg.label = '\0'; 84636285Sbrian bundle.cfg.mtu = DEF_MTU; 84736285Sbrian bundle.cfg.autoload.max.packets = 0; 84836285Sbrian bundle.cfg.autoload.max.timeout = 0; 84936285Sbrian bundle.cfg.autoload.min.packets = 0; 85036285Sbrian bundle.cfg.autoload.min.timeout = 0; 85138544Sbrian bundle.cfg.choked.timeout = CHOKED_TIMEOUT; 85236928Sbrian bundle.phys_type.all = type; 85336928Sbrian bundle.phys_type.open = 0; 85436285Sbrian 85536285Sbrian bundle.links = datalink_Create("deflink", &bundle, type); 85636285Sbrian if (bundle.links == NULL) { 85737019Sbrian log_Printf(LogALERT, "Cannot create data link: %s\n", strerror(errno)); 85840561Sbrian iface_Destroy(bundle.iface); 85940561Sbrian bundle.iface = NULL; 86036285Sbrian close(bundle.dev.fd); 86136285Sbrian return NULL; 86236285Sbrian } 86336285Sbrian 86436285Sbrian bundle.desc.type = BUNDLE_DESCRIPTOR; 86536285Sbrian bundle.desc.UpdateSet = bundle_UpdateSet; 86636285Sbrian bundle.desc.IsSet = bundle_IsSet; 86736285Sbrian bundle.desc.Read = bundle_DescriptorRead; 86836285Sbrian bundle.desc.Write = bundle_DescriptorWrite; 86936285Sbrian 87036285Sbrian mp_Init(&bundle.ncp.mp, &bundle); 87136285Sbrian 87236285Sbrian /* Send over the first physical link by default */ 87336285Sbrian ipcp_Init(&bundle.ncp.ipcp, &bundle, &bundle.links->physical->link, 87436285Sbrian &bundle.fsm); 87536285Sbrian 87636285Sbrian memset(&bundle.filter, '\0', sizeof bundle.filter); 87736285Sbrian bundle.filter.in.fragok = bundle.filter.in.logok = 1; 87836285Sbrian bundle.filter.in.name = "IN"; 87936285Sbrian bundle.filter.out.fragok = bundle.filter.out.logok = 1; 88036285Sbrian bundle.filter.out.name = "OUT"; 88136285Sbrian bundle.filter.dial.name = "DIAL"; 88236285Sbrian bundle.filter.dial.logok = 1; 88336285Sbrian bundle.filter.alive.name = "ALIVE"; 88436285Sbrian bundle.filter.alive.logok = 1; 88536285Sbrian memset(&bundle.idle.timer, '\0', sizeof bundle.idle.timer); 88636285Sbrian bundle.idle.done = 0; 88736285Sbrian bundle.notify.fd = -1; 88836285Sbrian memset(&bundle.autoload.timer, '\0', sizeof bundle.autoload.timer); 88936285Sbrian bundle.autoload.done = 0; 89036285Sbrian bundle.autoload.running = 0; 89138544Sbrian memset(&bundle.choked.timer, '\0', sizeof bundle.choked.timer); 89243313Sbrian#ifndef NORADIUS 89343313Sbrian radius_Init(&bundle.radius); 89443313Sbrian#endif 89536285Sbrian 89636285Sbrian /* Clean out any leftover crud */ 89740561Sbrian iface_Clear(bundle.iface, IFACE_CLEAR_ALL); 89836285Sbrian 89936452Sbrian bundle_LockTun(&bundle); 90036452Sbrian 90136285Sbrian return &bundle; 90236285Sbrian} 90336285Sbrian 90436285Sbrianstatic void 90536285Sbrianbundle_DownInterface(struct bundle *bundle) 90636285Sbrian{ 90736285Sbrian struct ifreq ifrq; 90836285Sbrian int s; 90936285Sbrian 91036285Sbrian route_IfDelete(bundle, 1); 91136285Sbrian 91236285Sbrian s = ID0socket(AF_INET, SOCK_DGRAM, 0); 91336285Sbrian if (s < 0) { 91436285Sbrian log_Printf(LogERROR, "bundle_DownInterface: socket: %s\n", strerror(errno)); 91536285Sbrian return; 91636285Sbrian } 91736285Sbrian 91836285Sbrian memset(&ifrq, '\0', sizeof ifrq); 91940561Sbrian strncpy(ifrq.ifr_name, bundle->iface->name, sizeof ifrq.ifr_name - 1); 92036285Sbrian ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0'; 92136285Sbrian if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) { 92236285Sbrian log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCGIFFLAGS): %s\n", 92336285Sbrian strerror(errno)); 92436285Sbrian close(s); 92536285Sbrian return; 92636285Sbrian } 92736285Sbrian ifrq.ifr_flags &= ~IFF_UP; 92836285Sbrian if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) { 92936285Sbrian log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCSIFFLAGS): %s\n", 93036285Sbrian strerror(errno)); 93136285Sbrian close(s); 93236285Sbrian return; 93336285Sbrian } 93436285Sbrian close(s); 93536285Sbrian} 93636285Sbrian 93736285Sbrianvoid 93836285Sbrianbundle_Destroy(struct bundle *bundle) 93936285Sbrian{ 94036285Sbrian struct datalink *dl; 94136285Sbrian 94236285Sbrian /* 94336285Sbrian * Clean up the interface. We don't need to timer_Stop()s, mp_Down(), 94436285Sbrian * ipcp_CleanInterface() and bundle_DownInterface() unless we're getting 94536285Sbrian * out under exceptional conditions such as a descriptor exception. 94636285Sbrian */ 94736285Sbrian timer_Stop(&bundle->idle.timer); 94838544Sbrian timer_Stop(&bundle->choked.timer); 94936285Sbrian timer_Stop(&bundle->autoload.timer); 95036285Sbrian mp_Down(&bundle->ncp.mp); 95136285Sbrian ipcp_CleanInterface(&bundle->ncp.ipcp); 95236285Sbrian bundle_DownInterface(bundle); 95336452Sbrian 95443313Sbrian#ifndef NORADIUS 95543313Sbrian /* Tell the radius server the bad news */ 95643313Sbrian radius_Destroy(&bundle->radius); 95743313Sbrian#endif 95843313Sbrian 95936285Sbrian /* Again, these are all DATALINK_CLOSED unless we're abending */ 96036285Sbrian dl = bundle->links; 96136285Sbrian while (dl) 96236285Sbrian dl = datalink_Destroy(dl); 96336285Sbrian 96436452Sbrian close(bundle->dev.fd); 96536452Sbrian bundle_UnlockTun(bundle); 96636452Sbrian 96736285Sbrian /* In case we never made PHASE_NETWORK */ 96836285Sbrian bundle_Notify(bundle, EX_ERRDEAD); 96936285Sbrian 97040561Sbrian iface_Destroy(bundle->iface); 97140561Sbrian bundle->iface = NULL; 97236285Sbrian} 97336285Sbrian 97436285Sbrianstruct rtmsg { 97536285Sbrian struct rt_msghdr m_rtm; 97636285Sbrian char m_space[64]; 97736285Sbrian}; 97836285Sbrian 97936285Sbrianint 98036285Sbrianbundle_SetRoute(struct bundle *bundle, int cmd, struct in_addr dst, 98137927Sbrian struct in_addr gateway, struct in_addr mask, int bang, int ssh) 98236285Sbrian{ 98336285Sbrian struct rtmsg rtmes; 98436285Sbrian int s, nb, wb; 98536285Sbrian char *cp; 98636285Sbrian const char *cmdstr; 98736285Sbrian struct sockaddr_in rtdata; 98836285Sbrian int result = 1; 98936285Sbrian 99036285Sbrian if (bang) 99136285Sbrian cmdstr = (cmd == RTM_ADD ? "Add!" : "Delete!"); 99236285Sbrian else 99336285Sbrian cmdstr = (cmd == RTM_ADD ? "Add" : "Delete"); 99436285Sbrian s = ID0socket(PF_ROUTE, SOCK_RAW, 0); 99536285Sbrian if (s < 0) { 99636285Sbrian log_Printf(LogERROR, "bundle_SetRoute: socket(): %s\n", strerror(errno)); 99736285Sbrian return result; 99836285Sbrian } 99936285Sbrian memset(&rtmes, '\0', sizeof rtmes); 100036285Sbrian rtmes.m_rtm.rtm_version = RTM_VERSION; 100136285Sbrian rtmes.m_rtm.rtm_type = cmd; 100236285Sbrian rtmes.m_rtm.rtm_addrs = RTA_DST; 100336285Sbrian rtmes.m_rtm.rtm_seq = ++bundle->routing_seq; 100436285Sbrian rtmes.m_rtm.rtm_pid = getpid(); 100536285Sbrian rtmes.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC; 100636285Sbrian 100740665Sbrian if (cmd == RTM_ADD || cmd == RTM_CHANGE) { 100840665Sbrian if (bundle->ncp.ipcp.cfg.sendpipe > 0) { 100940665Sbrian rtmes.m_rtm.rtm_rmx.rmx_sendpipe = bundle->ncp.ipcp.cfg.sendpipe; 101040665Sbrian rtmes.m_rtm.rtm_inits |= RTV_SPIPE; 101140665Sbrian } 101240665Sbrian if (bundle->ncp.ipcp.cfg.recvpipe > 0) { 101340665Sbrian rtmes.m_rtm.rtm_rmx.rmx_recvpipe = bundle->ncp.ipcp.cfg.recvpipe; 101440665Sbrian rtmes.m_rtm.rtm_inits |= RTV_RPIPE; 101540665Sbrian } 101640665Sbrian } 101740665Sbrian 101836285Sbrian memset(&rtdata, '\0', sizeof rtdata); 101936285Sbrian rtdata.sin_len = sizeof rtdata; 102036285Sbrian rtdata.sin_family = AF_INET; 102136285Sbrian rtdata.sin_port = 0; 102236285Sbrian rtdata.sin_addr = dst; 102336285Sbrian 102436285Sbrian cp = rtmes.m_space; 102536285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 102636285Sbrian cp += rtdata.sin_len; 102736285Sbrian if (cmd == RTM_ADD) { 102836285Sbrian if (gateway.s_addr == INADDR_ANY) { 102942321Sbrian if (!ssh) 103042321Sbrian log_Printf(LogERROR, "bundle_SetRoute: Cannot add a route with" 103142321Sbrian " destination 0.0.0.0\n"); 103240561Sbrian close(s); 103340561Sbrian return result; 103436285Sbrian } else { 103536285Sbrian rtdata.sin_addr = gateway; 103636285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 103736285Sbrian cp += rtdata.sin_len; 103836285Sbrian rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY; 103936285Sbrian } 104036285Sbrian } 104136285Sbrian 104236285Sbrian if (dst.s_addr == INADDR_ANY) 104336285Sbrian mask.s_addr = INADDR_ANY; 104436285Sbrian 104536285Sbrian if (cmd == RTM_ADD || dst.s_addr == INADDR_ANY) { 104636285Sbrian rtdata.sin_addr = mask; 104736285Sbrian memcpy(cp, &rtdata, rtdata.sin_len); 104836285Sbrian cp += rtdata.sin_len; 104936285Sbrian rtmes.m_rtm.rtm_addrs |= RTA_NETMASK; 105036285Sbrian } 105136285Sbrian 105236285Sbrian nb = cp - (char *) &rtmes; 105336285Sbrian rtmes.m_rtm.rtm_msglen = nb; 105436285Sbrian wb = ID0write(s, &rtmes, nb); 105536285Sbrian if (wb < 0) { 105636285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute failure:\n"); 105736285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Cmd = %s\n", cmdstr); 105836285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Dst = %s\n", inet_ntoa(dst)); 105936285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Gateway = %s\n", inet_ntoa(gateway)); 106036285Sbrian log_Printf(LogTCPIP, "bundle_SetRoute: Mask = %s\n", inet_ntoa(mask)); 106136285Sbrianfailed: 106236285Sbrian if (cmd == RTM_ADD && (rtmes.m_rtm.rtm_errno == EEXIST || 106336285Sbrian (rtmes.m_rtm.rtm_errno == 0 && errno == EEXIST))) { 106436285Sbrian if (!bang) { 106536285Sbrian log_Printf(LogWARN, "Add route failed: %s already exists\n", 106640665Sbrian dst.s_addr == 0 ? "default" : inet_ntoa(dst)); 106736285Sbrian result = 0; /* Don't add to our dynamic list */ 106836285Sbrian } else { 106936285Sbrian rtmes.m_rtm.rtm_type = cmd = RTM_CHANGE; 107036285Sbrian if ((wb = ID0write(s, &rtmes, nb)) < 0) 107136285Sbrian goto failed; 107236285Sbrian } 107336285Sbrian } else if (cmd == RTM_DELETE && 107436285Sbrian (rtmes.m_rtm.rtm_errno == ESRCH || 107536285Sbrian (rtmes.m_rtm.rtm_errno == 0 && errno == ESRCH))) { 107636285Sbrian if (!bang) 107736285Sbrian log_Printf(LogWARN, "Del route failed: %s: Non-existent\n", 107836285Sbrian inet_ntoa(dst)); 107937927Sbrian } else if (rtmes.m_rtm.rtm_errno == 0) { 108037927Sbrian if (!ssh || errno != ENETUNREACH) 108137927Sbrian log_Printf(LogWARN, "%s route failed: %s: errno: %s\n", cmdstr, 108237927Sbrian inet_ntoa(dst), strerror(errno)); 108337927Sbrian } else 108436285Sbrian log_Printf(LogWARN, "%s route failed: %s: %s\n", 108537927Sbrian cmdstr, inet_ntoa(dst), strerror(rtmes.m_rtm.rtm_errno)); 108636285Sbrian } 108736285Sbrian log_Printf(LogDEBUG, "wrote %d: cmd = %s, dst = %x, gateway = %x\n", 108836285Sbrian wb, cmdstr, (unsigned)dst.s_addr, (unsigned)gateway.s_addr); 108936285Sbrian close(s); 109036285Sbrian 109136285Sbrian return result; 109236285Sbrian} 109336285Sbrian 109436285Sbrianvoid 109536285Sbrianbundle_LinkClosed(struct bundle *bundle, struct datalink *dl) 109636285Sbrian{ 109736285Sbrian /* 109836285Sbrian * Our datalink has closed. 109936285Sbrian * CleanDatalinks() (called from DoLoop()) will remove closed 110036465Sbrian * BACKGROUND and DIRECT links. 110136285Sbrian * If it's the last data link, enter phase DEAD. 110236285Sbrian * 110336285Sbrian * NOTE: dl may not be in our list (bundle_SendDatalink()) ! 110436285Sbrian */ 110536285Sbrian 110636285Sbrian struct datalink *odl; 110736285Sbrian int other_links; 110836285Sbrian 110938200Sbrian log_SetTtyCommandMode(dl); 111038200Sbrian 111136285Sbrian other_links = 0; 111236285Sbrian for (odl = bundle->links; odl; odl = odl->next) 111336285Sbrian if (odl != dl && odl->state != DATALINK_CLOSED) 111436285Sbrian other_links++; 111536285Sbrian 111636285Sbrian if (!other_links) { 111736465Sbrian if (dl->physical->type != PHYS_AUTO) /* Not in -auto mode */ 111836285Sbrian bundle_DownInterface(bundle); 111937060Sbrian fsm2initial(&bundle->ncp.ipcp.fsm); 112036285Sbrian bundle_NewPhase(bundle, PHASE_DEAD); 112136314Sbrian bundle_StopIdleTimer(bundle); 112236285Sbrian bundle_StopAutoLoadTimer(bundle); 112336285Sbrian bundle->autoload.running = 0; 112436285Sbrian } else 112536285Sbrian bundle->autoload.running = 1; 112636285Sbrian} 112736285Sbrian 112836285Sbrianvoid 112937955Sbrianbundle_Open(struct bundle *bundle, const char *name, int mask, int force) 113036285Sbrian{ 113136285Sbrian /* 113236285Sbrian * Please open the given datalink, or all if name == NULL 113336285Sbrian */ 113436285Sbrian struct datalink *dl; 113536285Sbrian 113636285Sbrian timer_Stop(&bundle->autoload.timer); 113736285Sbrian for (dl = bundle->links; dl; dl = dl->next) 113836285Sbrian if (name == NULL || !strcasecmp(dl->name, name)) { 113937955Sbrian if ((mask & dl->physical->type) && 114037955Sbrian (dl->state == DATALINK_CLOSED || 114137955Sbrian (force && dl->state == DATALINK_OPENING && 114244468Sbrian dl->dial.timer.state == TIMER_RUNNING))) { 114344468Sbrian if (force) /* Ignore redial timeout ? */ 114444468Sbrian timer_Stop(&dl->dial.timer); 114536285Sbrian datalink_Up(dl, 1, 1); 114636465Sbrian if (mask == PHYS_AUTO) 114736465Sbrian /* Only one AUTO link at a time (see the AutoLoad timer) */ 114836285Sbrian break; 114936285Sbrian } 115036285Sbrian if (name != NULL) 115136285Sbrian break; 115236285Sbrian } 115336285Sbrian} 115436285Sbrian 115536285Sbrianstruct datalink * 115636285Sbrianbundle2datalink(struct bundle *bundle, const char *name) 115736285Sbrian{ 115836285Sbrian struct datalink *dl; 115936285Sbrian 116036285Sbrian if (name != NULL) { 116136285Sbrian for (dl = bundle->links; dl; dl = dl->next) 116236285Sbrian if (!strcasecmp(dl->name, name)) 116336285Sbrian return dl; 116436285Sbrian } else if (bundle->links && !bundle->links->next) 116536285Sbrian return bundle->links; 116636285Sbrian 116736285Sbrian return NULL; 116836285Sbrian} 116936285Sbrian 117036285Sbrianint 117136285Sbrianbundle_FillQueues(struct bundle *bundle) 117236285Sbrian{ 117336285Sbrian int total; 117436285Sbrian 117536285Sbrian if (bundle->ncp.mp.active) 117636285Sbrian total = mp_FillQueues(bundle); 117736285Sbrian else { 117836285Sbrian struct datalink *dl; 117936285Sbrian int add; 118036285Sbrian 118136285Sbrian for (total = 0, dl = bundle->links; dl; dl = dl->next) 118236285Sbrian if (dl->state == DATALINK_OPEN) { 118336285Sbrian add = link_QueueLen(&dl->physical->link); 118436285Sbrian if (add == 0 && dl->physical->out == NULL) 118536285Sbrian add = ip_FlushPacket(&dl->physical->link, bundle); 118636285Sbrian total += add; 118736285Sbrian } 118836285Sbrian } 118936285Sbrian 119038557Sbrian return total + ip_QueueLen(&bundle->ncp.ipcp); 119136285Sbrian} 119236285Sbrian 119336285Sbrianint 119436285Sbrianbundle_ShowLinks(struct cmdargs const *arg) 119536285Sbrian{ 119636285Sbrian struct datalink *dl; 119736285Sbrian 119836285Sbrian for (dl = arg->bundle->links; dl; dl = dl->next) { 119936316Sbrian prompt_Printf(arg->prompt, "Name: %s [%s, %s]", 120036316Sbrian dl->name, mode2Nam(dl->physical->type), datalink_State(dl)); 120136285Sbrian if (dl->physical->link.throughput.rolling && dl->state == DATALINK_OPEN) 120236316Sbrian prompt_Printf(arg->prompt, " weight %d, %d bytes/sec", 120336285Sbrian dl->mp.weight, 120436285Sbrian dl->physical->link.throughput.OctetsPerSecond); 120536285Sbrian prompt_Printf(arg->prompt, "\n"); 120636285Sbrian } 120736285Sbrian 120836285Sbrian return 0; 120936285Sbrian} 121036285Sbrian 121136285Sbrianstatic const char * 121236285Sbrianoptval(struct bundle *bundle, int bit) 121336285Sbrian{ 121436285Sbrian return (bundle->cfg.opt & bit) ? "enabled" : "disabled"; 121536285Sbrian} 121636285Sbrian 121736285Sbrianint 121836285Sbrianbundle_ShowStatus(struct cmdargs const *arg) 121936285Sbrian{ 122036285Sbrian int remaining; 122136285Sbrian 122236285Sbrian prompt_Printf(arg->prompt, "Phase %s\n", bundle_PhaseName(arg->bundle)); 122340679Sbrian prompt_Printf(arg->prompt, " Title: %s\n", arg->bundle->argv[0]); 122436285Sbrian prompt_Printf(arg->prompt, " Device: %s\n", arg->bundle->dev.Name); 122536285Sbrian prompt_Printf(arg->prompt, " Interface: %s @ %lubps\n", 122640561Sbrian arg->bundle->iface->name, arg->bundle->ifSpeed); 122736285Sbrian 122836285Sbrian prompt_Printf(arg->prompt, "\nDefaults:\n"); 122936285Sbrian prompt_Printf(arg->prompt, " Label: %s\n", arg->bundle->cfg.label); 123036285Sbrian prompt_Printf(arg->prompt, " Auth name: %s\n", 123136285Sbrian arg->bundle->cfg.auth.name); 123236285Sbrian prompt_Printf(arg->prompt, " Auto Load: Up after %ds of >= %d packets\n", 123336285Sbrian arg->bundle->cfg.autoload.max.timeout, 123436285Sbrian arg->bundle->cfg.autoload.max.packets); 123536285Sbrian prompt_Printf(arg->prompt, " Down after %ds of <= %d" 123636285Sbrian " packets\n", arg->bundle->cfg.autoload.min.timeout, 123736285Sbrian arg->bundle->cfg.autoload.min.packets); 123836285Sbrian if (arg->bundle->autoload.timer.state == TIMER_RUNNING) 123936285Sbrian prompt_Printf(arg->prompt, " %ds remaining 'till " 124036285Sbrian "a link comes %s\n", 124136285Sbrian bundle_RemainingAutoLoadTime(arg->bundle), 124236285Sbrian arg->bundle->autoload.comingup ? "up" : "down"); 124336285Sbrian else 124436285Sbrian prompt_Printf(arg->prompt, " %srunning with %d" 124536285Sbrian " packets queued\n", arg->bundle->autoload.running ? 124638557Sbrian "" : "not ", ip_QueueLen(&arg->bundle->ncp.ipcp)); 124736285Sbrian 124838544Sbrian prompt_Printf(arg->prompt, " Choked Timer: %ds\n", 124938544Sbrian arg->bundle->cfg.choked.timeout); 125043313Sbrian 125143313Sbrian#ifndef NORADIUS 125243313Sbrian radius_Show(&arg->bundle->radius, arg->prompt); 125343313Sbrian#endif 125443313Sbrian 125536285Sbrian prompt_Printf(arg->prompt, " Idle Timer: "); 125636285Sbrian if (arg->bundle->cfg.idle_timeout) { 125736285Sbrian prompt_Printf(arg->prompt, "%ds", arg->bundle->cfg.idle_timeout); 125836285Sbrian remaining = bundle_RemainingIdleTime(arg->bundle); 125936285Sbrian if (remaining != -1) 126036285Sbrian prompt_Printf(arg->prompt, " (%ds remaining)", remaining); 126136285Sbrian prompt_Printf(arg->prompt, "\n"); 126236285Sbrian } else 126336285Sbrian prompt_Printf(arg->prompt, "disabled\n"); 126436285Sbrian prompt_Printf(arg->prompt, " MTU: "); 126536285Sbrian if (arg->bundle->cfg.mtu) 126636285Sbrian prompt_Printf(arg->prompt, "%d\n", arg->bundle->cfg.mtu); 126736285Sbrian else 126836285Sbrian prompt_Printf(arg->prompt, "unspecified\n"); 126936285Sbrian 127040665Sbrian prompt_Printf(arg->prompt, " sendpipe: "); 127140665Sbrian if (arg->bundle->ncp.ipcp.cfg.sendpipe > 0) 127240665Sbrian prompt_Printf(arg->prompt, "%ld\n", arg->bundle->ncp.ipcp.cfg.sendpipe); 127340665Sbrian else 127440665Sbrian prompt_Printf(arg->prompt, "unspecified\n"); 127540665Sbrian prompt_Printf(arg->prompt, " recvpipe: "); 127640665Sbrian if (arg->bundle->ncp.ipcp.cfg.recvpipe > 0) 127740665Sbrian prompt_Printf(arg->prompt, "%ld\n", arg->bundle->ncp.ipcp.cfg.recvpipe); 127840665Sbrian else 127940665Sbrian prompt_Printf(arg->prompt, "unspecified\n"); 128040665Sbrian 128136285Sbrian prompt_Printf(arg->prompt, " Sticky Routes: %s\n", 128236285Sbrian optval(arg->bundle, OPT_SROUTES)); 128336285Sbrian prompt_Printf(arg->prompt, " ID check: %s\n", 128436285Sbrian optval(arg->bundle, OPT_IDCHECK)); 128536285Sbrian prompt_Printf(arg->prompt, " Loopback: %s\n", 128636285Sbrian optval(arg->bundle, OPT_LOOPBACK)); 128736285Sbrian prompt_Printf(arg->prompt, " PasswdAuth: %s\n", 128836285Sbrian optval(arg->bundle, OPT_PASSWDAUTH)); 128936285Sbrian prompt_Printf(arg->prompt, " Proxy: %s\n", 129036285Sbrian optval(arg->bundle, OPT_PROXY)); 129140665Sbrian prompt_Printf(arg->prompt, " Proxyall: %s\n", 129240665Sbrian optval(arg->bundle, OPT_PROXYALL)); 129336285Sbrian prompt_Printf(arg->prompt, " Throughput: %s\n", 129436285Sbrian optval(arg->bundle, OPT_THROUGHPUT)); 129536285Sbrian prompt_Printf(arg->prompt, " Utmp Logging: %s\n", 129636285Sbrian optval(arg->bundle, OPT_UTMP)); 129740561Sbrian prompt_Printf(arg->prompt, " Iface-Alias: %s\n", 129840561Sbrian optval(arg->bundle, OPT_IFACEALIAS)); 129936285Sbrian 130036285Sbrian return 0; 130136285Sbrian} 130236285Sbrian 130336285Sbrianstatic void 130436285Sbrianbundle_IdleTimeout(void *v) 130536285Sbrian{ 130636285Sbrian struct bundle *bundle = (struct bundle *)v; 130736285Sbrian 130836285Sbrian log_Printf(LogPHASE, "Idle timer expired.\n"); 130936285Sbrian bundle_StopIdleTimer(bundle); 131037007Sbrian bundle_Close(bundle, NULL, CLOSE_STAYDOWN); 131136285Sbrian} 131236285Sbrian 131336285Sbrian/* 131436285Sbrian * Start Idle timer. If timeout is reached, we call bundle_Close() to 131536285Sbrian * close LCP and link. 131636285Sbrian */ 131736285Sbrianvoid 131836285Sbrianbundle_StartIdleTimer(struct bundle *bundle) 131936285Sbrian{ 132036285Sbrian timer_Stop(&bundle->idle.timer); 132136928Sbrian if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) != 132236928Sbrian bundle->phys_type.open && bundle->cfg.idle_timeout) { 132336285Sbrian bundle->idle.timer.func = bundle_IdleTimeout; 132436285Sbrian bundle->idle.timer.name = "idle"; 132536285Sbrian bundle->idle.timer.load = bundle->cfg.idle_timeout * SECTICKS; 132636285Sbrian bundle->idle.timer.arg = bundle; 132736285Sbrian timer_Start(&bundle->idle.timer); 132836285Sbrian bundle->idle.done = time(NULL) + bundle->cfg.idle_timeout; 132936285Sbrian } 133036285Sbrian} 133136285Sbrian 133236285Sbrianvoid 133336285Sbrianbundle_SetIdleTimer(struct bundle *bundle, int value) 133436285Sbrian{ 133536285Sbrian bundle->cfg.idle_timeout = value; 133636285Sbrian if (bundle_LinkIsUp(bundle)) 133736285Sbrian bundle_StartIdleTimer(bundle); 133836285Sbrian} 133936285Sbrian 134036285Sbrianvoid 134136285Sbrianbundle_StopIdleTimer(struct bundle *bundle) 134236285Sbrian{ 134336285Sbrian timer_Stop(&bundle->idle.timer); 134436285Sbrian bundle->idle.done = 0; 134536285Sbrian} 134636285Sbrian 134736285Sbrianstatic int 134836285Sbrianbundle_RemainingIdleTime(struct bundle *bundle) 134936285Sbrian{ 135036285Sbrian if (bundle->idle.done) 135136285Sbrian return bundle->idle.done - time(NULL); 135236285Sbrian return -1; 135336285Sbrian} 135436285Sbrian 135536285Sbrianint 135636285Sbrianbundle_IsDead(struct bundle *bundle) 135736285Sbrian{ 135836285Sbrian return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp); 135936285Sbrian} 136036285Sbrian 136136285Sbrianstatic struct datalink * 136236285Sbrianbundle_DatalinkLinkout(struct bundle *bundle, struct datalink *dl) 136336285Sbrian{ 136436285Sbrian struct datalink **dlp; 136536285Sbrian 136636314Sbrian for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next) 136736314Sbrian if (*dlp == dl) { 136836314Sbrian *dlp = dl->next; 136936314Sbrian dl->next = NULL; 137036314Sbrian bundle_LinksRemoved(bundle); 137136314Sbrian return dl; 137236314Sbrian } 137336285Sbrian 137436285Sbrian return NULL; 137536285Sbrian} 137636285Sbrian 137736285Sbrianstatic void 137836285Sbrianbundle_DatalinkLinkin(struct bundle *bundle, struct datalink *dl) 137936285Sbrian{ 138036285Sbrian struct datalink **dlp = &bundle->links; 138136285Sbrian 138236285Sbrian while (*dlp) 138336285Sbrian dlp = &(*dlp)->next; 138436285Sbrian 138536285Sbrian *dlp = dl; 138636285Sbrian dl->next = NULL; 138736285Sbrian 138836285Sbrian bundle_LinkAdded(bundle, dl); 138936285Sbrian} 139036285Sbrian 139136285Sbrianvoid 139236285Sbrianbundle_CleanDatalinks(struct bundle *bundle) 139336285Sbrian{ 139436285Sbrian struct datalink **dlp = &bundle->links; 139536285Sbrian int found = 0; 139636285Sbrian 139736285Sbrian while (*dlp) 139836285Sbrian if ((*dlp)->state == DATALINK_CLOSED && 139936465Sbrian (*dlp)->physical->type & (PHYS_DIRECT|PHYS_BACKGROUND)) { 140036285Sbrian *dlp = datalink_Destroy(*dlp); 140136285Sbrian found++; 140236285Sbrian } else 140336285Sbrian dlp = &(*dlp)->next; 140436285Sbrian 140536285Sbrian if (found) 140636285Sbrian bundle_LinksRemoved(bundle); 140736285Sbrian} 140836285Sbrian 140936285Sbrianint 141036285Sbrianbundle_DatalinkClone(struct bundle *bundle, struct datalink *dl, 141136285Sbrian const char *name) 141236285Sbrian{ 141336285Sbrian if (bundle2datalink(bundle, name)) { 141436285Sbrian log_Printf(LogWARN, "Clone: %s: name already exists\n", name); 141536285Sbrian return 0; 141636285Sbrian } 141736285Sbrian 141836285Sbrian bundle_DatalinkLinkin(bundle, datalink_Clone(dl, name)); 141936285Sbrian return 1; 142036285Sbrian} 142136285Sbrian 142236285Sbrianvoid 142336285Sbrianbundle_DatalinkRemove(struct bundle *bundle, struct datalink *dl) 142436285Sbrian{ 142536285Sbrian dl = bundle_DatalinkLinkout(bundle, dl); 142636285Sbrian if (dl) 142736285Sbrian datalink_Destroy(dl); 142836285Sbrian} 142936285Sbrian 143036285Sbrianvoid 143136285Sbrianbundle_SetLabel(struct bundle *bundle, const char *label) 143236285Sbrian{ 143336285Sbrian if (label) 143436285Sbrian strncpy(bundle->cfg.label, label, sizeof bundle->cfg.label - 1); 143536285Sbrian else 143636285Sbrian *bundle->cfg.label = '\0'; 143736285Sbrian} 143836285Sbrian 143936285Sbrianconst char * 144036285Sbrianbundle_GetLabel(struct bundle *bundle) 144136285Sbrian{ 144236285Sbrian return *bundle->cfg.label ? bundle->cfg.label : NULL; 144336285Sbrian} 144436285Sbrian 144536285Sbrianvoid 144636285Sbrianbundle_ReceiveDatalink(struct bundle *bundle, int s, struct sockaddr_un *sun) 144736285Sbrian{ 144836285Sbrian char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)]; 144936285Sbrian struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 145036285Sbrian struct msghdr msg; 145136285Sbrian struct iovec iov[SCATTER_SEGMENTS]; 145236285Sbrian struct datalink *dl; 145336285Sbrian int niov, link_fd, expect, f; 145436450Sbrian pid_t pid; 145536285Sbrian 145636285Sbrian log_Printf(LogPHASE, "Receiving datalink\n"); 145736285Sbrian 145836285Sbrian /* Create our scatter/gather array */ 145936285Sbrian niov = 1; 146036285Sbrian iov[0].iov_len = strlen(Version) + 1; 146136285Sbrian iov[0].iov_base = (char *)malloc(iov[0].iov_len); 146236450Sbrian if (datalink2iov(NULL, iov, &niov, sizeof iov / sizeof *iov, 0) == -1) { 146336345Sbrian close(s); 146436285Sbrian return; 146536345Sbrian } 146636285Sbrian 146736450Sbrian pid = getpid(); 146836450Sbrian write(s, &pid, sizeof pid); 146936450Sbrian 147036285Sbrian for (f = expect = 0; f < niov; f++) 147136285Sbrian expect += iov[f].iov_len; 147236285Sbrian 147336285Sbrian /* Set up our message */ 147436285Sbrian cmsg->cmsg_len = sizeof cmsgbuf; 147536285Sbrian cmsg->cmsg_level = SOL_SOCKET; 147636345Sbrian cmsg->cmsg_type = 0; 147736285Sbrian 147836285Sbrian memset(&msg, '\0', sizeof msg); 147936285Sbrian msg.msg_name = (caddr_t)sun; 148036285Sbrian msg.msg_namelen = sizeof *sun; 148136285Sbrian msg.msg_iov = iov; 148236285Sbrian msg.msg_iovlen = niov; 148336285Sbrian msg.msg_control = cmsgbuf; 148436285Sbrian msg.msg_controllen = sizeof cmsgbuf; 148536285Sbrian 148636285Sbrian log_Printf(LogDEBUG, "Expecting %d scatter/gather bytes\n", expect); 148736285Sbrian f = expect + 100; 148836285Sbrian setsockopt(s, SOL_SOCKET, SO_RCVBUF, &f, sizeof f); 148936285Sbrian if ((f = recvmsg(s, &msg, MSG_WAITALL)) != expect) { 149036285Sbrian if (f == -1) 149136285Sbrian log_Printf(LogERROR, "Failed recvmsg: %s\n", strerror(errno)); 149236285Sbrian else 149336285Sbrian log_Printf(LogERROR, "Failed recvmsg: Got %d, not %d\n", f, expect); 149436285Sbrian while (niov--) 149536285Sbrian free(iov[niov].iov_base); 149636345Sbrian close(s); 149736285Sbrian return; 149836285Sbrian } 149936285Sbrian 150036345Sbrian write(s, "!", 1); /* ACK */ 150137054Sbrian close(s); 150236285Sbrian 150337054Sbrian if (cmsg->cmsg_type != SCM_RIGHTS) { 150437054Sbrian log_Printf(LogERROR, "Recvmsg: no descriptor received !\n"); 150537054Sbrian while (niov--) 150637054Sbrian free(iov[niov].iov_base); 150737054Sbrian return; 150836345Sbrian } 150936285Sbrian 151037054Sbrian /* We've successfully received an open file descriptor through our socket */ 151137054Sbrian log_Printf(LogDEBUG, "Receiving device descriptor\n"); 151237054Sbrian link_fd = *(int *)CMSG_DATA(cmsg); 151337054Sbrian 151436285Sbrian if (strncmp(Version, iov[0].iov_base, iov[0].iov_len)) { 151536285Sbrian log_Printf(LogWARN, "Cannot receive datalink, incorrect version" 151636285Sbrian " (\"%.*s\", not \"%s\")\n", (int)iov[0].iov_len, 151737188Sbrian (char *)iov[0].iov_base, Version); 151836285Sbrian close(link_fd); 151936285Sbrian while (niov--) 152036285Sbrian free(iov[niov].iov_base); 152136285Sbrian return; 152236285Sbrian } 152336285Sbrian 152436285Sbrian niov = 1; 152536285Sbrian dl = iov2datalink(bundle, iov, &niov, sizeof iov / sizeof *iov, link_fd); 152636285Sbrian if (dl) { 152736285Sbrian bundle_DatalinkLinkin(bundle, dl); 152836285Sbrian datalink_AuthOk(dl); 152936285Sbrian } else 153036285Sbrian close(link_fd); 153136285Sbrian 153236285Sbrian free(iov[0].iov_base); 153336285Sbrian} 153436285Sbrian 153536285Sbrianvoid 153636285Sbrianbundle_SendDatalink(struct datalink *dl, int s, struct sockaddr_un *sun) 153736285Sbrian{ 153836285Sbrian char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)], ack; 153936285Sbrian struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 154036285Sbrian struct msghdr msg; 154136285Sbrian struct iovec iov[SCATTER_SEGMENTS]; 154236452Sbrian int niov, link_fd, f, expect, newsid; 154336450Sbrian pid_t newpid; 154436285Sbrian 154536285Sbrian log_Printf(LogPHASE, "Transmitting datalink %s\n", dl->name); 154636285Sbrian 154736314Sbrian bundle_LinkClosed(dl->bundle, dl); 154836285Sbrian bundle_DatalinkLinkout(dl->bundle, dl); 154936285Sbrian 155036285Sbrian /* Build our scatter/gather array */ 155136285Sbrian iov[0].iov_len = strlen(Version) + 1; 155236285Sbrian iov[0].iov_base = strdup(Version); 155336285Sbrian niov = 1; 155436285Sbrian 155536450Sbrian read(s, &newpid, sizeof newpid); 155636450Sbrian link_fd = datalink2iov(dl, iov, &niov, sizeof iov / sizeof *iov, newpid); 155736285Sbrian 155836285Sbrian if (link_fd != -1) { 155936345Sbrian memset(&msg, '\0', sizeof msg); 156036285Sbrian 156136285Sbrian msg.msg_name = (caddr_t)sun; 156236285Sbrian msg.msg_namelen = sizeof *sun; 156336285Sbrian msg.msg_iov = iov; 156436285Sbrian msg.msg_iovlen = niov; 156536285Sbrian 156636452Sbrian cmsg->cmsg_len = sizeof cmsgbuf; 156736452Sbrian cmsg->cmsg_level = SOL_SOCKET; 156836452Sbrian cmsg->cmsg_type = SCM_RIGHTS; 156936452Sbrian *(int *)CMSG_DATA(cmsg) = link_fd; 157036452Sbrian msg.msg_control = cmsgbuf; 157136452Sbrian msg.msg_controllen = sizeof cmsgbuf; 157236345Sbrian 157336285Sbrian for (f = expect = 0; f < niov; f++) 157436285Sbrian expect += iov[f].iov_len; 157536285Sbrian 157636285Sbrian log_Printf(LogDEBUG, "Sending %d bytes in scatter/gather array\n", expect); 157736285Sbrian 157836285Sbrian f = expect + SOCKET_OVERHEAD; 157936285Sbrian setsockopt(s, SOL_SOCKET, SO_SNDBUF, &f, sizeof f); 158036285Sbrian if (sendmsg(s, &msg, 0) == -1) 158136285Sbrian log_Printf(LogERROR, "Failed sendmsg: %s\n", strerror(errno)); 158236285Sbrian /* We must get the ACK before closing the descriptor ! */ 158336285Sbrian read(s, &ack, 1); 158436345Sbrian 158536452Sbrian newsid = tcgetpgrp(link_fd) == getpgrp(); 158636285Sbrian close(link_fd); 158736452Sbrian if (newsid) 158836452Sbrian bundle_setsid(dl->bundle, 1); 158936285Sbrian } 159036450Sbrian close(s); 159136285Sbrian 159236285Sbrian while (niov--) 159336285Sbrian free(iov[niov].iov_base); 159436285Sbrian} 159536285Sbrian 159636285Sbrianint 159736285Sbrianbundle_RenameDatalink(struct bundle *bundle, struct datalink *ndl, 159836285Sbrian const char *name) 159936285Sbrian{ 160036285Sbrian struct datalink *dl; 160136285Sbrian 160236285Sbrian if (!strcasecmp(ndl->name, name)) 160336285Sbrian return 1; 160436285Sbrian 160536285Sbrian for (dl = bundle->links; dl; dl = dl->next) 160636285Sbrian if (!strcasecmp(dl->name, name)) 160736285Sbrian return 0; 160836285Sbrian 160936285Sbrian datalink_Rename(ndl, name); 161036285Sbrian return 1; 161136285Sbrian} 161236285Sbrian 161336285Sbrianint 161436285Sbrianbundle_SetMode(struct bundle *bundle, struct datalink *dl, int mode) 161536285Sbrian{ 161636285Sbrian int omode; 161736285Sbrian 161836285Sbrian omode = dl->physical->type; 161936285Sbrian if (omode == mode) 162036285Sbrian return 1; 162136285Sbrian 162236928Sbrian if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO)) 162336928Sbrian /* First auto link */ 162436285Sbrian if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) { 162536928Sbrian log_Printf(LogWARN, "You must `set ifaddr' or `open' before" 162636928Sbrian " changing mode to %s\n", mode2Nam(mode)); 162736285Sbrian return 0; 162836285Sbrian } 162936285Sbrian 163036285Sbrian if (!datalink_SetMode(dl, mode)) 163136285Sbrian return 0; 163236285Sbrian 163336928Sbrian if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) && 163436928Sbrian bundle->phase != PHASE_NETWORK) 163536928Sbrian /* First auto link, we need an interface */ 163636285Sbrian ipcp_InterfaceUp(&bundle->ncp.ipcp); 163736285Sbrian 163836285Sbrian /* Regenerate phys_type and adjust autoload & idle timers */ 163936285Sbrian bundle_LinksRemoved(bundle); 164036285Sbrian 164136285Sbrian return 1; 164236285Sbrian} 164336452Sbrian 164436452Sbrianvoid 164536452Sbrianbundle_setsid(struct bundle *bundle, int holdsession) 164636452Sbrian{ 164736452Sbrian /* 164836452Sbrian * Lose the current session. This means getting rid of our pid 164936452Sbrian * too so that the tty device will really go away, and any getty 165036452Sbrian * etc will be allowed to restart. 165136452Sbrian */ 165236452Sbrian pid_t pid, orig; 165336452Sbrian int fds[2]; 165436452Sbrian char done; 165536452Sbrian struct datalink *dl; 165636452Sbrian 165736452Sbrian orig = getpid(); 165836452Sbrian if (pipe(fds) == -1) { 165936452Sbrian log_Printf(LogERROR, "pipe: %s\n", strerror(errno)); 166036452Sbrian return; 166136452Sbrian } 166236452Sbrian switch ((pid = fork())) { 166336452Sbrian case -1: 166436452Sbrian log_Printf(LogERROR, "fork: %s\n", strerror(errno)); 166536452Sbrian close(fds[0]); 166636452Sbrian close(fds[1]); 166736452Sbrian return; 166836452Sbrian case 0: 166944541Sbrian close(fds[1]); 167044541Sbrian read(fds[0], &done, 1); /* uu_locks are mine ! */ 167136452Sbrian close(fds[0]); 167236452Sbrian if (pipe(fds) == -1) { 167336452Sbrian log_Printf(LogERROR, "pipe(2): %s\n", strerror(errno)); 167436452Sbrian return; 167536452Sbrian } 167636452Sbrian switch ((pid = fork())) { 167736452Sbrian case -1: 167837019Sbrian log_Printf(LogERROR, "fork(2): %s\n", strerror(errno)); 167936452Sbrian close(fds[0]); 168036452Sbrian close(fds[1]); 168136452Sbrian return; 168236452Sbrian case 0: 168344541Sbrian close(fds[1]); 168444541Sbrian bundle_LockTun(bundle); /* update pid */ 168544541Sbrian read(fds[0], &done, 1); /* uu_locks are mine ! */ 168636452Sbrian close(fds[0]); 168736452Sbrian setsid(); 168836452Sbrian log_Printf(LogPHASE, "%d -> %d: %s session control\n", 168936452Sbrian (int)orig, (int)getpid(), 169036452Sbrian holdsession ? "Passed" : "Dropped"); 169141799Sbrian timer_InitService(0); /* Start the Timer Service */ 169236452Sbrian break; 169336452Sbrian default: 169444541Sbrian close(fds[0]); 169536452Sbrian /* Give away all our modem locks (to the final process) */ 169636452Sbrian for (dl = bundle->links; dl; dl = dl->next) 169736452Sbrian if (dl->state != DATALINK_CLOSED) 169836452Sbrian modem_ChangedPid(dl->physical, pid); 169944541Sbrian write(fds[1], "!", 1); /* done */ 170044541Sbrian close(fds[1]); 170136452Sbrian exit(0); 170236452Sbrian break; 170336452Sbrian } 170436452Sbrian break; 170536452Sbrian default: 170644541Sbrian close(fds[0]); 170736452Sbrian /* Give away all our modem locks (to the intermediate process) */ 170836452Sbrian for (dl = bundle->links; dl; dl = dl->next) 170936452Sbrian if (dl->state != DATALINK_CLOSED) 171036452Sbrian modem_ChangedPid(dl->physical, pid); 171144541Sbrian write(fds[1], "!", 1); /* done */ 171244541Sbrian close(fds[1]); 171336452Sbrian if (holdsession) { 171436452Sbrian int fd, status; 171536452Sbrian 171636452Sbrian timer_TermService(); 171736452Sbrian signal(SIGPIPE, SIG_DFL); 171836452Sbrian signal(SIGALRM, SIG_DFL); 171936452Sbrian signal(SIGHUP, SIG_DFL); 172036452Sbrian signal(SIGTERM, SIG_DFL); 172136452Sbrian signal(SIGINT, SIG_DFL); 172236452Sbrian signal(SIGQUIT, SIG_DFL); 172336452Sbrian for (fd = getdtablesize(); fd >= 0; fd--) 172436452Sbrian close(fd); 172536452Sbrian setuid(geteuid()); 172636452Sbrian /* 172736452Sbrian * Reap the intermediate process. As we're not exiting but the 172836452Sbrian * intermediate is, we don't want it to become defunct. 172936452Sbrian */ 173036452Sbrian waitpid(pid, &status, 0); 173136467Sbrian /* Tweak our process arguments.... */ 173236467Sbrian bundle->argv[0] = "session owner"; 173336467Sbrian bundle->argv[1] = NULL; 173436452Sbrian /* 173536452Sbrian * Hang around for a HUP. This should happen as soon as the 173636452Sbrian * ppp that we passed our ctty descriptor to closes it. 173736452Sbrian * NOTE: If this process dies, the passed descriptor becomes 173836452Sbrian * invalid and will give a select() error by setting one 173936452Sbrian * of the error fds, aborting the other ppp. We don't 174036452Sbrian * want that to happen ! 174136452Sbrian */ 174236452Sbrian pause(); 174336452Sbrian } 174436452Sbrian exit(0); 174536452Sbrian break; 174636452Sbrian } 174736452Sbrian} 174840622Sbrian 174940622Sbrianint 175040622Sbrianbundle_HighestState(struct bundle *bundle) 175140622Sbrian{ 175240622Sbrian struct datalink *dl; 175340622Sbrian int result = DATALINK_CLOSED; 175440622Sbrian 175540622Sbrian for (dl = bundle->links; dl; dl = dl->next) 175640622Sbrian if (result < dl->state) 175740622Sbrian result = dl->state; 175840622Sbrian 175940622Sbrian return result; 176040622Sbrian} 176141654Sbrian 176241654Sbrianint 176341654Sbrianbundle_Exception(struct bundle *bundle, int fd) 176441654Sbrian{ 176541654Sbrian struct datalink *dl; 176641654Sbrian 176741654Sbrian for (dl = bundle->links; dl; dl = dl->next) 176841654Sbrian if (dl->physical->fd == fd) { 176941654Sbrian datalink_Down(dl, CLOSE_NORMAL); 177041654Sbrian return 1; 177141654Sbrian } 177241654Sbrian 177341654Sbrian return 0; 177441654Sbrian} 1775