17a6f8720SBrian Somers /*- 27a6f8720SBrian Somers * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org> 37a6f8720SBrian Somers * All rights reserved. 47a6f8720SBrian Somers * 57a6f8720SBrian Somers * Redistribution and use in source and binary forms, with or without 67a6f8720SBrian Somers * modification, are permitted provided that the following conditions 77a6f8720SBrian Somers * are met: 87a6f8720SBrian Somers * 1. Redistributions of source code must retain the above copyright 97a6f8720SBrian Somers * notice, this list of conditions and the following disclaimer. 107a6f8720SBrian Somers * 2. Redistributions in binary form must reproduce the above copyright 117a6f8720SBrian Somers * notice, this list of conditions and the following disclaimer in the 127a6f8720SBrian Somers * documentation and/or other materials provided with the distribution. 137a6f8720SBrian Somers * 147a6f8720SBrian Somers * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 157a6f8720SBrian Somers * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 167a6f8720SBrian Somers * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 177a6f8720SBrian Somers * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 187a6f8720SBrian Somers * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 197a6f8720SBrian Somers * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 207a6f8720SBrian Somers * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 217a6f8720SBrian Somers * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 227a6f8720SBrian Somers * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 237a6f8720SBrian Somers * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 247a6f8720SBrian Somers * SUCH DAMAGE. 257a6f8720SBrian Somers * 266ca65df0SBrian Somers * $Id: bundle.c,v 1.56 1999/06/02 00:46:50 brian Exp $ 277a6f8720SBrian Somers */ 287a6f8720SBrian Somers 291384bd27SBrian Somers #include <sys/param.h> 307a6f8720SBrian Somers #include <sys/socket.h> 317a6f8720SBrian Somers #include <netinet/in.h> 327a6f8720SBrian Somers #include <net/if.h> 330f203c7eSBrian Somers #include <net/if_tun.h> 347a6f8720SBrian Somers #include <arpa/inet.h> 357a6f8720SBrian Somers #include <net/route.h> 36eaa4df37SBrian Somers #include <netinet/in_systm.h> 37eaa4df37SBrian Somers #include <netinet/ip.h> 381fa665f5SBrian Somers #include <sys/un.h> 397a6f8720SBrian Somers 407a6f8720SBrian Somers #include <errno.h> 417a6f8720SBrian Somers #include <fcntl.h> 4247723d29SBrian Somers #include <paths.h> 437a6f8720SBrian Somers #include <stdio.h> 446f384573SBrian Somers #include <stdlib.h> 457a6f8720SBrian Somers #include <string.h> 467a6f8720SBrian Somers #include <sys/ioctl.h> 4796c9bb21SBrian Somers #include <sys/uio.h> 4854cd8e13SBrian Somers #include <sys/wait.h> 497a6f8720SBrian Somers #include <termios.h> 507a6f8720SBrian Somers #include <unistd.h> 517a6f8720SBrian Somers 525d9e6103SBrian Somers #include "layer.h" 53c9e11a11SBrian Somers #include "defs.h" 547a6f8720SBrian Somers #include "command.h" 557a6f8720SBrian Somers #include "mbuf.h" 567a6f8720SBrian Somers #include "log.h" 577a6f8720SBrian Somers #include "id.h" 587a6f8720SBrian Somers #include "timer.h" 597a6f8720SBrian Somers #include "fsm.h" 607a6f8720SBrian Somers #include "iplist.h" 61879ed6faSBrian Somers #include "lqr.h" 62455aabc3SBrian Somers #include "hdlc.h" 637a6f8720SBrian Somers #include "throughput.h" 64eaa4df37SBrian Somers #include "slcompress.h" 657a6f8720SBrian Somers #include "ipcp.h" 665ca5389aSBrian Somers #include "filter.h" 672f786681SBrian Somers #include "descriptor.h" 687a6f8720SBrian Somers #include "route.h" 697a6f8720SBrian Somers #include "lcp.h" 707a6f8720SBrian Somers #include "ccp.h" 713b0f8d2eSBrian Somers #include "link.h" 723b0f8d2eSBrian Somers #include "mp.h" 73972a1bcfSBrian Somers #ifndef NORADIUS 74972a1bcfSBrian Somers #include "radius.h" 75972a1bcfSBrian Somers #endif 763b0f8d2eSBrian Somers #include "bundle.h" 77455aabc3SBrian Somers #include "async.h" 78455aabc3SBrian Somers #include "physical.h" 79455aabc3SBrian Somers #include "auth.h" 805d9e6103SBrian Somers #include "proto.h" 81455aabc3SBrian Somers #include "chap.h" 82455aabc3SBrian Somers #include "tun.h" 8385b542cfSBrian Somers #include "prompt.h" 843006ec67SBrian Somers #include "chat.h" 8592b09558SBrian Somers #include "cbcp.h" 863006ec67SBrian Somers #include "datalink.h" 873006ec67SBrian Somers #include "ip.h" 888fa6ebe4SBrian Somers #include "iface.h" 897a6f8720SBrian Somers 906815097bSBrian Somers #define SCATTER_SEGMENTS 5 /* version, datalink, name, physical, device */ 9196c9bb21SBrian Somers #define SOCKET_OVERHEAD 100 /* additional buffer space for large */ 9296c9bb21SBrian Somers /* {recv,send}msg() calls */ 9396c9bb21SBrian Somers 9404eaa58cSBrian Somers static int bundle_RemainingIdleTime(struct bundle *); 9504eaa58cSBrian Somers static int bundle_RemainingAutoLoadTime(struct bundle *); 9604eaa58cSBrian Somers 97455aabc3SBrian Somers static const char *PhaseNames[] = { 98455aabc3SBrian Somers "Dead", "Establish", "Authenticate", "Network", "Terminate" 99455aabc3SBrian Somers }; 100455aabc3SBrian Somers 101455aabc3SBrian Somers const char * 102455aabc3SBrian Somers bundle_PhaseName(struct bundle *bundle) 1037a6f8720SBrian Somers { 104455aabc3SBrian Somers return bundle->phase <= PHASE_TERMINATE ? 105455aabc3SBrian Somers PhaseNames[bundle->phase] : "unknown"; 1067a6f8720SBrian Somers } 1077a6f8720SBrian Somers 108455aabc3SBrian Somers void 1095563ebdeSBrian Somers bundle_NewPhase(struct bundle *bundle, u_int new) 110455aabc3SBrian Somers { 111aef795ccSBrian Somers if (new == bundle->phase) 112aef795ccSBrian Somers return; 113aef795ccSBrian Somers 114e2ebb036SBrian Somers if (new <= PHASE_TERMINATE) 115dd7e2610SBrian Somers log_Printf(LogPHASE, "bundle: %s\n", PhaseNames[new]); 1167a6f8720SBrian Somers 117455aabc3SBrian Somers switch (new) { 118455aabc3SBrian Somers case PHASE_DEAD: 1190f2f3eb3SBrian Somers log_DisplayPrompts(); 120455aabc3SBrian Somers bundle->phase = new; 121455aabc3SBrian Somers break; 122455aabc3SBrian Somers 123455aabc3SBrian Somers case PHASE_ESTABLISH: 124455aabc3SBrian Somers bundle->phase = new; 125455aabc3SBrian Somers break; 126455aabc3SBrian Somers 127455aabc3SBrian Somers case PHASE_AUTHENTICATE: 128455aabc3SBrian Somers bundle->phase = new; 1290f2f3eb3SBrian Somers log_DisplayPrompts(); 130455aabc3SBrian Somers break; 131455aabc3SBrian Somers 132455aabc3SBrian Somers case PHASE_NETWORK: 133dd7e2610SBrian Somers fsm_Up(&bundle->ncp.ipcp.fsm); 134dd7e2610SBrian Somers fsm_Open(&bundle->ncp.ipcp.fsm); 135673903ecSBrian Somers bundle->phase = new; 1360f2f3eb3SBrian Somers log_DisplayPrompts(); 137673903ecSBrian Somers break; 138455aabc3SBrian Somers 139455aabc3SBrian Somers case PHASE_TERMINATE: 140455aabc3SBrian Somers bundle->phase = new; 141673903ecSBrian Somers mp_Down(&bundle->ncp.mp); 1420f2f3eb3SBrian Somers log_DisplayPrompts(); 143455aabc3SBrian Somers break; 1447a6f8720SBrian Somers } 1457a6f8720SBrian Somers } 1467a6f8720SBrian Somers 1476d666775SBrian Somers static void 1486d666775SBrian Somers bundle_LayerStart(void *v, struct fsm *fp) 1497a6f8720SBrian Somers { 1503006ec67SBrian Somers /* The given FSM is about to start up ! */ 1517a6f8720SBrian Somers } 1527a6f8720SBrian Somers 1535cf4388bSBrian Somers 1545cf4388bSBrian Somers static void 1555cf4388bSBrian Somers bundle_Notify(struct bundle *bundle, char c) 1565cf4388bSBrian Somers { 1575cf4388bSBrian Somers if (bundle->notify.fd != -1) { 1585cf4388bSBrian Somers if (write(bundle->notify.fd, &c, 1) == 1) 159dd7e2610SBrian Somers log_Printf(LogPHASE, "Parent notified of success.\n"); 1605cf4388bSBrian Somers else 161dd7e2610SBrian Somers log_Printf(LogPHASE, "Failed to notify parent of success.\n"); 1625cf4388bSBrian Somers close(bundle->notify.fd); 1635cf4388bSBrian Somers bundle->notify.fd = -1; 1645cf4388bSBrian Somers } 1655cf4388bSBrian Somers } 1663b0f8d2eSBrian Somers 1676d666775SBrian Somers static void 1686f8e9f0aSBrian Somers bundle_ClearQueues(void *v) 1696f8e9f0aSBrian Somers { 1706f8e9f0aSBrian Somers struct bundle *bundle = (struct bundle *)v; 1716f8e9f0aSBrian Somers struct datalink *dl; 1726f8e9f0aSBrian Somers 1736f8e9f0aSBrian Somers log_Printf(LogPHASE, "Clearing choked output queue\n"); 1746f8e9f0aSBrian Somers timer_Stop(&bundle->choked.timer); 1756f8e9f0aSBrian Somers 1766f8e9f0aSBrian Somers /* 1776f8e9f0aSBrian Somers * Emergency time: 1786f8e9f0aSBrian Somers * 1796f8e9f0aSBrian Somers * We've had a full queue for PACKET_DEL_SECS seconds without being 1806f8e9f0aSBrian Somers * able to get rid of any of the packets. We've probably given up 1816f8e9f0aSBrian Somers * on the redials at this point, and the queued data has almost 1826f8e9f0aSBrian Somers * definitely been timed out by the layer above. As this is preventing 1836f8e9f0aSBrian Somers * us from reading the TUN_NAME device (we don't want to buffer stuff 1846f8e9f0aSBrian Somers * indefinitely), we may as well nuke this data and start with a clean 1856f8e9f0aSBrian Somers * slate ! 1866f8e9f0aSBrian Somers * 1876f8e9f0aSBrian Somers * Unfortunately, this has the side effect of shafting any compression 1886f8e9f0aSBrian Somers * dictionaries in use (causing the relevant RESET_REQ/RESET_ACK). 1896f8e9f0aSBrian Somers */ 1906f8e9f0aSBrian Somers 1915a72b6edSBrian Somers ip_DeleteQueue(&bundle->ncp.ipcp); 1926f8e9f0aSBrian Somers mp_DeleteQueue(&bundle->ncp.mp); 1936f8e9f0aSBrian Somers for (dl = bundle->links; dl; dl = dl->next) 1946f8e9f0aSBrian Somers physical_DeleteQueue(dl->physical); 1956f8e9f0aSBrian Somers } 1966f8e9f0aSBrian Somers 1976f8e9f0aSBrian Somers static void 19804eaa58cSBrian Somers bundle_AutoLoadTimeout(void *v) 19904eaa58cSBrian Somers { 20004eaa58cSBrian Somers struct bundle *bundle = (struct bundle *)v; 20104eaa58cSBrian Somers 20204eaa58cSBrian Somers if (bundle->autoload.comingup) { 20304eaa58cSBrian Somers log_Printf(LogPHASE, "autoload: Another link is required\n"); 20404eaa58cSBrian Somers /* bundle_Open() stops the timer */ 205ba23f397SBrian Somers bundle_Open(bundle, NULL, PHYS_AUTO, 0); 20604eaa58cSBrian Somers } else { 20704eaa58cSBrian Somers struct datalink *dl, *last; 20804eaa58cSBrian Somers 20904eaa58cSBrian Somers timer_Stop(&bundle->autoload.timer); 21004eaa58cSBrian Somers for (last = NULL, dl = bundle->links; dl; dl = dl->next) 21181358fa3SBrian Somers if (dl->physical->type == PHYS_AUTO && dl->state == DATALINK_OPEN) 21204eaa58cSBrian Somers last = dl; 21304eaa58cSBrian Somers 21404eaa58cSBrian Somers if (last) 2159c81b87dSBrian Somers datalink_Close(last, CLOSE_STAYDOWN); 21604eaa58cSBrian Somers } 21704eaa58cSBrian Somers } 21804eaa58cSBrian Somers 21904eaa58cSBrian Somers static void 22004eaa58cSBrian Somers bundle_StartAutoLoadTimer(struct bundle *bundle, int up) 22104eaa58cSBrian Somers { 22204eaa58cSBrian Somers struct datalink *dl; 22304eaa58cSBrian Somers 22404eaa58cSBrian Somers timer_Stop(&bundle->autoload.timer); 225ec5e7f36SBrian Somers bundle->autoload.comingup = up ? 1 : 0; 22604eaa58cSBrian Somers 22704eaa58cSBrian Somers if (bundle->CleaningUp || bundle->phase != PHASE_NETWORK) { 22804eaa58cSBrian Somers dl = NULL; 22904eaa58cSBrian Somers bundle->autoload.running = 0; 23004eaa58cSBrian Somers } else if (up) { 23104eaa58cSBrian Somers for (dl = bundle->links; dl; dl = dl->next) 23281358fa3SBrian Somers if (dl->state == DATALINK_CLOSED && dl->physical->type == PHYS_AUTO) { 23304eaa58cSBrian Somers if (bundle->cfg.autoload.max.timeout) { 23404eaa58cSBrian Somers bundle->autoload.timer.func = bundle_AutoLoadTimeout; 23504eaa58cSBrian Somers bundle->autoload.timer.name = "autoload up"; 23604eaa58cSBrian Somers bundle->autoload.timer.load = 23704eaa58cSBrian Somers bundle->cfg.autoload.max.timeout * SECTICKS; 23804eaa58cSBrian Somers bundle->autoload.timer.arg = bundle; 23904eaa58cSBrian Somers timer_Start(&bundle->autoload.timer); 24004eaa58cSBrian Somers bundle->autoload.done = time(NULL) + bundle->cfg.autoload.max.timeout; 24104eaa58cSBrian Somers } else 24204eaa58cSBrian Somers bundle_AutoLoadTimeout(bundle); 24304eaa58cSBrian Somers break; 24404eaa58cSBrian Somers } 24504eaa58cSBrian Somers bundle->autoload.running = (dl || bundle->cfg.autoload.min.timeout) ? 1 : 0; 24604eaa58cSBrian Somers } else { 24704eaa58cSBrian Somers int nlinks; 24804eaa58cSBrian Somers struct datalink *adl; 24904eaa58cSBrian Somers 25004eaa58cSBrian Somers for (nlinks = 0, adl = NULL, dl = bundle->links; dl; dl = dl->next) 25104eaa58cSBrian Somers if (dl->state == DATALINK_OPEN) { 25281358fa3SBrian Somers if (dl->physical->type == PHYS_AUTO) 25304eaa58cSBrian Somers adl = dl; 25404eaa58cSBrian Somers if (++nlinks > 1 && adl) { 25504eaa58cSBrian Somers if (bundle->cfg.autoload.min.timeout) { 25604eaa58cSBrian Somers bundle->autoload.timer.func = bundle_AutoLoadTimeout; 25704eaa58cSBrian Somers bundle->autoload.timer.name = "autoload down"; 25804eaa58cSBrian Somers bundle->autoload.timer.load = 25904eaa58cSBrian Somers bundle->cfg.autoload.min.timeout * SECTICKS; 26004eaa58cSBrian Somers bundle->autoload.timer.arg = bundle; 26104eaa58cSBrian Somers timer_Start(&bundle->autoload.timer); 26204eaa58cSBrian Somers bundle->autoload.done = 26304eaa58cSBrian Somers time(NULL) + bundle->cfg.autoload.min.timeout; 26404eaa58cSBrian Somers } 26504eaa58cSBrian Somers break; 26604eaa58cSBrian Somers } 26704eaa58cSBrian Somers } 26804eaa58cSBrian Somers 26904eaa58cSBrian Somers bundle->autoload.running = 1; 27004eaa58cSBrian Somers } 27104eaa58cSBrian Somers } 27204eaa58cSBrian Somers 27304eaa58cSBrian Somers static void 27404eaa58cSBrian Somers bundle_StopAutoLoadTimer(struct bundle *bundle) 27504eaa58cSBrian Somers { 27604eaa58cSBrian Somers timer_Stop(&bundle->autoload.timer); 27704eaa58cSBrian Somers bundle->autoload.done = 0; 27804eaa58cSBrian Somers } 27904eaa58cSBrian Somers 28004eaa58cSBrian Somers static int 28104eaa58cSBrian Somers bundle_RemainingAutoLoadTime(struct bundle *bundle) 28204eaa58cSBrian Somers { 28304eaa58cSBrian Somers if (bundle->autoload.done) 28404eaa58cSBrian Somers return bundle->autoload.done - time(NULL); 28504eaa58cSBrian Somers return -1; 28604eaa58cSBrian Somers } 28704eaa58cSBrian Somers 288ff0f9439SBrian Somers static void 289ff0f9439SBrian Somers bundle_LinkAdded(struct bundle *bundle, struct datalink *dl) 290ff0f9439SBrian Somers { 291ff0f9439SBrian Somers bundle->phys_type.all |= dl->physical->type; 292ff0f9439SBrian Somers if (dl->state == DATALINK_OPEN) 293ff0f9439SBrian Somers bundle->phys_type.open |= dl->physical->type; 294ff0f9439SBrian Somers 295ff0f9439SBrian Somers /* Note: We only re-add links that are DATALINK_OPEN */ 296ff0f9439SBrian Somers if (dl->physical->type == PHYS_AUTO && 297ff0f9439SBrian Somers bundle->autoload.timer.state == TIMER_STOPPED && 298ff0f9439SBrian Somers dl->state != DATALINK_OPEN && 299ff0f9439SBrian Somers bundle->phase == PHASE_NETWORK) 300ff0f9439SBrian Somers bundle->autoload.running = 1; 301ff0f9439SBrian Somers 302ff0f9439SBrian Somers if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 303ff0f9439SBrian Somers != bundle->phys_type.open && bundle->idle.timer.state == TIMER_STOPPED) 304ff0f9439SBrian Somers /* We may need to start our idle timer */ 305ff0f9439SBrian Somers bundle_StartIdleTimer(bundle); 306ff0f9439SBrian Somers } 307ff0f9439SBrian Somers 30892b09558SBrian Somers void 309ff0f9439SBrian Somers bundle_LinksRemoved(struct bundle *bundle) 310ff0f9439SBrian Somers { 311ff0f9439SBrian Somers struct datalink *dl; 312ff0f9439SBrian Somers 313ff0f9439SBrian Somers bundle->phys_type.all = bundle->phys_type.open = 0; 314ff0f9439SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 315ff0f9439SBrian Somers bundle_LinkAdded(bundle, dl); 316ff0f9439SBrian Somers 317ff0f9439SBrian Somers if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) 318ff0f9439SBrian Somers == bundle->phys_type.open) 319ff0f9439SBrian Somers bundle_StopIdleTimer(bundle); 320ff0f9439SBrian Somers } 32104eaa58cSBrian Somers 32204eaa58cSBrian Somers static void 3236f384573SBrian Somers bundle_LayerUp(void *v, struct fsm *fp) 3247a6f8720SBrian Somers { 3253006ec67SBrian Somers /* 3263006ec67SBrian Somers * The given fsm is now up 327ff0f9439SBrian Somers * If it's an LCP, adjust our phys_mode.open value. 32849052c95SBrian Somers * If it's an LCP set our mtu (if we're multilink, add up the link 32904eaa58cSBrian Somers * speeds and set the MRRU) and start our autoload timer. 330565e35e5SBrian Somers * If it's an NCP, tell our -background parent to go away. 3313b0f8d2eSBrian Somers * If it's the first NCP, start the idle timer. 3323006ec67SBrian Somers */ 3336f384573SBrian Somers struct bundle *bundle = (struct bundle *)v; 3346d666775SBrian Somers 3355563ebdeSBrian Somers if (fp->proto == PROTO_LCP) { 336ff0f9439SBrian Somers struct physical *p = link2physical(fp->link); 337ff0f9439SBrian Somers 338ff0f9439SBrian Somers bundle_LinkAdded(bundle, p->dl); 3393b0f8d2eSBrian Somers if (bundle->ncp.mp.active) { 3403b0f8d2eSBrian Somers struct datalink *dl; 3415563ebdeSBrian Somers 3428fa6ebe4SBrian Somers bundle->ifSpeed = 0; 343faefde08SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 344eeab6bf5SBrian Somers if (dl->state == DATALINK_OPEN) 3455d9e6103SBrian Somers bundle->ifSpeed += physical_GetSpeed(dl->physical); 346faefde08SBrian Somers tun_configure(bundle, bundle->ncp.mp.peer_mrru); 34704eaa58cSBrian Somers bundle->autoload.running = 1; 348faefde08SBrian Somers } else { 3495d9e6103SBrian Somers bundle->ifSpeed = physical_GetSpeed(p); 350faefde08SBrian Somers tun_configure(bundle, fsm2lcp(fp)->his_mru); 351faefde08SBrian Somers } 3523b0f8d2eSBrian Somers } else if (fp->proto == PROTO_IPCP) { 353ab886ad0SBrian Somers bundle_StartIdleTimer(bundle); 3545cf4388bSBrian Somers bundle_Notify(bundle, EX_NORMAL); 3557a6f8720SBrian Somers } 356ab886ad0SBrian Somers } 3577a6f8720SBrian Somers 3586d666775SBrian Somers static void 3596d666775SBrian Somers bundle_LayerDown(void *v, struct fsm *fp) 3606d666775SBrian Somers { 3616d666775SBrian Somers /* 3626d666775SBrian Somers * The given FSM has been told to come down. 363ab886ad0SBrian Somers * If it's our last NCP, stop the idle timer. 364ff0f9439SBrian Somers * If it's an LCP, adjust our phys_type.open value and any timers. 36586b1f0d7SBrian Somers * If it's an LCP and we're in multilink mode, adjust our tun 36686b1f0d7SBrian Somers * speed and make sure our minimum sequence number is adjusted. 3676d666775SBrian Somers */ 368ab886ad0SBrian Somers 369ab886ad0SBrian Somers struct bundle *bundle = (struct bundle *)v; 370ab886ad0SBrian Somers 371078c562eSBrian Somers if (fp->proto == PROTO_IPCP) 372ab886ad0SBrian Somers bundle_StopIdleTimer(bundle); 373ff0f9439SBrian Somers else if (fp->proto == PROTO_LCP) { 374ff0f9439SBrian Somers bundle_LinksRemoved(bundle); /* adjust timers & phys_type values */ 375ff0f9439SBrian Somers if (bundle->ncp.mp.active) { 3763b0f8d2eSBrian Somers struct datalink *dl; 37786b1f0d7SBrian Somers struct datalink *lost; 3783b0f8d2eSBrian Somers 3798fa6ebe4SBrian Somers bundle->ifSpeed = 0; 38086b1f0d7SBrian Somers lost = NULL; 381faefde08SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 38286b1f0d7SBrian Somers if (fp == &dl->physical->link.lcp.fsm) 38386b1f0d7SBrian Somers lost = dl; 38486b1f0d7SBrian Somers else if (dl->state == DATALINK_OPEN) 3855d9e6103SBrian Somers bundle->ifSpeed += physical_GetSpeed(dl->physical); 38686b1f0d7SBrian Somers 3878fa6ebe4SBrian Somers if (bundle->ifSpeed) 388faefde08SBrian Somers /* Don't configure down to a speed of 0 */ 389faefde08SBrian Somers tun_configure(bundle, bundle->ncp.mp.link.lcp.his_mru); 39086b1f0d7SBrian Somers 39186b1f0d7SBrian Somers if (lost) 39286b1f0d7SBrian Somers mp_LinkLost(&bundle->ncp.mp, lost); 39386b1f0d7SBrian Somers else 394a33b2ef7SBrian Somers log_Printf(LogALERT, "Oops, lost an unrecognised datalink (%s) !\n", 39586b1f0d7SBrian Somers fp->link->name); 3963b0f8d2eSBrian Somers } 3976d666775SBrian Somers } 398ff0f9439SBrian Somers } 3996d666775SBrian Somers 4006d666775SBrian Somers static void 4016d666775SBrian Somers bundle_LayerFinish(void *v, struct fsm *fp) 4026d666775SBrian Somers { 4036d666775SBrian Somers /* The given fsm is now down (fp cannot be NULL) 4046d666775SBrian Somers * 405dd7e2610SBrian Somers * If it's the last LCP, fsm_Down all NCPs 406dd7e2610SBrian Somers * If it's the last NCP, fsm_Close all LCPs 4076d666775SBrian Somers */ 4086d666775SBrian Somers 4096d666775SBrian Somers struct bundle *bundle = (struct bundle *)v; 4106d666775SBrian Somers struct datalink *dl; 4116d666775SBrian Somers 4123b0f8d2eSBrian Somers if (fp->proto == PROTO_IPCP) { 41326afeaa2SBrian Somers if (bundle_Phase(bundle) != PHASE_DEAD) 41425092092SBrian Somers bundle_NewPhase(bundle, PHASE_TERMINATE); 4156d666775SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 4169c81b87dSBrian Somers datalink_Close(dl, CLOSE_NORMAL); 41709206a6fSBrian Somers fsm2initial(fp); 4183b0f8d2eSBrian Somers } else if (fp->proto == PROTO_LCP) { 4193b0f8d2eSBrian Somers int others_active; 420a611cad6SBrian Somers 4213b0f8d2eSBrian Somers others_active = 0; 4223b0f8d2eSBrian Somers for (dl = bundle->links; dl; dl = dl->next) 4233b0f8d2eSBrian Somers if (fp != &dl->physical->link.lcp.fsm && 4243b0f8d2eSBrian Somers dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 4253b0f8d2eSBrian Somers others_active++; 4263b0f8d2eSBrian Somers 42709206a6fSBrian Somers if (!others_active) 42809206a6fSBrian Somers fsm2initial(&bundle->ncp.ipcp.fsm); 4293b0f8d2eSBrian Somers } 4303b0f8d2eSBrian Somers } 4316d666775SBrian Somers 4327a6f8720SBrian Somers int 4337a6f8720SBrian Somers bundle_LinkIsUp(const struct bundle *bundle) 4347a6f8720SBrian Somers { 4355828db6dSBrian Somers return bundle->ncp.ipcp.fsm.state == ST_OPENED; 4367a6f8720SBrian Somers } 4377a6f8720SBrian Somers 4387a6f8720SBrian Somers void 4399c81b87dSBrian Somers bundle_Close(struct bundle *bundle, const char *name, int how) 4407a6f8720SBrian Somers { 441455aabc3SBrian Somers /* 4423006ec67SBrian Somers * Please close the given datalink. 443dd7e2610SBrian Somers * If name == NULL or name is the last datalink, fsm_Close all NCPs 4446f384573SBrian Somers * (except our MP) 4453b0f8d2eSBrian Somers * If it isn't the last datalink, just Close that datalink. 446455aabc3SBrian Somers */ 4477a6f8720SBrian Somers 4483b0f8d2eSBrian Somers struct datalink *dl, *this_dl; 4493b0f8d2eSBrian Somers int others_active; 4503006ec67SBrian Somers 4513b0f8d2eSBrian Somers others_active = 0; 4523b0f8d2eSBrian Somers this_dl = NULL; 4533b0f8d2eSBrian Somers 4543b0f8d2eSBrian Somers for (dl = bundle->links; dl; dl = dl->next) { 4553b0f8d2eSBrian Somers if (name && !strcasecmp(name, dl->name)) 4563b0f8d2eSBrian Somers this_dl = dl; 4573b0f8d2eSBrian Somers if (name == NULL || this_dl == dl) { 4589c81b87dSBrian Somers switch (how) { 4599c81b87dSBrian Somers case CLOSE_LCP: 4609c81b87dSBrian Somers datalink_DontHangup(dl); 4619c81b87dSBrian Somers /* fall through */ 4629c81b87dSBrian Somers case CLOSE_STAYDOWN: 4633006ec67SBrian Somers datalink_StayDown(dl); 4649c81b87dSBrian Somers break; 4659c81b87dSBrian Somers } 4663b0f8d2eSBrian Somers } else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP) 4673b0f8d2eSBrian Somers others_active++; 4683b0f8d2eSBrian Somers } 4693b0f8d2eSBrian Somers 4703b0f8d2eSBrian Somers if (name && this_dl == NULL) { 471dd7e2610SBrian Somers log_Printf(LogWARN, "%s: Invalid datalink name\n", name); 4723b0f8d2eSBrian Somers return; 4733b0f8d2eSBrian Somers } 4743b0f8d2eSBrian Somers 4753b0f8d2eSBrian Somers if (!others_active) { 47604eaa58cSBrian Somers bundle_StopIdleTimer(bundle); 47704eaa58cSBrian Somers bundle_StopAutoLoadTimer(bundle); 4783b0f8d2eSBrian Somers if (bundle->ncp.ipcp.fsm.state > ST_CLOSED || 4793b0f8d2eSBrian Somers bundle->ncp.ipcp.fsm.state == ST_STARTING) 480dd7e2610SBrian Somers fsm_Close(&bundle->ncp.ipcp.fsm); 4813b0f8d2eSBrian Somers else { 48209206a6fSBrian Somers fsm2initial(&bundle->ncp.ipcp.fsm); 483d345321bSBrian Somers for (dl = bundle->links; dl; dl = dl->next) 4849c81b87dSBrian Somers datalink_Close(dl, how); 4857a6f8720SBrian Somers } 4863b0f8d2eSBrian Somers } else if (this_dl && this_dl->state != DATALINK_CLOSED && 4873b0f8d2eSBrian Somers this_dl->state != DATALINK_HANGUP) 4889c81b87dSBrian Somers datalink_Close(this_dl, how); 489d2fd8d77SBrian Somers } 4907a6f8720SBrian Somers 4911bc9b5baSBrian Somers void 492899011c4SBrian Somers bundle_Down(struct bundle *bundle, int how) 4931bc9b5baSBrian Somers { 4941bc9b5baSBrian Somers struct datalink *dl; 4951bc9b5baSBrian Somers 4961bc9b5baSBrian Somers for (dl = bundle->links; dl; dl = dl->next) 497899011c4SBrian Somers datalink_Down(dl, how); 4981bc9b5baSBrian Somers } 4991bc9b5baSBrian Somers 5002f786681SBrian Somers static int 5012f786681SBrian Somers bundle_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) 5022f786681SBrian Somers { 5032f786681SBrian Somers struct bundle *bundle = descriptor2bundle(d); 5042f786681SBrian Somers struct datalink *dl; 50504eaa58cSBrian Somers int result, want, queued, nlinks; 5062f786681SBrian Somers 5072f786681SBrian Somers result = 0; 5082f786681SBrian Somers 509078c562eSBrian Somers /* If there are aren't many packets queued, look for some more. */ 51004eaa58cSBrian Somers for (nlinks = 0, dl = bundle->links; dl; dl = dl->next) 51104eaa58cSBrian Somers nlinks++; 51204eaa58cSBrian Somers 51304eaa58cSBrian Somers if (nlinks) { 5145a72b6edSBrian Somers queued = r ? bundle_FillQueues(bundle) : ip_QueueLen(&bundle->ncp.ipcp); 51504eaa58cSBrian Somers if (bundle->autoload.running) { 51604eaa58cSBrian Somers if (queued < bundle->cfg.autoload.max.packets) { 51704eaa58cSBrian Somers if (queued > bundle->cfg.autoload.min.packets) 51804eaa58cSBrian Somers bundle_StopAutoLoadTimer(bundle); 51904eaa58cSBrian Somers else if (bundle->autoload.timer.state != TIMER_RUNNING || 52004eaa58cSBrian Somers bundle->autoload.comingup) 52104eaa58cSBrian Somers bundle_StartAutoLoadTimer(bundle, 0); 522ec5e7f36SBrian Somers } else if ((bundle_Phase(bundle) == PHASE_NETWORK || queued) && 523ec5e7f36SBrian Somers (bundle->autoload.timer.state != TIMER_RUNNING || 524f4007327SBrian Somers !bundle->autoload.comingup)) 52504eaa58cSBrian Somers bundle_StartAutoLoadTimer(bundle, 1); 52604eaa58cSBrian Somers } 52704eaa58cSBrian Somers 528ff0f9439SBrian Somers if (r && (bundle->phase == PHASE_NETWORK || 529ff0f9439SBrian Somers bundle->phys_type.all & PHYS_AUTO)) { 53004eaa58cSBrian Somers /* enough surplus so that we can tell if we're getting swamped */ 53104eaa58cSBrian Somers want = bundle->cfg.autoload.max.packets + nlinks * 2; 53204eaa58cSBrian Somers /* but at least 20 packets ! */ 53304eaa58cSBrian Somers if (want < 20) 53404eaa58cSBrian Somers want = 20; 53504eaa58cSBrian Somers if (queued < want) { 53604eaa58cSBrian Somers /* Not enough - select() for more */ 5376f8e9f0aSBrian Somers if (bundle->choked.timer.state == TIMER_RUNNING) 5386f8e9f0aSBrian Somers timer_Stop(&bundle->choked.timer); /* Not needed any more */ 53904eaa58cSBrian Somers FD_SET(bundle->dev.fd, r); 540faefde08SBrian Somers if (*n < bundle->dev.fd + 1) 541faefde08SBrian Somers *n = bundle->dev.fd + 1; 5421384bd27SBrian Somers log_Printf(LogTIMER, "%s: fdset(r) %d\n", TUN_NAME, bundle->dev.fd); 543078c562eSBrian Somers result++; 5446f8e9f0aSBrian Somers } else if (bundle->choked.timer.state == TIMER_STOPPED) { 5456f8e9f0aSBrian Somers bundle->choked.timer.func = bundle_ClearQueues; 5466f8e9f0aSBrian Somers bundle->choked.timer.name = "output choke"; 5476f8e9f0aSBrian Somers bundle->choked.timer.load = bundle->cfg.choked.timeout * SECTICKS; 5486f8e9f0aSBrian Somers bundle->choked.timer.arg = bundle; 5496f8e9f0aSBrian Somers timer_Start(&bundle->choked.timer); 550078c562eSBrian Somers } 55104eaa58cSBrian Somers } 55204eaa58cSBrian Somers } 553078c562eSBrian Somers 554f0cdd9c0SBrian Somers #ifndef NORADIUS 555f0cdd9c0SBrian Somers result += descriptor_UpdateSet(&bundle->radius.desc, r, w, e, n); 556f0cdd9c0SBrian Somers #endif 557f0cdd9c0SBrian Somers 55871555108SBrian Somers /* Which links need a select() ? */ 55971555108SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 56071555108SBrian Somers result += descriptor_UpdateSet(&dl->desc, r, w, e, n); 56171555108SBrian Somers 562ea722969SBrian Somers /* 563ea722969SBrian Somers * This *MUST* be called after the datalink UpdateSet()s as it 56404eaa58cSBrian Somers * might be ``holding'' one of the datalinks (death-row) and 56504eaa58cSBrian Somers * wants to be able to de-select() it from the descriptor set. 566ea722969SBrian Somers */ 5670f2f3eb3SBrian Somers result += descriptor_UpdateSet(&bundle->ncp.mp.server.desc, r, w, e, n); 568ea722969SBrian Somers 5692f786681SBrian Somers return result; 5702f786681SBrian Somers } 5712f786681SBrian Somers 5722f786681SBrian Somers static int 5732f786681SBrian Somers bundle_IsSet(struct descriptor *d, const fd_set *fdset) 5742f786681SBrian Somers { 5752f786681SBrian Somers struct bundle *bundle = descriptor2bundle(d); 5762f786681SBrian Somers struct datalink *dl; 5772f786681SBrian Somers 5782f786681SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 5792f786681SBrian Somers if (descriptor_IsSet(&dl->desc, fdset)) 5802f786681SBrian Somers return 1; 5812f786681SBrian Somers 582f0cdd9c0SBrian Somers #ifndef NORADIUS 583f0cdd9c0SBrian Somers if (descriptor_IsSet(&bundle->radius.desc, fdset)) 584f0cdd9c0SBrian Somers return 1; 585f0cdd9c0SBrian Somers #endif 586f0cdd9c0SBrian Somers 587332b9de0SBrian Somers if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 588332b9de0SBrian Somers return 1; 589332b9de0SBrian Somers 590faefde08SBrian Somers return FD_ISSET(bundle->dev.fd, fdset); 5912f786681SBrian Somers } 5922f786681SBrian Somers 5932f786681SBrian Somers static void 5942f786681SBrian Somers bundle_DescriptorRead(struct descriptor *d, struct bundle *bundle, 5952f786681SBrian Somers const fd_set *fdset) 5962f786681SBrian Somers { 5972f786681SBrian Somers struct datalink *dl; 5982f786681SBrian Somers 599ea722969SBrian Somers if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 600ea722969SBrian Somers descriptor_Read(&bundle->ncp.mp.server.desc, bundle, fdset); 601ea722969SBrian Somers 6022f786681SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 6032f786681SBrian Somers if (descriptor_IsSet(&dl->desc, fdset)) 6042f786681SBrian Somers descriptor_Read(&dl->desc, bundle, fdset); 605b6217683SBrian Somers 606f0cdd9c0SBrian Somers #ifndef NORADIUS 607f0cdd9c0SBrian Somers if (descriptor_IsSet(&bundle->radius.desc, fdset)) 608f0cdd9c0SBrian Somers descriptor_Read(&bundle->radius.desc, bundle, fdset); 609f0cdd9c0SBrian Somers #endif 610f0cdd9c0SBrian Somers 611faefde08SBrian Somers if (FD_ISSET(bundle->dev.fd, fdset)) { 612078c562eSBrian Somers struct tun_data tun; 613078c562eSBrian Somers int n, pri; 614078c562eSBrian Somers 615078c562eSBrian Somers /* something to read from tun */ 616faefde08SBrian Somers n = read(bundle->dev.fd, &tun, sizeof tun); 617078c562eSBrian Somers if (n < 0) { 618a33b2ef7SBrian Somers log_Printf(LogWARN, "read from %s: %s\n", TUN_NAME, strerror(errno)); 619078c562eSBrian Somers return; 620078c562eSBrian Somers } 621078c562eSBrian Somers n -= sizeof tun - sizeof tun.data; 622078c562eSBrian Somers if (n <= 0) { 623a33b2ef7SBrian Somers log_Printf(LogERROR, "read from %s: Only %d bytes read ?\n", TUN_NAME, n); 624078c562eSBrian Somers return; 625078c562eSBrian Somers } 626078c562eSBrian Somers if (!tun_check_header(tun, AF_INET)) 627078c562eSBrian Somers return; 628078c562eSBrian Somers 629078c562eSBrian Somers if (((struct ip *)tun.data)->ip_dst.s_addr == 630078c562eSBrian Somers bundle->ncp.ipcp.my_ip.s_addr) { 631078c562eSBrian Somers /* we've been asked to send something addressed *to* us :( */ 632078c562eSBrian Somers if (Enabled(bundle, OPT_LOOPBACK)) { 633078c562eSBrian Somers pri = PacketCheck(bundle, tun.data, n, &bundle->filter.in); 634078c562eSBrian Somers if (pri >= 0) { 6355d9e6103SBrian Somers n += sizeof tun - sizeof tun.data; 6365d9e6103SBrian Somers write(bundle->dev.fd, &tun, n); 637078c562eSBrian Somers log_Printf(LogDEBUG, "Looped back packet addressed to myself\n"); 638078c562eSBrian Somers } 639078c562eSBrian Somers return; 640078c562eSBrian Somers } else 641078c562eSBrian Somers log_Printf(LogDEBUG, "Oops - forwarding packet addressed to myself\n"); 642078c562eSBrian Somers } 643078c562eSBrian Somers 644078c562eSBrian Somers /* 645078c562eSBrian Somers * Process on-demand dialup. Output packets are queued within tunnel 646078c562eSBrian Somers * device until IPCP is opened. 647078c562eSBrian Somers */ 648078c562eSBrian Somers 649078c562eSBrian Somers if (bundle_Phase(bundle) == PHASE_DEAD) { 650078c562eSBrian Somers /* 651078c562eSBrian Somers * Note, we must be in AUTO mode :-/ otherwise our interface should 652078c562eSBrian Somers * *not* be UP and we can't receive data 653078c562eSBrian Somers */ 654078c562eSBrian Somers if ((pri = PacketCheck(bundle, tun.data, n, &bundle->filter.dial)) >= 0) 655ba23f397SBrian Somers bundle_Open(bundle, NULL, PHYS_AUTO, 0); 656078c562eSBrian Somers else 657078c562eSBrian Somers /* 658078c562eSBrian Somers * Drop the packet. If we were to queue it, we'd just end up with 659078c562eSBrian Somers * a pile of timed-out data in our output queue by the time we get 660078c562eSBrian Somers * around to actually dialing. We'd also prematurely reach the 661078c562eSBrian Somers * threshold at which we stop select()ing to read() the tun 662078c562eSBrian Somers * device - breaking auto-dial. 663078c562eSBrian Somers */ 664078c562eSBrian Somers return; 665078c562eSBrian Somers } 666078c562eSBrian Somers 667078c562eSBrian Somers pri = PacketCheck(bundle, tun.data, n, &bundle->filter.out); 6685d9e6103SBrian Somers if (pri >= 0) 6695a72b6edSBrian Somers ip_Enqueue(&bundle->ncp.ipcp, pri, tun.data, n); 670078c562eSBrian Somers } 671078c562eSBrian Somers } 6722f786681SBrian Somers 6731af29a6eSBrian Somers static int 6742f786681SBrian Somers bundle_DescriptorWrite(struct descriptor *d, struct bundle *bundle, 6752f786681SBrian Somers const fd_set *fdset) 6762f786681SBrian Somers { 6772f786681SBrian Somers struct datalink *dl; 6781af29a6eSBrian Somers int result = 0; 6792f786681SBrian Somers 680ea722969SBrian Somers /* This is not actually necessary as struct mpserver doesn't Write() */ 681ea722969SBrian Somers if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset)) 682ea722969SBrian Somers descriptor_Write(&bundle->ncp.mp.server.desc, bundle, fdset); 683ea722969SBrian Somers 6842f786681SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 6852f786681SBrian Somers if (descriptor_IsSet(&dl->desc, fdset)) 6861af29a6eSBrian Somers result += descriptor_Write(&dl->desc, bundle, fdset); 6871af29a6eSBrian Somers 6881af29a6eSBrian Somers return result; 6892f786681SBrian Somers } 6902f786681SBrian Somers 691da66dd13SBrian Somers void 6921384bd27SBrian Somers bundle_LockTun(struct bundle *bundle) 6931384bd27SBrian Somers { 6941384bd27SBrian Somers FILE *lockfile; 6951384bd27SBrian Somers char pidfile[MAXPATHLEN]; 6961384bd27SBrian Somers 6971384bd27SBrian Somers snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 6981384bd27SBrian Somers lockfile = ID0fopen(pidfile, "w"); 6991384bd27SBrian Somers if (lockfile != NULL) { 7001384bd27SBrian Somers fprintf(lockfile, "%d\n", (int)getpid()); 7011384bd27SBrian Somers fclose(lockfile); 7021384bd27SBrian Somers } 7031384bd27SBrian Somers #ifndef RELEASE_CRUNCH 7041384bd27SBrian Somers else 7051384bd27SBrian Somers log_Printf(LogERROR, "Warning: Can't create %s: %s\n", 7061384bd27SBrian Somers pidfile, strerror(errno)); 7071384bd27SBrian Somers #endif 7081384bd27SBrian Somers } 7091384bd27SBrian Somers 7101384bd27SBrian Somers static void 7111384bd27SBrian Somers bundle_UnlockTun(struct bundle *bundle) 7121384bd27SBrian Somers { 7131384bd27SBrian Somers char pidfile[MAXPATHLEN]; 7141384bd27SBrian Somers 7151384bd27SBrian Somers snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit); 7161384bd27SBrian Somers ID0unlink(pidfile); 7171384bd27SBrian Somers } 7187a6f8720SBrian Somers 7197a6f8720SBrian Somers struct bundle * 7208e7b8599SBrian Somers bundle_Create(const char *prefix, int type, const char **argv) 7217a6f8720SBrian Somers { 7227a6f8720SBrian Somers static struct bundle bundle; /* there can be only one */ 7234e5196e9SBrian Somers int enoentcount, err; 7244e5196e9SBrian Somers const char *ifname; 7256ca65df0SBrian Somers #if defined(TUNSIFMODE) || defined(TUNSLMODE) 7260f203c7eSBrian Somers int iff; 7270f203c7eSBrian Somers #endif 7287a6f8720SBrian Somers 7298fa6ebe4SBrian Somers if (bundle.iface != NULL) { /* Already allocated ! */ 730a33b2ef7SBrian Somers log_Printf(LogALERT, "bundle_Create: There's only one BUNDLE !\n"); 7317a6f8720SBrian Somers return NULL; 7327a6f8720SBrian Somers } 7337a6f8720SBrian Somers 7347a6f8720SBrian Somers err = ENOENT; 7357a6f8720SBrian Somers enoentcount = 0; 736107d62e7SBrian Somers for (bundle.unit = 0; ; bundle.unit++) { 737faefde08SBrian Somers snprintf(bundle.dev.Name, sizeof bundle.dev.Name, "%s%d", 738faefde08SBrian Somers prefix, bundle.unit); 739faefde08SBrian Somers bundle.dev.fd = ID0open(bundle.dev.Name, O_RDWR); 740faefde08SBrian Somers if (bundle.dev.fd >= 0) 7417a6f8720SBrian Somers break; 742107d62e7SBrian Somers else if (errno == ENXIO) { 7437a6f8720SBrian Somers err = errno; 744107d62e7SBrian Somers break; 7457a6f8720SBrian Somers } else if (errno == ENOENT) { 7467a6f8720SBrian Somers if (++enoentcount > 2) 747107d62e7SBrian Somers break; 7487a6f8720SBrian Somers } else 7497a6f8720SBrian Somers err = errno; 7507a6f8720SBrian Somers } 7517a6f8720SBrian Somers 752faefde08SBrian Somers if (bundle.dev.fd < 0) { 753dd7e2610SBrian Somers log_Printf(LogWARN, "No available tunnel devices found (%s).\n", 75485b542cfSBrian Somers strerror(err)); 7557a6f8720SBrian Somers return NULL; 7567a6f8720SBrian Somers } 7577a6f8720SBrian Somers 758dd7e2610SBrian Somers log_SetTun(bundle.unit); 7598e7b8599SBrian Somers bundle.argv = argv; 7600f781a72SBrian Somers bundle.argv0 = argv[0]; 7610f781a72SBrian Somers bundle.argv1 = argv[1]; 7627a6f8720SBrian Somers 7638fa6ebe4SBrian Somers ifname = strrchr(bundle.dev.Name, '/'); 7648fa6ebe4SBrian Somers if (ifname == NULL) 7658fa6ebe4SBrian Somers ifname = bundle.dev.Name; 7667a6f8720SBrian Somers else 7678fa6ebe4SBrian Somers ifname++; 7688fa6ebe4SBrian Somers 7698fa6ebe4SBrian Somers bundle.iface = iface_Create(ifname); 7708fa6ebe4SBrian Somers if (bundle.iface == NULL) { 7718fa6ebe4SBrian Somers close(bundle.dev.fd); 7728fa6ebe4SBrian Somers return NULL; 7738fa6ebe4SBrian Somers } 7747a6f8720SBrian Somers 7750f203c7eSBrian Somers #ifdef TUNSIFMODE 7760f203c7eSBrian Somers /* Make sure we're POINTOPOINT */ 7770f203c7eSBrian Somers iff = IFF_POINTOPOINT; 7780f203c7eSBrian Somers if (ID0ioctl(bundle.dev.fd, TUNSIFMODE, &iff) < 0) 7790f203c7eSBrian Somers log_Printf(LogERROR, "bundle_Create: ioctl(TUNSIFMODE): %s\n", 7800f203c7eSBrian Somers strerror(errno)); 7810f203c7eSBrian Somers #endif 7820f203c7eSBrian Somers 7836ca65df0SBrian Somers #ifdef TUNSLMODE 7846ca65df0SBrian Somers /* Make sure we're POINTOPOINT */ 7856ca65df0SBrian Somers iff = 0; 7866ca65df0SBrian Somers if (ID0ioctl(bundle.dev.fd, TUNSLMODE, &iff) < 0) 7876ca65df0SBrian Somers log_Printf(LogERROR, "bundle_Create: ioctl(TUNSLMODE): %s\n", 7886ca65df0SBrian Somers strerror(errno)); 7896ca65df0SBrian Somers #endif 7906ca65df0SBrian Somers 7914e5196e9SBrian Somers if (!iface_SetFlags(bundle.iface, IFF_UP)) { 7928fa6ebe4SBrian Somers iface_Destroy(bundle.iface); 7938fa6ebe4SBrian Somers bundle.iface = NULL; 794faefde08SBrian Somers close(bundle.dev.fd); 7957a6f8720SBrian Somers return NULL; 7967a6f8720SBrian Somers } 7977a6f8720SBrian Somers 7988fa6ebe4SBrian Somers log_Printf(LogPHASE, "Using interface: %s\n", ifname); 7997a6f8720SBrian Somers 8008fa6ebe4SBrian Somers bundle.ifSpeed = 0; 801820de6ebSBrian Somers bundle.routing_seq = 0; 802a0cbd833SBrian Somers bundle.phase = PHASE_DEAD; 803a0cbd833SBrian Somers bundle.CleaningUp = 0; 804615ad4f9SBrian Somers bundle.AliasEnabled = 0; 8057a6f8720SBrian Somers 8066d666775SBrian Somers bundle.fsm.LayerStart = bundle_LayerStart; 8076f384573SBrian Somers bundle.fsm.LayerUp = bundle_LayerUp; 8086d666775SBrian Somers bundle.fsm.LayerDown = bundle_LayerDown; 8096d666775SBrian Somers bundle.fsm.LayerFinish = bundle_LayerFinish; 8106d666775SBrian Somers bundle.fsm.object = &bundle; 8117a6f8720SBrian Somers 812ab886ad0SBrian Somers bundle.cfg.idle_timeout = NCP_IDLE_TIMEOUT; 8131342caedSBrian Somers *bundle.cfg.auth.name = '\0'; 8141342caedSBrian Somers *bundle.cfg.auth.key = '\0'; 815610b185fSBrian Somers bundle.cfg.opt = OPT_SROUTES | OPT_IDCHECK | OPT_LOOPBACK | 816610b185fSBrian Somers OPT_THROUGHPUT | OPT_UTMP; 81749052c95SBrian Somers *bundle.cfg.label = '\0'; 81849052c95SBrian Somers bundle.cfg.mtu = DEF_MTU; 81904eaa58cSBrian Somers bundle.cfg.autoload.max.packets = 0; 82004eaa58cSBrian Somers bundle.cfg.autoload.max.timeout = 0; 82104eaa58cSBrian Somers bundle.cfg.autoload.min.packets = 0; 82204eaa58cSBrian Somers bundle.cfg.autoload.min.timeout = 0; 8236f8e9f0aSBrian Somers bundle.cfg.choked.timeout = CHOKED_TIMEOUT; 824ff0f9439SBrian Somers bundle.phys_type.all = type; 825ff0f9439SBrian Somers bundle.phys_type.open = 0; 826ab886ad0SBrian Somers 8276f384573SBrian Somers bundle.links = datalink_Create("deflink", &bundle, type); 8283006ec67SBrian Somers if (bundle.links == NULL) { 829a33b2ef7SBrian Somers log_Printf(LogALERT, "Cannot create data link: %s\n", strerror(errno)); 8308fa6ebe4SBrian Somers iface_Destroy(bundle.iface); 8318fa6ebe4SBrian Somers bundle.iface = NULL; 832faefde08SBrian Somers close(bundle.dev.fd); 8332289f246SBrian Somers return NULL; 8342289f246SBrian Somers } 8352289f246SBrian Somers 8362f786681SBrian Somers bundle.desc.type = BUNDLE_DESCRIPTOR; 8372f786681SBrian Somers bundle.desc.UpdateSet = bundle_UpdateSet; 8382f786681SBrian Somers bundle.desc.IsSet = bundle_IsSet; 8392f786681SBrian Somers bundle.desc.Read = bundle_DescriptorRead; 8402f786681SBrian Somers bundle.desc.Write = bundle_DescriptorWrite; 8412f786681SBrian Somers 84249052c95SBrian Somers mp_Init(&bundle.ncp.mp, &bundle); 84349052c95SBrian Somers 84449052c95SBrian Somers /* Send over the first physical link by default */ 8455828db6dSBrian Somers ipcp_Init(&bundle.ncp.ipcp, &bundle, &bundle.links->physical->link, 8465828db6dSBrian Somers &bundle.fsm); 8476d666775SBrian Somers 8485ca5389aSBrian Somers memset(&bundle.filter, '\0', sizeof bundle.filter); 8495ca5389aSBrian Somers bundle.filter.in.fragok = bundle.filter.in.logok = 1; 8505ca5389aSBrian Somers bundle.filter.in.name = "IN"; 8515ca5389aSBrian Somers bundle.filter.out.fragok = bundle.filter.out.logok = 1; 8525ca5389aSBrian Somers bundle.filter.out.name = "OUT"; 8535ca5389aSBrian Somers bundle.filter.dial.name = "DIAL"; 8548390b576SBrian Somers bundle.filter.dial.logok = 1; 8555ca5389aSBrian Somers bundle.filter.alive.name = "ALIVE"; 8565ca5389aSBrian Somers bundle.filter.alive.logok = 1; 85793ee0ff2SBrian Somers memset(&bundle.idle.timer, '\0', sizeof bundle.idle.timer); 85893ee0ff2SBrian Somers bundle.idle.done = 0; 8595cf4388bSBrian Somers bundle.notify.fd = -1; 86004eaa58cSBrian Somers memset(&bundle.autoload.timer, '\0', sizeof bundle.autoload.timer); 86104eaa58cSBrian Somers bundle.autoload.done = 0; 86204eaa58cSBrian Somers bundle.autoload.running = 0; 8636f8e9f0aSBrian Somers memset(&bundle.choked.timer, '\0', sizeof bundle.choked.timer); 864972a1bcfSBrian Somers #ifndef NORADIUS 865972a1bcfSBrian Somers radius_Init(&bundle.radius); 866972a1bcfSBrian Somers #endif 86793ee0ff2SBrian Somers 8686d666775SBrian Somers /* Clean out any leftover crud */ 8698fa6ebe4SBrian Somers iface_Clear(bundle.iface, IFACE_CLEAR_ALL); 8706d666775SBrian Somers 8711384bd27SBrian Somers bundle_LockTun(&bundle); 8721384bd27SBrian Somers 8737a6f8720SBrian Somers return &bundle; 8747a6f8720SBrian Somers } 8757a6f8720SBrian Somers 87668a0f0ccSBrian Somers static void 87768a0f0ccSBrian Somers bundle_DownInterface(struct bundle *bundle) 87868a0f0ccSBrian Somers { 879dd7e2610SBrian Somers route_IfDelete(bundle, 1); 8804e5196e9SBrian Somers iface_ClearFlags(bundle->iface, IFF_UP); 88168a0f0ccSBrian Somers } 88268a0f0ccSBrian Somers 88368a0f0ccSBrian Somers void 88468a0f0ccSBrian Somers bundle_Destroy(struct bundle *bundle) 88568a0f0ccSBrian Somers { 8863006ec67SBrian Somers struct datalink *dl; 887b6217683SBrian Somers 888ea722969SBrian Somers /* 88904eaa58cSBrian Somers * Clean up the interface. We don't need to timer_Stop()s, mp_Down(), 890ea722969SBrian Somers * ipcp_CleanInterface() and bundle_DownInterface() unless we're getting 891ea722969SBrian Somers * out under exceptional conditions such as a descriptor exception. 892ea722969SBrian Somers */ 89304eaa58cSBrian Somers timer_Stop(&bundle->idle.timer); 8946f8e9f0aSBrian Somers timer_Stop(&bundle->choked.timer); 89504eaa58cSBrian Somers timer_Stop(&bundle->autoload.timer); 89666f634b6SBrian Somers mp_Down(&bundle->ncp.mp); 897dd7e2610SBrian Somers ipcp_CleanInterface(&bundle->ncp.ipcp); 89868a0f0ccSBrian Somers bundle_DownInterface(bundle); 8993006ec67SBrian Somers 900972a1bcfSBrian Somers #ifndef NORADIUS 901972a1bcfSBrian Somers /* Tell the radius server the bad news */ 902972a1bcfSBrian Somers radius_Destroy(&bundle->radius); 903972a1bcfSBrian Somers #endif 904972a1bcfSBrian Somers 905ea722969SBrian Somers /* Again, these are all DATALINK_CLOSED unless we're abending */ 9063006ec67SBrian Somers dl = bundle->links; 9073006ec67SBrian Somers while (dl) 9083006ec67SBrian Somers dl = datalink_Destroy(dl); 9093006ec67SBrian Somers 9101384bd27SBrian Somers close(bundle->dev.fd); 9111384bd27SBrian Somers bundle_UnlockTun(bundle); 9121384bd27SBrian Somers 913ea722969SBrian Somers /* In case we never made PHASE_NETWORK */ 9145cf4388bSBrian Somers bundle_Notify(bundle, EX_ERRDEAD); 915b6217683SBrian Somers 9168fa6ebe4SBrian Somers iface_Destroy(bundle->iface); 9178fa6ebe4SBrian Somers bundle->iface = NULL; 91868a0f0ccSBrian Somers } 91968a0f0ccSBrian Somers 9207a6f8720SBrian Somers struct rtmsg { 9217a6f8720SBrian Somers struct rt_msghdr m_rtm; 9227a6f8720SBrian Somers char m_space[64]; 9237a6f8720SBrian Somers }; 9247a6f8720SBrian Somers 925610b185fSBrian Somers int 926820de6ebSBrian Somers bundle_SetRoute(struct bundle *bundle, int cmd, struct in_addr dst, 9272062443fSBrian Somers struct in_addr gateway, struct in_addr mask, int bang, int ssh) 9287a6f8720SBrian Somers { 9297a6f8720SBrian Somers struct rtmsg rtmes; 9307a6f8720SBrian Somers int s, nb, wb; 9317a6f8720SBrian Somers char *cp; 9327a6f8720SBrian Somers const char *cmdstr; 9337a6f8720SBrian Somers struct sockaddr_in rtdata; 934610b185fSBrian Somers int result = 1; 9357a6f8720SBrian Somers 9367a6f8720SBrian Somers if (bang) 9377a6f8720SBrian Somers cmdstr = (cmd == RTM_ADD ? "Add!" : "Delete!"); 9387a6f8720SBrian Somers else 9397a6f8720SBrian Somers cmdstr = (cmd == RTM_ADD ? "Add" : "Delete"); 9407a6f8720SBrian Somers s = ID0socket(PF_ROUTE, SOCK_RAW, 0); 9417a6f8720SBrian Somers if (s < 0) { 942dd7e2610SBrian Somers log_Printf(LogERROR, "bundle_SetRoute: socket(): %s\n", strerror(errno)); 943610b185fSBrian Somers return result; 9447a6f8720SBrian Somers } 9457a6f8720SBrian Somers memset(&rtmes, '\0', sizeof rtmes); 9467a6f8720SBrian Somers rtmes.m_rtm.rtm_version = RTM_VERSION; 9477a6f8720SBrian Somers rtmes.m_rtm.rtm_type = cmd; 9487a6f8720SBrian Somers rtmes.m_rtm.rtm_addrs = RTA_DST; 949820de6ebSBrian Somers rtmes.m_rtm.rtm_seq = ++bundle->routing_seq; 9507a6f8720SBrian Somers rtmes.m_rtm.rtm_pid = getpid(); 9517a6f8720SBrian Somers rtmes.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC; 9527a6f8720SBrian Somers 9533afe5ccbSBrian Somers if (cmd == RTM_ADD || cmd == RTM_CHANGE) { 9543afe5ccbSBrian Somers if (bundle->ncp.ipcp.cfg.sendpipe > 0) { 9553afe5ccbSBrian Somers rtmes.m_rtm.rtm_rmx.rmx_sendpipe = bundle->ncp.ipcp.cfg.sendpipe; 9563afe5ccbSBrian Somers rtmes.m_rtm.rtm_inits |= RTV_SPIPE; 9573afe5ccbSBrian Somers } 9583afe5ccbSBrian Somers if (bundle->ncp.ipcp.cfg.recvpipe > 0) { 9593afe5ccbSBrian Somers rtmes.m_rtm.rtm_rmx.rmx_recvpipe = bundle->ncp.ipcp.cfg.recvpipe; 9603afe5ccbSBrian Somers rtmes.m_rtm.rtm_inits |= RTV_RPIPE; 9613afe5ccbSBrian Somers } 9623afe5ccbSBrian Somers } 9633afe5ccbSBrian Somers 9647a6f8720SBrian Somers memset(&rtdata, '\0', sizeof rtdata); 96550e5c17dSBrian Somers rtdata.sin_len = sizeof rtdata; 9667a6f8720SBrian Somers rtdata.sin_family = AF_INET; 9677a6f8720SBrian Somers rtdata.sin_port = 0; 9687a6f8720SBrian Somers rtdata.sin_addr = dst; 9697a6f8720SBrian Somers 9707a6f8720SBrian Somers cp = rtmes.m_space; 97150e5c17dSBrian Somers memcpy(cp, &rtdata, rtdata.sin_len); 97250e5c17dSBrian Somers cp += rtdata.sin_len; 973e43ebac1SBrian Somers if (cmd == RTM_ADD) { 9747a6f8720SBrian Somers if (gateway.s_addr == INADDR_ANY) { 9750aa8aa17SBrian Somers if (!ssh) 9768fa6ebe4SBrian Somers log_Printf(LogERROR, "bundle_SetRoute: Cannot add a route with" 9778fa6ebe4SBrian Somers " destination 0.0.0.0\n"); 9788fa6ebe4SBrian Somers close(s); 9798fa6ebe4SBrian Somers return result; 9807a6f8720SBrian Somers } else { 9817a6f8720SBrian Somers rtdata.sin_addr = gateway; 98250e5c17dSBrian Somers memcpy(cp, &rtdata, rtdata.sin_len); 98350e5c17dSBrian Somers cp += rtdata.sin_len; 9847a6f8720SBrian Somers rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY; 9857a6f8720SBrian Somers } 986e43ebac1SBrian Somers } 9877a6f8720SBrian Somers 9887a6f8720SBrian Somers if (dst.s_addr == INADDR_ANY) 9897a6f8720SBrian Somers mask.s_addr = INADDR_ANY; 9907a6f8720SBrian Somers 9917a6f8720SBrian Somers if (cmd == RTM_ADD || dst.s_addr == INADDR_ANY) { 9927a6f8720SBrian Somers rtdata.sin_addr = mask; 99350e5c17dSBrian Somers memcpy(cp, &rtdata, rtdata.sin_len); 99450e5c17dSBrian Somers cp += rtdata.sin_len; 9957a6f8720SBrian Somers rtmes.m_rtm.rtm_addrs |= RTA_NETMASK; 9967a6f8720SBrian Somers } 9977a6f8720SBrian Somers 9987a6f8720SBrian Somers nb = cp - (char *) &rtmes; 9997a6f8720SBrian Somers rtmes.m_rtm.rtm_msglen = nb; 10007a6f8720SBrian Somers wb = ID0write(s, &rtmes, nb); 10017a6f8720SBrian Somers if (wb < 0) { 1002dd7e2610SBrian Somers log_Printf(LogTCPIP, "bundle_SetRoute failure:\n"); 1003dd7e2610SBrian Somers log_Printf(LogTCPIP, "bundle_SetRoute: Cmd = %s\n", cmdstr); 1004dd7e2610SBrian Somers log_Printf(LogTCPIP, "bundle_SetRoute: Dst = %s\n", inet_ntoa(dst)); 1005dd7e2610SBrian Somers log_Printf(LogTCPIP, "bundle_SetRoute: Gateway = %s\n", inet_ntoa(gateway)); 1006dd7e2610SBrian Somers log_Printf(LogTCPIP, "bundle_SetRoute: Mask = %s\n", inet_ntoa(mask)); 10077a6f8720SBrian Somers failed: 10087a6f8720SBrian Somers if (cmd == RTM_ADD && (rtmes.m_rtm.rtm_errno == EEXIST || 1009e43ebac1SBrian Somers (rtmes.m_rtm.rtm_errno == 0 && errno == EEXIST))) { 1010610b185fSBrian Somers if (!bang) { 1011dd7e2610SBrian Somers log_Printf(LogWARN, "Add route failed: %s already exists\n", 10123afe5ccbSBrian Somers dst.s_addr == 0 ? "default" : inet_ntoa(dst)); 1013610b185fSBrian Somers result = 0; /* Don't add to our dynamic list */ 1014610b185fSBrian Somers } else { 10157a6f8720SBrian Somers rtmes.m_rtm.rtm_type = cmd = RTM_CHANGE; 10167a6f8720SBrian Somers if ((wb = ID0write(s, &rtmes, nb)) < 0) 10177a6f8720SBrian Somers goto failed; 10187a6f8720SBrian Somers } 1019e43ebac1SBrian Somers } else if (cmd == RTM_DELETE && 10207a6f8720SBrian Somers (rtmes.m_rtm.rtm_errno == ESRCH || 10217a6f8720SBrian Somers (rtmes.m_rtm.rtm_errno == 0 && errno == ESRCH))) { 10227a6f8720SBrian Somers if (!bang) 1023dd7e2610SBrian Somers log_Printf(LogWARN, "Del route failed: %s: Non-existent\n", 10247a6f8720SBrian Somers inet_ntoa(dst)); 10252062443fSBrian Somers } else if (rtmes.m_rtm.rtm_errno == 0) { 10262062443fSBrian Somers if (!ssh || errno != ENETUNREACH) 1027dd7e2610SBrian Somers log_Printf(LogWARN, "%s route failed: %s: errno: %s\n", cmdstr, 10287a6f8720SBrian Somers inet_ntoa(dst), strerror(errno)); 10292062443fSBrian Somers } else 1030dd7e2610SBrian Somers log_Printf(LogWARN, "%s route failed: %s: %s\n", 10317a6f8720SBrian Somers cmdstr, inet_ntoa(dst), strerror(rtmes.m_rtm.rtm_errno)); 10327a6f8720SBrian Somers } 1033dd7e2610SBrian Somers log_Printf(LogDEBUG, "wrote %d: cmd = %s, dst = %x, gateway = %x\n", 1034fe3125a0SBrian Somers wb, cmdstr, (unsigned)dst.s_addr, (unsigned)gateway.s_addr); 10357a6f8720SBrian Somers close(s); 1036610b185fSBrian Somers 1037610b185fSBrian Somers return result; 10387a6f8720SBrian Somers } 103983d1af55SBrian Somers 104083d1af55SBrian Somers void 10413006ec67SBrian Somers bundle_LinkClosed(struct bundle *bundle, struct datalink *dl) 10423006ec67SBrian Somers { 10433006ec67SBrian Somers /* 10443006ec67SBrian Somers * Our datalink has closed. 1045ea722969SBrian Somers * CleanDatalinks() (called from DoLoop()) will remove closed 104681358fa3SBrian Somers * BACKGROUND and DIRECT links. 10473b0f8d2eSBrian Somers * If it's the last data link, enter phase DEAD. 1048ea722969SBrian Somers * 1049ea722969SBrian Somers * NOTE: dl may not be in our list (bundle_SendDatalink()) ! 10503006ec67SBrian Somers */ 10515b8b8060SBrian Somers 10523b0f8d2eSBrian Somers struct datalink *odl; 10533b0f8d2eSBrian Somers int other_links; 10545b8b8060SBrian Somers 1055bf1d3ff6SBrian Somers log_SetTtyCommandMode(dl); 1056bf1d3ff6SBrian Somers 10573b0f8d2eSBrian Somers other_links = 0; 10583b0f8d2eSBrian Somers for (odl = bundle->links; odl; odl = odl->next) 10593b0f8d2eSBrian Somers if (odl != dl && odl->state != DATALINK_CLOSED) 10603b0f8d2eSBrian Somers other_links++; 10613b0f8d2eSBrian Somers 10623b0f8d2eSBrian Somers if (!other_links) { 106381358fa3SBrian Somers if (dl->physical->type != PHYS_AUTO) /* Not in -auto mode */ 106403704096SBrian Somers bundle_DownInterface(bundle); 106509206a6fSBrian Somers fsm2initial(&bundle->ncp.ipcp.fsm); 10665563ebdeSBrian Somers bundle_NewPhase(bundle, PHASE_DEAD); 10670f2f3eb3SBrian Somers bundle_StopIdleTimer(bundle); 106804eaa58cSBrian Somers bundle_StopAutoLoadTimer(bundle); 106904eaa58cSBrian Somers bundle->autoload.running = 0; 107004eaa58cSBrian Somers } else 107104eaa58cSBrian Somers bundle->autoload.running = 1; 1072455aabc3SBrian Somers } 1073455aabc3SBrian Somers 1074455aabc3SBrian Somers void 1075ba23f397SBrian Somers bundle_Open(struct bundle *bundle, const char *name, int mask, int force) 10763006ec67SBrian Somers { 10773006ec67SBrian Somers /* 10783006ec67SBrian Somers * Please open the given datalink, or all if name == NULL 10793006ec67SBrian Somers */ 10803006ec67SBrian Somers struct datalink *dl; 10813006ec67SBrian Somers 108204eaa58cSBrian Somers timer_Stop(&bundle->autoload.timer); 10833006ec67SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 10843006ec67SBrian Somers if (name == NULL || !strcasecmp(dl->name, name)) { 1085ba23f397SBrian Somers if ((mask & dl->physical->type) && 1086ba23f397SBrian Somers (dl->state == DATALINK_CLOSED || 1087ba23f397SBrian Somers (force && dl->state == DATALINK_OPENING && 1088c11e57a3SBrian Somers dl->dial.timer.state == TIMER_RUNNING))) { 1089c11e57a3SBrian Somers if (force) /* Ignore redial timeout ? */ 1090c11e57a3SBrian Somers timer_Stop(&dl->dial.timer); 1091565e35e5SBrian Somers datalink_Up(dl, 1, 1); 109281358fa3SBrian Somers if (mask == PHYS_AUTO) 109381358fa3SBrian Somers /* Only one AUTO link at a time (see the AutoLoad timer) */ 109404eaa58cSBrian Somers break; 109504eaa58cSBrian Somers } 10963006ec67SBrian Somers if (name != NULL) 10973006ec67SBrian Somers break; 10983006ec67SBrian Somers } 10993006ec67SBrian Somers } 11003006ec67SBrian Somers 11013006ec67SBrian Somers struct datalink * 11023006ec67SBrian Somers bundle2datalink(struct bundle *bundle, const char *name) 11033006ec67SBrian Somers { 11043006ec67SBrian Somers struct datalink *dl; 11053006ec67SBrian Somers 11063006ec67SBrian Somers if (name != NULL) { 11073006ec67SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 11083006ec67SBrian Somers if (!strcasecmp(dl->name, name)) 11093006ec67SBrian Somers return dl; 11103006ec67SBrian Somers } else if (bundle->links && !bundle->links->next) 11113006ec67SBrian Somers return bundle->links; 11123006ec67SBrian Somers 11133006ec67SBrian Somers return NULL; 11143006ec67SBrian Somers } 11153006ec67SBrian Somers 11163006ec67SBrian Somers int 11173006ec67SBrian Somers bundle_FillQueues(struct bundle *bundle) 11183006ec67SBrian Somers { 11193b0f8d2eSBrian Somers int total; 11203b0f8d2eSBrian Somers 11211bc9b5baSBrian Somers if (bundle->ncp.mp.active) 11223b0f8d2eSBrian Somers total = mp_FillQueues(bundle); 11231bc9b5baSBrian Somers else { 11241bc9b5baSBrian Somers struct datalink *dl; 11251bc9b5baSBrian Somers int add; 11261bc9b5baSBrian Somers 11271bc9b5baSBrian Somers for (total = 0, dl = bundle->links; dl; dl = dl->next) 11281bc9b5baSBrian Somers if (dl->state == DATALINK_OPEN) { 11291bc9b5baSBrian Somers add = link_QueueLen(&dl->physical->link); 11301bc9b5baSBrian Somers if (add == 0 && dl->physical->out == NULL) 11315d9e6103SBrian Somers add = ip_PushPacket(&dl->physical->link, bundle); 11321bc9b5baSBrian Somers total += add; 11331bc9b5baSBrian Somers } 11343006ec67SBrian Somers } 11353006ec67SBrian Somers 11365a72b6edSBrian Somers return total + ip_QueueLen(&bundle->ncp.ipcp); 11373006ec67SBrian Somers } 1138aef795ccSBrian Somers 1139aef795ccSBrian Somers int 1140aef795ccSBrian Somers bundle_ShowLinks(struct cmdargs const *arg) 1141aef795ccSBrian Somers { 1142aef795ccSBrian Somers struct datalink *dl; 1143aef795ccSBrian Somers 11449c53a7b1SBrian Somers for (dl = arg->bundle->links; dl; dl = dl->next) { 1145d4156d00SBrian Somers prompt_Printf(arg->prompt, "Name: %s [%s, %s]", 1146d4156d00SBrian Somers dl->name, mode2Nam(dl->physical->type), datalink_State(dl)); 1147eeab6bf5SBrian Somers if (dl->physical->link.throughput.rolling && dl->state == DATALINK_OPEN) 11485d9e6103SBrian Somers prompt_Printf(arg->prompt, " weight %d, %Ld bytes/sec", 1149eeab6bf5SBrian Somers dl->mp.weight, 11509c53a7b1SBrian Somers dl->physical->link.throughput.OctetsPerSecond); 11519c53a7b1SBrian Somers prompt_Printf(arg->prompt, "\n"); 11529c53a7b1SBrian Somers } 1153aef795ccSBrian Somers 1154aef795ccSBrian Somers return 0; 1155aef795ccSBrian Somers } 1156ab886ad0SBrian Somers 11571342caedSBrian Somers static const char * 11581342caedSBrian Somers optval(struct bundle *bundle, int bit) 11591342caedSBrian Somers { 11601342caedSBrian Somers return (bundle->cfg.opt & bit) ? "enabled" : "disabled"; 11611342caedSBrian Somers } 11621342caedSBrian Somers 1163c08717dfSBrian Somers int 1164c08717dfSBrian Somers bundle_ShowStatus(struct cmdargs const *arg) 1165c08717dfSBrian Somers { 1166c08717dfSBrian Somers int remaining; 1167c08717dfSBrian Somers 1168c08717dfSBrian Somers prompt_Printf(arg->prompt, "Phase %s\n", bundle_PhaseName(arg->bundle)); 11690f781a72SBrian Somers prompt_Printf(arg->prompt, " Title: %s\n", arg->bundle->argv[0]); 1170faefde08SBrian Somers prompt_Printf(arg->prompt, " Device: %s\n", arg->bundle->dev.Name); 1171faefde08SBrian Somers prompt_Printf(arg->prompt, " Interface: %s @ %lubps\n", 11728fa6ebe4SBrian Somers arg->bundle->iface->name, arg->bundle->ifSpeed); 1173c08717dfSBrian Somers 1174c08717dfSBrian Somers prompt_Printf(arg->prompt, "\nDefaults:\n"); 1175643f4904SBrian Somers prompt_Printf(arg->prompt, " Label: %s\n", arg->bundle->cfg.label); 1176610b185fSBrian Somers prompt_Printf(arg->prompt, " Auth name: %s\n", 1177610b185fSBrian Somers arg->bundle->cfg.auth.name); 117804eaa58cSBrian Somers prompt_Printf(arg->prompt, " Auto Load: Up after %ds of >= %d packets\n", 117904eaa58cSBrian Somers arg->bundle->cfg.autoload.max.timeout, 118004eaa58cSBrian Somers arg->bundle->cfg.autoload.max.packets); 118104eaa58cSBrian Somers prompt_Printf(arg->prompt, " Down after %ds of <= %d" 118204eaa58cSBrian Somers " packets\n", arg->bundle->cfg.autoload.min.timeout, 118304eaa58cSBrian Somers arg->bundle->cfg.autoload.min.packets); 118404eaa58cSBrian Somers if (arg->bundle->autoload.timer.state == TIMER_RUNNING) 118504eaa58cSBrian Somers prompt_Printf(arg->prompt, " %ds remaining 'till " 118604eaa58cSBrian Somers "a link comes %s\n", 118704eaa58cSBrian Somers bundle_RemainingAutoLoadTime(arg->bundle), 118804eaa58cSBrian Somers arg->bundle->autoload.comingup ? "up" : "down"); 118904eaa58cSBrian Somers else 119004eaa58cSBrian Somers prompt_Printf(arg->prompt, " %srunning with %d" 119104eaa58cSBrian Somers " packets queued\n", arg->bundle->autoload.running ? 11925a72b6edSBrian Somers "" : "not ", ip_QueueLen(&arg->bundle->ncp.ipcp)); 119304eaa58cSBrian Somers 11946f8e9f0aSBrian Somers prompt_Printf(arg->prompt, " Choked Timer: %ds\n", 11956f8e9f0aSBrian Somers arg->bundle->cfg.choked.timeout); 1196972a1bcfSBrian Somers 1197972a1bcfSBrian Somers #ifndef NORADIUS 1198972a1bcfSBrian Somers radius_Show(&arg->bundle->radius, arg->prompt); 1199972a1bcfSBrian Somers #endif 1200972a1bcfSBrian Somers 1201c08717dfSBrian Somers prompt_Printf(arg->prompt, " Idle Timer: "); 1202c08717dfSBrian Somers if (arg->bundle->cfg.idle_timeout) { 1203c08717dfSBrian Somers prompt_Printf(arg->prompt, "%ds", arg->bundle->cfg.idle_timeout); 1204c08717dfSBrian Somers remaining = bundle_RemainingIdleTime(arg->bundle); 1205c08717dfSBrian Somers if (remaining != -1) 1206c08717dfSBrian Somers prompt_Printf(arg->prompt, " (%ds remaining)", remaining); 1207c08717dfSBrian Somers prompt_Printf(arg->prompt, "\n"); 1208c08717dfSBrian Somers } else 1209c08717dfSBrian Somers prompt_Printf(arg->prompt, "disabled\n"); 1210ce828a6eSBrian Somers prompt_Printf(arg->prompt, " MTU: "); 1211ce828a6eSBrian Somers if (arg->bundle->cfg.mtu) 1212ce828a6eSBrian Somers prompt_Printf(arg->prompt, "%d\n", arg->bundle->cfg.mtu); 1213ce828a6eSBrian Somers else 1214ce828a6eSBrian Somers prompt_Printf(arg->prompt, "unspecified\n"); 1215c08717dfSBrian Somers 12163afe5ccbSBrian Somers prompt_Printf(arg->prompt, " sendpipe: "); 12173afe5ccbSBrian Somers if (arg->bundle->ncp.ipcp.cfg.sendpipe > 0) 12183afe5ccbSBrian Somers prompt_Printf(arg->prompt, "%ld\n", arg->bundle->ncp.ipcp.cfg.sendpipe); 12193afe5ccbSBrian Somers else 12203afe5ccbSBrian Somers prompt_Printf(arg->prompt, "unspecified\n"); 12213afe5ccbSBrian Somers prompt_Printf(arg->prompt, " recvpipe: "); 12223afe5ccbSBrian Somers if (arg->bundle->ncp.ipcp.cfg.recvpipe > 0) 12233afe5ccbSBrian Somers prompt_Printf(arg->prompt, "%ld\n", arg->bundle->ncp.ipcp.cfg.recvpipe); 12243afe5ccbSBrian Somers else 12253afe5ccbSBrian Somers prompt_Printf(arg->prompt, "unspecified\n"); 12263afe5ccbSBrian Somers 1227610b185fSBrian Somers prompt_Printf(arg->prompt, " Sticky Routes: %s\n", 1228610b185fSBrian Somers optval(arg->bundle, OPT_SROUTES)); 12291342caedSBrian Somers prompt_Printf(arg->prompt, " ID check: %s\n", 12301342caedSBrian Somers optval(arg->bundle, OPT_IDCHECK)); 1231ac685e31SBrian Somers prompt_Printf(arg->prompt, " Keep-Session: %s\n", 1232ac685e31SBrian Somers optval(arg->bundle, OPT_KEEPSESSION)); 12331342caedSBrian Somers prompt_Printf(arg->prompt, " Loopback: %s\n", 12341342caedSBrian Somers optval(arg->bundle, OPT_LOOPBACK)); 12351342caedSBrian Somers prompt_Printf(arg->prompt, " PasswdAuth: %s\n", 12361342caedSBrian Somers optval(arg->bundle, OPT_PASSWDAUTH)); 12371342caedSBrian Somers prompt_Printf(arg->prompt, " Proxy: %s\n", 12381342caedSBrian Somers optval(arg->bundle, OPT_PROXY)); 12393afe5ccbSBrian Somers prompt_Printf(arg->prompt, " Proxyall: %s\n", 12403afe5ccbSBrian Somers optval(arg->bundle, OPT_PROXYALL)); 12411342caedSBrian Somers prompt_Printf(arg->prompt, " Throughput: %s\n", 12421342caedSBrian Somers optval(arg->bundle, OPT_THROUGHPUT)); 1243610b185fSBrian Somers prompt_Printf(arg->prompt, " Utmp Logging: %s\n", 12441342caedSBrian Somers optval(arg->bundle, OPT_UTMP)); 12458fa6ebe4SBrian Somers prompt_Printf(arg->prompt, " Iface-Alias: %s\n", 12468fa6ebe4SBrian Somers optval(arg->bundle, OPT_IFACEALIAS)); 12471342caedSBrian Somers 1248c08717dfSBrian Somers return 0; 1249c08717dfSBrian Somers } 1250c08717dfSBrian Somers 1251ab886ad0SBrian Somers static void 1252ab886ad0SBrian Somers bundle_IdleTimeout(void *v) 1253ab886ad0SBrian Somers { 1254ab886ad0SBrian Somers struct bundle *bundle = (struct bundle *)v; 1255ab886ad0SBrian Somers 1256dd7e2610SBrian Somers log_Printf(LogPHASE, "Idle timer expired.\n"); 125704eaa58cSBrian Somers bundle_StopIdleTimer(bundle); 12589c81b87dSBrian Somers bundle_Close(bundle, NULL, CLOSE_STAYDOWN); 1259ab886ad0SBrian Somers } 1260ab886ad0SBrian Somers 1261ab886ad0SBrian Somers /* 1262ab886ad0SBrian Somers * Start Idle timer. If timeout is reached, we call bundle_Close() to 1263ab886ad0SBrian Somers * close LCP and link. 1264ab886ad0SBrian Somers */ 1265ab886ad0SBrian Somers void 1266ab886ad0SBrian Somers bundle_StartIdleTimer(struct bundle *bundle) 1267ab886ad0SBrian Somers { 1268dd7e2610SBrian Somers timer_Stop(&bundle->idle.timer); 1269ff0f9439SBrian Somers if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) != 1270ff0f9439SBrian Somers bundle->phys_type.open && bundle->cfg.idle_timeout) { 127193ee0ff2SBrian Somers bundle->idle.timer.func = bundle_IdleTimeout; 12723b0f8d2eSBrian Somers bundle->idle.timer.name = "idle"; 127393ee0ff2SBrian Somers bundle->idle.timer.load = bundle->cfg.idle_timeout * SECTICKS; 127493ee0ff2SBrian Somers bundle->idle.timer.arg = bundle; 1275dd7e2610SBrian Somers timer_Start(&bundle->idle.timer); 127693ee0ff2SBrian Somers bundle->idle.done = time(NULL) + bundle->cfg.idle_timeout; 1277ab886ad0SBrian Somers } 1278ab886ad0SBrian Somers } 1279ab886ad0SBrian Somers 1280ab886ad0SBrian Somers void 1281ab886ad0SBrian Somers bundle_SetIdleTimer(struct bundle *bundle, int value) 1282ab886ad0SBrian Somers { 1283ab886ad0SBrian Somers bundle->cfg.idle_timeout = value; 1284ab886ad0SBrian Somers if (bundle_LinkIsUp(bundle)) 1285ab886ad0SBrian Somers bundle_StartIdleTimer(bundle); 1286ab886ad0SBrian Somers } 1287ab886ad0SBrian Somers 1288ab886ad0SBrian Somers void 1289ab886ad0SBrian Somers bundle_StopIdleTimer(struct bundle *bundle) 1290ab886ad0SBrian Somers { 1291dd7e2610SBrian Somers timer_Stop(&bundle->idle.timer); 12924a632c80SBrian Somers bundle->idle.done = 0; 1293ab886ad0SBrian Somers } 1294ab886ad0SBrian Somers 129504eaa58cSBrian Somers static int 1296ab886ad0SBrian Somers bundle_RemainingIdleTime(struct bundle *bundle) 1297ab886ad0SBrian Somers { 129893ee0ff2SBrian Somers if (bundle->idle.done) 129993ee0ff2SBrian Somers return bundle->idle.done - time(NULL); 1300ab886ad0SBrian Somers return -1; 1301ab886ad0SBrian Somers } 13023b0f8d2eSBrian Somers 13033b0f8d2eSBrian Somers int 13043b0f8d2eSBrian Somers bundle_IsDead(struct bundle *bundle) 13053b0f8d2eSBrian Somers { 13063b0f8d2eSBrian Somers return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp); 13073b0f8d2eSBrian Somers } 1308b6217683SBrian Somers 130904eaa58cSBrian Somers static struct datalink * 131004eaa58cSBrian Somers bundle_DatalinkLinkout(struct bundle *bundle, struct datalink *dl) 1311cd7bd93aSBrian Somers { 1312cd7bd93aSBrian Somers struct datalink **dlp; 1313cd7bd93aSBrian Somers 1314cd7bd93aSBrian Somers for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next) 1315cd7bd93aSBrian Somers if (*dlp == dl) { 131604eaa58cSBrian Somers *dlp = dl->next; 131704eaa58cSBrian Somers dl->next = NULL; 131804eaa58cSBrian Somers bundle_LinksRemoved(bundle); 131904eaa58cSBrian Somers return dl; 1320cd7bd93aSBrian Somers } 132104eaa58cSBrian Somers 132204eaa58cSBrian Somers return NULL; 132304eaa58cSBrian Somers } 132404eaa58cSBrian Somers 132504eaa58cSBrian Somers static void 132604eaa58cSBrian Somers bundle_DatalinkLinkin(struct bundle *bundle, struct datalink *dl) 132704eaa58cSBrian Somers { 132804eaa58cSBrian Somers struct datalink **dlp = &bundle->links; 132904eaa58cSBrian Somers 133004eaa58cSBrian Somers while (*dlp) 133104eaa58cSBrian Somers dlp = &(*dlp)->next; 133204eaa58cSBrian Somers 133304eaa58cSBrian Somers *dlp = dl; 133404eaa58cSBrian Somers dl->next = NULL; 133504eaa58cSBrian Somers 133604eaa58cSBrian Somers bundle_LinkAdded(bundle, dl); 1337565e35e5SBrian Somers } 1338565e35e5SBrian Somers 1339565e35e5SBrian Somers void 1340565e35e5SBrian Somers bundle_CleanDatalinks(struct bundle *bundle) 1341565e35e5SBrian Somers { 1342565e35e5SBrian Somers struct datalink **dlp = &bundle->links; 134304eaa58cSBrian Somers int found = 0; 1344565e35e5SBrian Somers 1345565e35e5SBrian Somers while (*dlp) 1346565e35e5SBrian Somers if ((*dlp)->state == DATALINK_CLOSED && 134781358fa3SBrian Somers (*dlp)->physical->type & (PHYS_DIRECT|PHYS_BACKGROUND)) { 1348565e35e5SBrian Somers *dlp = datalink_Destroy(*dlp); 134904eaa58cSBrian Somers found++; 135004eaa58cSBrian Somers } else 1351565e35e5SBrian Somers dlp = &(*dlp)->next; 135204eaa58cSBrian Somers 135304eaa58cSBrian Somers if (found) 135404eaa58cSBrian Somers bundle_LinksRemoved(bundle); 135504eaa58cSBrian Somers } 135604eaa58cSBrian Somers 135704eaa58cSBrian Somers int 135804eaa58cSBrian Somers bundle_DatalinkClone(struct bundle *bundle, struct datalink *dl, 135904eaa58cSBrian Somers const char *name) 136004eaa58cSBrian Somers { 136104eaa58cSBrian Somers if (bundle2datalink(bundle, name)) { 136204eaa58cSBrian Somers log_Printf(LogWARN, "Clone: %s: name already exists\n", name); 136304eaa58cSBrian Somers return 0; 136404eaa58cSBrian Somers } 136504eaa58cSBrian Somers 136604eaa58cSBrian Somers bundle_DatalinkLinkin(bundle, datalink_Clone(dl, name)); 136704eaa58cSBrian Somers return 1; 136804eaa58cSBrian Somers } 136904eaa58cSBrian Somers 137004eaa58cSBrian Somers void 137104eaa58cSBrian Somers bundle_DatalinkRemove(struct bundle *bundle, struct datalink *dl) 137204eaa58cSBrian Somers { 137304eaa58cSBrian Somers dl = bundle_DatalinkLinkout(bundle, dl); 137404eaa58cSBrian Somers if (dl) 137504eaa58cSBrian Somers datalink_Destroy(dl); 1376cd7bd93aSBrian Somers } 137749052c95SBrian Somers 137849052c95SBrian Somers void 137949052c95SBrian Somers bundle_SetLabel(struct bundle *bundle, const char *label) 138049052c95SBrian Somers { 138149052c95SBrian Somers if (label) 138249052c95SBrian Somers strncpy(bundle->cfg.label, label, sizeof bundle->cfg.label - 1); 138349052c95SBrian Somers else 138449052c95SBrian Somers *bundle->cfg.label = '\0'; 138549052c95SBrian Somers } 138649052c95SBrian Somers 138749052c95SBrian Somers const char * 138849052c95SBrian Somers bundle_GetLabel(struct bundle *bundle) 138949052c95SBrian Somers { 139049052c95SBrian Somers return *bundle->cfg.label ? bundle->cfg.label : NULL; 139149052c95SBrian Somers } 13921fa665f5SBrian Somers 13931fa665f5SBrian Somers void 139496c9bb21SBrian Somers bundle_ReceiveDatalink(struct bundle *bundle, int s, struct sockaddr_un *sun) 13951fa665f5SBrian Somers { 139696c9bb21SBrian Somers char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)]; 139796c9bb21SBrian Somers struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 139896c9bb21SBrian Somers struct msghdr msg; 139996c9bb21SBrian Somers struct iovec iov[SCATTER_SEGMENTS]; 1400b7c5748eSBrian Somers struct datalink *dl; 140196c9bb21SBrian Somers int niov, link_fd, expect, f; 140285fd273aSBrian Somers pid_t pid; 14036f384573SBrian Somers 1404dd7e2610SBrian Somers log_Printf(LogPHASE, "Receiving datalink\n"); 14056f384573SBrian Somers 140696c9bb21SBrian Somers /* Create our scatter/gather array */ 140796c9bb21SBrian Somers niov = 1; 140896c9bb21SBrian Somers iov[0].iov_len = strlen(Version) + 1; 140996c9bb21SBrian Somers iov[0].iov_base = (char *)malloc(iov[0].iov_len); 141085fd273aSBrian Somers if (datalink2iov(NULL, iov, &niov, sizeof iov / sizeof *iov, 0) == -1) { 141154cd8e13SBrian Somers close(s); 14126f384573SBrian Somers return; 141354cd8e13SBrian Somers } 14146f384573SBrian Somers 141585fd273aSBrian Somers pid = getpid(); 141685fd273aSBrian Somers write(s, &pid, sizeof pid); 141785fd273aSBrian Somers 141896c9bb21SBrian Somers for (f = expect = 0; f < niov; f++) 141996c9bb21SBrian Somers expect += iov[f].iov_len; 142096c9bb21SBrian Somers 142196c9bb21SBrian Somers /* Set up our message */ 142296c9bb21SBrian Somers cmsg->cmsg_len = sizeof cmsgbuf; 142396c9bb21SBrian Somers cmsg->cmsg_level = SOL_SOCKET; 142454cd8e13SBrian Somers cmsg->cmsg_type = 0; 142596c9bb21SBrian Somers 142696c9bb21SBrian Somers memset(&msg, '\0', sizeof msg); 142796c9bb21SBrian Somers msg.msg_name = (caddr_t)sun; 142896c9bb21SBrian Somers msg.msg_namelen = sizeof *sun; 142996c9bb21SBrian Somers msg.msg_iov = iov; 143096c9bb21SBrian Somers msg.msg_iovlen = niov; 143196c9bb21SBrian Somers msg.msg_control = cmsgbuf; 143296c9bb21SBrian Somers msg.msg_controllen = sizeof cmsgbuf; 143396c9bb21SBrian Somers 143496c9bb21SBrian Somers log_Printf(LogDEBUG, "Expecting %d scatter/gather bytes\n", expect); 143596c9bb21SBrian Somers f = expect + 100; 143696c9bb21SBrian Somers setsockopt(s, SOL_SOCKET, SO_RCVBUF, &f, sizeof f); 143796c9bb21SBrian Somers if ((f = recvmsg(s, &msg, MSG_WAITALL)) != expect) { 143896c9bb21SBrian Somers if (f == -1) 143996c9bb21SBrian Somers log_Printf(LogERROR, "Failed recvmsg: %s\n", strerror(errno)); 144096c9bb21SBrian Somers else 144196c9bb21SBrian Somers log_Printf(LogERROR, "Failed recvmsg: Got %d, not %d\n", f, expect); 144296c9bb21SBrian Somers while (niov--) 144396c9bb21SBrian Somers free(iov[niov].iov_base); 144454cd8e13SBrian Somers close(s); 144596c9bb21SBrian Somers return; 144696c9bb21SBrian Somers } 144796c9bb21SBrian Somers 1448c0d9a877SBrian Somers write(s, "!", 1); /* ACK */ 1449ad5b0e8bSBrian Somers close(s); 1450c0d9a877SBrian Somers 1451ad5b0e8bSBrian Somers if (cmsg->cmsg_type != SCM_RIGHTS) { 1452ad5b0e8bSBrian Somers log_Printf(LogERROR, "Recvmsg: no descriptor received !\n"); 1453ad5b0e8bSBrian Somers while (niov--) 1454ad5b0e8bSBrian Somers free(iov[niov].iov_base); 1455ad5b0e8bSBrian Somers return; 145654cd8e13SBrian Somers } 145754cd8e13SBrian Somers 1458ad5b0e8bSBrian Somers /* We've successfully received an open file descriptor through our socket */ 1459ad5b0e8bSBrian Somers log_Printf(LogDEBUG, "Receiving device descriptor\n"); 1460ad5b0e8bSBrian Somers link_fd = *(int *)CMSG_DATA(cmsg); 1461ad5b0e8bSBrian Somers 146296c9bb21SBrian Somers if (strncmp(Version, iov[0].iov_base, iov[0].iov_len)) { 146396c9bb21SBrian Somers log_Printf(LogWARN, "Cannot receive datalink, incorrect version" 146496c9bb21SBrian Somers " (\"%.*s\", not \"%s\")\n", (int)iov[0].iov_len, 14657d81ddf5SBrian Somers (char *)iov[0].iov_base, Version); 146696c9bb21SBrian Somers close(link_fd); 146796c9bb21SBrian Somers while (niov--) 146896c9bb21SBrian Somers free(iov[niov].iov_base); 146996c9bb21SBrian Somers return; 147096c9bb21SBrian Somers } 147196c9bb21SBrian Somers 147296c9bb21SBrian Somers niov = 1; 1473b7c5748eSBrian Somers dl = iov2datalink(bundle, iov, &niov, sizeof iov / sizeof *iov, link_fd); 1474b7c5748eSBrian Somers if (dl) { 147504eaa58cSBrian Somers bundle_DatalinkLinkin(bundle, dl); 1476b7c5748eSBrian Somers datalink_AuthOk(dl); 147796c9bb21SBrian Somers } else 147896c9bb21SBrian Somers close(link_fd); 147996c9bb21SBrian Somers 148096c9bb21SBrian Somers free(iov[0].iov_base); 14811fa665f5SBrian Somers } 14821fa665f5SBrian Somers 14831fa665f5SBrian Somers void 148496c9bb21SBrian Somers bundle_SendDatalink(struct datalink *dl, int s, struct sockaddr_un *sun) 14851fa665f5SBrian Somers { 1486c0d9a877SBrian Somers char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)], ack; 148796c9bb21SBrian Somers struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf; 148896c9bb21SBrian Somers struct msghdr msg; 148996c9bb21SBrian Somers struct iovec iov[SCATTER_SEGMENTS]; 14901384bd27SBrian Somers int niov, link_fd, f, expect, newsid; 149185fd273aSBrian Somers pid_t newpid; 14926f384573SBrian Somers 1493dd7e2610SBrian Somers log_Printf(LogPHASE, "Transmitting datalink %s\n", dl->name); 14946f384573SBrian Somers 149504eaa58cSBrian Somers bundle_LinkClosed(dl->bundle, dl); 14960f2f3eb3SBrian Somers bundle_DatalinkLinkout(dl->bundle, dl); 1497ea722969SBrian Somers 149896c9bb21SBrian Somers /* Build our scatter/gather array */ 149996c9bb21SBrian Somers iov[0].iov_len = strlen(Version) + 1; 150096c9bb21SBrian Somers iov[0].iov_base = strdup(Version); 150196c9bb21SBrian Somers niov = 1; 15026f384573SBrian Somers 150385fd273aSBrian Somers read(s, &newpid, sizeof newpid); 150485fd273aSBrian Somers link_fd = datalink2iov(dl, iov, &niov, sizeof iov / sizeof *iov, newpid); 15056f384573SBrian Somers 15066f384573SBrian Somers if (link_fd != -1) { 150796c9bb21SBrian Somers memset(&msg, '\0', sizeof msg); 150854cd8e13SBrian Somers 150996c9bb21SBrian Somers msg.msg_name = (caddr_t)sun; 151096c9bb21SBrian Somers msg.msg_namelen = sizeof *sun; 151196c9bb21SBrian Somers msg.msg_iov = iov; 151296c9bb21SBrian Somers msg.msg_iovlen = niov; 151354cd8e13SBrian Somers 151454cd8e13SBrian Somers cmsg->cmsg_len = sizeof cmsgbuf; 151554cd8e13SBrian Somers cmsg->cmsg_level = SOL_SOCKET; 151654cd8e13SBrian Somers cmsg->cmsg_type = SCM_RIGHTS; 151754cd8e13SBrian Somers *(int *)CMSG_DATA(cmsg) = link_fd; 151896c9bb21SBrian Somers msg.msg_control = cmsgbuf; 151996c9bb21SBrian Somers msg.msg_controllen = sizeof cmsgbuf; 152047723d29SBrian Somers 152196c9bb21SBrian Somers for (f = expect = 0; f < niov; f++) 152296c9bb21SBrian Somers expect += iov[f].iov_len; 152347723d29SBrian Somers 152496c9bb21SBrian Somers log_Printf(LogDEBUG, "Sending %d bytes in scatter/gather array\n", expect); 152547723d29SBrian Somers 152696c9bb21SBrian Somers f = expect + SOCKET_OVERHEAD; 152796c9bb21SBrian Somers setsockopt(s, SOL_SOCKET, SO_SNDBUF, &f, sizeof f); 152896c9bb21SBrian Somers if (sendmsg(s, &msg, 0) == -1) 152996c9bb21SBrian Somers log_Printf(LogERROR, "Failed sendmsg: %s\n", strerror(errno)); 1530c0d9a877SBrian Somers /* We must get the ACK before closing the descriptor ! */ 1531c0d9a877SBrian Somers read(s, &ack, 1); 153254cd8e13SBrian Somers 1533ac685e31SBrian Somers newsid = Enabled(dl->bundle, OPT_KEEPSESSION) || 1534ac685e31SBrian Somers tcgetpgrp(link_fd) == getpgrp(); 153596c9bb21SBrian Somers close(link_fd); 15361384bd27SBrian Somers if (newsid) 15371384bd27SBrian Somers bundle_setsid(dl->bundle, 1); 153847723d29SBrian Somers } 153985fd273aSBrian Somers close(s); 154096c9bb21SBrian Somers 154196c9bb21SBrian Somers while (niov--) 154296c9bb21SBrian Somers free(iov[niov].iov_base); 15431fa665f5SBrian Somers } 1544dd0645c5SBrian Somers 1545dd0645c5SBrian Somers int 154658d55334SBrian Somers bundle_RenameDatalink(struct bundle *bundle, struct datalink *ndl, 154758d55334SBrian Somers const char *name) 154858d55334SBrian Somers { 154958d55334SBrian Somers struct datalink *dl; 155058d55334SBrian Somers 155158d55334SBrian Somers if (!strcasecmp(ndl->name, name)) 155258d55334SBrian Somers return 1; 155358d55334SBrian Somers 155458d55334SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 155558d55334SBrian Somers if (!strcasecmp(dl->name, name)) 155658d55334SBrian Somers return 0; 155758d55334SBrian Somers 155858d55334SBrian Somers datalink_Rename(ndl, name); 155958d55334SBrian Somers return 1; 156058d55334SBrian Somers } 156158d55334SBrian Somers 156258d55334SBrian Somers int 1563dd0645c5SBrian Somers bundle_SetMode(struct bundle *bundle, struct datalink *dl, int mode) 1564dd0645c5SBrian Somers { 1565dd0645c5SBrian Somers int omode; 1566dd0645c5SBrian Somers 1567dd0645c5SBrian Somers omode = dl->physical->type; 1568dd0645c5SBrian Somers if (omode == mode) 1569dd0645c5SBrian Somers return 1; 1570dd0645c5SBrian Somers 1571ff0f9439SBrian Somers if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO)) 1572ff0f9439SBrian Somers /* First auto link */ 1573dd0645c5SBrian Somers if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) { 1574ff0f9439SBrian Somers log_Printf(LogWARN, "You must `set ifaddr' or `open' before" 1575ff0f9439SBrian Somers " changing mode to %s\n", mode2Nam(mode)); 1576dd0645c5SBrian Somers return 0; 1577dd0645c5SBrian Somers } 1578dd0645c5SBrian Somers 1579dd0645c5SBrian Somers if (!datalink_SetMode(dl, mode)) 1580dd0645c5SBrian Somers return 0; 1581dd0645c5SBrian Somers 1582ff0f9439SBrian Somers if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) && 1583ff0f9439SBrian Somers bundle->phase != PHASE_NETWORK) 1584ff0f9439SBrian Somers /* First auto link, we need an interface */ 1585dd0645c5SBrian Somers ipcp_InterfaceUp(&bundle->ncp.ipcp); 1586dd0645c5SBrian Somers 158704eaa58cSBrian Somers /* Regenerate phys_type and adjust autoload & idle timers */ 158804eaa58cSBrian Somers bundle_LinksRemoved(bundle); 1589dd0645c5SBrian Somers 1590dd0645c5SBrian Somers return 1; 1591dd0645c5SBrian Somers } 15921384bd27SBrian Somers 15931384bd27SBrian Somers void 15941384bd27SBrian Somers bundle_setsid(struct bundle *bundle, int holdsession) 15951384bd27SBrian Somers { 15961384bd27SBrian Somers /* 15971384bd27SBrian Somers * Lose the current session. This means getting rid of our pid 15981384bd27SBrian Somers * too so that the tty device will really go away, and any getty 15991384bd27SBrian Somers * etc will be allowed to restart. 16001384bd27SBrian Somers */ 16011384bd27SBrian Somers pid_t pid, orig; 16021384bd27SBrian Somers int fds[2]; 16031384bd27SBrian Somers char done; 16041384bd27SBrian Somers struct datalink *dl; 16051384bd27SBrian Somers 16061384bd27SBrian Somers orig = getpid(); 16071384bd27SBrian Somers if (pipe(fds) == -1) { 16081384bd27SBrian Somers log_Printf(LogERROR, "pipe: %s\n", strerror(errno)); 16091384bd27SBrian Somers return; 16101384bd27SBrian Somers } 16111384bd27SBrian Somers switch ((pid = fork())) { 16121384bd27SBrian Somers case -1: 16131384bd27SBrian Somers log_Printf(LogERROR, "fork: %s\n", strerror(errno)); 16141384bd27SBrian Somers close(fds[0]); 16151384bd27SBrian Somers close(fds[1]); 16161384bd27SBrian Somers return; 16171384bd27SBrian Somers case 0: 16181384bd27SBrian Somers close(fds[1]); 16194be0e57dSBrian Somers read(fds[0], &done, 1); /* uu_locks are mine ! */ 16204be0e57dSBrian Somers close(fds[0]); 16211384bd27SBrian Somers if (pipe(fds) == -1) { 16221384bd27SBrian Somers log_Printf(LogERROR, "pipe(2): %s\n", strerror(errno)); 16231384bd27SBrian Somers return; 16241384bd27SBrian Somers } 16251384bd27SBrian Somers switch ((pid = fork())) { 16261384bd27SBrian Somers case -1: 1627a33b2ef7SBrian Somers log_Printf(LogERROR, "fork(2): %s\n", strerror(errno)); 16281384bd27SBrian Somers close(fds[0]); 16291384bd27SBrian Somers close(fds[1]); 16301384bd27SBrian Somers return; 16311384bd27SBrian Somers case 0: 16321384bd27SBrian Somers close(fds[1]); 16334be0e57dSBrian Somers bundle_LockTun(bundle); /* update pid */ 16344be0e57dSBrian Somers read(fds[0], &done, 1); /* uu_locks are mine ! */ 16354be0e57dSBrian Somers close(fds[0]); 16361384bd27SBrian Somers setsid(); 16371384bd27SBrian Somers log_Printf(LogPHASE, "%d -> %d: %s session control\n", 16381384bd27SBrian Somers (int)orig, (int)getpid(), 16391384bd27SBrian Somers holdsession ? "Passed" : "Dropped"); 16407e778f13SBrian Somers timer_InitService(0); /* Start the Timer Service */ 16411384bd27SBrian Somers break; 16421384bd27SBrian Somers default: 16434be0e57dSBrian Somers close(fds[0]); 16445d9e6103SBrian Somers /* Give away all our physical locks (to the final process) */ 16451384bd27SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 16461384bd27SBrian Somers if (dl->state != DATALINK_CLOSED) 16475d9e6103SBrian Somers physical_ChangedPid(dl->physical, pid); 16484be0e57dSBrian Somers write(fds[1], "!", 1); /* done */ 16494be0e57dSBrian Somers close(fds[1]); 16501384bd27SBrian Somers exit(0); 16511384bd27SBrian Somers break; 16521384bd27SBrian Somers } 16531384bd27SBrian Somers break; 16541384bd27SBrian Somers default: 16554be0e57dSBrian Somers close(fds[0]); 16565d9e6103SBrian Somers /* Give away all our physical locks (to the intermediate process) */ 16571384bd27SBrian Somers for (dl = bundle->links; dl; dl = dl->next) 16581384bd27SBrian Somers if (dl->state != DATALINK_CLOSED) 16595d9e6103SBrian Somers physical_ChangedPid(dl->physical, pid); 16604be0e57dSBrian Somers write(fds[1], "!", 1); /* done */ 16614be0e57dSBrian Somers close(fds[1]); 16621384bd27SBrian Somers if (holdsession) { 16631384bd27SBrian Somers int fd, status; 16641384bd27SBrian Somers 16651384bd27SBrian Somers timer_TermService(); 16661384bd27SBrian Somers signal(SIGPIPE, SIG_DFL); 16671384bd27SBrian Somers signal(SIGALRM, SIG_DFL); 16681384bd27SBrian Somers signal(SIGHUP, SIG_DFL); 16691384bd27SBrian Somers signal(SIGTERM, SIG_DFL); 16701384bd27SBrian Somers signal(SIGINT, SIG_DFL); 16711384bd27SBrian Somers signal(SIGQUIT, SIG_DFL); 16721384bd27SBrian Somers for (fd = getdtablesize(); fd >= 0; fd--) 16731384bd27SBrian Somers close(fd); 16741384bd27SBrian Somers setuid(geteuid()); 16751384bd27SBrian Somers /* 16761384bd27SBrian Somers * Reap the intermediate process. As we're not exiting but the 16771384bd27SBrian Somers * intermediate is, we don't want it to become defunct. 16781384bd27SBrian Somers */ 16791384bd27SBrian Somers waitpid(pid, &status, 0); 16808e7b8599SBrian Somers /* Tweak our process arguments.... */ 16818e7b8599SBrian Somers bundle->argv[0] = "session owner"; 16828e7b8599SBrian Somers bundle->argv[1] = NULL; 16831384bd27SBrian Somers /* 16841384bd27SBrian Somers * Hang around for a HUP. This should happen as soon as the 16851384bd27SBrian Somers * ppp that we passed our ctty descriptor to closes it. 16861384bd27SBrian Somers * NOTE: If this process dies, the passed descriptor becomes 16871384bd27SBrian Somers * invalid and will give a select() error by setting one 16881384bd27SBrian Somers * of the error fds, aborting the other ppp. We don't 16891384bd27SBrian Somers * want that to happen ! 16901384bd27SBrian Somers */ 16911384bd27SBrian Somers pause(); 16921384bd27SBrian Somers } 16931384bd27SBrian Somers exit(0); 16941384bd27SBrian Somers break; 16951384bd27SBrian Somers } 16961384bd27SBrian Somers } 16979b5f8ffdSBrian Somers 16989b5f8ffdSBrian Somers int 16999b5f8ffdSBrian Somers bundle_HighestState(struct bundle *bundle) 17009b5f8ffdSBrian Somers { 17019b5f8ffdSBrian Somers struct datalink *dl; 17029b5f8ffdSBrian Somers int result = DATALINK_CLOSED; 17039b5f8ffdSBrian Somers 17049b5f8ffdSBrian Somers for (dl = bundle->links; dl; dl = dl->next) 17059b5f8ffdSBrian Somers if (result < dl->state) 17069b5f8ffdSBrian Somers result = dl->state; 17079b5f8ffdSBrian Somers 17089b5f8ffdSBrian Somers return result; 17099b5f8ffdSBrian Somers } 1710991c2a7bSBrian Somers 1711991c2a7bSBrian Somers int 1712991c2a7bSBrian Somers bundle_Exception(struct bundle *bundle, int fd) 1713991c2a7bSBrian Somers { 1714991c2a7bSBrian Somers struct datalink *dl; 1715991c2a7bSBrian Somers 1716991c2a7bSBrian Somers for (dl = bundle->links; dl; dl = dl->next) 1717991c2a7bSBrian Somers if (dl->physical->fd == fd) { 1718991c2a7bSBrian Somers datalink_Down(dl, CLOSE_NORMAL); 1719991c2a7bSBrian Somers return 1; 1720991c2a7bSBrian Somers } 1721991c2a7bSBrian Somers 1722991c2a7bSBrian Somers return 0; 1723991c2a7bSBrian Somers } 17241d1fc017SBrian Somers 17251d1fc017SBrian Somers void 17261d1fc017SBrian Somers bundle_AdjustFilters(struct bundle *bundle, struct in_addr *my_ip, 17271d1fc017SBrian Somers struct in_addr *peer_ip) 17281d1fc017SBrian Somers { 17291d1fc017SBrian Somers filter_AdjustAddr(&bundle->filter.in, my_ip, peer_ip); 17301d1fc017SBrian Somers filter_AdjustAddr(&bundle->filter.out, my_ip, peer_ip); 17311d1fc017SBrian Somers filter_AdjustAddr(&bundle->filter.dial, my_ip, peer_ip); 17321d1fc017SBrian Somers filter_AdjustAddr(&bundle->filter.alive, my_ip, peer_ip); 17331d1fc017SBrian Somers } 1734