xref: /freebsd/usr.sbin/ppp/bundle.c (revision 6ca65df0a7aafa67751b58ef83e58b556aa627ca)
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