freebsd-skq/usr.sbin/ppp/bundle.c
brian 0deba2c342 Reduce the interface MTU by 2 when MPPE has been successfully negotiated.
This is necessary because MPPE will combine the protocol id with the
payload received on the tun interface, encrypt it, then prepend its
own protocol id, effectively increasing the payload by two bytes.
2001-07-03 22:20:19 +00:00

1947 lines
54 KiB
C

/*-
* Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <net/if_tun.h> /* For TUNS* ioctls */
#include <net/route.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <sys/un.h>
#include <errno.h>
#include <fcntl.h>
#ifdef __OpenBSD__
#include <util.h>
#else
#include <libutil.h>
#endif
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/uio.h>
#include <sys/wait.h>
#if defined(__FreeBSD__) && !defined(NOKLDLOAD)
#ifdef NOSUID
#include <sys/linker.h>
#endif
#include <sys/module.h>
#endif
#include <termios.h>
#include <unistd.h>
#include "layer.h"
#include "defs.h"
#include "command.h"
#include "mbuf.h"
#include "log.h"
#include "id.h"
#include "timer.h"
#include "fsm.h"
#include "iplist.h"
#include "lqr.h"
#include "hdlc.h"
#include "throughput.h"
#include "slcompress.h"
#include "ipcp.h"
#include "filter.h"
#include "descriptor.h"
#include "route.h"
#include "lcp.h"
#include "ccp.h"
#include "link.h"
#include "mp.h"
#ifndef NORADIUS
#include "radius.h"
#endif
#include "bundle.h"
#include "async.h"
#include "physical.h"
#include "auth.h"
#include "proto.h"
#include "chap.h"
#include "tun.h"
#include "prompt.h"
#include "chat.h"
#include "cbcp.h"
#include "datalink.h"
#include "ip.h"
#include "iface.h"
#include "server.h"
#ifdef HAVE_DES
#include "mppe.h"
#endif
#define SCATTER_SEGMENTS 7 /* version, datalink, name, physical,
throughput, throughput, device */
#define SEND_MAXFD 3 /* Max file descriptors passed through
the local domain socket */
static int bundle_RemainingIdleTime(struct bundle *);
static const char * const PhaseNames[] = {
"Dead", "Establish", "Authenticate", "Network", "Terminate"
};
const char *
bundle_PhaseName(struct bundle *bundle)
{
return bundle->phase <= PHASE_TERMINATE ?
PhaseNames[bundle->phase] : "unknown";
}
void
bundle_NewPhase(struct bundle *bundle, u_int new)
{
if (new == bundle->phase)
return;
if (new <= PHASE_TERMINATE)
log_Printf(LogPHASE, "bundle: %s\n", PhaseNames[new]);
switch (new) {
case PHASE_DEAD:
bundle->phase = new;
#ifdef HAVE_DES
MPPE_MasterKeyValid = 0;
#endif
log_DisplayPrompts();
break;
case PHASE_ESTABLISH:
bundle->phase = new;
break;
case PHASE_AUTHENTICATE:
bundle->phase = new;
log_DisplayPrompts();
break;
case PHASE_NETWORK:
fsm_Up(&bundle->ncp.ipcp.fsm);
fsm_Open(&bundle->ncp.ipcp.fsm);
bundle->phase = new;
log_DisplayPrompts();
break;
case PHASE_TERMINATE:
bundle->phase = new;
mp_Down(&bundle->ncp.mp);
log_DisplayPrompts();
break;
}
}
static void
bundle_LayerStart(void *v, struct fsm *fp)
{
/* The given FSM is about to start up ! */
}
void
bundle_Notify(struct bundle *bundle, char c)
{
if (bundle->notify.fd != -1) {
int ret;
ret = write(bundle->notify.fd, &c, 1);
if (c != EX_REDIAL && c != EX_RECONNECT) {
if (ret == 1)
log_Printf(LogCHAT, "Parent notified of %s\n",
c == EX_NORMAL ? "success" : "failure");
else
log_Printf(LogERROR, "Failed to notify parent of success\n");
close(bundle->notify.fd);
bundle->notify.fd = -1;
} else if (ret == 1)
log_Printf(LogCHAT, "Parent notified of %s\n", ex_desc(c));
else
log_Printf(LogERROR, "Failed to notify parent of %s\n", ex_desc(c));
}
}
static void
bundle_ClearQueues(void *v)
{
struct bundle *bundle = (struct bundle *)v;
struct datalink *dl;
log_Printf(LogPHASE, "Clearing choked output queue\n");
timer_Stop(&bundle->choked.timer);
/*
* Emergency time:
*
* We've had a full queue for PACKET_DEL_SECS seconds without being
* able to get rid of any of the packets. We've probably given up
* on the redials at this point, and the queued data has almost
* definitely been timed out by the layer above. As this is preventing
* us from reading the TUN_NAME device (we don't want to buffer stuff
* indefinitely), we may as well nuke this data and start with a clean
* slate !
*
* Unfortunately, this has the side effect of shafting any compression
* dictionaries in use (causing the relevant RESET_REQ/RESET_ACK).
*/
ip_DeleteQueue(&bundle->ncp.ipcp);
mp_DeleteQueue(&bundle->ncp.mp);
for (dl = bundle->links; dl; dl = dl->next)
physical_DeleteQueue(dl->physical);
}
static void
bundle_LinkAdded(struct bundle *bundle, struct datalink *dl)
{
bundle->phys_type.all |= dl->physical->type;
if (dl->state == DATALINK_OPEN)
bundle->phys_type.open |= dl->physical->type;
if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL))
!= bundle->phys_type.open && bundle->idle.timer.state == TIMER_STOPPED)
/* We may need to start our idle timer */
bundle_StartIdleTimer(bundle, 0);
}
void
bundle_LinksRemoved(struct bundle *bundle)
{
struct datalink *dl;
bundle->phys_type.all = bundle->phys_type.open = 0;
for (dl = bundle->links; dl; dl = dl->next)
bundle_LinkAdded(bundle, dl);
bundle_CalculateBandwidth(bundle);
mp_CheckAutoloadTimer(&bundle->ncp.mp);
if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL))
== bundle->phys_type.open)
bundle_StopIdleTimer(bundle);
}
static void
bundle_LayerUp(void *v, struct fsm *fp)
{
/*
* The given fsm is now up
* If it's an LCP, adjust our phys_mode.open value and check the
* autoload timer.
* If it's the first NCP, calculate our bandwidth
* If it's the first NCP, set our ``upat'' time
* If it's the first NCP, start the idle timer.
* If it's an NCP, tell our -background parent to go away.
* If it's the first NCP, start the autoload timer
*/
struct bundle *bundle = (struct bundle *)v;
if (fp->proto == PROTO_LCP) {
struct physical *p = link2physical(fp->link);
bundle_LinkAdded(bundle, p->dl);
mp_CheckAutoloadTimer(&bundle->ncp.mp);
} else if (fp->proto == PROTO_IPCP) {
bundle_CalculateBandwidth(fp->bundle);
time(&bundle->upat);
bundle_StartIdleTimer(bundle, 0);
bundle_Notify(bundle, EX_NORMAL);
mp_CheckAutoloadTimer(&fp->bundle->ncp.mp);
} else if (fp->proto == PROTO_CCP)
bundle_CalculateBandwidth(fp->bundle); /* Against ccp_MTUOverhead */
}
static void
bundle_LayerDown(void *v, struct fsm *fp)
{
/*
* The given FSM has been told to come down.
* If it's our last NCP, stop the idle timer.
* If it's our last NCP, clear our ``upat'' value.
* If it's our last NCP, stop the autoload timer
* If it's an LCP, adjust our phys_type.open value and any timers.
* If it's an LCP and we're in multilink mode, adjust our tun
* If it's the last LCP, down all NCPs
* speed and make sure our minimum sequence number is adjusted.
*/
struct bundle *bundle = (struct bundle *)v;
if (fp->proto == PROTO_IPCP) {
bundle_StopIdleTimer(bundle);
bundle->upat = 0;
mp_StopAutoloadTimer(&bundle->ncp.mp);
} else if (fp->proto == PROTO_LCP) {
struct datalink *dl;
struct datalink *lost;
int others_active;
bundle_LinksRemoved(bundle); /* adjust timers & phys_type values */
lost = NULL;
others_active = 0;
for (dl = bundle->links; dl; dl = dl->next) {
if (fp == &dl->physical->link.lcp.fsm)
lost = dl;
else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP)
others_active++;
}
if (bundle->ncp.mp.active) {
bundle_CalculateBandwidth(bundle);
if (lost)
mp_LinkLost(&bundle->ncp.mp, lost);
else
log_Printf(LogALERT, "Oops, lost an unrecognised datalink (%s) !\n",
fp->link->name);
}
if (!others_active)
/* Down the NCPs. We don't expect to get fsm_Close()d ourself ! */
fsm2initial(&bundle->ncp.ipcp.fsm);
}
}
static void
bundle_LayerFinish(void *v, struct fsm *fp)
{
/* The given fsm is now down (fp cannot be NULL)
*
* If it's the last NCP, fsm_Close all LCPs
*/
struct bundle *bundle = (struct bundle *)v;
struct datalink *dl;
if (fp->proto == PROTO_IPCP) {
if (bundle_Phase(bundle) != PHASE_DEAD)
bundle_NewPhase(bundle, PHASE_TERMINATE);
for (dl = bundle->links; dl; dl = dl->next)
if (dl->state == DATALINK_OPEN)
datalink_Close(dl, CLOSE_STAYDOWN);
fsm2initial(fp);
}
}
int
bundle_LinkIsUp(const struct bundle *bundle)
{
return bundle->ncp.ipcp.fsm.state == ST_OPENED;
}
void
bundle_Close(struct bundle *bundle, const char *name, int how)
{
/*
* Please close the given datalink.
* If name == NULL or name is the last datalink, fsm_Close all NCPs
* (except our MP)
* If it isn't the last datalink, just Close that datalink.
*/
struct datalink *dl, *this_dl;
int others_active;
others_active = 0;
this_dl = NULL;
for (dl = bundle->links; dl; dl = dl->next) {
if (name && !strcasecmp(name, dl->name))
this_dl = dl;
if (name == NULL || this_dl == dl) {
switch (how) {
case CLOSE_LCP:
datalink_DontHangup(dl);
break;
case CLOSE_STAYDOWN:
datalink_StayDown(dl);
break;
}
} else if (dl->state != DATALINK_CLOSED && dl->state != DATALINK_HANGUP)
others_active++;
}
if (name && this_dl == NULL) {
log_Printf(LogWARN, "%s: Invalid datalink name\n", name);
return;
}
if (!others_active) {
bundle_StopIdleTimer(bundle);
if (bundle->ncp.ipcp.fsm.state > ST_CLOSED ||
bundle->ncp.ipcp.fsm.state == ST_STARTING)
fsm_Close(&bundle->ncp.ipcp.fsm);
else {
fsm2initial(&bundle->ncp.ipcp.fsm);
for (dl = bundle->links; dl; dl = dl->next)
datalink_Close(dl, how);
}
} else if (this_dl && this_dl->state != DATALINK_CLOSED &&
this_dl->state != DATALINK_HANGUP)
datalink_Close(this_dl, how);
}
void
bundle_Down(struct bundle *bundle, int how)
{
struct datalink *dl;
for (dl = bundle->links; dl; dl = dl->next)
datalink_Down(dl, how);
}
static size_t
bundle_FillQueues(struct bundle *bundle)
{
size_t total;
if (bundle->ncp.mp.active)
total = mp_FillQueues(bundle);
else {
struct datalink *dl;
size_t add;
for (total = 0, dl = bundle->links; dl; dl = dl->next)
if (dl->state == DATALINK_OPEN) {
add = link_QueueLen(&dl->physical->link);
if (add == 0 && dl->physical->out == NULL)
add = ip_PushPacket(&dl->physical->link, bundle);
total += add;
}
}
return total + ip_QueueLen(&bundle->ncp.ipcp);
}
static int
bundle_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n)
{
struct bundle *bundle = descriptor2bundle(d);
struct datalink *dl;
int result, nlinks;
u_short ifqueue;
size_t queued;
result = 0;
/* If there are aren't many packets queued, look for some more. */
for (nlinks = 0, dl = bundle->links; dl; dl = dl->next)
nlinks++;
if (nlinks) {
queued = r ? bundle_FillQueues(bundle) : ip_QueueLen(&bundle->ncp.ipcp);
if (r && (bundle->phase == PHASE_NETWORK ||
bundle->phys_type.all & PHYS_AUTO)) {
/* enough surplus so that we can tell if we're getting swamped */
ifqueue = nlinks > bundle->cfg.ifqueue ? nlinks : bundle->cfg.ifqueue;
if (queued < ifqueue) {
/* Not enough - select() for more */
if (bundle->choked.timer.state == TIMER_RUNNING)
timer_Stop(&bundle->choked.timer); /* Not needed any more */
FD_SET(bundle->dev.fd, r);
if (*n < bundle->dev.fd + 1)
*n = bundle->dev.fd + 1;
log_Printf(LogTIMER, "%s: fdset(r) %d\n", TUN_NAME, bundle->dev.fd);
result++;
} else if (bundle->choked.timer.state == TIMER_STOPPED) {
bundle->choked.timer.func = bundle_ClearQueues;
bundle->choked.timer.name = "output choke";
bundle->choked.timer.load = bundle->cfg.choked.timeout * SECTICKS;
bundle->choked.timer.arg = bundle;
timer_Start(&bundle->choked.timer);
}
}
}
#ifndef NORADIUS
result += descriptor_UpdateSet(&bundle->radius.desc, r, w, e, n);
#endif
/* Which links need a select() ? */
for (dl = bundle->links; dl; dl = dl->next)
result += descriptor_UpdateSet(&dl->desc, r, w, e, n);
/*
* This *MUST* be called after the datalink UpdateSet()s as it
* might be ``holding'' one of the datalinks (death-row) and
* wants to be able to de-select() it from the descriptor set.
*/
result += descriptor_UpdateSet(&bundle->ncp.mp.server.desc, r, w, e, n);
return result;
}
static int
bundle_IsSet(struct fdescriptor *d, const fd_set *fdset)
{
struct bundle *bundle = descriptor2bundle(d);
struct datalink *dl;
for (dl = bundle->links; dl; dl = dl->next)
if (descriptor_IsSet(&dl->desc, fdset))
return 1;
#ifndef NORADIUS
if (descriptor_IsSet(&bundle->radius.desc, fdset))
return 1;
#endif
if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset))
return 1;
return FD_ISSET(bundle->dev.fd, fdset);
}
static void
bundle_DescriptorRead(struct fdescriptor *d, struct bundle *bundle,
const fd_set *fdset)
{
struct datalink *dl;
unsigned secs;
if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset))
descriptor_Read(&bundle->ncp.mp.server.desc, bundle, fdset);
for (dl = bundle->links; dl; dl = dl->next)
if (descriptor_IsSet(&dl->desc, fdset))
descriptor_Read(&dl->desc, bundle, fdset);
#ifndef NORADIUS
if (descriptor_IsSet(&bundle->radius.desc, fdset))
descriptor_Read(&bundle->radius.desc, bundle, fdset);
#endif
if (FD_ISSET(bundle->dev.fd, fdset)) {
struct tun_data tun;
int n, pri;
char *data;
size_t sz;
if (bundle->dev.header) {
data = (char *)&tun;
sz = sizeof tun;
} else {
data = tun.data;
sz = sizeof tun.data;
}
/* something to read from tun */
n = read(bundle->dev.fd, data, sz);
if (n < 0) {
log_Printf(LogWARN, "%s: read: %s\n", bundle->dev.Name, strerror(errno));
return;
}
if (bundle->dev.header) {
n -= sz - sizeof tun.data;
if (n <= 0) {
log_Printf(LogERROR, "%s: read: Got only %d bytes of data !\n",
bundle->dev.Name, n);
return;
}
if (ntohl(tun.header.family) != AF_INET)
/* XXX: Should be maintaining drop/family counts ! */
return;
}
if (((struct ip *)tun.data)->ip_dst.s_addr ==
bundle->ncp.ipcp.my_ip.s_addr) {
/* we've been asked to send something addressed *to* us :( */
if (Enabled(bundle, OPT_LOOPBACK)) {
pri = PacketCheck(bundle, tun.data, n, &bundle->filter.in, NULL, NULL);
if (pri >= 0) {
n += sz - sizeof tun.data;
write(bundle->dev.fd, data, n);
log_Printf(LogDEBUG, "Looped back packet addressed to myself\n");
}
return;
} else
log_Printf(LogDEBUG, "Oops - forwarding packet addressed to myself\n");
}
/*
* Process on-demand dialup. Output packets are queued within tunnel
* device until IPCP is opened.
*/
if (bundle_Phase(bundle) == PHASE_DEAD) {
/*
* Note, we must be in AUTO mode :-/ otherwise our interface should
* *not* be UP and we can't receive data
*/
pri = PacketCheck(bundle, tun.data, n, &bundle->filter.dial, NULL, NULL);
if (pri >= 0)
bundle_Open(bundle, NULL, PHYS_AUTO, 0);
else
/*
* Drop the packet. If we were to queue it, we'd just end up with
* a pile of timed-out data in our output queue by the time we get
* around to actually dialing. We'd also prematurely reach the
* threshold at which we stop select()ing to read() the tun
* device - breaking auto-dial.
*/
return;
}
secs = 0;
pri = PacketCheck(bundle, tun.data, n, &bundle->filter.out, NULL, &secs);
if (pri >= 0) {
/* Prepend the number of seconds timeout given in the filter */
tun.header.timeout = secs;
ip_Enqueue(&bundle->ncp.ipcp, pri, (char *)&tun, n + sizeof tun.header);
}
}
}
static int
bundle_DescriptorWrite(struct fdescriptor *d, struct bundle *bundle,
const fd_set *fdset)
{
struct datalink *dl;
int result = 0;
/* This is not actually necessary as struct mpserver doesn't Write() */
if (descriptor_IsSet(&bundle->ncp.mp.server.desc, fdset))
descriptor_Write(&bundle->ncp.mp.server.desc, bundle, fdset);
for (dl = bundle->links; dl; dl = dl->next)
if (descriptor_IsSet(&dl->desc, fdset))
result += descriptor_Write(&dl->desc, bundle, fdset);
return result;
}
void
bundle_LockTun(struct bundle *bundle)
{
FILE *lockfile;
char pidfile[PATH_MAX];
snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit);
lockfile = ID0fopen(pidfile, "w");
if (lockfile != NULL) {
fprintf(lockfile, "%d\n", (int)getpid());
fclose(lockfile);
}
#ifndef RELEASE_CRUNCH
else
log_Printf(LogERROR, "Warning: Can't create %s: %s\n",
pidfile, strerror(errno));
#endif
}
static void
bundle_UnlockTun(struct bundle *bundle)
{
char pidfile[PATH_MAX];
snprintf(pidfile, sizeof pidfile, "%stun%d.pid", _PATH_VARRUN, bundle->unit);
ID0unlink(pidfile);
}
struct bundle *
bundle_Create(const char *prefix, int type, int unit)
{
static struct bundle bundle; /* there can be only one */
int enoentcount, err, minunit, maxunit;
const char *ifname;
#if defined(__FreeBSD__) && !defined(NOKLDLOAD)
int kldtried;
#endif
#if defined(TUNSIFMODE) || defined(TUNSLMODE) || defined(TUNSIFHEAD)
int iff;
#endif
if (bundle.iface != NULL) { /* Already allocated ! */
log_Printf(LogALERT, "bundle_Create: There's only one BUNDLE !\n");
return NULL;
}
if (unit == -1) {
minunit = 0;
maxunit = -1;
} else {
minunit = unit;
maxunit = unit + 1;
}
err = ENOENT;
enoentcount = 0;
#if defined(__FreeBSD__) && !defined(NOKLDLOAD)
kldtried = 0;
#endif
for (bundle.unit = minunit; bundle.unit != maxunit; bundle.unit++) {
snprintf(bundle.dev.Name, sizeof bundle.dev.Name, "%s%d",
prefix, bundle.unit);
bundle.dev.fd = ID0open(bundle.dev.Name, O_RDWR);
if (bundle.dev.fd >= 0)
break;
else if (errno == ENXIO || errno == ENOENT) {
#if defined(__FreeBSD__) && !defined(NOKLDLOAD)
if (bundle.unit == minunit && !kldtried++) {
/*
* Attempt to load the tunnel interface KLD if it isn't loaded
* already.
*/
if (modfind("if_tun") == -1) {
if (ID0kldload("if_tun") != -1) {
bundle.unit--;
continue;
}
log_Printf(LogWARN, "kldload: if_tun: %s\n", strerror(errno));
}
}
#endif
if (errno != ENOENT || ++enoentcount > 2) {
err = errno;
break;
}
} else
err = errno;
}
if (bundle.dev.fd < 0) {
if (unit == -1)
log_Printf(LogWARN, "No available tunnel devices found (%s)\n",
strerror(err));
else
log_Printf(LogWARN, "%s%d: %s\n", prefix, unit, strerror(err));
return NULL;
}
log_SetTun(bundle.unit);
ifname = strrchr(bundle.dev.Name, '/');
if (ifname == NULL)
ifname = bundle.dev.Name;
else
ifname++;
bundle.iface = iface_Create(ifname);
if (bundle.iface == NULL) {
close(bundle.dev.fd);
return NULL;
}
#ifdef TUNSIFMODE
/* Make sure we're POINTOPOINT */
iff = IFF_POINTOPOINT;
if (ID0ioctl(bundle.dev.fd, TUNSIFMODE, &iff) < 0)
log_Printf(LogERROR, "bundle_Create: ioctl(TUNSIFMODE): %s\n",
strerror(errno));
#endif
#ifdef TUNSLMODE
/* Make sure we're not prepending sockaddrs */
iff = 0;
if (ID0ioctl(bundle.dev.fd, TUNSLMODE, &iff) < 0)
log_Printf(LogERROR, "bundle_Create: ioctl(TUNSLMODE): %s\n",
strerror(errno));
#endif
#ifdef TUNSIFHEAD
/* We want the address family please ! */
iff = 1;
if (ID0ioctl(bundle.dev.fd, TUNSIFHEAD, &iff) < 0) {
log_Printf(LogERROR, "bundle_Create: ioctl(TUNSIFHEAD): %s\n",
strerror(errno));
bundle.dev.header = 0;
} else
bundle.dev.header = 1;
#else
#ifdef __OpenBSD__
/* Always present for OpenBSD */
bundle.dev.header = 1;
#else
/*
* If TUNSIFHEAD isn't available and we're not OpenBSD, assume
* everything's AF_INET (hopefully the tun device won't pass us
* anything else !).
*/
bundle.dev.header = 0;
#endif
#endif
if (!iface_SetFlags(bundle.iface->name, IFF_UP)) {
iface_Destroy(bundle.iface);
bundle.iface = NULL;
close(bundle.dev.fd);
return NULL;
}
log_Printf(LogPHASE, "Using interface: %s\n", ifname);
bundle.bandwidth = 0;
bundle.routing_seq = 0;
bundle.phase = PHASE_DEAD;
bundle.CleaningUp = 0;
bundle.NatEnabled = 0;
bundle.fsm.LayerStart = bundle_LayerStart;
bundle.fsm.LayerUp = bundle_LayerUp;
bundle.fsm.LayerDown = bundle_LayerDown;
bundle.fsm.LayerFinish = bundle_LayerFinish;
bundle.fsm.object = &bundle;
bundle.cfg.idle.timeout = NCP_IDLE_TIMEOUT;
bundle.cfg.idle.min_timeout = 0;
*bundle.cfg.auth.name = '\0';
*bundle.cfg.auth.key = '\0';
bundle.cfg.opt = OPT_SROUTES | OPT_IDCHECK | OPT_LOOPBACK | OPT_TCPMSSFIXUP |
OPT_THROUGHPUT | OPT_UTMP;
*bundle.cfg.label = '\0';
bundle.cfg.ifqueue = DEF_IFQUEUE;
bundle.cfg.choked.timeout = CHOKED_TIMEOUT;
bundle.phys_type.all = type;
bundle.phys_type.open = 0;
bundle.upat = 0;
bundle.links = datalink_Create("deflink", &bundle, type);
if (bundle.links == NULL) {
log_Printf(LogALERT, "Cannot create data link: %s\n", strerror(errno));
iface_Destroy(bundle.iface);
bundle.iface = NULL;
close(bundle.dev.fd);
return NULL;
}
bundle.desc.type = BUNDLE_DESCRIPTOR;
bundle.desc.UpdateSet = bundle_UpdateSet;
bundle.desc.IsSet = bundle_IsSet;
bundle.desc.Read = bundle_DescriptorRead;
bundle.desc.Write = bundle_DescriptorWrite;
mp_Init(&bundle.ncp.mp, &bundle);
/* Send over the first physical link by default */
ipcp_Init(&bundle.ncp.ipcp, &bundle, &bundle.links->physical->link,
&bundle.fsm);
memset(&bundle.filter, '\0', sizeof bundle.filter);
bundle.filter.in.fragok = bundle.filter.in.logok = 1;
bundle.filter.in.name = "IN";
bundle.filter.out.fragok = bundle.filter.out.logok = 1;
bundle.filter.out.name = "OUT";
bundle.filter.dial.name = "DIAL";
bundle.filter.dial.logok = 1;
bundle.filter.alive.name = "ALIVE";
bundle.filter.alive.logok = 1;
{
int i;
for (i = 0; i < MAXFILTERS; i++) {
bundle.filter.in.rule[i].f_action = A_NONE;
bundle.filter.out.rule[i].f_action = A_NONE;
bundle.filter.dial.rule[i].f_action = A_NONE;
bundle.filter.alive.rule[i].f_action = A_NONE;
}
}
memset(&bundle.idle.timer, '\0', sizeof bundle.idle.timer);
bundle.idle.done = 0;
bundle.notify.fd = -1;
memset(&bundle.choked.timer, '\0', sizeof bundle.choked.timer);
#ifndef NORADIUS
radius_Init(&bundle.radius);
#endif
/* Clean out any leftover crud */
iface_Clear(bundle.iface, IFACE_CLEAR_ALL);
bundle_LockTun(&bundle);
return &bundle;
}
static void
bundle_DownInterface(struct bundle *bundle)
{
route_IfDelete(bundle, 1);
iface_ClearFlags(bundle->iface->name, IFF_UP);
}
void
bundle_Destroy(struct bundle *bundle)
{
struct datalink *dl;
/*
* Clean up the interface. We don't need to timer_Stop()s, mp_Down(),
* ipcp_CleanInterface() and bundle_DownInterface() unless we're getting
* out under exceptional conditions such as a descriptor exception.
*/
timer_Stop(&bundle->idle.timer);
timer_Stop(&bundle->choked.timer);
mp_Down(&bundle->ncp.mp);
ipcp_CleanInterface(&bundle->ncp.ipcp);
bundle_DownInterface(bundle);
#ifndef NORADIUS
/* Tell the radius server the bad news */
log_Printf(LogDEBUG, "Radius: Destroy called from bundle_Destroy\n");
radius_Destroy(&bundle->radius);
#endif
/* Again, these are all DATALINK_CLOSED unless we're abending */
dl = bundle->links;
while (dl)
dl = datalink_Destroy(dl);
ipcp_Destroy(&bundle->ncp.ipcp);
close(bundle->dev.fd);
bundle_UnlockTun(bundle);
/* In case we never made PHASE_NETWORK */
bundle_Notify(bundle, EX_ERRDEAD);
iface_Destroy(bundle->iface);
bundle->iface = NULL;
}
void
bundle_LinkClosed(struct bundle *bundle, struct datalink *dl)
{
/*
* Our datalink has closed.
* CleanDatalinks() (called from DoLoop()) will remove closed
* BACKGROUND, FOREGROUND and DIRECT links.
* If it's the last data link, enter phase DEAD.
*
* NOTE: dl may not be in our list (bundle_SendDatalink()) !
*/
struct datalink *odl;
int other_links;
log_SetTtyCommandMode(dl);
other_links = 0;
for (odl = bundle->links; odl; odl = odl->next)
if (odl != dl && odl->state != DATALINK_CLOSED)
other_links++;
if (!other_links) {
if (dl->physical->type != PHYS_AUTO) /* Not in -auto mode */
bundle_DownInterface(bundle);
fsm2initial(&bundle->ncp.ipcp.fsm);
bundle_NewPhase(bundle, PHASE_DEAD);
bundle_StopIdleTimer(bundle);
}
}
void
bundle_Open(struct bundle *bundle, const char *name, int mask, int force)
{
/*
* Please open the given datalink, or all if name == NULL
*/
struct datalink *dl;
for (dl = bundle->links; dl; dl = dl->next)
if (name == NULL || !strcasecmp(dl->name, name)) {
if ((mask & dl->physical->type) &&
(dl->state == DATALINK_CLOSED ||
(force && dl->state == DATALINK_OPENING &&
dl->dial.timer.state == TIMER_RUNNING) ||
dl->state == DATALINK_READY)) {
timer_Stop(&dl->dial.timer); /* We're finished with this */
datalink_Up(dl, 1, 1);
if (mask & PHYS_AUTO)
break; /* Only one AUTO link at a time */
}
if (name != NULL)
break;
}
}
struct datalink *
bundle2datalink(struct bundle *bundle, const char *name)
{
struct datalink *dl;
if (name != NULL) {
for (dl = bundle->links; dl; dl = dl->next)
if (!strcasecmp(dl->name, name))
return dl;
} else if (bundle->links && !bundle->links->next)
return bundle->links;
return NULL;
}
int
bundle_ShowLinks(struct cmdargs const *arg)
{
struct datalink *dl;
struct pppThroughput *t;
unsigned long long octets;
int secs;
for (dl = arg->bundle->links; dl; dl = dl->next) {
octets = MAX(dl->physical->link.stats.total.in.OctetsPerSecond,
dl->physical->link.stats.total.out.OctetsPerSecond);
prompt_Printf(arg->prompt, "Name: %s [%s, %s]",
dl->name, mode2Nam(dl->physical->type), datalink_State(dl));
if (dl->physical->link.stats.total.rolling && dl->state == DATALINK_OPEN)
prompt_Printf(arg->prompt, " bandwidth %d, %llu bps (%llu bytes/sec)",
dl->mp.bandwidth ? dl->mp.bandwidth :
physical_GetSpeed(dl->physical),
octets * 8, octets);
prompt_Printf(arg->prompt, "\n");
}
t = &arg->bundle->ncp.mp.link.stats.total;
octets = MAX(t->in.OctetsPerSecond, t->out.OctetsPerSecond);
secs = t->downtime ? 0 : throughput_uptime(t);
if (secs > t->SamplePeriod)
secs = t->SamplePeriod;
if (secs)
prompt_Printf(arg->prompt, "Currently averaging %llu bps (%llu bytes/sec)"
" over the last %d secs\n", octets * 8, octets, secs);
return 0;
}
static const char *
optval(struct bundle *bundle, int bit)
{
return (bundle->cfg.opt & bit) ? "enabled" : "disabled";
}
int
bundle_ShowStatus(struct cmdargs const *arg)
{
int remaining;
prompt_Printf(arg->prompt, "Phase %s\n", bundle_PhaseName(arg->bundle));
prompt_Printf(arg->prompt, " Device: %s\n", arg->bundle->dev.Name);
prompt_Printf(arg->prompt, " Interface: %s @ %lubps",
arg->bundle->iface->name, arg->bundle->bandwidth);
if (arg->bundle->upat) {
int secs = time(NULL) - arg->bundle->upat;
prompt_Printf(arg->prompt, ", up time %d:%02d:%02d", secs / 3600,
(secs / 60) % 60, secs % 60);
}
prompt_Printf(arg->prompt, "\n Queued: %lu of %u\n",
(unsigned long)ip_QueueLen(&arg->bundle->ncp.ipcp),
arg->bundle->cfg.ifqueue);
prompt_Printf(arg->prompt, "\nDefaults:\n");
prompt_Printf(arg->prompt, " Label: %s\n",
arg->bundle->cfg.label);
prompt_Printf(arg->prompt, " Auth name: %s\n",
arg->bundle->cfg.auth.name);
prompt_Printf(arg->prompt, " Diagnostic socket: ");
if (*server.cfg.sockname != '\0') {
prompt_Printf(arg->prompt, "%s", server.cfg.sockname);
if (server.cfg.mask != (mode_t)-1)
prompt_Printf(arg->prompt, ", mask 0%03o", (int)server.cfg.mask);
prompt_Printf(arg->prompt, "%s\n", server.fd == -1 ? " (not open)" : "");
} else if (server.cfg.port != 0)
prompt_Printf(arg->prompt, "TCP port %d%s\n", server.cfg.port,
server.fd == -1 ? " (not open)" : "");
else
prompt_Printf(arg->prompt, "none\n");
prompt_Printf(arg->prompt, " Choked Timer: %ds\n",
arg->bundle->cfg.choked.timeout);
#ifndef NORADIUS
radius_Show(&arg->bundle->radius, arg->prompt);
#endif
prompt_Printf(arg->prompt, " Idle Timer: ");
if (arg->bundle->cfg.idle.timeout) {
prompt_Printf(arg->prompt, "%ds", arg->bundle->cfg.idle.timeout);
if (arg->bundle->cfg.idle.min_timeout)
prompt_Printf(arg->prompt, ", min %ds",
arg->bundle->cfg.idle.min_timeout);
remaining = bundle_RemainingIdleTime(arg->bundle);
if (remaining != -1)
prompt_Printf(arg->prompt, " (%ds remaining)", remaining);
prompt_Printf(arg->prompt, "\n");
} else
prompt_Printf(arg->prompt, "disabled\n");
prompt_Printf(arg->prompt, " sendpipe: ");
if (arg->bundle->ncp.ipcp.cfg.sendpipe > 0)
prompt_Printf(arg->prompt, "%-20ld", arg->bundle->ncp.ipcp.cfg.sendpipe);
else
prompt_Printf(arg->prompt, "unspecified ");
prompt_Printf(arg->prompt, " recvpipe: ");
if (arg->bundle->ncp.ipcp.cfg.recvpipe > 0)
prompt_Printf(arg->prompt, "%ld\n", arg->bundle->ncp.ipcp.cfg.recvpipe);
else
prompt_Printf(arg->prompt, "unspecified\n");
prompt_Printf(arg->prompt, " Sticky Routes: %-20.20s",
optval(arg->bundle, OPT_SROUTES));
prompt_Printf(arg->prompt, " Filter Decap: %s\n",
optval(arg->bundle, OPT_FILTERDECAP));
prompt_Printf(arg->prompt, " ID check: %-20.20s",
optval(arg->bundle, OPT_IDCHECK));
prompt_Printf(arg->prompt, " Keep-Session: %s\n",
optval(arg->bundle, OPT_KEEPSESSION));
prompt_Printf(arg->prompt, " Loopback: %-20.20s",
optval(arg->bundle, OPT_LOOPBACK));
prompt_Printf(arg->prompt, " PasswdAuth: %s\n",
optval(arg->bundle, OPT_PASSWDAUTH));
prompt_Printf(arg->prompt, " Proxy: %-20.20s",
optval(arg->bundle, OPT_PROXY));
prompt_Printf(arg->prompt, " Proxyall: %s\n",
optval(arg->bundle, OPT_PROXYALL));
prompt_Printf(arg->prompt, " TCPMSS Fixup: %-20.20s",
optval(arg->bundle, OPT_TCPMSSFIXUP));
prompt_Printf(arg->prompt, " Throughput: %s\n",
optval(arg->bundle, OPT_THROUGHPUT));
prompt_Printf(arg->prompt, " Utmp Logging: %-20.20s",
optval(arg->bundle, OPT_UTMP));
prompt_Printf(arg->prompt, " Iface-Alias: %s\n",
optval(arg->bundle, OPT_IFACEALIAS));
return 0;
}
static void
bundle_IdleTimeout(void *v)
{
struct bundle *bundle = (struct bundle *)v;
log_Printf(LogPHASE, "Idle timer expired\n");
bundle_StopIdleTimer(bundle);
bundle_Close(bundle, NULL, CLOSE_STAYDOWN);
}
/*
* Start Idle timer. If timeout is reached, we call bundle_Close() to
* close LCP and link.
*/
void
bundle_StartIdleTimer(struct bundle *bundle, unsigned secs)
{
timer_Stop(&bundle->idle.timer);
if ((bundle->phys_type.open & (PHYS_DEDICATED|PHYS_DDIAL)) !=
bundle->phys_type.open && bundle->cfg.idle.timeout) {
time_t now = time(NULL);
if (secs == 0)
secs = bundle->cfg.idle.timeout;
/* We want at least `secs' */
if (bundle->cfg.idle.min_timeout > secs && bundle->upat) {
int up = now - bundle->upat;
if ((long long)bundle->cfg.idle.min_timeout - up > (long long)secs)
/* Only increase from the current `remaining' value */
secs = bundle->cfg.idle.min_timeout - up;
}
bundle->idle.timer.func = bundle_IdleTimeout;
bundle->idle.timer.name = "idle";
bundle->idle.timer.load = secs * SECTICKS;
bundle->idle.timer.arg = bundle;
timer_Start(&bundle->idle.timer);
bundle->idle.done = now + secs;
}
}
void
bundle_SetIdleTimer(struct bundle *bundle, int timeout, int min_timeout)
{
bundle->cfg.idle.timeout = timeout;
if (min_timeout >= 0)
bundle->cfg.idle.min_timeout = min_timeout;
if (bundle_LinkIsUp(bundle))
bundle_StartIdleTimer(bundle, 0);
}
void
bundle_StopIdleTimer(struct bundle *bundle)
{
timer_Stop(&bundle->idle.timer);
bundle->idle.done = 0;
}
static int
bundle_RemainingIdleTime(struct bundle *bundle)
{
if (bundle->idle.done)
return bundle->idle.done - time(NULL);
return -1;
}
int
bundle_IsDead(struct bundle *bundle)
{
return !bundle->links || (bundle->phase == PHASE_DEAD && bundle->CleaningUp);
}
static struct datalink *
bundle_DatalinkLinkout(struct bundle *bundle, struct datalink *dl)
{
struct datalink **dlp;
for (dlp = &bundle->links; *dlp; dlp = &(*dlp)->next)
if (*dlp == dl) {
*dlp = dl->next;
dl->next = NULL;
bundle_LinksRemoved(bundle);
return dl;
}
return NULL;
}
static void
bundle_DatalinkLinkin(struct bundle *bundle, struct datalink *dl)
{
struct datalink **dlp = &bundle->links;
while (*dlp)
dlp = &(*dlp)->next;
*dlp = dl;
dl->next = NULL;
bundle_LinkAdded(bundle, dl);
mp_CheckAutoloadTimer(&bundle->ncp.mp);
}
void
bundle_CleanDatalinks(struct bundle *bundle)
{
struct datalink **dlp = &bundle->links;
int found = 0;
while (*dlp)
if ((*dlp)->state == DATALINK_CLOSED &&
(*dlp)->physical->type &
(PHYS_DIRECT|PHYS_BACKGROUND|PHYS_FOREGROUND)) {
*dlp = datalink_Destroy(*dlp);
found++;
} else
dlp = &(*dlp)->next;
if (found)
bundle_LinksRemoved(bundle);
}
int
bundle_DatalinkClone(struct bundle *bundle, struct datalink *dl,
const char *name)
{
if (bundle2datalink(bundle, name)) {
log_Printf(LogWARN, "Clone: %s: name already exists\n", name);
return 0;
}
bundle_DatalinkLinkin(bundle, datalink_Clone(dl, name));
return 1;
}
void
bundle_DatalinkRemove(struct bundle *bundle, struct datalink *dl)
{
dl = bundle_DatalinkLinkout(bundle, dl);
if (dl)
datalink_Destroy(dl);
}
void
bundle_SetLabel(struct bundle *bundle, const char *label)
{
if (label)
strncpy(bundle->cfg.label, label, sizeof bundle->cfg.label - 1);
else
*bundle->cfg.label = '\0';
}
const char *
bundle_GetLabel(struct bundle *bundle)
{
return *bundle->cfg.label ? bundle->cfg.label : NULL;
}
int
bundle_LinkSize()
{
struct iovec iov[SCATTER_SEGMENTS];
int niov, expect, f;
iov[0].iov_len = strlen(Version) + 1;
iov[0].iov_base = NULL;
niov = 1;
if (datalink2iov(NULL, iov, &niov, SCATTER_SEGMENTS, NULL, NULL) == -1) {
log_Printf(LogERROR, "Cannot determine space required for link\n");
return 0;
}
for (f = expect = 0; f < niov; f++)
expect += iov[f].iov_len;
return expect;
}
void
bundle_ReceiveDatalink(struct bundle *bundle, int s)
{
char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int) * SEND_MAXFD];
int niov, expect, f, *fd, nfd, onfd, got;
struct iovec iov[SCATTER_SEGMENTS];
struct cmsghdr *cmsg;
struct msghdr msg;
struct datalink *dl;
pid_t pid;
log_Printf(LogPHASE, "Receiving datalink\n");
/*
* Create our scatter/gather array - passing NULL gets the space
* allocation requirement rather than actually flattening the
* structures.
*/
iov[0].iov_len = strlen(Version) + 1;
iov[0].iov_base = NULL;
niov = 1;
if (datalink2iov(NULL, iov, &niov, SCATTER_SEGMENTS, NULL, NULL) == -1) {
log_Printf(LogERROR, "Cannot determine space required for link\n");
return;
}
/* Allocate the scatter/gather array for recvmsg() */
for (f = expect = 0; f < niov; f++) {
if ((iov[f].iov_base = malloc(iov[f].iov_len)) == NULL) {
log_Printf(LogERROR, "Cannot allocate space to receive link\n");
return;
}
if (f)
expect += iov[f].iov_len;
}
/* Set up our message */
cmsg = (struct cmsghdr *)cmsgbuf;
cmsg->cmsg_len = sizeof cmsgbuf;
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = 0;
memset(&msg, '\0', sizeof msg);
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 1; /* Only send the version at the first pass */
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof cmsgbuf;
log_Printf(LogDEBUG, "Expecting %u scatter/gather bytes\n",
(unsigned)iov[0].iov_len);
if ((got = recvmsg(s, &msg, MSG_WAITALL)) != iov[0].iov_len) {
if (got == -1)
log_Printf(LogERROR, "Failed recvmsg: %s\n", strerror(errno));
else
log_Printf(LogERROR, "Failed recvmsg: Got %d, not %u\n",
got, (unsigned)iov[0].iov_len);
while (niov--)
free(iov[niov].iov_base);
return;
}
if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
log_Printf(LogERROR, "Recvmsg: no descriptors received !\n");
while (niov--)
free(iov[niov].iov_base);
return;
}
fd = (int *)(cmsg + 1);
nfd = (cmsg->cmsg_len - sizeof *cmsg) / sizeof(int);
if (nfd < 2) {
log_Printf(LogERROR, "Recvmsg: %d descriptor%s received (too few) !\n",
nfd, nfd == 1 ? "" : "s");
while (nfd--)
close(fd[nfd]);
while (niov--)
free(iov[niov].iov_base);
return;
}
/*
* We've successfully received two or more open file descriptors
* through our socket, plus a version string. Make sure it's the
* correct version, and drop the connection if it's not.
*/
if (strncmp(Version, iov[0].iov_base, iov[0].iov_len)) {
log_Printf(LogWARN, "Cannot receive datalink, incorrect version"
" (\"%.*s\", not \"%s\")\n", (int)iov[0].iov_len,
(char *)iov[0].iov_base, Version);
while (nfd--)
close(fd[nfd]);
while (niov--)
free(iov[niov].iov_base);
return;
}
/*
* Everything looks good. Send the other side our process id so that
* they can transfer lock ownership, and wait for them to send the
* actual link data.
*/
pid = getpid();
if ((got = write(fd[1], &pid, sizeof pid)) != sizeof pid) {
if (got == -1)
log_Printf(LogERROR, "Failed write: %s\n", strerror(errno));
else
log_Printf(LogERROR, "Failed write: Got %d, not %d\n", got,
(int)(sizeof pid));
while (nfd--)
close(fd[nfd]);
while (niov--)
free(iov[niov].iov_base);
return;
}
if ((got = readv(fd[1], iov + 1, niov - 1)) != expect) {
if (got == -1)
log_Printf(LogERROR, "Failed write: %s\n", strerror(errno));
else
log_Printf(LogERROR, "Failed write: Got %d, not %d\n", got, expect);
while (nfd--)
close(fd[nfd]);
while (niov--)
free(iov[niov].iov_base);
return;
}
close(fd[1]);
onfd = nfd; /* We've got this many in our array */
nfd -= 2; /* Don't include p->fd and our reply descriptor */
niov = 1; /* Skip the version id */
dl = iov2datalink(bundle, iov, &niov, sizeof iov / sizeof *iov, fd[0],
fd + 2, &nfd);
if (dl) {
if (nfd) {
log_Printf(LogERROR, "bundle_ReceiveDatalink: Failed to handle %d "
"auxiliary file descriptors (%d remain)\n", onfd, nfd);
datalink_Destroy(dl);
while (nfd--)
close(fd[onfd--]);
close(fd[0]);
} else {
bundle_DatalinkLinkin(bundle, dl);
datalink_AuthOk(dl);
bundle_CalculateBandwidth(dl->bundle);
}
} else {
while (nfd--)
close(fd[onfd--]);
close(fd[0]);
close(fd[1]);
}
free(iov[0].iov_base);
}
void
bundle_SendDatalink(struct datalink *dl, int s, struct sockaddr_un *sun)
{
char cmsgbuf[sizeof(struct cmsghdr) + sizeof(int) * SEND_MAXFD];
const char *constlock;
char *lock;
struct cmsghdr *cmsg;
struct msghdr msg;
struct iovec iov[SCATTER_SEGMENTS];
int niov, f, expect, newsid, fd[SEND_MAXFD], nfd, reply[2], got;
pid_t newpid;
log_Printf(LogPHASE, "Transmitting datalink %s\n", dl->name);
/* Record the base device name for a lock transfer later */
constlock = physical_LockedDevice(dl->physical);
if (constlock) {
lock = alloca(strlen(constlock) + 1);
strcpy(lock, constlock);
} else
lock = NULL;
bundle_LinkClosed(dl->bundle, dl);
bundle_DatalinkLinkout(dl->bundle, dl);
/* Build our scatter/gather array */
iov[0].iov_len = strlen(Version) + 1;
iov[0].iov_base = strdup(Version);
niov = 1;
nfd = 0;
fd[0] = datalink2iov(dl, iov, &niov, SCATTER_SEGMENTS, fd + 2, &nfd);
if (fd[0] != -1 && socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, reply) != -1) {
/*
* fd[1] is used to get the peer process id back, then to confirm that
* we've transferred any device locks to that process id.
*/
fd[1] = reply[1];
nfd += 2; /* Include fd[0] and fd[1] */
memset(&msg, '\0', sizeof msg);
msg.msg_name = NULL;
msg.msg_namelen = 0;
/*
* Only send the version to start... We used to send the whole lot, but
* this caused problems with our RECVBUF size as a single link is about
* 22k ! This way, we should bump into no limits.
*/
msg.msg_iovlen = 1;
msg.msg_iov = iov;
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof *cmsg + sizeof(int) * nfd;
msg.msg_flags = 0;
cmsg = (struct cmsghdr *)cmsgbuf;
cmsg->cmsg_len = msg.msg_controllen;
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
for (f = 0; f < nfd; f++)
*((int *)(cmsg + 1) + f) = fd[f];
for (f = 1, expect = 0; f < niov; f++)
expect += iov[f].iov_len;
if (setsockopt(reply[0], SOL_SOCKET, SO_SNDBUF, &expect, sizeof(int)) == -1)
log_Printf(LogERROR, "setsockopt(SO_RCVBUF, %d): %s\n", expect,
strerror(errno));
if (setsockopt(reply[1], SOL_SOCKET, SO_RCVBUF, &expect, sizeof(int)) == -1)
log_Printf(LogERROR, "setsockopt(SO_RCVBUF, %d): %s\n", expect,
strerror(errno));
log_Printf(LogDEBUG, "Sending %d descriptor%s and %u bytes in scatter"
"/gather array\n", nfd, nfd == 1 ? "" : "s",
(unsigned)iov[0].iov_len);
if ((got = sendmsg(s, &msg, 0)) == -1)
log_Printf(LogERROR, "Failed sendmsg: %s: %s\n",
sun->sun_path, strerror(errno));
else if (got != iov[0].iov_len)
log_Printf(LogERROR, "%s: Failed initial sendmsg: Only sent %d of %u\n",
sun->sun_path, got, (unsigned)iov[0].iov_len);
else {
/* We must get the ACK before closing the descriptor ! */
int res;
if ((got = read(reply[0], &newpid, sizeof newpid)) == sizeof newpid) {
log_Printf(LogDEBUG, "Received confirmation from pid %d\n",
(int)newpid);
if (lock && (res = ID0uu_lock_txfr(lock, newpid)) != UU_LOCK_OK)
log_Printf(LogERROR, "uu_lock_txfr: %s\n", uu_lockerr(res));
log_Printf(LogDEBUG, "Transmitting link (%d bytes)\n", expect);
if ((got = writev(reply[0], iov + 1, niov - 1)) != expect) {
if (got == -1)
log_Printf(LogERROR, "%s: Failed writev: %s\n",
sun->sun_path, strerror(errno));
else
log_Printf(LogERROR, "%s: Failed writev: Wrote %d of %d\n",
sun->sun_path, got, expect);
}
} else if (got == -1)
log_Printf(LogERROR, "%s: Failed socketpair read: %s\n",
sun->sun_path, strerror(errno));
else
log_Printf(LogERROR, "%s: Failed socketpair read: Got %d of %d\n",
sun->sun_path, got, (int)(sizeof newpid));
}
close(reply[0]);
close(reply[1]);
newsid = Enabled(dl->bundle, OPT_KEEPSESSION) ||
tcgetpgrp(fd[0]) == getpgrp();
while (nfd)
close(fd[--nfd]);
if (newsid)
bundle_setsid(dl->bundle, got != -1);
}
close(s);
while (niov--)
free(iov[niov].iov_base);
}
int
bundle_RenameDatalink(struct bundle *bundle, struct datalink *ndl,
const char *name)
{
struct datalink *dl;
if (!strcasecmp(ndl->name, name))
return 1;
for (dl = bundle->links; dl; dl = dl->next)
if (!strcasecmp(dl->name, name))
return 0;
datalink_Rename(ndl, name);
return 1;
}
int
bundle_SetMode(struct bundle *bundle, struct datalink *dl, int mode)
{
int omode;
omode = dl->physical->type;
if (omode == mode)
return 1;
if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO))
/* First auto link */
if (bundle->ncp.ipcp.peer_ip.s_addr == INADDR_ANY) {
log_Printf(LogWARN, "You must `set ifaddr' or `open' before"
" changing mode to %s\n", mode2Nam(mode));
return 0;
}
if (!datalink_SetMode(dl, mode))
return 0;
if (mode == PHYS_AUTO && !(bundle->phys_type.all & PHYS_AUTO) &&
bundle->phase != PHASE_NETWORK)
/* First auto link, we need an interface */
ipcp_InterfaceUp(&bundle->ncp.ipcp);
/* Regenerate phys_type and adjust idle timer */
bundle_LinksRemoved(bundle);
return 1;
}
void
bundle_setsid(struct bundle *bundle, int holdsession)
{
/*
* Lose the current session. This means getting rid of our pid
* too so that the tty device will really go away, and any getty
* etc will be allowed to restart.
*/
pid_t pid, orig;
int fds[2];
char done;
struct datalink *dl;
if (!holdsession && bundle_IsDead(bundle)) {
/*
* No need to lose our session after all... we're going away anyway
*
* We should really stop the timer and pause if holdsession is set and
* the bundle's dead, but that leaves other resources lying about :-(
*/
return;
}
orig = getpid();
if (pipe(fds) == -1) {
log_Printf(LogERROR, "pipe: %s\n", strerror(errno));
return;
}
switch ((pid = fork())) {
case -1:
log_Printf(LogERROR, "fork: %s\n", strerror(errno));
close(fds[0]);
close(fds[1]);
return;
case 0:
close(fds[1]);
read(fds[0], &done, 1); /* uu_locks are mine ! */
close(fds[0]);
if (pipe(fds) == -1) {
log_Printf(LogERROR, "pipe(2): %s\n", strerror(errno));
return;
}
switch ((pid = fork())) {
case -1:
log_Printf(LogERROR, "fork(2): %s\n", strerror(errno));
close(fds[0]);
close(fds[1]);
return;
case 0:
close(fds[1]);
bundle_LockTun(bundle); /* update pid */
read(fds[0], &done, 1); /* uu_locks are mine ! */
close(fds[0]);
setsid();
bundle_ChangedPID(bundle);
log_Printf(LogDEBUG, "%d -> %d: %s session control\n",
(int)orig, (int)getpid(),
holdsession ? "Passed" : "Dropped");
timer_InitService(0); /* Start the Timer Service */
break;
default:
close(fds[0]);
/* Give away all our physical locks (to the final process) */
for (dl = bundle->links; dl; dl = dl->next)
if (dl->state != DATALINK_CLOSED)
physical_ChangedPid(dl->physical, pid);
write(fds[1], "!", 1); /* done */
close(fds[1]);
_exit(0);
break;
}
break;
default:
close(fds[0]);
/* Give away all our physical locks (to the intermediate process) */
for (dl = bundle->links; dl; dl = dl->next)
if (dl->state != DATALINK_CLOSED)
physical_ChangedPid(dl->physical, pid);
write(fds[1], "!", 1); /* done */
close(fds[1]);
if (holdsession) {
int fd, status;
timer_TermService();
signal(SIGPIPE, SIG_DFL);
signal(SIGALRM, SIG_DFL);
signal(SIGHUP, SIG_DFL);
signal(SIGTERM, SIG_DFL);
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
for (fd = getdtablesize(); fd >= 0; fd--)
close(fd);
/*
* Reap the intermediate process. As we're not exiting but the
* intermediate is, we don't want it to become defunct.
*/
waitpid(pid, &status, 0);
/* Tweak our process arguments.... */
SetTitle("session owner");
#ifndef NOSUID
setuid(ID0realuid());
#endif
/*
* Hang around for a HUP. This should happen as soon as the
* ppp that we passed our ctty descriptor to closes it.
* NOTE: If this process dies, the passed descriptor becomes
* invalid and will give a select() error by setting one
* of the error fds, aborting the other ppp. We don't
* want that to happen !
*/
pause();
}
_exit(0);
break;
}
}
int
bundle_HighestState(struct bundle *bundle)
{
struct datalink *dl;
int result = DATALINK_CLOSED;
for (dl = bundle->links; dl; dl = dl->next)
if (result < dl->state)
result = dl->state;
return result;
}
int
bundle_Exception(struct bundle *bundle, int fd)
{
struct datalink *dl;
for (dl = bundle->links; dl; dl = dl->next)
if (dl->physical->fd == fd) {
datalink_Down(dl, CLOSE_NORMAL);
return 1;
}
return 0;
}
void
bundle_AdjustFilters(struct bundle *bundle, struct in_addr *my_ip,
struct in_addr *peer_ip)
{
filter_AdjustAddr(&bundle->filter.in, my_ip, peer_ip, NULL);
filter_AdjustAddr(&bundle->filter.out, my_ip, peer_ip, NULL);
filter_AdjustAddr(&bundle->filter.dial, my_ip, peer_ip, NULL);
filter_AdjustAddr(&bundle->filter.alive, my_ip, peer_ip, NULL);
}
void
bundle_AdjustDNS(struct bundle *bundle, struct in_addr dns[2])
{
filter_AdjustAddr(&bundle->filter.in, NULL, NULL, dns);
filter_AdjustAddr(&bundle->filter.out, NULL, NULL, dns);
filter_AdjustAddr(&bundle->filter.dial, NULL, NULL, dns);
filter_AdjustAddr(&bundle->filter.alive, NULL, NULL, dns);
}
void
bundle_CalculateBandwidth(struct bundle *bundle)
{
struct datalink *dl;
int sp, overhead, maxoverhead;
bundle->bandwidth = 0;
bundle->iface->mtu = 0;
maxoverhead = 0;
for (dl = bundle->links; dl; dl = dl->next) {
overhead = ccp_MTUOverhead(&dl->physical->link.ccp);
if (maxoverhead < overhead)
maxoverhead = overhead;
if (dl->state == DATALINK_OPEN) {
if ((sp = dl->mp.bandwidth) == 0 &&
(sp = physical_GetSpeed(dl->physical)) == 0)
log_Printf(LogDEBUG, "%s: %s: Cannot determine bandwidth\n",
dl->name, dl->physical->name.full);
else
bundle->bandwidth += sp;
if (!bundle->ncp.mp.active) {
bundle->iface->mtu = dl->physical->link.lcp.his_mru;
break;
}
}
}
if(bundle->bandwidth == 0)
bundle->bandwidth = 115200; /* Shrug */
if (bundle->ncp.mp.active) {
bundle->iface->mtu = bundle->ncp.mp.peer_mrru;
overhead = ccp_MTUOverhead(&bundle->ncp.mp.link.ccp);
if (maxoverhead < overhead)
maxoverhead = overhead;
} else if (!bundle->iface->mtu)
bundle->iface->mtu = DEF_MRU;
#ifndef NORADIUS
if (bundle->radius.valid && bundle->radius.mtu &&
bundle->radius.mtu < bundle->iface->mtu) {
log_Printf(LogLCP, "Reducing MTU to radius value %lu\n",
bundle->radius.mtu);
bundle->iface->mtu = bundle->radius.mtu;
}
#endif
if (maxoverhead) {
log_Printf(LogLCP, "Reducing MTU from %d to %d (CCP requirement)\n",
bundle->iface->mtu, bundle->iface->mtu - maxoverhead);
bundle->iface->mtu -= maxoverhead;
}
tun_configure(bundle);
route_UpdateMTU(bundle);
}
void
bundle_AutoAdjust(struct bundle *bundle, int percent, int what)
{
struct datalink *dl, *choice, *otherlinkup;
choice = otherlinkup = NULL;
for (dl = bundle->links; dl; dl = dl->next)
if (dl->physical->type == PHYS_AUTO) {
if (dl->state == DATALINK_OPEN) {
if (what == AUTO_DOWN) {
if (choice)
otherlinkup = choice;
choice = dl;
}
} else if (dl->state == DATALINK_CLOSED) {
if (what == AUTO_UP) {
choice = dl;
break;
}
} else {
/* An auto link in an intermediate state - forget it for the moment */
choice = NULL;
break;
}
} else if (dl->state == DATALINK_OPEN && what == AUTO_DOWN)
otherlinkup = dl;
if (choice) {
if (what == AUTO_UP) {
log_Printf(LogPHASE, "%d%% saturation -> Opening link ``%s''\n",
percent, choice->name);
datalink_Up(choice, 1, 1);
mp_CheckAutoloadTimer(&bundle->ncp.mp);
} else if (otherlinkup) { /* Only bring the second-last link down */
log_Printf(LogPHASE, "%d%% saturation -> Closing link ``%s''\n",
percent, choice->name);
datalink_Close(choice, CLOSE_STAYDOWN);
mp_CheckAutoloadTimer(&bundle->ncp.mp);
}
}
}
int
bundle_WantAutoloadTimer(struct bundle *bundle)
{
struct datalink *dl;
int autolink, opened;
if (bundle->phase == PHASE_NETWORK) {
for (autolink = opened = 0, dl = bundle->links; dl; dl = dl->next)
if (dl->physical->type == PHYS_AUTO) {
if (++autolink == 2 || (autolink == 1 && opened))
/* Two auto links or one auto and one open in NETWORK phase */
return 1;
} else if (dl->state == DATALINK_OPEN) {
opened++;
if (autolink)
/* One auto and one open link in NETWORK phase */
return 1;
}
}
return 0;
}
void
bundle_ChangedPID(struct bundle *bundle)
{
#ifdef TUNSIFPID
ioctl(bundle->dev.fd, TUNSIFPID, 0);
#endif
}