#include "pppd.h"
#include "fsm.h"
#include "ipcp.h"
-#include "patchlevel.h"
#ifdef IPX_CHANGE
#include "ipxcp.h"
#endif
#endif /* IPX_CHANGE */
+#ifdef PPP_FILTER
+#include <net/bpf.h>
+#include <linux/filter.h>
+#endif /* PPP_FILTER */
+
#ifdef LOCKLIB
#include <sys/locks.h>
#endif
static int sock6_fd = -1;
#endif /* INET6 */
static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
+static int chindex; /* channel index (new style driver) */
static fd_set in_fds; /* set of fds that wait_input waits for */
static int max_in_fd; /* highest fd set in in_fds */
static u_int32_t default_route_gateway; /* Gateway for default route added */
static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
static char proxy_arp_dev[16]; /* Device for proxy arp entry */
+static u_int32_t our_old_addr; /* for detecting address changes */
+static int dynaddr_set; /* 1 if ip_dynaddr set */
+static int looped; /* 1 if using loop */
+static int link_mtu; /* mtu for the link (not bundle) */
static struct utsname utsname; /* for the kernel version */
static int kernel_version;
#define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
+#define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
+
/* Prototypes for procedures local to this file. */
static int get_flags (int fd);
static void set_flags (int fd, int flags);
static int translate_speed (int bps);
static int baud_rate_of (int speed);
-static char *path_to_route (void);
static void close_route_table (void);
static int open_route_table (void);
static int read_route_table (struct rtentry *rt);
static void decode_version (char *buf, int *version, int *mod, int *patch);
static int set_kdebugflag(int level);
static int ppp_registered(void);
+static int make_ppp_unit(void);
extern u_char inpacket_buf[]; /* borrowed from main.c */
void sys_init(void)
{
- int osmaj, osmin, ospatch;
int flags;
- openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
- setlogmask(LOG_UPTO(LOG_INFO));
- if (debug)
- setlogmask(LOG_UPTO(LOG_DEBUG));
-
if (new_style_driver) {
ppp_dev_fd = open("/dev/ppp", O_RDWR);
if (ppp_dev_fd < 0)
#ifdef INET6
sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
if (sock6_fd < 0)
- fatal("Couldn't create IPv6 socket: %m(%d)", errno);
+ sock6_fd = -errno; /* save errno for later */
#endif
FD_ZERO(&in_fds);
max_in_fd = 0;
-
- uname(&utsname);
- osmaj = osmin = ospatch = 0;
- sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
- kernel_version = KVERSION(osmaj, osmin, ospatch);
}
/********************************************************************
static int set_kdebugflag (int requested_level)
{
+ if (new_style_driver && ifunit < 0)
+ return 1;
if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
if ( ! ok_error (errno) )
error("ioctl(PPPIOCSDEBUG): %m");
/********************************************************************
*
- * establish_ppp - Turn the serial port into a ppp interface.
+ * tty_establish_ppp - Turn the serial port into a ppp interface.
*/
-int establish_ppp (int tty_fd)
+int tty_establish_ppp (int tty_fd)
{
int x;
+ int fd = -1;
-/*
- * The current PPP device will be the tty file.
- */
- set_ppp_fd (tty_fd);
/*
* Ensure that the tty device is in exclusive mode.
*/
if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
if ( ! ok_error ( errno ))
- warn("ioctl(TIOCEXCL): %m");
+ warn("Couldn't make tty exclusive: %m");
}
/*
* Demand mode - prime the old ppp device to relinquish the unit.
*/
- if (!new_style_driver && demand
- && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
- fatal("ioctl(transfer ppp unit): %m(%d)", errno);
+ if (!new_style_driver && looped
+ && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
+ error("ioctl(transfer ppp unit): %m");
+ return -1;
+ }
/*
* Set the current tty to the PPP discpline
*/
+
+#ifndef N_SYNC_PPP
+#define N_SYNC_PPP 14
+#endif
+ ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
- if ( ! ok_error (errno) )
- fatal("ioctl(TIOCSETD): %m(%d)", errno);
+ if ( ! ok_error (errno) ) {
+ error("Couldn't set tty to PPP discipline: %m");
+ return -1;
+ }
}
-/*
- * Find out which interface we were given.
- */
+
if (new_style_driver) {
- if (!demand) {
- /* allocate ourselves a ppp unit */
+ /* Open another instance of /dev/ppp and connect the channel to it */
+ int flags;
+
+ if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
+ error("Couldn't get channel number: %m");
+ goto err;
+ }
+ dbglog("using channel %d", chindex);
+ fd = open("/dev/ppp", O_RDWR);
+ if (fd < 0) {
+ error("Couldn't reopen /dev/ppp: %m");
+ goto err;
+ }
+ if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
+ error("Couldn't attach to channel %d: %m", chindex);
+ goto err_close;
+ }
+ flags = fcntl(fd, F_GETFL);
+ if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
+ warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
+ set_ppp_fd(fd);
+
+ if (!looped)
ifunit = -1;
- if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
- fatal("Couldn't create new ppp unit: %m");
- set_kdebugflag(kdebugflag);
- } else {
- set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
+ if (!looped && !multilink) {
+ /*
+ * Create a new PPP unit.
+ */
+ if (make_ppp_unit() < 0)
+ goto err_close;
}
- if (ioctl(tty_fd, PPPIOCATTACH, &ifunit) < 0) {
- if (errno == EIO)
- return -1;
- fatal("Couldn't attach tty to PPP unit %d: %m", ifunit);
+
+ if (looped)
+ set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
+
+ if (!multilink) {
+ add_fd(ppp_dev_fd);
+ if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
+ error("Couldn't attach to PPP unit %d: %m", ifunit);
+ goto err_close;
+ }
}
+
} else {
+ /*
+ * Old-style driver: find out which interface we were given.
+ */
+ set_ppp_fd (tty_fd);
if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
- if ( ! ok_error (errno))
- fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
+ if (ok_error (errno))
+ goto err;
+ fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
}
/* Check that we got the same unit again. */
- if (demand && x != ifunit)
+ if (looped && x != ifunit)
fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
ifunit = x;
+
+ /*
+ * Fetch the initial file flags and reset blocking mode on the file.
+ */
+ initfdflags = fcntl(tty_fd, F_GETFL);
+ if (initfdflags == -1 ||
+ fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
+ if ( ! ok_error (errno))
+ warn("Couldn't set device to non-blocking mode: %m");
+ }
}
-/*
- * Enable debug in the driver if requested.
- */
- if (!demand)
+ looped = 0;
+
+ /*
+ * Enable debug in the driver if requested.
+ */
+ if (!looped)
set_kdebugflag (kdebugflag);
- set_flags(tty_fd, get_flags(tty_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
- SC_RCV_EVNP | SC_RCV_ODDP));
+#define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
+#define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
+ | SC_LOG_FLUSH)
+
+ set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
+ | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
driver_version, driver_modification, driver_patch));
-/*
- * Fetch the initial file flags and reset blocking mode on the file.
- */
- initfdflags = fcntl(tty_fd, F_GETFL);
- if (initfdflags == -1 ||
- fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
- if ( ! ok_error (errno))
- warn("Couldn't set device to non-blocking mode: %m");
- }
+ return ppp_fd;
- return ppp_dev_fd;
+ err_close:
+ close(fd);
+ err:
+ if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
+ warn("Couldn't reset tty to normal line discipline: %m");
+ return -1;
}
/********************************************************************
*
- * disestablish_ppp - Restore the serial port to normal operation.
+ * tty_disestablish_ppp - Restore the serial port to normal operation,
+ * and reconnect the ppp unit to the loopback if in demand mode.
* This shouldn't call die() because it's called from die().
*/
-void disestablish_ppp(int tty_fd)
+void tty_disestablish_ppp(int tty_fd)
{
if (!hungup) {
/*
}
}
initfdflags = -1;
- if (new_style_driver)
- set_ppp_fd(-1);
+
+ if (new_style_driver) {
+ close(ppp_fd);
+ ppp_fd = -1;
+ if (demand) {
+ set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
+ looped = 1;
+ } else if (ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
+ error("Couldn't release PPP unit: %m");
+ if (!multilink)
+ remove_fd(ppp_dev_fd);
+ } else {
+ /* old-style driver */
+ if (demand)
+ set_ppp_fd(slave_fd);
+ }
+}
+
+/*
+ * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
+ * Assumes new_style_driver.
+ */
+static int make_ppp_unit()
+{
+ int x;
+
+ ifunit = req_unit;
+ x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
+ if (x < 0 && req_unit >= 0 && errno == EEXIST) {
+ warn("Couldn't allocate PPP unit %d as it is already in use");
+ ifunit = -1;
+ x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
+ }
+ if (x < 0)
+ error("Couldn't create new ppp unit: %m");
+ return x;
+}
+
+/*
+ * cfg_bundle - configure the existing bundle.
+ * Used in demand mode.
+ */
+void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
+{
+ int flags;
+
+ if (!new_style_driver)
+ return;
+
+ /* set the mrru, mtu and flags */
+ if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
+ error("Couldn't set MRRU: %m");
+ flags = get_flags(ppp_dev_fd);
+ flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
+ flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
+ | (mrru? SC_MULTILINK: 0);
+
+ set_flags(ppp_dev_fd, flags);
+
+ /* connect up the channel */
+ if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
+ fatal("Couldn't attach to PPP unit %d: %m", ifunit);
+ add_fd(ppp_dev_fd);
+}
+
+/*
+ * make_new_bundle - create a new PPP unit (i.e. a bundle)
+ * and connect our channel to it. This should only get called
+ * if `multilink' was set at the time establish_ppp was called.
+ * In demand mode this uses our existing bundle instead of making
+ * a new one.
+ */
+void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
+{
+ if (!new_style_driver)
+ return;
+
+ /* make us a ppp unit */
+ if (make_ppp_unit() < 0)
+ die(1);
+
+ /* set the mrru and flags */
+ cfg_bundle(mrru, mtru, rssn, tssn);
+}
+
+/*
+ * bundle_attach - attach our link to a given PPP unit.
+ * We assume the unit is controlled by another pppd.
+ */
+int bundle_attach(int ifnum)
+{
+ if (!new_style_driver)
+ return -1;
+
+ if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
+ if (errno == ENXIO)
+ return 0; /* doesn't still exist */
+ fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
+ }
+ if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
+ fatal("Couldn't connect to interface unit %d: %m", ifnum);
+ set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
+
+ ifunit = ifnum;
+ return 1;
}
/********************************************************************
#ifdef B57600
{ 57600, B57600 },
#endif
+#ifdef B76800
+ { 76800, B76800 },
+#endif
#ifdef B115200
{ 115200, B115200 },
#endif
#endif
#ifdef B460800
{ 460800, B460800 },
+#endif
+#ifdef B921600
+ { 921600, B921600 },
#endif
{ 0, 0 }
};
void output (int unit, unsigned char *p, int len)
{
+ int fd = ppp_fd;
+ int proto;
+
if (debug)
dbglog("sent %P", p, len);
if (new_style_driver) {
p += 2;
len -= 2;
+ proto = (p[0] << 8) + p[1];
+ if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
+ fd = ppp_dev_fd;
}
- if (write(ppp_dev_fd, p, len) < 0) {
+ if (write(fd, p, len) < 0) {
if (errno == EWOULDBLOCK || errno == ENOBUFS
|| errno == ENXIO || errno == EIO || errno == EINTR)
warn("write: warning: %m (%d)", errno);
void wait_input(struct timeval *timo)
{
- fd_set ready;
+ fd_set ready, exc;
int n;
ready = in_fds;
- n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
+ exc = in_fds;
+ n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
if (n < 0 && errno != EINTR)
fatal("select: %m(%d)", errno);
}
int read_packet (unsigned char *buf)
{
- int len;
+ int len, nr;
len = PPP_MRU + PPP_HDRLEN;
if (new_style_driver) {
*buf++ = PPP_UI;
len -= 2;
}
- len = read(ppp_dev_fd, buf, len);
- if (len < 0) {
- if (errno == EWOULDBLOCK || errno == EIO)
- return -1;
- fatal("read: %m(%d)", errno);
+ nr = -1;
+ if (ppp_fd >= 0) {
+ nr = read(ppp_fd, buf, len);
+ if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
+ error("read: %m");
+ if (nr < 0 && errno == ENXIO)
+ return 0;
}
- return new_style_driver? len+2: len;
+ if (nr < 0 && new_style_driver && ifunit >= 0) {
+ /* N.B. we read ppp_fd first since LCP packets come in there. */
+ nr = read(ppp_dev_fd, buf, len);
+ if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
+ error("read /dev/ppp: %m");
+ if (nr < 0 && errno == ENXIO)
+ return 0;
+ }
+ return (new_style_driver && nr > 0)? nr+2: nr;
}
/********************************************************************
return rv;
}
+/*
+ * netif_set_mtu - set the MTU on the PPP network interface.
+ */
+void
+netif_set_mtu(int unit, int mtu)
+{
+ struct ifreq ifr;
+
+ SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
+
+ memset (&ifr, '\0', sizeof (ifr));
+ strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+ ifr.ifr_mtu = mtu;
+
+ if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
+ fatal("ioctl(SIOCSIFMTU): %m");
+}
+
/********************************************************************
*
- * ppp_send_config - configure the transmit characteristics of
+ * tty_send_config - configure the transmit characteristics of
* the ppp interface.
*/
-void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
+void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
{
u_int x;
- struct ifreq ifr;
-
- SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
+
/*
- * Set the MTU and other parameters for the ppp device
+ * Set the asyncmap and other parameters for the ppp device
*/
- memset (&ifr, '\0', sizeof (ifr));
- strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
- ifr.ifr_mtu = mtu;
-
- if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
- fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
-
if (!still_ppp())
return;
+ link_mtu = mtu;
SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
if (!ok_error(errno))
/********************************************************************
*
- * ppp_set_xaccm - set the extended transmit ACCM for the interface.
+ * tty_set_xaccm - set the extended transmit ACCM for the interface.
*/
-void ppp_set_xaccm (int unit, ext_accm accm)
+void tty_set_xaccm (ext_accm accm)
{
SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
accm[0], accm[1], accm[2], accm[3]));
/********************************************************************
*
- * ppp_recv_config - configure the receive-side characteristics of
+ * tty_recv_config - configure the receive-side characteristics of
* the ppp interface.
*/
-void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
+void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
{
SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
/*
if ( ! ok_error (errno))
error("ioctl(PPPIOCSMRU): %m(%d)", errno);
}
- if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
+ if (new_style_driver && ifunit >= 0
+ && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
error("Couldn't set MRU in generic PPP layer: %m");
SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
void ccp_flags_set (int unit, int isopen, int isup)
{
- if (still_ppp()) {
+ if (still_ppp() && ifunit >= 0) {
int x = get_flags(ppp_dev_fd);
x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
}
}
+#ifdef PPP_FILTER
+/*
+ * set_filters - set the active and pass filters in the kernel driver.
+ */
+int set_filters(struct bpf_program *pass, struct bpf_program *active)
+{
+ struct sock_fprog fp;
+
+ fp.len = pass->bf_len;
+ fp.filter = (struct sock_filter *) pass->bf_insns;
+ if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
+ if (errno == ENOTTY)
+ warn("kernel does not support PPP filtering");
+ else
+ error("Couldn't set pass-filter in kernel: %m");
+ return 0;
+ }
+ fp.len = active->bf_len;
+ fp.filter = (struct sock_filter *) active->bf_insns;
+ if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
+ error("Couldn't set active-filter in kernel: %m");
+ return 0;
+ }
+ return 1;
+}
+#endif /* PPP_FILTER */
+
/********************************************************************
*
* get_idle_time - return how long the link has been idle.
}
stats->bytes_in = req.stats.p.ppp_ibytes;
stats->bytes_out = req.stats.p.ppp_obytes;
+ stats->pkts_in = req.stats.p.ppp_ipackets;
+ stats->pkts_out = req.stats.p.ppp_opackets;
return 1;
}
FILE *fp;
if (proc_path_len == 0) {
+ /* Default the mount location of /proc */
+ strlcpy (proc_path, "/proc", sizeof(proc_path));
+ proc_path_len = 5;
fp = fopen(MOUNTED, "r");
- if (fp == NULL) {
- /* Default the mount location of /proc */
- strlcpy (proc_path, "/proc", sizeof(proc_path));
- proc_path_len = 5;
-
- } else {
+ if (fp != NULL) {
while ((mntent = getmntent(fp)) != NULL) {
if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
continue;
- if (strcmp(mntent->mnt_type, "proc") == 0)
+ if (strcmp(mntent->mnt_type, "proc") == 0) {
+ strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
+ proc_path_len = strlen(proc_path);
break;
+ }
}
fclose (fp);
- if (mntent == 0)
- proc_path_len = -1;
- else {
- strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
- proc_path_len = strlen(proc_path);
- }
}
}
- if (proc_path_len < 0)
- return 0;
-
strlcpy(proc_path + proc_path_len, tail,
sizeof(proc_path) - proc_path_len);
return proc_path;
}
/*
- * path_to_route - determine the path to the proc file system data
+ * /proc/net/route parsing stuff.
*/
#define ROUTE_MAX_COLS 12
FILE *route_fd = (FILE *) 0;
static int route_flags_col, route_mask_col;
static int route_num_cols;
-static char *path_to_route (void);
static int open_route_table (void);
static void close_route_table (void);
static int read_route_table (struct rtentry *rt);
-/********************************************************************
- *
- * path_to_route - find the path to the route tables in the proc file system
- */
-
-static char *path_to_route (void)
-{
- char *path;
-
- path = path_to_procfs("/net/route");
- if (path == 0)
- error("proc file system not mounted");
- return path;
-}
-
/********************************************************************
*
* close_route_table - close the interface to the route table
close_route_table();
- path = path_to_route();
- if (path == NULL)
- return 0;
-
+ path = path_to_procfs("/net/route");
route_fd = fopen (path, "r");
if (route_fd == NULL) {
- error("can't open %s: %m (%d)", path, errno);
+ error("can't open routing table %s: %m", path);
return 0;
}
p = NULL;
}
- ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
- strtoul(cols[route_dest_col], NULL, 16);
-
- ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
- strtoul(cols[route_gw_col], NULL, 16);
-
- ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
- strtoul(cols[route_mask_col], NULL, 16);
+ SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
+ SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
+ SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
rt->rt_dev = cols[route_dev_col];
if ((rt->rt_flags & RTF_UP) == 0)
continue;
- if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
+ if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
+ continue;
+ if (SIN_ADDR(rt->rt_dst) == 0L) {
result = 1;
break;
}
while (read_route_table(&rt)) {
if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
continue;
- if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
- == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
+ if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
result = 1;
break;
}
struct rtentry rt;
if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
- struct in_addr old_gateway =
- ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
+ u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
- if (old_gateway.s_addr != gateway)
+ if (old_gateway != gateway)
error("not replacing existing default route to %s [%I]",
rt.rt_dev, old_gateway);
return 0;
if (kernel_version > KVERSION(2,1,0)) {
SET_SA_FAMILY (rt.rt_genmask, AF_INET);
- ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
+ SIN_ADDR(rt.rt_genmask) = 0L;
}
- ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
+ SIN_ADDR(rt.rt_gateway) = gateway;
rt.rt_flags = RTF_UP | RTF_GATEWAY;
if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
if (kernel_version > KVERSION(2,1,0)) {
SET_SA_FAMILY (rt.rt_genmask, AF_INET);
- ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
+ SIN_ADDR(rt.rt_genmask) = 0L;
}
- ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
+ SIN_ADDR(rt.rt_gateway) = gateway;
rt.rt_flags = RTF_UP | RTF_GATEWAY;
if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
memset (&arpreq, '\0', sizeof(arpreq));
SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
- ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
+ SIN_ADDR(arpreq.arp_pa) = his_adr;
arpreq.arp_flags = ATF_PERM | ATF_PUBL;
/*
* Get the hardware address of an interface on the same subnet
proxy_arp_addr = his_adr;
has_proxy_arp = 1;
- forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
- if (forw_path != 0) {
- int fd = open(forw_path, O_WRONLY);
- if (fd >= 0) {
- write(fd, "1", 1);
- close(fd);
+ if (tune_kernel) {
+ forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
+ if (forw_path != 0) {
+ int fd = open(forw_path, O_WRONLY);
+ if (fd >= 0) {
+ if (write(fd, "1", 1) != 1)
+ error("Couldn't enable IP forwarding: %m");
+ close(fd);
+ }
}
}
}
has_proxy_arp = 0;
memset (&arpreq, '\0', sizeof(arpreq));
SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
- ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
+ SIN_ADDR(arpreq.arp_pa) = his_adr;
arpreq.arp_flags = ATF_PERM | ATF_PUBL;
strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
if (ifr->ifr_addr.sa_family == AF_INET) {
- ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
+ ina = SIN_ADDR(ifr->ifr_addr);
strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
ifreq.ifr_name));
if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
continue;
- mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
+ mask = SIN_ADDR(ifreq.ifr_addr);
SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
ip_ntoa(ina), ntohl(mask)));
return 1;
}
+/*
+ * get_if_hwaddr - get the hardware address for the specified
+ * network interface device.
+ */
+int
+get_if_hwaddr(u_char *addr, char *name)
+{
+ struct ifreq ifreq;
+ int ret, sock_fd;
+
+ sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (sock_fd < 0)
+ return 0;
+ memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
+ strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
+ ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
+ close(sock_fd);
+ if (ret >= 0)
+ memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
+ return ret;
+}
+
+/*
+ * get_first_ethernet - return the name of the first ethernet-style
+ * interface on this system.
+ */
+char *
+get_first_ethernet()
+{
+ return "eth0";
+}
+
/********************************************************************
*
* Return user specified netmask, modified by any mask we might determine
*/
if (ifr->ifr_addr.sa_family != AF_INET)
continue;
- ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
+ ina = SIN_ADDR(ifr->ifr_addr);
if (((ntohl(ina) ^ addr) & nmask) != 0)
continue;
/*
*/
if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
continue;
- mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
+ mask |= SIN_ADDR(ifreq.ifr_addr);
break;
}
return mask;
static void decode_version (char *buf, int *version,
int *modification, int *patch)
{
- *version = (int) strtoul (buf, &buf, 10);
+ char *endp;
+
+ *version = (int) strtoul (buf, &endp, 10);
*modification = 0;
*patch = 0;
- if (*buf == '.') {
- ++buf;
- *modification = (int) strtoul (buf, &buf, 10);
- if (*buf == '.') {
- ++buf;
+ if (endp != buf && *endp == '.') {
+ buf = endp + 1;
+ *modification = (int) strtoul (buf, &endp, 10);
+ if (endp != buf && *endp == '.') {
+ buf = endp + 1;
*patch = (int) strtoul (buf, &buf, 10);
}
}
-
- if (*buf != '\0') {
- *version =
- *modification =
- *patch = 0;
- }
}
/********************************************************************
struct ifreq ifr;
int size;
int my_version, my_modification, my_patch;
+ int osmaj, osmin, ospatch;
no_ppp_msg =
"This system lacks kernel support for PPP. This could be because\n"
"ppp.o exists in /lib/modules/`uname -r`/net.\n"
"See README.linux file in the ppp distribution for more details.\n";
+ /* get the kernel version now, since we are called before sys_init */
+ uname(&utsname);
+ osmaj = osmin = ospatch = 0;
+ sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
+ kernel_version = KVERSION(osmaj, osmin, ospatch);
+
fd = open("/dev/ppp", O_RDWR);
+#if 0
if (fd < 0 && errno == ENOENT) {
/* try making it and see if that helps. */
if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
fd = open("/dev/ppp", O_RDWR);
}
}
+#endif /* 0 */
if (fd >= 0) {
new_style_driver = 1;
close(fd);
return 1;
}
+ if (kernel_version >= KVERSION(2,3,13)) {
+ if (errno == ENOENT)
+ no_ppp_msg =
+ "pppd is unable to open the /dev/ppp device.\n"
+ "You need to create the /dev/ppp device node by\n"
+ "executing the following command as root:\n"
+ " mknod /dev/ppp c 108 0\n";
+ return 0;
+ }
/*
* Open a socket for doing the ioctl operations.
/*
* Set our IP address
*/
- ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
+ SIN_ADDR(ifr.ifr_addr) = our_adr;
if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
if (errno != EEXIST) {
if (! ok_error (errno))
/*
* Set the gateway address
*/
- ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
+ SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
if (kernel_version >= KVERSION(2,1,16))
net_mask = ~0L;
if (net_mask != 0) {
- ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
+ SIN_ADDR(ifr.ifr_netmask) = net_mask;
if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
if (! ok_error (errno))
error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
SET_SA_FAMILY (rt.rt_gateway, AF_INET);
rt.rt_dev = ifname;
- ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
- ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
+ SIN_ADDR(rt.rt_gateway) = 0L;
+ SIN_ADDR(rt.rt_dst) = his_adr;
rt.rt_flags = RTF_UP | RTF_HOST;
if (kernel_version > KVERSION(2,1,0)) {
SET_SA_FAMILY (rt.rt_genmask, AF_INET);
- ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
+ SIN_ADDR(rt.rt_genmask) = -1L;
}
if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
return (0);
}
}
+
+ /* set ip_dynaddr in demand mode if address changes */
+ if (demand && tune_kernel && !dynaddr_set
+ && our_old_addr && our_old_addr != our_adr) {
+ /* set ip_dynaddr if possible */
+ char *path;
+ int fd;
+
+ path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
+ if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
+ if (write(fd, "1", 1) != 1)
+ error("Couldn't enable dynamic IP addressing: %m");
+ close(fd);
+ }
+ dynaddr_set = 1; /* only 1 attempt */
+ }
+ our_old_addr = 0;
+
return 1;
}
SET_SA_FAMILY (rt.rt_gateway, AF_INET);
rt.rt_dev = ifname;
- ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
- ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
+ SIN_ADDR(rt.rt_gateway) = 0;
+ SIN_ADDR(rt.rt_dst) = his_adr;
rt.rt_flags = RTF_UP | RTF_HOST;
if (kernel_version > KVERSION(2,1,0)) {
SET_SA_FAMILY (rt.rt_genmask, AF_INET);
- ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
+ SIN_ADDR(rt.rt_genmask) = -1L;
}
if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
}
}
+ our_old_addr = our_adr;
+
return 1;
}
struct ifreq ifr;
struct in6_rtmsg rt6;
+ if (sock6_fd < 0) {
+ errno = -sock6_fd;
+ error("IPv6 socket creation failed: %m");
+ return 0;
+ }
memset(&ifr, 0, sizeof (ifr));
strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
struct ifreq ifr;
struct in6_ifreq ifr6;
+ if (sock6_fd < 0) {
+ errno = -sock6_fd;
+ error("IPv6 socket creation failed: %m");
+ return 0;
+ }
memset(&ifr, 0, sizeof(ifr));
strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
warn("Couldn't unlock pty slave %s: %m", pty_name);
#endif
- if ((sfd = open(pty_name, O_RDWR)) < 0)
+ if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
warn("Couldn't open pty slave %s: %m", pty_name);
}
}
*slave_fdp = sfd;
if (tcgetattr(sfd, &tios) == 0) {
tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
- tios.c_cflag |= CS8 | CREAD;
- tios.c_iflag = IGNPAR | CLOCAL;
+ tios.c_cflag |= CS8 | CREAD | CLOCAL;
+ tios.c_iflag = IGNPAR;
tios.c_oflag = 0;
tios.c_lflag = 0;
if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
{
int flags;
+ looped = 1;
if (new_style_driver) {
/* allocate ourselves a ppp unit */
- ifunit = -1;
- if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
- fatal("Couldn't create PPP unit: %m");
+ if (make_ppp_unit() < 0)
+ die(1);
set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
set_kdebugflag(kdebugflag);
ppp_fd = -1;
return master_fd;
}
-/********************************************************************
- *
- * restore_loop - reattach the ppp unit to the loopback.
- *
- * The kernel ppp driver automatically reattaches the ppp unit to
- * the loopback if the serial port is set to a line discipline other
- * than ppp, or if it detects a modem hangup. The former will happen
- * in disestablish_ppp if the latter hasn't already happened, so we
- * shouldn't need to do anything.
- *
- * Just to be sure, set the real serial port to the normal discipline.
- */
-
-void
-restore_loop(void)
-{
- if (new_style_driver) {
- set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
- return;
- }
- if (ppp_fd != slave_fd) {
- (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
- set_ppp_fd(slave_fd);
- }
-}
-
/********************************************************************
*
* sifnpmode - Set the mode for handling packets for a given NP.
npi.protocol = proto;
npi.mode = mode;
if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
- if (! ok_error (errno)) {
+ if (! ok_error (errno))
error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
proto, mode, errno);
- error("ppp_dev_fd=%d slave_fd=%d\n", ppp_dev_fd, slave_fd);
- }
return 0;
}
return 1;
* Disable the IPX protocol if the support is not present in the kernel.
*/
char *path;
- int fd;
if (ipxcp_protent.enabled_flag) {
struct stat stat_buf;
driver_patch);
return 0;
}
- if (demand) {
- /* set ip_dynaddr if possible */
- path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
- if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
- write(fd, "1", 1);
- close(fd);
- }
+ if (multilink && !new_style_driver) {
+ warn("Warning: multilink is not supported by the kernel driver");
+ multilink = 0;
}
return 1;
}
projects / ppp.git / blobdiff