xref: /freebsd/usr.sbin/ppp/bundle.c (revision 8fa6ebe47d24a6621f1be15f3157e2e1a046596e)
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  *
268fa6ebe4SBrian Somers  *	$Id: bundle.c,v 1.35 1998/09/17 00:45:25 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>
337a6f8720SBrian Somers #include <arpa/inet.h>
347a6f8720SBrian Somers #include <net/route.h>
357a6f8720SBrian Somers #include <net/if_dl.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 
521595bacdSBrian Somers #ifndef NOALIAS
531595bacdSBrian Somers #ifdef __OpenBSD__
541595bacdSBrian Somers #include "alias.h"
551595bacdSBrian Somers #else
561595bacdSBrian Somers #include <alias.h>
571595bacdSBrian Somers #endif
581595bacdSBrian Somers #endif
59c9e11a11SBrian Somers #include "defs.h"
607a6f8720SBrian Somers #include "command.h"
617a6f8720SBrian Somers #include "mbuf.h"
627a6f8720SBrian Somers #include "log.h"
637a6f8720SBrian Somers #include "id.h"
647a6f8720SBrian Somers #include "timer.h"
657a6f8720SBrian Somers #include "fsm.h"
667a6f8720SBrian Somers #include "iplist.h"
67879ed6faSBrian Somers #include "lqr.h"
68455aabc3SBrian Somers #include "hdlc.h"
697a6f8720SBrian Somers #include "throughput.h"
70eaa4df37SBrian Somers #include "slcompress.h"
717a6f8720SBrian Somers #include "ipcp.h"
725ca5389aSBrian Somers #include "filter.h"
732f786681SBrian Somers #include "descriptor.h"
747a6f8720SBrian Somers #include "route.h"
757a6f8720SBrian Somers #include "lcp.h"
767a6f8720SBrian Somers #include "ccp.h"
773b0f8d2eSBrian Somers #include "link.h"
783b0f8d2eSBrian Somers #include "mp.h"
793b0f8d2eSBrian Somers #include "bundle.h"
80455aabc3SBrian Somers #include "async.h"
81455aabc3SBrian Somers #include "physical.h"
822289f246SBrian Somers #include "modem.h"
83455aabc3SBrian Somers #include "auth.h"
84455aabc3SBrian Somers #include "lcpproto.h"
85455aabc3SBrian Somers #include "chap.h"
86455aabc3SBrian Somers #include "tun.h"
8785b542cfSBrian Somers #include "prompt.h"
883006ec67SBrian Somers #include "chat.h"
8992b09558SBrian Somers #include "cbcp.h"
903006ec67SBrian Somers #include "datalink.h"
913006ec67SBrian Somers #include "ip.h"
928fa6ebe4SBrian Somers #include "iface.h"
937a6f8720SBrian Somers 
9496c9bb21SBrian Somers #define SCATTER_SEGMENTS 4	/* version, datalink, name, physical */
9596c9bb21SBrian Somers #define SOCKET_OVERHEAD	100	/* additional buffer space for large */
9696c9bb21SBrian Somers                                 /* {recv,send}msg() calls            */
9796c9bb21SBrian Somers 
9804eaa58cSBrian Somers static int bundle_RemainingIdleTime(struct bundle *);
9904eaa58cSBrian Somers static int bundle_RemainingAutoLoadTime(struct bundle *);
10004eaa58cSBrian Somers 
101455aabc3SBrian Somers static const char *PhaseNames[] = {
102455aabc3SBrian Somers   "Dead", "Establish", "Authenticate", "Network", "Terminate"
103455aabc3SBrian Somers };
104455aabc3SBrian Somers 
105455aabc3SBrian Somers const char *
106455aabc3SBrian Somers bundle_PhaseName(struct bundle *bundle)
1077a6f8720SBrian Somers {
108455aabc3SBrian Somers   return bundle->phase <= PHASE_TERMINATE ?
109455aabc3SBrian Somers     PhaseNames[bundle->phase] : "unknown";
1107a6f8720SBrian Somers }
1117a6f8720SBrian Somers 
112455aabc3SBrian Somers void
1135563ebdeSBrian Somers bundle_NewPhase(struct bundle *bundle, u_int new)
114455aabc3SBrian Somers {
115aef795ccSBrian Somers   if (new == bundle->phase)
116aef795ccSBrian Somers     return;
117aef795ccSBrian Somers 
118e2ebb036SBrian Somers   if (new <= PHASE_TERMINATE)
119dd7e2610SBrian Somers     log_Printf(LogPHASE, "bundle: %s\n", PhaseNames[new]);
1207a6f8720SBrian Somers 
121455aabc3SBrian Somers   switch (new) {
122455aabc3SBrian Somers   case PHASE_DEAD:
1230f2f3eb3SBrian Somers     log_DisplayPrompts();
124455aabc3SBrian Somers     bundle->phase = new;
125455aabc3SBrian Somers     break;
126455aabc3SBrian Somers 
127455aabc3SBrian Somers   case PHASE_ESTABLISH:
128455aabc3SBrian Somers     bundle->phase = new;
129455aabc3SBrian Somers     break;
130455aabc3SBrian Somers 
131455aabc3SBrian Somers   case PHASE_AUTHENTICATE:
132455aabc3SBrian Somers     bundle->phase = new;
1330f2f3eb3SBrian Somers     log_DisplayPrompts();
134455aabc3SBrian Somers     break;
135455aabc3SBrian Somers 
136455aabc3SBrian Somers   case PHASE_NETWORK:
1375828db6dSBrian Somers     ipcp_Setup(&bundle->ncp.ipcp);
138dd7e2610SBrian Somers     fsm_Up(&bundle->ncp.ipcp.fsm);
139dd7e2610SBrian Somers     fsm_Open(&bundle->ncp.ipcp.fsm);
140673903ecSBrian Somers     bundle->phase = new;
1410f2f3eb3SBrian Somers     log_DisplayPrompts();
142673903ecSBrian Somers     break;
143455aabc3SBrian Somers 
144455aabc3SBrian Somers   case PHASE_TERMINATE:
145455aabc3SBrian Somers     bundle->phase = new;
146673903ecSBrian Somers     mp_Down(&bundle->ncp.mp);
1470f2f3eb3SBrian Somers     log_DisplayPrompts();
148455aabc3SBrian Somers     break;
1497a6f8720SBrian Somers   }
1507a6f8720SBrian Somers }
1517a6f8720SBrian Somers 
1526d666775SBrian Somers static void
1536d666775SBrian Somers bundle_LayerStart(void *v, struct fsm *fp)
1547a6f8720SBrian Somers {
1553006ec67SBrian Somers   /* The given FSM is about to start up ! */
1567a6f8720SBrian Somers }
1577a6f8720SBrian Somers 
1585cf4388bSBrian Somers 
1595cf4388bSBrian Somers static void
1605cf4388bSBrian Somers bundle_Notify(struct bundle *bundle, char c)
1615cf4388bSBrian Somers {
1625cf4388bSBrian Somers   if (bundle->notify.fd != -1) {
1635cf4388bSBrian Somers     if (write(bundle->notify.fd, &c, 1) == 1)
164dd7e2610SBrian Somers       log_Printf(LogPHASE, "Parent notified of success.\n");
1655cf4388bSBrian Somers     else
166dd7e2610SBrian Somers       log_Printf(LogPHASE, "Failed to notify parent of success.\n");
1675cf4388bSBrian Somers     close(bundle->notify.fd);
1685cf4388bSBrian Somers     bundle->notify.fd = -1;
1695cf4388bSBrian Somers   }
1705cf4388bSBrian Somers }
1713b0f8d2eSBrian Somers 
1726d666775SBrian Somers static void
1736f8e9f0aSBrian Somers bundle_ClearQueues(void *v)
1746f8e9f0aSBrian Somers {
1756f8e9f0aSBrian Somers   struct bundle *bundle = (struct bundle *)v;
1766f8e9f0aSBrian Somers   struct datalink *dl;
1776f8e9f0aSBrian Somers 
1786f8e9f0aSBrian Somers   log_Printf(LogPHASE, "Clearing choked output queue\n");
1796f8e9f0aSBrian Somers   timer_Stop(&bundle->choked.timer);
1806f8e9f0aSBrian Somers 
1816f8e9f0aSBrian Somers   /*
1826f8e9f0aSBrian Somers    * Emergency time:
1836f8e9f0aSBrian Somers    *
1846f8e9f0aSBrian Somers    * We've had a full queue for PACKET_DEL_SECS seconds without being
1856f8e9f0aSBrian Somers    * able to get rid of any of the packets.  We've probably given up
1866f8e9f0aSBrian Somers    * on the redials at this point, and the queued data has almost
1876f8e9f0aSBrian Somers    * definitely been timed out by the layer above.  As this is preventing
1886f8e9f0aSBrian Somers    * us from reading the TUN_NAME device (we don't want to buffer stuff
1896f8e9f0aSBrian Somers    * indefinitely), we may as well nuke this data and start with a clean
1906f8e9f0aSBrian Somers    * slate !
1916f8e9f0aSBrian Somers    *
1926f8e9f0aSBrian Somers    * Unfortunately, this has the side effect of shafting any compression
1936f8e9f0aSBrian Somers    * dictionaries in use (causing the relevant RESET_REQ/RESET_ACK).
1946f8e9f0aSBrian Somers    */
1956f8e9f0aSBrian Somers 
1965a72b6edSBrian Somers   ip_DeleteQueue(&bundle->ncp.ipcp);
1976f8e9f0aSBrian Somers   mp_DeleteQueue(&bundle->ncp.mp);
1986f8e9f0aSBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
1996f8e9f0aSBrian Somers     physical_DeleteQueue(dl->physical);
2006f8e9f0aSBrian Somers }
2016f8e9f0aSBrian Somers 
2026f8e9f0aSBrian Somers static void
20304eaa58cSBrian Somers bundle_AutoLoadTimeout(void *v)
20404eaa58cSBrian Somers {
20504eaa58cSBrian Somers   struct bundle *bundle = (struct bundle *)v;
20604eaa58cSBrian Somers 
20704eaa58cSBrian Somers   if (bundle->autoload.comingup) {
20804eaa58cSBrian Somers     log_Printf(LogPHASE, "autoload: Another link is required\n");
20904eaa58cSBrian Somers     /* bundle_Open() stops the timer */
210ba23f397SBrian Somers     bundle_Open(bundle, NULL, PHYS_AUTO, 0);
21104eaa58cSBrian Somers   } else {
21204eaa58cSBrian Somers     struct datalink *dl, *last;
21304eaa58cSBrian Somers 
21404eaa58cSBrian Somers     timer_Stop(&bundle->autoload.timer);
21504eaa58cSBrian Somers     for (last = NULL, dl = bundle->links; dl; dl = dl->next)
21681358fa3SBrian Somers       if (dl->physical->type == PHYS_AUTO && dl->state == DATALINK_OPEN)
21704eaa58cSBrian Somers         last = dl;
21804eaa58cSBrian Somers 
21904eaa58cSBrian Somers     if (last)
2209c81b87dSBrian Somers       datalink_Close(last, CLOSE_STAYDOWN);
22104eaa58cSBrian Somers   }
22204eaa58cSBrian Somers }
22304eaa58cSBrian Somers 
22404eaa58cSBrian Somers static void
22504eaa58cSBrian Somers bundle_StartAutoLoadTimer(struct bundle *bundle, int up)
22604eaa58cSBrian Somers {
22704eaa58cSBrian Somers   struct datalink *dl;
22804eaa58cSBrian Somers 
22904eaa58cSBrian Somers   timer_Stop(&bundle->autoload.timer);
23004eaa58cSBrian Somers 
23104eaa58cSBrian Somers   if (bundle->CleaningUp || bundle->phase != PHASE_NETWORK) {
23204eaa58cSBrian Somers     dl = NULL;
23304eaa58cSBrian Somers     bundle->autoload.running = 0;
23404eaa58cSBrian Somers   } else if (up) {
23504eaa58cSBrian Somers     for (dl = bundle->links; dl; dl = dl->next)
23681358fa3SBrian Somers       if (dl->state == DATALINK_CLOSED && dl->physical->type == PHYS_AUTO) {
23704eaa58cSBrian Somers         if (bundle->cfg.autoload.max.timeout) {
23804eaa58cSBrian Somers           bundle->autoload.timer.func = bundle_AutoLoadTimeout;
23904eaa58cSBrian Somers           bundle->autoload.timer.name = "autoload up";
24004eaa58cSBrian Somers           bundle->autoload.timer.load =
24104eaa58cSBrian Somers             bundle->cfg.autoload.max.timeout * SECTICKS;
24204eaa58cSBrian Somers           bundle->autoload.timer.arg = bundle;
24304eaa58cSBrian Somers           timer_Start(&bundle->autoload.timer);
24404eaa58cSBrian Somers           bundle->autoload.done = time(NULL) + bundle->cfg.autoload.max.timeout;
24504eaa58cSBrian Somers         } else
24604eaa58cSBrian Somers           bundle_AutoLoadTimeout(bundle);
24704eaa58cSBrian Somers         break;
24804eaa58cSBrian Somers       }
24904eaa58cSBrian Somers     bundle->autoload.running = (dl || bundle->cfg.autoload.min.timeout) ? 1 : 0;
25004eaa58cSBrian Somers   } else {
25104eaa58cSBrian Somers     int nlinks;
25204eaa58cSBrian Somers     struct datalink *adl;
25304eaa58cSBrian Somers 
25404eaa58cSBrian Somers     for (nlinks = 0, adl = NULL, dl = bundle->links; dl; dl = dl->next)
25504eaa58cSBrian Somers       if (dl->state == DATALINK_OPEN) {
25681358fa3SBrian Somers         if (dl->physical->type == PHYS_AUTO)
25704eaa58cSBrian Somers           adl = dl;
25804eaa58cSBrian Somers         if (++nlinks > 1 && adl) {
25904eaa58cSBrian Somers           if (bundle->cfg.autoload.min.timeout) {
26004eaa58cSBrian Somers             bundle->autoload.timer.func = bundle_AutoLoadTimeout;
26104eaa58cSBrian Somers             bundle->autoload.timer.name = "autoload down";
26204eaa58cSBrian Somers             bundle->autoload.timer.load =
26304eaa58cSBrian Somers               bundle->cfg.autoload.min.timeout * SECTICKS;
26404eaa58cSBrian Somers             bundle->autoload.timer.arg = bundle;
26504eaa58cSBrian Somers             timer_Start(&bundle->autoload.timer);
26604eaa58cSBrian Somers             bundle->autoload.done =
26704eaa58cSBrian Somers               time(NULL) + bundle->cfg.autoload.min.timeout;
26804eaa58cSBrian Somers           }
26904eaa58cSBrian Somers           break;
27004eaa58cSBrian Somers         }
27104eaa58cSBrian Somers       }
27204eaa58cSBrian Somers 
27304eaa58cSBrian Somers     bundle->autoload.running = 1;
27404eaa58cSBrian Somers   }
27504eaa58cSBrian Somers 
27604eaa58cSBrian Somers   bundle->autoload.comingup = up ? 1 : 0;
27704eaa58cSBrian Somers }
27804eaa58cSBrian Somers 
27904eaa58cSBrian Somers static void
28004eaa58cSBrian Somers bundle_StopAutoLoadTimer(struct bundle *bundle)
28104eaa58cSBrian Somers {
28204eaa58cSBrian Somers   timer_Stop(&bundle->autoload.timer);
28304eaa58cSBrian Somers   bundle->autoload.done = 0;
28404eaa58cSBrian Somers }
28504eaa58cSBrian Somers 
28604eaa58cSBrian Somers static int
28704eaa58cSBrian Somers bundle_RemainingAutoLoadTime(struct bundle *bundle)
28804eaa58cSBrian Somers {
28904eaa58cSBrian Somers   if (bundle->autoload.done)
29004eaa58cSBrian Somers     return bundle->autoload.done - time(NULL);
29104eaa58cSBrian Somers   return -1;
29204eaa58cSBrian Somers }
29304eaa58cSBrian Somers 
294ff0f9439SBrian Somers static void
295ff0f9439SBrian Somers bundle_LinkAdded(struct bundle *bundle, struct datalink *dl)
296ff0f9439SBrian Somers {
297ff0f9439SBrian Somers   bundle->phys_type.all |= dl->physical->type;
298ff0f9439SBrian Somers   if (dl->state == DATALINK_OPEN)
299ff0f9439SBrian Somers     bundle->phys_type.open |= dl->physical->type;
300ff0f9439SBrian Somers 
301ff0f9439SBrian Somers   /* Note: We only re-add links that are DATALINK_OPEN */
302ff0f9439SBrian Somers   if (dl->physical->type == PHYS_AUTO &&
303ff0f9439SBrian Somers       bundle->autoload.timer.state == TIMER_STOPPED &&
304ff0f9439SBrian Somers       dl->state != DATALINK_OPEN &&
305ff0f9439SBrian Somers       bundle->phase == PHASE_NETWORK)
306ff0f9439SBrian Somers     bundle->autoload.running = 1;
307ff0f9439SBrian Somers 
308ff0f9439SBrian Somers   if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL))
309ff0f9439SBrian Somers       != bundle->phys_type.open && bundle->idle.timer.state == TIMER_STOPPED)
310ff0f9439SBrian Somers     /* We may need to start our idle timer */
311ff0f9439SBrian Somers     bundle_StartIdleTimer(bundle);
312ff0f9439SBrian Somers }
313ff0f9439SBrian Somers 
31492b09558SBrian Somers void
315ff0f9439SBrian Somers bundle_LinksRemoved(struct bundle *bundle)
316ff0f9439SBrian Somers {
317ff0f9439SBrian Somers   struct datalink *dl;
318ff0f9439SBrian Somers 
319ff0f9439SBrian Somers   bundle->phys_type.all = bundle->phys_type.open = 0;
320ff0f9439SBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
321ff0f9439SBrian Somers     bundle_LinkAdded(bundle, dl);
322ff0f9439SBrian Somers 
323ff0f9439SBrian Somers   if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL))
324ff0f9439SBrian Somers       == bundle->phys_type.open)
325ff0f9439SBrian Somers     bundle_StopIdleTimer(bundle);
326ff0f9439SBrian Somers }
32704eaa58cSBrian Somers 
32804eaa58cSBrian Somers static void
3296f384573SBrian Somers bundle_LayerUp(void *v, struct fsm *fp)
3307a6f8720SBrian Somers {
3313006ec67SBrian Somers   /*
3323006ec67SBrian Somers    * The given fsm is now up
333ff0f9439SBrian Somers    * If it's an LCP, adjust our phys_mode.open value.
33449052c95SBrian Somers    * If it's an LCP set our mtu (if we're multilink, add up the link
33504eaa58cSBrian Somers    * speeds and set the MRRU) and start our autoload timer.
336565e35e5SBrian Somers    * If it's an NCP, tell our -background parent to go away.
3373b0f8d2eSBrian Somers    * If it's the first NCP, start the idle timer.
3383006ec67SBrian Somers    */
3396f384573SBrian Somers   struct bundle *bundle = (struct bundle *)v;
3406d666775SBrian Somers 
3415563ebdeSBrian Somers   if (fp->proto == PROTO_LCP) {
342ff0f9439SBrian Somers     struct physical *p = link2physical(fp->link);
343ff0f9439SBrian Somers 
344ff0f9439SBrian Somers     bundle_LinkAdded(bundle, p->dl);
3453b0f8d2eSBrian Somers     if (bundle->ncp.mp.active) {
3463b0f8d2eSBrian Somers       struct datalink *dl;
3475563ebdeSBrian Somers 
3488fa6ebe4SBrian Somers       bundle->ifSpeed = 0;
349faefde08SBrian Somers       for (dl = bundle->links; dl; dl = dl->next)
350eeab6bf5SBrian Somers         if (dl->state == DATALINK_OPEN)
3518fa6ebe4SBrian Somers           bundle->ifSpeed += modem_Speed(dl->physical);
352faefde08SBrian Somers       tun_configure(bundle, bundle->ncp.mp.peer_mrru);
35304eaa58cSBrian Somers       bundle->autoload.running = 1;
354faefde08SBrian Somers     } else {
3558fa6ebe4SBrian Somers       bundle->ifSpeed = modem_Speed(p);
356faefde08SBrian Somers       tun_configure(bundle, fsm2lcp(fp)->his_mru);
357faefde08SBrian Somers     }
3583b0f8d2eSBrian Somers   } else if (fp->proto == PROTO_IPCP) {
359ab886ad0SBrian Somers     bundle_StartIdleTimer(bundle);
3605cf4388bSBrian Somers     bundle_Notify(bundle, EX_NORMAL);
3617a6f8720SBrian Somers   }
362ab886ad0SBrian Somers }
3637a6f8720SBrian Somers 
3646d666775SBrian Somers static void
3656d666775SBrian Somers bundle_LayerDown(void *v, struct fsm *fp)
3666d666775SBrian Somers {
3676d666775SBrian Somers   /*
3686d666775SBrian Somers    * The given FSM has been told to come down.
369ab886ad0SBrian Somers    * If it's our last NCP, stop the idle timer.
370ff0f9439SBrian Somers    * If it's an LCP, adjust our phys_type.open value and any timers.
37186b1f0d7SBrian Somers    * If it's an LCP and we're in multilink mode, adjust our tun
37286b1f0d7SBrian Somers    * speed and make sure our minimum sequence number is adjusted.
3736d666775SBrian Somers    */
374ab886ad0SBrian Somers 
375ab886ad0SBrian Somers   struct bundle *bundle = (struct bundle *)v;
376ab886ad0SBrian Somers 
377078c562eSBrian Somers   if (fp->proto == PROTO_IPCP)
378ab886ad0SBrian Somers     bundle_StopIdleTimer(bundle);
379ff0f9439SBrian Somers   else if (fp->proto == PROTO_LCP) {
380ff0f9439SBrian Somers     bundle_LinksRemoved(bundle);  /* adjust timers & phys_type values */
381ff0f9439SBrian Somers     if (bundle->ncp.mp.active) {
3823b0f8d2eSBrian Somers       struct datalink *dl;
38386b1f0d7SBrian Somers       struct datalink *lost;
3843b0f8d2eSBrian Somers 
3858fa6ebe4SBrian Somers       bundle->ifSpeed = 0;
38686b1f0d7SBrian Somers       lost = NULL;
387faefde08SBrian Somers       for (dl = bundle->links; dl; dl = dl->next)
38886b1f0d7SBrian Somers         if (fp == &dl->physical->link.lcp.fsm)
38986b1f0d7SBrian Somers           lost = dl;
39086b1f0d7SBrian Somers         else if (dl->state == DATALINK_OPEN)
3918fa6ebe4SBrian Somers           bundle->ifSpeed += modem_Speed(dl->physical);
39286b1f0d7SBrian Somers 
3938fa6ebe4SBrian Somers       if (bundle->ifSpeed)
394faefde08SBrian Somers         /* Don't configure down to a speed of 0 */
395faefde08SBrian Somers         tun_configure(bundle, bundle->ncp.mp.link.lcp.his_mru);
39686b1f0d7SBrian Somers 
39786b1f0d7SBrian Somers       if (lost)
39886b1f0d7SBrian Somers         mp_LinkLost(&bundle->ncp.mp, lost);
39986b1f0d7SBrian Somers       else
400a33b2ef7SBrian Somers         log_Printf(LogALERT, "Oops, lost an unrecognised datalink (%s) !\n",
40186b1f0d7SBrian Somers                    fp->link->name);
4023b0f8d2eSBrian Somers     }
4036d666775SBrian Somers   }
404ff0f9439SBrian Somers }
4056d666775SBrian Somers 
4066d666775SBrian Somers static void
4076d666775SBrian Somers bundle_LayerFinish(void *v, struct fsm *fp)
4086d666775SBrian Somers {
4096d666775SBrian Somers   /* The given fsm is now down (fp cannot be NULL)
4106d666775SBrian Somers    *
411dd7e2610SBrian Somers    * If it's the last LCP, fsm_Down all NCPs
412dd7e2610SBrian Somers    * If it's the last NCP, fsm_Close all LCPs
4136d666775SBrian Somers    */
4146d666775SBrian Somers 
4156d666775SBrian Somers   struct bundle *bundle = (struct bundle *)v;
4166d666775SBrian Somers   struct datalink *dl;
4176d666775SBrian Somers 
4183b0f8d2eSBrian Somers   if (fp->proto == PROTO_IPCP) {
41926afeaa2SBrian Somers     if (bundle_Phase(bundle) != PHASE_DEAD)
42025092092SBrian Somers       bundle_NewPhase(bundle, PHASE_TERMINATE);
4216d666775SBrian Somers     for (dl = bundle->links; dl; dl = dl->next)
4229c81b87dSBrian Somers       datalink_Close(dl, CLOSE_NORMAL);
42309206a6fSBrian Somers     fsm2initial(fp);
4243b0f8d2eSBrian Somers   } else if (fp->proto == PROTO_LCP) {
4253b0f8d2eSBrian Somers     int others_active;
426a611cad6SBrian Somers 
4273b0f8d2eSBrian Somers     others_active = 0;
4283b0f8d2eSBrian Somers     for (dl = bundle->links; dl; dl = dl->next)
4293b0f8d2eSBrian Somers       if (fp != &dl->physical->link.lcp.fsm &&
4303b0f8d2eSBrian Somers           dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP)
4313b0f8d2eSBrian Somers         others_active++;
4323b0f8d2eSBrian Somers 
43309206a6fSBrian Somers     if (!others_active)
43409206a6fSBrian Somers       fsm2initial(&bundle->ncp.ipcp.fsm);
4353b0f8d2eSBrian Somers   }
4363b0f8d2eSBrian Somers }
4376d666775SBrian Somers 
4387a6f8720SBrian Somers int
4397a6f8720SBrian Somers bundle_LinkIsUp(const struct bundle *bundle)
4407a6f8720SBrian Somers {
4415828db6dSBrian Somers   return bundle->ncp.ipcp.fsm.state == ST_OPENED;
4427a6f8720SBrian Somers }
4437a6f8720SBrian Somers 
4447a6f8720SBrian Somers void
4459c81b87dSBrian Somers bundle_Close(struct bundle *bundle, const char *name, int how)
4467a6f8720SBrian Somers {
447455aabc3SBrian Somers   /*
4483006ec67SBrian Somers    * Please close the given datalink.
449dd7e2610SBrian Somers    * If name == NULL or name is the last datalink, fsm_Close all NCPs
4506f384573SBrian Somers    * (except our MP)
4513b0f8d2eSBrian Somers    * If it isn't the last datalink, just Close that datalink.
452455aabc3SBrian Somers    */
4537a6f8720SBrian Somers 
4543b0f8d2eSBrian Somers   struct datalink *dl, *this_dl;
4553b0f8d2eSBrian Somers   int others_active;
4563006ec67SBrian Somers 
4573b0f8d2eSBrian Somers   others_active = 0;
4583b0f8d2eSBrian Somers   this_dl = NULL;
4593b0f8d2eSBrian Somers 
4603b0f8d2eSBrian Somers   for (dl = bundle->links; dl; dl = dl->next) {
4613b0f8d2eSBrian Somers     if (name && !strcasecmp(name, dl->name))
4623b0f8d2eSBrian Somers       this_dl = dl;
4633b0f8d2eSBrian Somers     if (name == NULL || this_dl == dl) {
4649c81b87dSBrian Somers       switch (how) {
4659c81b87dSBrian Somers         case CLOSE_LCP:
4669c81b87dSBrian Somers           datalink_DontHangup(dl);
4679c81b87dSBrian Somers           /* fall through */
4689c81b87dSBrian Somers         case CLOSE_STAYDOWN:
4693006ec67SBrian Somers           datalink_StayDown(dl);
4709c81b87dSBrian Somers           break;
4719c81b87dSBrian Somers       }
4723b0f8d2eSBrian Somers     } else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP)
4733b0f8d2eSBrian Somers       others_active++;
4743b0f8d2eSBrian Somers   }
4753b0f8d2eSBrian Somers 
4763b0f8d2eSBrian Somers   if (name && this_dl == NULL) {
477dd7e2610SBrian Somers     log_Printf(LogWARN, "%s: Invalid datalink name\n", name);
4783b0f8d2eSBrian Somers     return;
4793b0f8d2eSBrian Somers   }
4803b0f8d2eSBrian Somers 
4813b0f8d2eSBrian Somers   if (!others_active) {
48204eaa58cSBrian Somers     bundle_StopIdleTimer(bundle);
48304eaa58cSBrian Somers     bundle_StopAutoLoadTimer(bundle);
4843b0f8d2eSBrian Somers     if (bundle->ncp.ipcp.fsm.state > ST_CLOSED ||
4853b0f8d2eSBrian Somers         bundle->ncp.ipcp.fsm.state == ST_STARTING)
486dd7e2610SBrian Somers       fsm_Close(&bundle->ncp.ipcp.fsm);
4873b0f8d2eSBrian Somers     else {
48809206a6fSBrian Somers       fsm2initial(&bundle->ncp.ipcp.fsm);
489d345321bSBrian Somers       for (dl = bundle->links; dl; dl = dl->next)
4909c81b87dSBrian Somers         datalink_Close(dl, how);
4917a6f8720SBrian Somers     }
4923b0f8d2eSBrian Somers   } else if (this_dl && this_dl->state != DATALINK_CLOSED &&
4933b0f8d2eSBrian Somers              this_dl->state != DATALINK_HANGUP)
4949c81b87dSBrian Somers     datalink_Close(this_dl, how);
495d2fd8d77SBrian Somers }
4967a6f8720SBrian Somers 
4971bc9b5baSBrian Somers void
498899011c4SBrian Somers bundle_Down(struct bundle *bundle, int how)
4991bc9b5baSBrian Somers {
5001bc9b5baSBrian Somers   struct datalink *dl;
5011bc9b5baSBrian Somers 
5021bc9b5baSBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
503899011c4SBrian Somers     datalink_Down(dl, how);
5041bc9b5baSBrian Somers }
5051bc9b5baSBrian Somers 
5062f786681SBrian Somers static int
5072f786681SBrian Somers bundle_UpdateSet(struct descriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n)
5082f786681SBrian Somers {
5092f786681SBrian Somers   struct bundle *bundle = descriptor2bundle(d);
5102f786681SBrian Somers   struct datalink *dl;
51104eaa58cSBrian Somers   int result, want, queued, nlinks;
5122f786681SBrian Somers 
5132f786681SBrian Somers   result = 0;
5142f786681SBrian Somers 
515078c562eSBrian Somers   /* If there are aren't many packets queued, look for some more. */
51604eaa58cSBrian Somers   for (nlinks = 0, dl = bundle->links; dl; dl = dl->next)
51704eaa58cSBrian Somers     nlinks++;
51804eaa58cSBrian Somers 
51904eaa58cSBrian Somers   if (nlinks) {
5205a72b6edSBrian Somers     queued = r ? bundle_FillQueues(bundle) : ip_QueueLen(&bundle->ncp.ipcp);
52104eaa58cSBrian Somers     if (bundle->autoload.running) {
52204eaa58cSBrian Somers       if (queued < bundle->cfg.autoload.max.packets) {
52304eaa58cSBrian Somers         if (queued > bundle->cfg.autoload.min.packets)
52404eaa58cSBrian Somers           bundle_StopAutoLoadTimer(bundle);
52504eaa58cSBrian Somers         else if (bundle->autoload.timer.state != TIMER_RUNNING ||
52604eaa58cSBrian Somers                  bundle->autoload.comingup)
52704eaa58cSBrian Somers           bundle_StartAutoLoadTimer(bundle, 0);
52804eaa58cSBrian Somers       } else if (bundle->autoload.timer.state != TIMER_RUNNING ||
52904eaa58cSBrian Somers                  !bundle->autoload.comingup)
53004eaa58cSBrian Somers         bundle_StartAutoLoadTimer(bundle, 1);
53104eaa58cSBrian Somers     }
53204eaa58cSBrian Somers 
533ff0f9439SBrian Somers     if (r && (bundle->phase == PHASE_NETWORK ||
534ff0f9439SBrian Somers               bundle->phys_type.all & PHYS_AUTO)) {
53504eaa58cSBrian Somers       /* enough surplus so that we can tell if we're getting swamped */
53604eaa58cSBrian Somers       want = bundle->cfg.autoload.max.packets + nlinks * 2;
53704eaa58cSBrian Somers       /* but at least 20 packets ! */
53804eaa58cSBrian Somers       if (want < 20)
53904eaa58cSBrian Somers         want = 20;
54004eaa58cSBrian Somers       if (queued < want) {
54104eaa58cSBrian Somers         /* Not enough - select() for more */
5426f8e9f0aSBrian Somers         if (bundle->choked.timer.state == TIMER_RUNNING)
5436f8e9f0aSBrian Somers           timer_Stop(&bundle->choked.timer);	/* Not needed any more */
54404eaa58cSBrian Somers         FD_SET(bundle->dev.fd, r);
545faefde08SBrian Somers         if (*n < bundle->dev.fd + 1)
546faefde08SBrian Somers           *n = bundle->dev.fd + 1;
5471384bd27SBrian Somers         log_Printf(LogTIMER, "%s: fdset(r) %d\n", TUN_NAME, bundle->dev.fd);
548078c562eSBrian Somers         result++;
5496f8e9f0aSBrian Somers       } else if (bundle->choked.timer.state == TIMER_STOPPED) {
5506f8e9f0aSBrian Somers         bundle->choked.timer.func = bundle_ClearQueues;
5516f8e9f0aSBrian Somers         bundle->choked.timer.name = "output choke";
5526f8e9f0aSBrian Somers         bundle->choked.timer.load = bundle->cfg.choked.timeout * SECTICKS;
5536f8e9f0aSBrian Somers         bundle->choked.timer.arg = bundle;
5546f8e9f0aSBrian Somers         timer_Start(&bundle->choked.timer);
555078c562eSBrian Somers       }
55604eaa58cSBrian Somers     }
55704eaa58cSBrian Somers   }
558078c562eSBrian Somers 
55971555108SBrian Somers   /* Which links need a select() ? */
56071555108SBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
56171555108SBrian Somers     result += descriptor_UpdateSet(&dl->desc, r, w, e, n);
56271555108SBrian Somers 
563ea722969SBrian Somers   /*
564ea722969SBrian Somers    * This *MUST* be called after the datalink UpdateSet()s as it
56504eaa58cSBrian Somers    * might be ``holding'' one of the datalinks (death-row) and
56604eaa58cSBrian Somers    * wants to be able to de-select() it from the descriptor set.
567ea722969SBrian Somers    */
5680f2f3eb3SBrian Somers   result += descriptor_UpdateSet(&bundle->ncp.mp.server.desc, r, w, e, n);
569ea722969SBrian Somers 
5702f786681SBrian Somers   return result;
5712f786681SBrian Somers }
5722f786681SBrian Somers 
5732f786681SBrian Somers static int
5742f786681SBrian Somers bundle_IsSet(struct descriptor *d, const fd_set *fdset)
5752f786681SBrian Somers {
5762f786681SBrian Somers   struct bundle *bundle = descriptor2bundle(d);
5772f786681SBrian Somers   struct datalink *dl;
5782f786681SBrian Somers 
5792f786681SBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
5802f786681SBrian Somers     if (descriptor_IsSet(&dl->desc, fdset))
5812f786681SBrian Somers       return 1;
5822f786681SBrian Somers 
583332b9de0SBrian Somers   if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset))
584332b9de0SBrian Somers     return 1;
585332b9de0SBrian Somers 
586faefde08SBrian Somers   return FD_ISSET(bundle->dev.fd, fdset);
5872f786681SBrian Somers }
5882f786681SBrian Somers 
5892f786681SBrian Somers static void
5902f786681SBrian Somers bundle_DescriptorRead(struct descriptor *d, struct bundle *bundle,
5912f786681SBrian Somers                       const fd_set *fdset)
5922f786681SBrian Somers {
5932f786681SBrian Somers   struct datalink *dl;
5942f786681SBrian Somers 
595ea722969SBrian Somers   if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset))
596ea722969SBrian Somers     descriptor_Read(&bundle->ncp.mp.server.desc, bundle, fdset);
597ea722969SBrian Somers 
5982f786681SBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
5992f786681SBrian Somers     if (descriptor_IsSet(&dl->desc, fdset))
6002f786681SBrian Somers       descriptor_Read(&dl->desc, bundle, fdset);
601b6217683SBrian Somers 
602faefde08SBrian Somers   if (FD_ISSET(bundle->dev.fd, fdset)) {
603078c562eSBrian Somers     struct tun_data tun;
604078c562eSBrian Somers     int n, pri;
605078c562eSBrian Somers 
606078c562eSBrian Somers     /* something to read from tun */
607faefde08SBrian Somers     n = read(bundle->dev.fd, &tun, sizeof tun);
608078c562eSBrian Somers     if (n < 0) {
609a33b2ef7SBrian Somers       log_Printf(LogWARN, "read from %s: %s\n", TUN_NAME, strerror(errno));
610078c562eSBrian Somers       return;
611078c562eSBrian Somers     }
612078c562eSBrian Somers     n -= sizeof tun - sizeof tun.data;
613078c562eSBrian Somers     if (n <= 0) {
614a33b2ef7SBrian Somers       log_Printf(LogERROR, "read from %s: Only %d bytes read ?\n", TUN_NAME, n);
615078c562eSBrian Somers       return;
616078c562eSBrian Somers     }
617078c562eSBrian Somers     if (!tun_check_header(tun, AF_INET))
618078c562eSBrian Somers       return;
619078c562eSBrian Somers 
620078c562eSBrian Somers     if (((struct ip *)tun.data)->ip_dst.s_addr ==
621078c562eSBrian Somers         bundle->ncp.ipcp.my_ip.s_addr) {
622078c562eSBrian Somers       /* we've been asked to send something addressed *to* us :( */
623078c562eSBrian Somers       if (Enabled(bundle, OPT_LOOPBACK)) {
624078c562eSBrian Somers         pri = PacketCheck(bundle, tun.data, n, &bundle->filter.in);
625078c562eSBrian Somers         if (pri >= 0) {
626078c562eSBrian Somers           struct mbuf *bp;
627078c562eSBrian Somers 
628078c562eSBrian Somers #ifndef NOALIAS
629615ad4f9SBrian Somers           if (bundle->AliasEnabled) {
630615ad4f9SBrian Somers             PacketAliasIn(tun.data, sizeof tun.data);
631078c562eSBrian Somers             n = ntohs(((struct ip *)tun.data)->ip_len);
632078c562eSBrian Somers           }
633078c562eSBrian Somers #endif
634078c562eSBrian Somers           bp = mbuf_Alloc(n, MB_IPIN);
635078c562eSBrian Somers           memcpy(MBUF_CTOP(bp), tun.data, n);
636078c562eSBrian Somers           ip_Input(bundle, bp);
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);
668078c562eSBrian Somers     if (pri >= 0) {
669078c562eSBrian Somers #ifndef NOALIAS
670615ad4f9SBrian Somers       if (bundle->AliasEnabled) {
671615ad4f9SBrian Somers         PacketAliasOut(tun.data, sizeof tun.data);
672078c562eSBrian Somers         n = ntohs(((struct ip *)tun.data)->ip_len);
673078c562eSBrian Somers       }
674078c562eSBrian Somers #endif
6755a72b6edSBrian Somers       ip_Enqueue(&bundle->ncp.ipcp, pri, tun.data, n);
676078c562eSBrian Somers     }
677078c562eSBrian Somers   }
6782f786681SBrian Somers }
6792f786681SBrian Somers 
6801af29a6eSBrian Somers static int
6812f786681SBrian Somers bundle_DescriptorWrite(struct descriptor *d, struct bundle *bundle,
6822f786681SBrian Somers                        const fd_set *fdset)
6832f786681SBrian Somers {
6842f786681SBrian Somers   struct datalink *dl;
6851af29a6eSBrian Somers   int result = 0;
6862f786681SBrian Somers 
687ea722969SBrian Somers   /* This is not actually necessary as struct mpserver doesn't Write() */
688ea722969SBrian Somers   if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset))
689ea722969SBrian Somers     descriptor_Write(&bundle->ncp.mp.server.desc, bundle, fdset);
690ea722969SBrian Somers 
6912f786681SBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
6922f786681SBrian Somers     if (descriptor_IsSet(&dl->desc, fdset))
6931af29a6eSBrian Somers       result += descriptor_Write(&dl->desc, bundle, fdset);
6941af29a6eSBrian Somers 
6951af29a6eSBrian Somers   return result;
6962f786681SBrian Somers }
6972f786681SBrian Somers 
698da66dd13SBrian Somers void
6991384bd27SBrian Somers bundle_LockTun(struct bundle *bundle)
7001384bd27SBrian Somers {
7011384bd27SBrian Somers   FILE *lockfile;
7021384bd27SBrian Somers   char pidfile[MAXPATHLEN];
7031384bd27SBrian Somers 
7041384bd27SBrian Somers   snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit);
7051384bd27SBrian Somers   lockfile = ID0fopen(pidfile, "w");
7061384bd27SBrian Somers   if (lockfile != NULL) {
7071384bd27SBrian Somers     fprintf(lockfile, "%d\n", (int)getpid());
7081384bd27SBrian Somers     fclose(lockfile);
7091384bd27SBrian Somers   }
7101384bd27SBrian Somers #ifndef RELEASE_CRUNCH
7111384bd27SBrian Somers   else
7121384bd27SBrian Somers     log_Printf(LogERROR, "Warning: Can't create %s: %s\n",
7131384bd27SBrian Somers                pidfile, strerror(errno));
7141384bd27SBrian Somers #endif
7151384bd27SBrian Somers }
7161384bd27SBrian Somers 
7171384bd27SBrian Somers static void
7181384bd27SBrian Somers bundle_UnlockTun(struct bundle *bundle)
7191384bd27SBrian Somers {
7201384bd27SBrian Somers   char pidfile[MAXPATHLEN];
7211384bd27SBrian Somers 
7221384bd27SBrian Somers   snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit);
7231384bd27SBrian Somers   ID0unlink(pidfile);
7241384bd27SBrian Somers }
7257a6f8720SBrian Somers 
7267a6f8720SBrian Somers struct bundle *
7278e7b8599SBrian Somers bundle_Create(const char *prefix, int type, const char **argv)
7287a6f8720SBrian Somers {
7297a6f8720SBrian Somers   int s, enoentcount, err;
7308fa6ebe4SBrian Somers   const char *ifname;
7317a6f8720SBrian Somers   struct ifreq ifrq;
7327a6f8720SBrian Somers   static struct bundle bundle;		/* there can be only one */
7337a6f8720SBrian Somers 
7348fa6ebe4SBrian Somers   if (bundle.iface != NULL) {	/* Already allocated ! */
735a33b2ef7SBrian Somers     log_Printf(LogALERT, "bundle_Create:  There's only one BUNDLE !\n");
7367a6f8720SBrian Somers     return NULL;
7377a6f8720SBrian Somers   }
7387a6f8720SBrian Somers 
7397a6f8720SBrian Somers   err = ENOENT;
7407a6f8720SBrian Somers   enoentcount = 0;
741107d62e7SBrian Somers   for (bundle.unit = 0; ; bundle.unit++) {
742faefde08SBrian Somers     snprintf(bundle.dev.Name, sizeof bundle.dev.Name, "%s%d",
743faefde08SBrian Somers              prefix, bundle.unit);
744faefde08SBrian Somers     bundle.dev.fd = ID0open(bundle.dev.Name, O_RDWR);
745faefde08SBrian Somers     if (bundle.dev.fd >= 0)
7467a6f8720SBrian Somers       break;
747107d62e7SBrian Somers     else if (errno == ENXIO) {
7487a6f8720SBrian Somers       err = errno;
749107d62e7SBrian Somers       break;
7507a6f8720SBrian Somers     } else if (errno == ENOENT) {
7517a6f8720SBrian Somers       if (++enoentcount > 2)
752107d62e7SBrian Somers 	break;
7537a6f8720SBrian Somers     } else
7547a6f8720SBrian Somers       err = errno;
7557a6f8720SBrian Somers   }
7567a6f8720SBrian Somers 
757faefde08SBrian Somers   if (bundle.dev.fd < 0) {
758dd7e2610SBrian Somers     log_Printf(LogWARN, "No available tunnel devices found (%s).\n",
75985b542cfSBrian Somers               strerror(err));
7607a6f8720SBrian Somers     return NULL;
7617a6f8720SBrian Somers   }
7627a6f8720SBrian Somers 
763dd7e2610SBrian Somers   log_SetTun(bundle.unit);
7648e7b8599SBrian Somers   bundle.argv = argv;
7657a6f8720SBrian Somers 
7667a6f8720SBrian Somers   s = socket(AF_INET, SOCK_DGRAM, 0);
7677a6f8720SBrian Somers   if (s < 0) {
768dd7e2610SBrian Somers     log_Printf(LogERROR, "bundle_Create: socket(): %s\n", strerror(errno));
769faefde08SBrian Somers     close(bundle.dev.fd);
7707a6f8720SBrian Somers     return NULL;
7717a6f8720SBrian Somers   }
7727a6f8720SBrian Somers 
7738fa6ebe4SBrian Somers   ifname = strrchr(bundle.dev.Name, '/');
7748fa6ebe4SBrian Somers   if (ifname == NULL)
7758fa6ebe4SBrian Somers     ifname = bundle.dev.Name;
7767a6f8720SBrian Somers   else
7778fa6ebe4SBrian Somers     ifname++;
7788fa6ebe4SBrian Somers 
7798fa6ebe4SBrian Somers   bundle.iface = iface_Create(ifname);
7808fa6ebe4SBrian Somers   if (bundle.iface == NULL) {
7818fa6ebe4SBrian Somers     close(s);
7828fa6ebe4SBrian Somers     close(bundle.dev.fd);
7838fa6ebe4SBrian Somers     return NULL;
7848fa6ebe4SBrian Somers   }
7857a6f8720SBrian Somers 
7867a6f8720SBrian Somers   /*
7877a6f8720SBrian Somers    * Now, bring up the interface.
7887a6f8720SBrian Somers    */
7897a6f8720SBrian Somers   memset(&ifrq, '\0', sizeof ifrq);
7908fa6ebe4SBrian Somers   strncpy(ifrq.ifr_name, ifname, sizeof ifrq.ifr_name - 1);
7917a6f8720SBrian Somers   ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0';
7927a6f8720SBrian Somers   if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) {
793a33b2ef7SBrian Somers     log_Printf(LogERROR, "bundle_Create: ioctl(SIOCGIFFLAGS): %s\n",
7947a6f8720SBrian Somers 	      strerror(errno));
7957a6f8720SBrian Somers     close(s);
7968fa6ebe4SBrian Somers     iface_Destroy(bundle.iface);
7978fa6ebe4SBrian Somers     bundle.iface = NULL;
798faefde08SBrian Somers     close(bundle.dev.fd);
7997a6f8720SBrian Somers     return NULL;
8007a6f8720SBrian Somers   }
8017a6f8720SBrian Somers   ifrq.ifr_flags |= IFF_UP;
8027a6f8720SBrian Somers   if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) {
803a33b2ef7SBrian Somers     log_Printf(LogERROR, "bundle_Create: ioctl(SIOCSIFFLAGS): %s\n",
8047a6f8720SBrian Somers 	      strerror(errno));
8057a6f8720SBrian Somers     close(s);
8068fa6ebe4SBrian Somers     iface_Destroy(bundle.iface);
8078fa6ebe4SBrian Somers     bundle.iface = NULL;
808faefde08SBrian Somers     close(bundle.dev.fd);
8097a6f8720SBrian Somers     return NULL;
8107a6f8720SBrian Somers   }
8117a6f8720SBrian Somers 
8127a6f8720SBrian Somers   close(s);
8137a6f8720SBrian Somers 
8148fa6ebe4SBrian Somers   log_Printf(LogPHASE, "Using interface: %s\n", ifname);
8157a6f8720SBrian Somers 
8168fa6ebe4SBrian Somers   bundle.ifSpeed = 0;
8177a6f8720SBrian Somers 
818820de6ebSBrian Somers   bundle.routing_seq = 0;
819a0cbd833SBrian Somers   bundle.phase = PHASE_DEAD;
820a0cbd833SBrian Somers   bundle.CleaningUp = 0;
821615ad4f9SBrian Somers   bundle.AliasEnabled = 0;
8227a6f8720SBrian Somers 
8236d666775SBrian Somers   bundle.fsm.LayerStart = bundle_LayerStart;
8246f384573SBrian Somers   bundle.fsm.LayerUp = bundle_LayerUp;
8256d666775SBrian Somers   bundle.fsm.LayerDown = bundle_LayerDown;
8266d666775SBrian Somers   bundle.fsm.LayerFinish = bundle_LayerFinish;
8276d666775SBrian Somers   bundle.fsm.object = &bundle;
8287a6f8720SBrian Somers 
829ab886ad0SBrian Somers   bundle.cfg.idle_timeout = NCP_IDLE_TIMEOUT;
8301342caedSBrian Somers   *bundle.cfg.auth.name = '\0';
8311342caedSBrian Somers   *bundle.cfg.auth.key = '\0';
832610b185fSBrian Somers   bundle.cfg.opt = OPT_SROUTES | OPT_IDCHECK | OPT_LOOPBACK |
833610b185fSBrian Somers                    OPT_THROUGHPUT | OPT_UTMP;
83449052c95SBrian Somers   *bundle.cfg.label = '\0';
83549052c95SBrian Somers   bundle.cfg.mtu = DEF_MTU;
83604eaa58cSBrian Somers   bundle.cfg.autoload.max.packets = 0;
83704eaa58cSBrian Somers   bundle.cfg.autoload.max.timeout = 0;
83804eaa58cSBrian Somers   bundle.cfg.autoload.min.packets = 0;
83904eaa58cSBrian Somers   bundle.cfg.autoload.min.timeout = 0;
8406f8e9f0aSBrian Somers   bundle.cfg.choked.timeout = CHOKED_TIMEOUT;
841ff0f9439SBrian Somers   bundle.phys_type.all = type;
842ff0f9439SBrian Somers   bundle.phys_type.open = 0;
843ab886ad0SBrian Somers 
8446f384573SBrian Somers   bundle.links = datalink_Create("deflink", &bundle, type);
8453006ec67SBrian Somers   if (bundle.links == NULL) {
846a33b2ef7SBrian Somers     log_Printf(LogALERT, "Cannot create data link: %s\n", strerror(errno));
8478fa6ebe4SBrian Somers     iface_Destroy(bundle.iface);
8488fa6ebe4SBrian Somers     bundle.iface = NULL;
849faefde08SBrian Somers     close(bundle.dev.fd);
8502289f246SBrian Somers     return NULL;
8512289f246SBrian Somers   }
8522289f246SBrian Somers 
8532f786681SBrian Somers   bundle.desc.type = BUNDLE_DESCRIPTOR;
8542f786681SBrian Somers   bundle.desc.UpdateSet = bundle_UpdateSet;
8552f786681SBrian Somers   bundle.desc.IsSet = bundle_IsSet;
8562f786681SBrian Somers   bundle.desc.Read = bundle_DescriptorRead;
8572f786681SBrian Somers   bundle.desc.Write = bundle_DescriptorWrite;
8582f786681SBrian Somers 
85949052c95SBrian Somers   mp_Init(&bundle.ncp.mp, &bundle);
86049052c95SBrian Somers 
86149052c95SBrian Somers   /* Send over the first physical link by default */
8625828db6dSBrian Somers   ipcp_Init(&bundle.ncp.ipcp, &bundle, &bundle.links->physical->link,
8635828db6dSBrian Somers             &bundle.fsm);
8646d666775SBrian Somers 
8655ca5389aSBrian Somers   memset(&bundle.filter, '\0', sizeof bundle.filter);
8665ca5389aSBrian Somers   bundle.filter.in.fragok = bundle.filter.in.logok = 1;
8675ca5389aSBrian Somers   bundle.filter.in.name = "IN";
8685ca5389aSBrian Somers   bundle.filter.out.fragok = bundle.filter.out.logok = 1;
8695ca5389aSBrian Somers   bundle.filter.out.name = "OUT";
8705ca5389aSBrian Somers   bundle.filter.dial.name = "DIAL";
8718390b576SBrian Somers   bundle.filter.dial.logok = 1;
8725ca5389aSBrian Somers   bundle.filter.alive.name = "ALIVE";
8735ca5389aSBrian Somers   bundle.filter.alive.logok = 1;
87493ee0ff2SBrian Somers   memset(&bundle.idle.timer, '\0', sizeof bundle.idle.timer);
87593ee0ff2SBrian Somers   bundle.idle.done = 0;
8765cf4388bSBrian Somers   bundle.notify.fd = -1;
87704eaa58cSBrian Somers   memset(&bundle.autoload.timer, '\0', sizeof bundle.autoload.timer);
87804eaa58cSBrian Somers   bundle.autoload.done = 0;
87904eaa58cSBrian Somers   bundle.autoload.running = 0;
8806f8e9f0aSBrian Somers   memset(&bundle.choked.timer, '\0', sizeof bundle.choked.timer);
88193ee0ff2SBrian Somers 
8826d666775SBrian Somers   /* Clean out any leftover crud */
8838fa6ebe4SBrian Somers   iface_Clear(bundle.iface, IFACE_CLEAR_ALL);
8846d666775SBrian Somers 
8851384bd27SBrian Somers   bundle_LockTun(&bundle);
8861384bd27SBrian Somers 
8877a6f8720SBrian Somers   return &bundle;
8887a6f8720SBrian Somers }
8897a6f8720SBrian Somers 
89068a0f0ccSBrian Somers static void
89168a0f0ccSBrian Somers bundle_DownInterface(struct bundle *bundle)
89268a0f0ccSBrian Somers {
89368a0f0ccSBrian Somers   struct ifreq ifrq;
89468a0f0ccSBrian Somers   int s;
89568a0f0ccSBrian Somers 
896dd7e2610SBrian Somers   route_IfDelete(bundle, 1);
89768a0f0ccSBrian Somers 
89868a0f0ccSBrian Somers   s = ID0socket(AF_INET, SOCK_DGRAM, 0);
89968a0f0ccSBrian Somers   if (s < 0) {
900dd7e2610SBrian Somers     log_Printf(LogERROR, "bundle_DownInterface: socket: %s\n", strerror(errno));
90168a0f0ccSBrian Somers     return;
90268a0f0ccSBrian Somers   }
90368a0f0ccSBrian Somers 
90468a0f0ccSBrian Somers   memset(&ifrq, '\0', sizeof ifrq);
9058fa6ebe4SBrian Somers   strncpy(ifrq.ifr_name, bundle->iface->name, sizeof ifrq.ifr_name - 1);
90668a0f0ccSBrian Somers   ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0';
90768a0f0ccSBrian Somers   if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) {
908dd7e2610SBrian Somers     log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCGIFFLAGS): %s\n",
90968a0f0ccSBrian Somers        strerror(errno));
91068a0f0ccSBrian Somers     close(s);
91168a0f0ccSBrian Somers     return;
91268a0f0ccSBrian Somers   }
91368a0f0ccSBrian Somers   ifrq.ifr_flags &= ~IFF_UP;
91468a0f0ccSBrian Somers   if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) {
915dd7e2610SBrian Somers     log_Printf(LogERROR, "bundle_DownInterface: ioctl(SIOCSIFFLAGS): %s\n",
91668a0f0ccSBrian Somers        strerror(errno));
91768a0f0ccSBrian Somers     close(s);
91868a0f0ccSBrian Somers     return;
91968a0f0ccSBrian Somers   }
92068a0f0ccSBrian Somers   close(s);
92168a0f0ccSBrian Somers }
92268a0f0ccSBrian Somers 
92368a0f0ccSBrian Somers void
92468a0f0ccSBrian Somers bundle_Destroy(struct bundle *bundle)
92568a0f0ccSBrian Somers {
9263006ec67SBrian Somers   struct datalink *dl;
927b6217683SBrian Somers 
928ea722969SBrian Somers   /*
92904eaa58cSBrian Somers    * Clean up the interface.  We don't need to timer_Stop()s, mp_Down(),
930ea722969SBrian Somers    * ipcp_CleanInterface() and bundle_DownInterface() unless we're getting
931ea722969SBrian Somers    * out under exceptional conditions such as a descriptor exception.
932ea722969SBrian Somers    */
93304eaa58cSBrian Somers   timer_Stop(&bundle->idle.timer);
9346f8e9f0aSBrian Somers   timer_Stop(&bundle->choked.timer);
93504eaa58cSBrian Somers   timer_Stop(&bundle->autoload.timer);
93666f634b6SBrian Somers   mp_Down(&bundle->ncp.mp);
937dd7e2610SBrian Somers   ipcp_CleanInterface(&bundle->ncp.ipcp);
93868a0f0ccSBrian Somers   bundle_DownInterface(bundle);
9393006ec67SBrian Somers 
940ea722969SBrian Somers   /* Again, these are all DATALINK_CLOSED unless we're abending */
9413006ec67SBrian Somers   dl = bundle->links;
9423006ec67SBrian Somers   while (dl)
9433006ec67SBrian Somers     dl = datalink_Destroy(dl);
9443006ec67SBrian Somers 
9451384bd27SBrian Somers   close(bundle->dev.fd);
9461384bd27SBrian Somers   bundle_UnlockTun(bundle);
9471384bd27SBrian Somers 
948ea722969SBrian Somers   /* In case we never made PHASE_NETWORK */
9495cf4388bSBrian Somers   bundle_Notify(bundle, EX_ERRDEAD);
950b6217683SBrian Somers 
9518fa6ebe4SBrian Somers   iface_Destroy(bundle->iface);
9528fa6ebe4SBrian Somers   bundle->iface = NULL;
95368a0f0ccSBrian Somers }
95468a0f0ccSBrian Somers 
9557a6f8720SBrian Somers struct rtmsg {
9567a6f8720SBrian Somers   struct rt_msghdr m_rtm;
9577a6f8720SBrian Somers   char m_space[64];
9587a6f8720SBrian Somers };
9597a6f8720SBrian Somers 
960610b185fSBrian Somers int
961820de6ebSBrian Somers bundle_SetRoute(struct bundle *bundle, int cmd, struct in_addr dst,
9622062443fSBrian Somers                 struct in_addr gateway, struct in_addr mask, int bang, int ssh)
9637a6f8720SBrian Somers {
9647a6f8720SBrian Somers   struct rtmsg rtmes;
9657a6f8720SBrian Somers   int s, nb, wb;
9667a6f8720SBrian Somers   char *cp;
9677a6f8720SBrian Somers   const char *cmdstr;
9687a6f8720SBrian Somers   struct sockaddr_in rtdata;
969610b185fSBrian Somers   int result = 1;
9707a6f8720SBrian Somers 
9717a6f8720SBrian Somers   if (bang)
9727a6f8720SBrian Somers     cmdstr = (cmd == RTM_ADD ? "Add!" : "Delete!");
9737a6f8720SBrian Somers   else
9747a6f8720SBrian Somers     cmdstr = (cmd == RTM_ADD ? "Add" : "Delete");
9757a6f8720SBrian Somers   s = ID0socket(PF_ROUTE, SOCK_RAW, 0);
9767a6f8720SBrian Somers   if (s < 0) {
977dd7e2610SBrian Somers     log_Printf(LogERROR, "bundle_SetRoute: socket(): %s\n", strerror(errno));
978610b185fSBrian Somers     return result;
9797a6f8720SBrian Somers   }
9807a6f8720SBrian Somers   memset(&rtmes, '\0', sizeof rtmes);
9817a6f8720SBrian Somers   rtmes.m_rtm.rtm_version = RTM_VERSION;
9827a6f8720SBrian Somers   rtmes.m_rtm.rtm_type = cmd;
9837a6f8720SBrian Somers   rtmes.m_rtm.rtm_addrs = RTA_DST;
984820de6ebSBrian Somers   rtmes.m_rtm.rtm_seq = ++bundle->routing_seq;
9857a6f8720SBrian Somers   rtmes.m_rtm.rtm_pid = getpid();
9867a6f8720SBrian Somers   rtmes.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC;
9877a6f8720SBrian Somers 
9887a6f8720SBrian Somers   memset(&rtdata, '\0', sizeof rtdata);
98950e5c17dSBrian Somers   rtdata.sin_len = sizeof rtdata;
9907a6f8720SBrian Somers   rtdata.sin_family = AF_INET;
9917a6f8720SBrian Somers   rtdata.sin_port = 0;
9927a6f8720SBrian Somers   rtdata.sin_addr = dst;
9937a6f8720SBrian Somers 
9947a6f8720SBrian Somers   cp = rtmes.m_space;
99550e5c17dSBrian Somers   memcpy(cp, &rtdata, rtdata.sin_len);
99650e5c17dSBrian Somers   cp += rtdata.sin_len;
997e43ebac1SBrian Somers   if (cmd == RTM_ADD) {
9987a6f8720SBrian Somers     if (gateway.s_addr == INADDR_ANY) {
9998fa6ebe4SBrian Somers       log_Printf(LogERROR, "bundle_SetRoute: Cannot add a route with"
10008fa6ebe4SBrian Somers                  " destination 0.0.0.0\n");
10018fa6ebe4SBrian Somers       close(s);
10028fa6ebe4SBrian Somers       return result;
10037a6f8720SBrian Somers     } else {
10047a6f8720SBrian Somers       rtdata.sin_addr = gateway;
100550e5c17dSBrian Somers       memcpy(cp, &rtdata, rtdata.sin_len);
100650e5c17dSBrian Somers       cp += rtdata.sin_len;
10077a6f8720SBrian Somers       rtmes.m_rtm.rtm_addrs |= RTA_GATEWAY;
10087a6f8720SBrian Somers     }
1009e43ebac1SBrian Somers   }
10107a6f8720SBrian Somers 
10117a6f8720SBrian Somers   if (dst.s_addr == INADDR_ANY)
10127a6f8720SBrian Somers     mask.s_addr = INADDR_ANY;
10137a6f8720SBrian Somers 
10147a6f8720SBrian Somers   if (cmd == RTM_ADD || dst.s_addr == INADDR_ANY) {
10157a6f8720SBrian Somers     rtdata.sin_addr = mask;
101650e5c17dSBrian Somers     memcpy(cp, &rtdata, rtdata.sin_len);
101750e5c17dSBrian Somers     cp += rtdata.sin_len;
10187a6f8720SBrian Somers     rtmes.m_rtm.rtm_addrs |= RTA_NETMASK;
10197a6f8720SBrian Somers   }
10207a6f8720SBrian Somers 
10217a6f8720SBrian Somers   nb = cp - (char *) &rtmes;
10227a6f8720SBrian Somers   rtmes.m_rtm.rtm_msglen = nb;
10237a6f8720SBrian Somers   wb = ID0write(s, &rtmes, nb);
10247a6f8720SBrian Somers   if (wb < 0) {
1025dd7e2610SBrian Somers     log_Printf(LogTCPIP, "bundle_SetRoute failure:\n");
1026dd7e2610SBrian Somers     log_Printf(LogTCPIP, "bundle_SetRoute:  Cmd = %s\n", cmdstr);
1027dd7e2610SBrian Somers     log_Printf(LogTCPIP, "bundle_SetRoute:  Dst = %s\n", inet_ntoa(dst));
1028dd7e2610SBrian Somers     log_Printf(LogTCPIP, "bundle_SetRoute:  Gateway = %s\n", inet_ntoa(gateway));
1029dd7e2610SBrian Somers     log_Printf(LogTCPIP, "bundle_SetRoute:  Mask = %s\n", inet_ntoa(mask));
10307a6f8720SBrian Somers failed:
10317a6f8720SBrian Somers     if (cmd == RTM_ADD && (rtmes.m_rtm.rtm_errno == EEXIST ||
1032e43ebac1SBrian Somers                            (rtmes.m_rtm.rtm_errno == 0 && errno == EEXIST))) {
1033610b185fSBrian Somers       if (!bang) {
1034dd7e2610SBrian Somers         log_Printf(LogWARN, "Add route failed: %s already exists\n",
10357a6f8720SBrian Somers                   inet_ntoa(dst));
1036610b185fSBrian Somers         result = 0;	/* Don't add to our dynamic list */
1037610b185fSBrian Somers       } else {
10387a6f8720SBrian Somers         rtmes.m_rtm.rtm_type = cmd = RTM_CHANGE;
10397a6f8720SBrian Somers         if ((wb = ID0write(s, &rtmes, nb)) < 0)
10407a6f8720SBrian Somers           goto failed;
10417a6f8720SBrian Somers       }
1042e43ebac1SBrian Somers     } else if (cmd == RTM_DELETE &&
10437a6f8720SBrian Somers              (rtmes.m_rtm.rtm_errno == ESRCH ||
10447a6f8720SBrian Somers               (rtmes.m_rtm.rtm_errno == 0 && errno == ESRCH))) {
10457a6f8720SBrian Somers       if (!bang)
1046dd7e2610SBrian Somers         log_Printf(LogWARN, "Del route failed: %s: Non-existent\n",
10477a6f8720SBrian Somers                   inet_ntoa(dst));
10482062443fSBrian Somers     } else if (rtmes.m_rtm.rtm_errno == 0) {
10492062443fSBrian Somers       if (!ssh || errno != ENETUNREACH)
1050dd7e2610SBrian Somers         log_Printf(LogWARN, "%s route failed: %s: errno: %s\n", cmdstr,
10517a6f8720SBrian Somers                    inet_ntoa(dst), strerror(errno));
10522062443fSBrian Somers     } else
1053dd7e2610SBrian Somers       log_Printf(LogWARN, "%s route failed: %s: %s\n",
10547a6f8720SBrian Somers 		 cmdstr, inet_ntoa(dst), strerror(rtmes.m_rtm.rtm_errno));
10557a6f8720SBrian Somers   }
1056dd7e2610SBrian Somers   log_Printf(LogDEBUG, "wrote %d: cmd = %s, dst = %x, gateway = %x\n",
1057fe3125a0SBrian Somers             wb, cmdstr, (unsigned)dst.s_addr, (unsigned)gateway.s_addr);
10587a6f8720SBrian Somers   close(s);
1059610b185fSBrian Somers 
1060610b185fSBrian Somers   return result;
10617a6f8720SBrian Somers }
106283d1af55SBrian Somers 
106383d1af55SBrian Somers void
10643006ec67SBrian Somers bundle_LinkClosed(struct bundle *bundle, struct datalink *dl)
10653006ec67SBrian Somers {
10663006ec67SBrian Somers   /*
10673006ec67SBrian Somers    * Our datalink has closed.
1068ea722969SBrian Somers    * CleanDatalinks() (called from DoLoop()) will remove closed
106981358fa3SBrian Somers    * BACKGROUND and DIRECT links.
10703b0f8d2eSBrian Somers    * If it's the last data link, enter phase DEAD.
1071ea722969SBrian Somers    *
1072ea722969SBrian Somers    * NOTE: dl may not be in our list (bundle_SendDatalink()) !
10733006ec67SBrian Somers    */
10745b8b8060SBrian Somers 
10753b0f8d2eSBrian Somers   struct datalink *odl;
10763b0f8d2eSBrian Somers   int other_links;
10775b8b8060SBrian Somers 
1078bf1d3ff6SBrian Somers   log_SetTtyCommandMode(dl);
1079bf1d3ff6SBrian Somers 
10803b0f8d2eSBrian Somers   other_links = 0;
10813b0f8d2eSBrian Somers   for (odl = bundle->links; odl; odl = odl->next)
10823b0f8d2eSBrian Somers     if (odl != dl && odl->state != DATALINK_CLOSED)
10833b0f8d2eSBrian Somers       other_links++;
10843b0f8d2eSBrian Somers 
10853b0f8d2eSBrian Somers   if (!other_links) {
108681358fa3SBrian Somers     if (dl->physical->type != PHYS_AUTO)	/* Not in -auto mode */
108703704096SBrian Somers       bundle_DownInterface(bundle);
108809206a6fSBrian Somers     fsm2initial(&bundle->ncp.ipcp.fsm);
10895563ebdeSBrian Somers     bundle_NewPhase(bundle, PHASE_DEAD);
10900f2f3eb3SBrian Somers     bundle_StopIdleTimer(bundle);
109104eaa58cSBrian Somers     bundle_StopAutoLoadTimer(bundle);
109204eaa58cSBrian Somers     bundle->autoload.running = 0;
109304eaa58cSBrian Somers   } else
109404eaa58cSBrian Somers     bundle->autoload.running = 1;
1095455aabc3SBrian Somers }
1096455aabc3SBrian Somers 
1097455aabc3SBrian Somers void
1098ba23f397SBrian Somers bundle_Open(struct bundle *bundle, const char *name, int mask, int force)
10993006ec67SBrian Somers {
11003006ec67SBrian Somers   /*
11013006ec67SBrian Somers    * Please open the given datalink, or all if name == NULL
11023006ec67SBrian Somers    */
11033006ec67SBrian Somers   struct datalink *dl;
11043006ec67SBrian Somers 
110504eaa58cSBrian Somers   timer_Stop(&bundle->autoload.timer);
11063006ec67SBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
11073006ec67SBrian Somers     if (name == NULL || !strcasecmp(dl->name, name)) {
1108ba23f397SBrian Somers       if ((mask & dl->physical->type) &&
1109ba23f397SBrian Somers           (dl->state == DATALINK_CLOSED ||
1110ba23f397SBrian Somers            (force && dl->state == DATALINK_OPENING &&
1111ba23f397SBrian Somers             dl->dial_timer.state == TIMER_RUNNING))) {
1112ba23f397SBrian Somers         if (force)
1113ba23f397SBrian Somers           timer_Stop(&dl->dial_timer);
1114565e35e5SBrian Somers         datalink_Up(dl, 1, 1);
111581358fa3SBrian Somers         if (mask == PHYS_AUTO)
111681358fa3SBrian Somers           /* Only one AUTO link at a time (see the AutoLoad timer) */
111704eaa58cSBrian Somers           break;
111804eaa58cSBrian Somers       }
11193006ec67SBrian Somers       if (name != NULL)
11203006ec67SBrian Somers         break;
11213006ec67SBrian Somers     }
11223006ec67SBrian Somers }
11233006ec67SBrian Somers 
11243006ec67SBrian Somers struct datalink *
11253006ec67SBrian Somers bundle2datalink(struct bundle *bundle, const char *name)
11263006ec67SBrian Somers {
11273006ec67SBrian Somers   struct datalink *dl;
11283006ec67SBrian Somers 
11293006ec67SBrian Somers   if (name != NULL) {
11303006ec67SBrian Somers     for (dl = bundle->links; dl; dl = dl->next)
11313006ec67SBrian Somers       if (!strcasecmp(dl->name, name))
11323006ec67SBrian Somers         return dl;
11333006ec67SBrian Somers   } else if (bundle->links && !bundle->links->next)
11343006ec67SBrian Somers     return bundle->links;
11353006ec67SBrian Somers 
11363006ec67SBrian Somers   return NULL;
11373006ec67SBrian Somers }
11383006ec67SBrian Somers 
11393006ec67SBrian Somers int
11403006ec67SBrian Somers bundle_FillQueues(struct bundle *bundle)
11413006ec67SBrian Somers {
11423b0f8d2eSBrian Somers   int total;
11433b0f8d2eSBrian Somers 
11441bc9b5baSBrian Somers   if (bundle->ncp.mp.active)
11453b0f8d2eSBrian Somers     total = mp_FillQueues(bundle);
11461bc9b5baSBrian Somers   else {
11471bc9b5baSBrian Somers     struct datalink *dl;
11481bc9b5baSBrian Somers     int add;
11491bc9b5baSBrian Somers 
11501bc9b5baSBrian Somers     for (total = 0, dl = bundle->links; dl; dl = dl->next)
11511bc9b5baSBrian Somers       if (dl->state == DATALINK_OPEN) {
11521bc9b5baSBrian Somers         add = link_QueueLen(&dl->physical->link);
11531bc9b5baSBrian Somers         if (add == 0 && dl->physical->out == NULL)
11541bc9b5baSBrian Somers           add = ip_FlushPacket(&dl->physical->link, bundle);
11551bc9b5baSBrian Somers         total += add;
11561bc9b5baSBrian Somers       }
11573006ec67SBrian Somers   }
11583006ec67SBrian Somers 
11595a72b6edSBrian Somers   return total + ip_QueueLen(&bundle->ncp.ipcp);
11603006ec67SBrian Somers }
1161aef795ccSBrian Somers 
1162aef795ccSBrian Somers int
1163aef795ccSBrian Somers bundle_ShowLinks(struct cmdargs const *arg)
1164aef795ccSBrian Somers {
1165aef795ccSBrian Somers   struct datalink *dl;
1166aef795ccSBrian Somers 
11679c53a7b1SBrian Somers   for (dl = arg->bundle->links; dl; dl = dl->next) {
1168d4156d00SBrian Somers     prompt_Printf(arg->prompt, "Name: %s [%s, %s]",
1169d4156d00SBrian Somers                   dl->name, mode2Nam(dl->physical->type), datalink_State(dl));
1170eeab6bf5SBrian Somers     if (dl->physical->link.throughput.rolling && dl->state == DATALINK_OPEN)
1171d4156d00SBrian Somers       prompt_Printf(arg->prompt, " weight %d, %d bytes/sec",
1172eeab6bf5SBrian Somers                     dl->mp.weight,
11739c53a7b1SBrian Somers                     dl->physical->link.throughput.OctetsPerSecond);
11749c53a7b1SBrian Somers     prompt_Printf(arg->prompt, "\n");
11759c53a7b1SBrian Somers   }
1176aef795ccSBrian Somers 
1177aef795ccSBrian Somers   return 0;
1178aef795ccSBrian Somers }
1179ab886ad0SBrian Somers 
11801342caedSBrian Somers static const char *
11811342caedSBrian Somers optval(struct bundle *bundle, int bit)
11821342caedSBrian Somers {
11831342caedSBrian Somers   return (bundle->cfg.opt & bit) ? "enabled" : "disabled";
11841342caedSBrian Somers }
11851342caedSBrian Somers 
1186c08717dfSBrian Somers int
1187c08717dfSBrian Somers bundle_ShowStatus(struct cmdargs const *arg)
1188c08717dfSBrian Somers {
1189c08717dfSBrian Somers   int remaining;
1190c08717dfSBrian Somers 
1191c08717dfSBrian Somers   prompt_Printf(arg->prompt, "Phase %s\n", bundle_PhaseName(arg->bundle));
1192faefde08SBrian Somers   prompt_Printf(arg->prompt, " Device:        %s\n", arg->bundle->dev.Name);
1193faefde08SBrian Somers   prompt_Printf(arg->prompt, " Interface:     %s @ %lubps\n",
11948fa6ebe4SBrian Somers                 arg->bundle->iface->name, arg->bundle->ifSpeed);
1195c08717dfSBrian Somers 
1196c08717dfSBrian Somers   prompt_Printf(arg->prompt, "\nDefaults:\n");
1197643f4904SBrian Somers   prompt_Printf(arg->prompt, " Label:         %s\n", arg->bundle->cfg.label);
1198610b185fSBrian Somers   prompt_Printf(arg->prompt, " Auth name:     %s\n",
1199610b185fSBrian Somers                 arg->bundle->cfg.auth.name);
120004eaa58cSBrian Somers   prompt_Printf(arg->prompt, " Auto Load:     Up after %ds of >= %d packets\n",
120104eaa58cSBrian Somers                 arg->bundle->cfg.autoload.max.timeout,
120204eaa58cSBrian Somers                 arg->bundle->cfg.autoload.max.packets);
120304eaa58cSBrian Somers   prompt_Printf(arg->prompt, "                Down after %ds of <= %d"
120404eaa58cSBrian Somers                 " packets\n", arg->bundle->cfg.autoload.min.timeout,
120504eaa58cSBrian Somers                 arg->bundle->cfg.autoload.min.packets);
120604eaa58cSBrian Somers   if (arg->bundle->autoload.timer.state == TIMER_RUNNING)
120704eaa58cSBrian Somers     prompt_Printf(arg->prompt, "                %ds remaining 'till "
120804eaa58cSBrian Somers                   "a link comes %s\n",
120904eaa58cSBrian Somers                   bundle_RemainingAutoLoadTime(arg->bundle),
121004eaa58cSBrian Somers                   arg->bundle->autoload.comingup ? "up" : "down");
121104eaa58cSBrian Somers   else
121204eaa58cSBrian Somers     prompt_Printf(arg->prompt, "                %srunning with %d"
121304eaa58cSBrian Somers                   " packets queued\n", arg->bundle->autoload.running ?
12145a72b6edSBrian Somers                   "" : "not ", ip_QueueLen(&arg->bundle->ncp.ipcp));
121504eaa58cSBrian Somers 
12166f8e9f0aSBrian Somers   prompt_Printf(arg->prompt, " Choked Timer:  %ds\n",
12176f8e9f0aSBrian Somers                 arg->bundle->cfg.choked.timeout);
1218c08717dfSBrian Somers   prompt_Printf(arg->prompt, " Idle Timer:    ");
1219c08717dfSBrian Somers   if (arg->bundle->cfg.idle_timeout) {
1220c08717dfSBrian Somers     prompt_Printf(arg->prompt, "%ds", arg->bundle->cfg.idle_timeout);
1221c08717dfSBrian Somers     remaining = bundle_RemainingIdleTime(arg->bundle);
1222c08717dfSBrian Somers     if (remaining != -1)
1223c08717dfSBrian Somers       prompt_Printf(arg->prompt, " (%ds remaining)", remaining);
1224c08717dfSBrian Somers     prompt_Printf(arg->prompt, "\n");
1225c08717dfSBrian Somers   } else
1226c08717dfSBrian Somers     prompt_Printf(arg->prompt, "disabled\n");
1227ce828a6eSBrian Somers   prompt_Printf(arg->prompt, " MTU:           ");
1228ce828a6eSBrian Somers   if (arg->bundle->cfg.mtu)
1229ce828a6eSBrian Somers     prompt_Printf(arg->prompt, "%d\n", arg->bundle->cfg.mtu);
1230ce828a6eSBrian Somers   else
1231ce828a6eSBrian Somers     prompt_Printf(arg->prompt, "unspecified\n");
1232c08717dfSBrian Somers 
1233610b185fSBrian Somers   prompt_Printf(arg->prompt, " Sticky Routes: %s\n",
1234610b185fSBrian Somers                 optval(arg->bundle, OPT_SROUTES));
12351342caedSBrian Somers   prompt_Printf(arg->prompt, " ID check:      %s\n",
12361342caedSBrian Somers                 optval(arg->bundle, OPT_IDCHECK));
12371342caedSBrian Somers   prompt_Printf(arg->prompt, " Loopback:      %s\n",
12381342caedSBrian Somers                 optval(arg->bundle, OPT_LOOPBACK));
12391342caedSBrian Somers   prompt_Printf(arg->prompt, " PasswdAuth:    %s\n",
12401342caedSBrian Somers                 optval(arg->bundle, OPT_PASSWDAUTH));
12411342caedSBrian Somers   prompt_Printf(arg->prompt, " Proxy:         %s\n",
12421342caedSBrian Somers                 optval(arg->bundle, OPT_PROXY));
12431342caedSBrian Somers   prompt_Printf(arg->prompt, " Throughput:    %s\n",
12441342caedSBrian Somers                 optval(arg->bundle, OPT_THROUGHPUT));
1245610b185fSBrian Somers   prompt_Printf(arg->prompt, " Utmp Logging:  %s\n",
12461342caedSBrian Somers                 optval(arg->bundle, OPT_UTMP));
12478fa6ebe4SBrian Somers   prompt_Printf(arg->prompt, " Iface-Alias:   %s\n",
12488fa6ebe4SBrian Somers                 optval(arg->bundle, OPT_IFACEALIAS));
12491342caedSBrian Somers 
1250c08717dfSBrian Somers   return 0;
1251c08717dfSBrian Somers }
1252c08717dfSBrian Somers 
1253ab886ad0SBrian Somers static void
1254ab886ad0SBrian Somers bundle_IdleTimeout(void *v)
1255ab886ad0SBrian Somers {
1256ab886ad0SBrian Somers   struct bundle *bundle = (struct bundle *)v;
1257ab886ad0SBrian Somers 
1258dd7e2610SBrian Somers   log_Printf(LogPHASE, "Idle timer expired.\n");
125904eaa58cSBrian Somers   bundle_StopIdleTimer(bundle);
12609c81b87dSBrian Somers   bundle_Close(bundle, NULL, CLOSE_STAYDOWN);
1261ab886ad0SBrian Somers }
1262ab886ad0SBrian Somers 
1263ab886ad0SBrian Somers /*
1264ab886ad0SBrian Somers  *  Start Idle timer. If timeout is reached, we call bundle_Close() to
1265ab886ad0SBrian Somers  *  close LCP and link.
1266ab886ad0SBrian Somers  */
1267ab886ad0SBrian Somers void
1268ab886ad0SBrian Somers bundle_StartIdleTimer(struct bundle *bundle)
1269ab886ad0SBrian Somers {
1270dd7e2610SBrian Somers   timer_Stop(&bundle->idle.timer);
1271ff0f9439SBrian Somers   if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) !=
1272ff0f9439SBrian Somers       bundle->phys_type.open && bundle->cfg.idle_timeout) {
127393ee0ff2SBrian Somers     bundle->idle.timer.func = bundle_IdleTimeout;
12743b0f8d2eSBrian Somers     bundle->idle.timer.name = "idle";
127593ee0ff2SBrian Somers     bundle->idle.timer.load = bundle->cfg.idle_timeout * SECTICKS;
127693ee0ff2SBrian Somers     bundle->idle.timer.arg = bundle;
1277dd7e2610SBrian Somers     timer_Start(&bundle->idle.timer);
127893ee0ff2SBrian Somers     bundle->idle.done = time(NULL) + bundle->cfg.idle_timeout;
1279ab886ad0SBrian Somers   }
1280ab886ad0SBrian Somers }
1281ab886ad0SBrian Somers 
1282ab886ad0SBrian Somers void
1283ab886ad0SBrian Somers bundle_SetIdleTimer(struct bundle *bundle, int value)
1284ab886ad0SBrian Somers {
1285ab886ad0SBrian Somers   bundle->cfg.idle_timeout = value;
1286ab886ad0SBrian Somers   if (bundle_LinkIsUp(bundle))
1287ab886ad0SBrian Somers     bundle_StartIdleTimer(bundle);
1288ab886ad0SBrian Somers }
1289ab886ad0SBrian Somers 
1290ab886ad0SBrian Somers void
1291ab886ad0SBrian Somers bundle_StopIdleTimer(struct bundle *bundle)
1292ab886ad0SBrian Somers {
1293dd7e2610SBrian Somers   timer_Stop(&bundle->idle.timer);
12944a632c80SBrian Somers   bundle->idle.done = 0;
1295ab886ad0SBrian Somers }
1296ab886ad0SBrian Somers 
129704eaa58cSBrian Somers static int
1298ab886ad0SBrian Somers bundle_RemainingIdleTime(struct bundle *bundle)
1299ab886ad0SBrian Somers {
130093ee0ff2SBrian Somers   if (bundle->idle.done)
130193ee0ff2SBrian Somers     return bundle->idle.done - time(NULL);
1302ab886ad0SBrian Somers   return -1;
1303ab886ad0SBrian Somers }
13043b0f8d2eSBrian Somers 
13053b0f8d2eSBrian Somers int
13063b0f8d2eSBrian Somers bundle_IsDead(struct bundle *bundle)
13073b0f8d2eSBrian Somers {
13083b0f8d2eSBrian Somers   return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp);
13093b0f8d2eSBrian Somers }
1310b6217683SBrian Somers 
131104eaa58cSBrian Somers static struct datalink *
131204eaa58cSBrian Somers bundle_DatalinkLinkout(struct bundle *bundle, struct datalink *dl)
1313cd7bd93aSBrian Somers {
1314cd7bd93aSBrian Somers   struct datalink **dlp;
1315cd7bd93aSBrian Somers 
1316cd7bd93aSBrian Somers   for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next)
1317cd7bd93aSBrian Somers     if (*dlp == dl) {
131804eaa58cSBrian Somers       *dlp = dl->next;
131904eaa58cSBrian Somers       dl->next = NULL;
132004eaa58cSBrian Somers       bundle_LinksRemoved(bundle);
132104eaa58cSBrian Somers       return dl;
1322cd7bd93aSBrian Somers     }
132304eaa58cSBrian Somers 
132404eaa58cSBrian Somers   return NULL;
132504eaa58cSBrian Somers }
132604eaa58cSBrian Somers 
132704eaa58cSBrian Somers static void
132804eaa58cSBrian Somers bundle_DatalinkLinkin(struct bundle *bundle, struct datalink *dl)
132904eaa58cSBrian Somers {
133004eaa58cSBrian Somers   struct datalink **dlp = &bundle->links;
133104eaa58cSBrian Somers 
133204eaa58cSBrian Somers   while (*dlp)
133304eaa58cSBrian Somers     dlp = &(*dlp)->next;
133404eaa58cSBrian Somers 
133504eaa58cSBrian Somers   *dlp = dl;
133604eaa58cSBrian Somers   dl->next = NULL;
133704eaa58cSBrian Somers 
133804eaa58cSBrian Somers   bundle_LinkAdded(bundle, dl);
1339565e35e5SBrian Somers }
1340565e35e5SBrian Somers 
1341565e35e5SBrian Somers void
1342565e35e5SBrian Somers bundle_CleanDatalinks(struct bundle *bundle)
1343565e35e5SBrian Somers {
1344565e35e5SBrian Somers   struct datalink **dlp = &bundle->links;
134504eaa58cSBrian Somers   int found = 0;
1346565e35e5SBrian Somers 
1347565e35e5SBrian Somers   while (*dlp)
1348565e35e5SBrian Somers     if ((*dlp)->state == DATALINK_CLOSED &&
134981358fa3SBrian Somers         (*dlp)->physical->type & (PHYS_DIRECT|PHYS_BACKGROUND)) {
1350565e35e5SBrian Somers       *dlp = datalink_Destroy(*dlp);
135104eaa58cSBrian Somers       found++;
135204eaa58cSBrian Somers     } else
1353565e35e5SBrian Somers       dlp = &(*dlp)->next;
135404eaa58cSBrian Somers 
135504eaa58cSBrian Somers   if (found)
135604eaa58cSBrian Somers     bundle_LinksRemoved(bundle);
135704eaa58cSBrian Somers }
135804eaa58cSBrian Somers 
135904eaa58cSBrian Somers int
136004eaa58cSBrian Somers bundle_DatalinkClone(struct bundle *bundle, struct datalink *dl,
136104eaa58cSBrian Somers                      const char *name)
136204eaa58cSBrian Somers {
136304eaa58cSBrian Somers   if (bundle2datalink(bundle, name)) {
136404eaa58cSBrian Somers     log_Printf(LogWARN, "Clone: %s: name already exists\n", name);
136504eaa58cSBrian Somers     return 0;
136604eaa58cSBrian Somers   }
136704eaa58cSBrian Somers 
136804eaa58cSBrian Somers   bundle_DatalinkLinkin(bundle, datalink_Clone(dl, name));
136904eaa58cSBrian Somers   return 1;
137004eaa58cSBrian Somers }
137104eaa58cSBrian Somers 
137204eaa58cSBrian Somers void
137304eaa58cSBrian Somers bundle_DatalinkRemove(struct bundle *bundle, struct datalink *dl)
137404eaa58cSBrian Somers {
137504eaa58cSBrian Somers   dl = bundle_DatalinkLinkout(bundle, dl);
137604eaa58cSBrian Somers   if (dl)
137704eaa58cSBrian Somers     datalink_Destroy(dl);
1378cd7bd93aSBrian Somers }
137949052c95SBrian Somers 
138049052c95SBrian Somers void
138149052c95SBrian Somers bundle_SetLabel(struct bundle *bundle, const char *label)
138249052c95SBrian Somers {
138349052c95SBrian Somers   if (label)
138449052c95SBrian Somers     strncpy(bundle->cfg.label, label, sizeof bundle->cfg.label - 1);
138549052c95SBrian Somers   else
138649052c95SBrian Somers     *bundle->cfg.label = '\0';
138749052c95SBrian Somers }
138849052c95SBrian Somers 
138949052c95SBrian Somers const char *
139049052c95SBrian Somers bundle_GetLabel(struct bundle *bundle)
139149052c95SBrian Somers {
139249052c95SBrian Somers   return *bundle->cfg.label ? bundle->cfg.label : NULL;
139349052c95SBrian Somers }
13941fa665f5SBrian Somers 
13951fa665f5SBrian Somers void
139696c9bb21SBrian Somers bundle_ReceiveDatalink(struct bundle *bundle, int s, struct sockaddr_un *sun)
13971fa665f5SBrian Somers {
139896c9bb21SBrian Somers   char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)];
139996c9bb21SBrian Somers   struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf;
140096c9bb21SBrian Somers   struct msghdr msg;
140196c9bb21SBrian Somers   struct iovec iov[SCATTER_SEGMENTS];
1402b7c5748eSBrian Somers   struct datalink *dl;
140396c9bb21SBrian Somers   int niov, link_fd, expect, f;
140485fd273aSBrian Somers   pid_t pid;
14056f384573SBrian Somers 
1406dd7e2610SBrian Somers   log_Printf(LogPHASE, "Receiving datalink\n");
14076f384573SBrian Somers 
140896c9bb21SBrian Somers   /* Create our scatter/gather array */
140996c9bb21SBrian Somers   niov = 1;
141096c9bb21SBrian Somers   iov[0].iov_len = strlen(Version) + 1;
141196c9bb21SBrian Somers   iov[0].iov_base = (char *)malloc(iov[0].iov_len);
141285fd273aSBrian Somers   if (datalink2iov(NULL, iov, &niov, sizeof iov / sizeof *iov, 0) == -1) {
141354cd8e13SBrian Somers     close(s);
14146f384573SBrian Somers     return;
141554cd8e13SBrian Somers   }
14166f384573SBrian Somers 
141785fd273aSBrian Somers   pid = getpid();
141885fd273aSBrian Somers   write(s, &pid, sizeof pid);
141985fd273aSBrian Somers 
142096c9bb21SBrian Somers   for (f = expect = 0; f < niov; f++)
142196c9bb21SBrian Somers     expect += iov[f].iov_len;
142296c9bb21SBrian Somers 
142396c9bb21SBrian Somers   /* Set up our message */
142496c9bb21SBrian Somers   cmsg->cmsg_len = sizeof cmsgbuf;
142596c9bb21SBrian Somers   cmsg->cmsg_level = SOL_SOCKET;
142654cd8e13SBrian Somers   cmsg->cmsg_type = 0;
142796c9bb21SBrian Somers 
142896c9bb21SBrian Somers   memset(&msg, '\0', sizeof msg);
142996c9bb21SBrian Somers   msg.msg_name = (caddr_t)sun;
143096c9bb21SBrian Somers   msg.msg_namelen = sizeof *sun;
143196c9bb21SBrian Somers   msg.msg_iov = iov;
143296c9bb21SBrian Somers   msg.msg_iovlen = niov;
143396c9bb21SBrian Somers   msg.msg_control = cmsgbuf;
143496c9bb21SBrian Somers   msg.msg_controllen = sizeof cmsgbuf;
143596c9bb21SBrian Somers 
143696c9bb21SBrian Somers   log_Printf(LogDEBUG, "Expecting %d scatter/gather bytes\n", expect);
143796c9bb21SBrian Somers   f = expect + 100;
143896c9bb21SBrian Somers   setsockopt(s, SOL_SOCKET, SO_RCVBUF, &f, sizeof f);
143996c9bb21SBrian Somers   if ((f = recvmsg(s, &msg, MSG_WAITALL)) != expect) {
144096c9bb21SBrian Somers     if (f == -1)
144196c9bb21SBrian Somers       log_Printf(LogERROR, "Failed recvmsg: %s\n", strerror(errno));
144296c9bb21SBrian Somers     else
144396c9bb21SBrian Somers       log_Printf(LogERROR, "Failed recvmsg: Got %d, not %d\n", f, expect);
144496c9bb21SBrian Somers     while (niov--)
144596c9bb21SBrian Somers       free(iov[niov].iov_base);
144654cd8e13SBrian Somers     close(s);
144796c9bb21SBrian Somers     return;
144896c9bb21SBrian Somers   }
144996c9bb21SBrian Somers 
1450c0d9a877SBrian Somers   write(s, "!", 1);	/* ACK */
1451ad5b0e8bSBrian Somers   close(s);
1452c0d9a877SBrian Somers 
1453ad5b0e8bSBrian Somers   if (cmsg->cmsg_type != SCM_RIGHTS) {
1454ad5b0e8bSBrian Somers     log_Printf(LogERROR, "Recvmsg: no descriptor received !\n");
1455ad5b0e8bSBrian Somers     while (niov--)
1456ad5b0e8bSBrian Somers       free(iov[niov].iov_base);
1457ad5b0e8bSBrian Somers     return;
145854cd8e13SBrian Somers   }
145954cd8e13SBrian Somers 
1460ad5b0e8bSBrian Somers   /* We've successfully received an open file descriptor through our socket */
1461ad5b0e8bSBrian Somers   log_Printf(LogDEBUG, "Receiving device descriptor\n");
1462ad5b0e8bSBrian Somers   link_fd = *(int *)CMSG_DATA(cmsg);
1463ad5b0e8bSBrian Somers 
146496c9bb21SBrian Somers   if (strncmp(Version, iov[0].iov_base, iov[0].iov_len)) {
146596c9bb21SBrian Somers     log_Printf(LogWARN, "Cannot receive datalink, incorrect version"
146696c9bb21SBrian Somers                " (\"%.*s\", not \"%s\")\n", (int)iov[0].iov_len,
14677d81ddf5SBrian Somers                (char *)iov[0].iov_base, Version);
146896c9bb21SBrian Somers     close(link_fd);
146996c9bb21SBrian Somers     while (niov--)
147096c9bb21SBrian Somers       free(iov[niov].iov_base);
147196c9bb21SBrian Somers     return;
147296c9bb21SBrian Somers   }
147396c9bb21SBrian Somers 
147496c9bb21SBrian Somers   niov = 1;
1475b7c5748eSBrian Somers   dl = iov2datalink(bundle, iov, &niov, sizeof iov / sizeof *iov, link_fd);
1476b7c5748eSBrian Somers   if (dl) {
147704eaa58cSBrian Somers     bundle_DatalinkLinkin(bundle, dl);
1478b7c5748eSBrian Somers     datalink_AuthOk(dl);
147996c9bb21SBrian Somers   } else
148096c9bb21SBrian Somers     close(link_fd);
148196c9bb21SBrian Somers 
148296c9bb21SBrian Somers   free(iov[0].iov_base);
14831fa665f5SBrian Somers }
14841fa665f5SBrian Somers 
14851fa665f5SBrian Somers void
148696c9bb21SBrian Somers bundle_SendDatalink(struct datalink *dl, int s, struct sockaddr_un *sun)
14871fa665f5SBrian Somers {
1488c0d9a877SBrian Somers   char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int)], ack;
148996c9bb21SBrian Somers   struct cmsghdr *cmsg = (struct cmsghdr *)cmsgbuf;
149096c9bb21SBrian Somers   struct msghdr msg;
149196c9bb21SBrian Somers   struct iovec iov[SCATTER_SEGMENTS];
14921384bd27SBrian Somers   int niov, link_fd, f, expect, newsid;
149385fd273aSBrian Somers   pid_t newpid;
14946f384573SBrian Somers 
1495dd7e2610SBrian Somers   log_Printf(LogPHASE, "Transmitting datalink %s\n", dl->name);
14966f384573SBrian Somers 
149704eaa58cSBrian Somers   bundle_LinkClosed(dl->bundle, dl);
14980f2f3eb3SBrian Somers   bundle_DatalinkLinkout(dl->bundle, dl);
1499ea722969SBrian Somers 
150096c9bb21SBrian Somers   /* Build our scatter/gather array */
150196c9bb21SBrian Somers   iov[0].iov_len = strlen(Version) + 1;
150296c9bb21SBrian Somers   iov[0].iov_base = strdup(Version);
150396c9bb21SBrian Somers   niov = 1;
15046f384573SBrian Somers 
150585fd273aSBrian Somers   read(s, &newpid, sizeof newpid);
150685fd273aSBrian Somers   link_fd = datalink2iov(dl, iov, &niov, sizeof iov / sizeof *iov, newpid);
15076f384573SBrian Somers 
15086f384573SBrian Somers   if (link_fd != -1) {
150996c9bb21SBrian Somers     memset(&msg, '\0', sizeof msg);
151054cd8e13SBrian Somers 
151196c9bb21SBrian Somers     msg.msg_name = (caddr_t)sun;
151296c9bb21SBrian Somers     msg.msg_namelen = sizeof *sun;
151396c9bb21SBrian Somers     msg.msg_iov = iov;
151496c9bb21SBrian Somers     msg.msg_iovlen = niov;
151554cd8e13SBrian Somers 
151654cd8e13SBrian Somers     cmsg->cmsg_len = sizeof cmsgbuf;
151754cd8e13SBrian Somers     cmsg->cmsg_level = SOL_SOCKET;
151854cd8e13SBrian Somers     cmsg->cmsg_type = SCM_RIGHTS;
151954cd8e13SBrian Somers     *(int *)CMSG_DATA(cmsg) = link_fd;
152096c9bb21SBrian Somers     msg.msg_control = cmsgbuf;
152196c9bb21SBrian Somers     msg.msg_controllen = sizeof cmsgbuf;
152247723d29SBrian Somers 
152396c9bb21SBrian Somers     for (f = expect = 0; f < niov; f++)
152496c9bb21SBrian Somers       expect += iov[f].iov_len;
152547723d29SBrian Somers 
152696c9bb21SBrian Somers     log_Printf(LogDEBUG, "Sending %d bytes in scatter/gather array\n", expect);
152747723d29SBrian Somers 
152896c9bb21SBrian Somers     f = expect + SOCKET_OVERHEAD;
152996c9bb21SBrian Somers     setsockopt(s, SOL_SOCKET, SO_SNDBUF, &f, sizeof f);
153096c9bb21SBrian Somers     if (sendmsg(s, &msg, 0) == -1)
153196c9bb21SBrian Somers       log_Printf(LogERROR, "Failed sendmsg: %s\n", strerror(errno));
1532c0d9a877SBrian Somers     /* We must get the ACK before closing the descriptor ! */
1533c0d9a877SBrian Somers     read(s, &ack, 1);
153454cd8e13SBrian Somers 
15351384bd27SBrian Somers     newsid = tcgetpgrp(link_fd) == getpgrp();
153696c9bb21SBrian Somers     close(link_fd);
15371384bd27SBrian Somers     if (newsid)
15381384bd27SBrian Somers       bundle_setsid(dl->bundle, 1);
153947723d29SBrian Somers   }
154085fd273aSBrian Somers   close(s);
154196c9bb21SBrian Somers 
154296c9bb21SBrian Somers   while (niov--)
154396c9bb21SBrian Somers     free(iov[niov].iov_base);
15441fa665f5SBrian Somers }
1545dd0645c5SBrian Somers 
1546dd0645c5SBrian Somers int
154758d55334SBrian Somers bundle_RenameDatalink(struct bundle *bundle, struct datalink *ndl,
154858d55334SBrian Somers                       const char *name)
154958d55334SBrian Somers {
155058d55334SBrian Somers   struct datalink *dl;
155158d55334SBrian Somers 
155258d55334SBrian Somers   if (!strcasecmp(ndl->name, name))
155358d55334SBrian Somers     return 1;
155458d55334SBrian Somers 
155558d55334SBrian Somers   for (dl = bundle->links; dl; dl = dl->next)
155658d55334SBrian Somers     if (!strcasecmp(dl->name, name))
155758d55334SBrian Somers       return 0;
155858d55334SBrian Somers 
155958d55334SBrian Somers   datalink_Rename(ndl, name);
156058d55334SBrian Somers   return 1;
156158d55334SBrian Somers }
156258d55334SBrian Somers 
156358d55334SBrian Somers int
1564dd0645c5SBrian Somers bundle_SetMode(struct bundle *bundle, struct datalink *dl, int mode)
1565dd0645c5SBrian Somers {
1566dd0645c5SBrian Somers   int omode;
1567dd0645c5SBrian Somers 
1568dd0645c5SBrian Somers   omode = dl->physical->type;
1569dd0645c5SBrian Somers   if (omode == mode)
1570dd0645c5SBrian Somers     return 1;
1571dd0645c5SBrian Somers 
1572ff0f9439SBrian Somers   if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO))
1573ff0f9439SBrian Somers     /* First auto link */
1574dd0645c5SBrian Somers     if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) {
1575ff0f9439SBrian Somers       log_Printf(LogWARN, "You must `set ifaddr' or `open' before"
1576ff0f9439SBrian Somers                  " changing mode to %s\n", mode2Nam(mode));
1577dd0645c5SBrian Somers       return 0;
1578dd0645c5SBrian Somers     }
1579dd0645c5SBrian Somers 
1580dd0645c5SBrian Somers   if (!datalink_SetMode(dl, mode))
1581dd0645c5SBrian Somers     return 0;
1582dd0645c5SBrian Somers 
1583ff0f9439SBrian Somers   if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) &&
1584ff0f9439SBrian Somers       bundle->phase != PHASE_NETWORK)
1585ff0f9439SBrian Somers     /* First auto link, we need an interface */
1586dd0645c5SBrian Somers     ipcp_InterfaceUp(&bundle->ncp.ipcp);
1587dd0645c5SBrian Somers 
158804eaa58cSBrian Somers   /* Regenerate phys_type and adjust autoload & idle timers */
158904eaa58cSBrian Somers   bundle_LinksRemoved(bundle);
1590dd0645c5SBrian Somers 
1591dd0645c5SBrian Somers   return 1;
1592dd0645c5SBrian Somers }
15931384bd27SBrian Somers 
15941384bd27SBrian Somers void
15951384bd27SBrian Somers bundle_setsid(struct bundle *bundle, int holdsession)
15961384bd27SBrian Somers {
15971384bd27SBrian Somers   /*
15981384bd27SBrian Somers    * Lose the current session.  This means getting rid of our pid
15991384bd27SBrian Somers    * too so that the tty device will really go away, and any getty
16001384bd27SBrian Somers    * etc will be allowed to restart.
16011384bd27SBrian Somers    */
16021384bd27SBrian Somers   pid_t pid, orig;
16031384bd27SBrian Somers   int fds[2];
16041384bd27SBrian Somers   char done;
16051384bd27SBrian Somers   struct datalink *dl;
16061384bd27SBrian Somers 
16071384bd27SBrian Somers   orig = getpid();
16081384bd27SBrian Somers   if (pipe(fds) == -1) {
16091384bd27SBrian Somers     log_Printf(LogERROR, "pipe: %s\n", strerror(errno));
16101384bd27SBrian Somers     return;
16111384bd27SBrian Somers   }
16121384bd27SBrian Somers   switch ((pid = fork())) {
16131384bd27SBrian Somers     case -1:
16141384bd27SBrian Somers       log_Printf(LogERROR, "fork: %s\n", strerror(errno));
16151384bd27SBrian Somers       close(fds[0]);
16161384bd27SBrian Somers       close(fds[1]);
16171384bd27SBrian Somers       return;
16181384bd27SBrian Somers     case 0:
16191384bd27SBrian Somers       close(fds[0]);
16201384bd27SBrian Somers       read(fds[1], &done, 1);		/* uu_locks are mine ! */
16211384bd27SBrian Somers       close(fds[1]);
16221384bd27SBrian Somers       if (pipe(fds) == -1) {
16231384bd27SBrian Somers         log_Printf(LogERROR, "pipe(2): %s\n", strerror(errno));
16241384bd27SBrian Somers         return;
16251384bd27SBrian Somers       }
16261384bd27SBrian Somers       switch ((pid = fork())) {
16271384bd27SBrian Somers         case -1:
1628a33b2ef7SBrian Somers           log_Printf(LogERROR, "fork(2): %s\n", strerror(errno));
16291384bd27SBrian Somers           close(fds[0]);
16301384bd27SBrian Somers           close(fds[1]);
16311384bd27SBrian Somers           return;
16321384bd27SBrian Somers         case 0:
16331384bd27SBrian Somers           close(fds[0]);
16341384bd27SBrian Somers           bundle_LockTun(bundle);	/* update pid */
16351384bd27SBrian Somers           read(fds[1], &done, 1);	/* uu_locks are mine ! */
16361384bd27SBrian Somers           close(fds[1]);
16371384bd27SBrian Somers           setsid();
16381384bd27SBrian Somers           log_Printf(LogPHASE, "%d -> %d: %s session control\n",
16391384bd27SBrian Somers                      (int)orig, (int)getpid(),
16401384bd27SBrian Somers                      holdsession ? "Passed" : "Dropped");
1641d2a69fc3SBrian Somers           timer_InitService();
16421384bd27SBrian Somers           break;
16431384bd27SBrian Somers         default:
16441384bd27SBrian Somers           close(fds[1]);
16451384bd27SBrian Somers           /* Give away all our modem locks (to the final process) */
16461384bd27SBrian Somers           for (dl = bundle->links; dl; dl = dl->next)
16471384bd27SBrian Somers             if (dl->state != DATALINK_CLOSED)
16481384bd27SBrian Somers               modem_ChangedPid(dl->physical, pid);
16491384bd27SBrian Somers           write(fds[0], "!", 1);	/* done */
16501384bd27SBrian Somers           close(fds[0]);
16511384bd27SBrian Somers           exit(0);
16521384bd27SBrian Somers           break;
16531384bd27SBrian Somers       }
16541384bd27SBrian Somers       break;
16551384bd27SBrian Somers     default:
16561384bd27SBrian Somers       close(fds[1]);
16571384bd27SBrian Somers       /* Give away all our modem locks (to the intermediate process) */
16581384bd27SBrian Somers       for (dl = bundle->links; dl; dl = dl->next)
16591384bd27SBrian Somers         if (dl->state != DATALINK_CLOSED)
16601384bd27SBrian Somers           modem_ChangedPid(dl->physical, pid);
16611384bd27SBrian Somers       write(fds[0], "!", 1);	/* done */
16621384bd27SBrian Somers       close(fds[0]);
16631384bd27SBrian Somers       if (holdsession) {
16641384bd27SBrian Somers         int fd, status;
16651384bd27SBrian Somers 
16661384bd27SBrian Somers         timer_TermService();
16671384bd27SBrian Somers         signal(SIGPIPE, SIG_DFL);
16681384bd27SBrian Somers         signal(SIGALRM, SIG_DFL);
16691384bd27SBrian Somers         signal(SIGHUP, SIG_DFL);
16701384bd27SBrian Somers         signal(SIGTERM, SIG_DFL);
16711384bd27SBrian Somers         signal(SIGINT, SIG_DFL);
16721384bd27SBrian Somers         signal(SIGQUIT, SIG_DFL);
16731384bd27SBrian Somers         for (fd = getdtablesize(); fd >= 0; fd--)
16741384bd27SBrian Somers           close(fd);
16751384bd27SBrian Somers         setuid(geteuid());
16761384bd27SBrian Somers         /*
16771384bd27SBrian Somers          * Reap the intermediate process.  As we're not exiting but the
16781384bd27SBrian Somers          * intermediate is, we don't want it to become defunct.
16791384bd27SBrian Somers          */
16801384bd27SBrian Somers         waitpid(pid, &status, 0);
16818e7b8599SBrian Somers         /* Tweak our process arguments.... */
16828e7b8599SBrian Somers         bundle->argv[0] = "session owner";
16838e7b8599SBrian Somers         bundle->argv[1] = NULL;
16841384bd27SBrian Somers         /*
16851384bd27SBrian Somers          * Hang around for a HUP.  This should happen as soon as the
16861384bd27SBrian Somers          * ppp that we passed our ctty descriptor to closes it.
16871384bd27SBrian Somers          * NOTE: If this process dies, the passed descriptor becomes
16881384bd27SBrian Somers          *       invalid and will give a select() error by setting one
16891384bd27SBrian Somers          *       of the error fds, aborting the other ppp.  We don't
16901384bd27SBrian Somers          *       want that to happen !
16911384bd27SBrian Somers          */
16921384bd27SBrian Somers         pause();
16931384bd27SBrian Somers       }
16941384bd27SBrian Somers       exit(0);
16951384bd27SBrian Somers       break;
16961384bd27SBrian Somers   }
16971384bd27SBrian Somers }
1698