#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 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;
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 */
{
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);
/********************************************************************
*
- * 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;
warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
set_ppp_fd(fd);
- ifunit = -1;
+ if (!looped)
+ ifunit = -1;
if (!looped && !multilink) {
/*
* Create a new PPP unit.
*/
- 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");
+ if (make_ppp_unit() < 0)
goto err_close;
- }
}
if (looped)
*/
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 (looped && x != ifunit)
if (!looped)
set_kdebugflag (kdebugflag);
- set_flags(ppp_fd, get_flags(ppp_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));
/********************************************************************
*
- * 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) {
/*
if (new_style_driver) {
close(ppp_fd);
ppp_fd = -1;
- if (!looped && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
+ 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);
}
}
/*
- * bundle_attach - attach our link to a given PPP unit.
+ * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
+ * Assumes new_style_driver.
*/
-int bundle_attach(int ifnum)
+static int make_ppp_unit()
{
- int mrru = 1500;
+ int x;
- if (!new_style_driver)
- return -1;
+ 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;
+}
- if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
- error("Couldn't attach to interface unit %d: %m\n", ifnum);
- return -1;
- }
- set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
- if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
- error("Couldn't set interface MRRU: %m");
+/*
+ * cfg_bundle - configure the existing bundle.
+ * Used in demand mode.
+ */
+void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
+{
+ int flags;
- if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0) {
- error("Couldn't connect to interface unit %d: %m", ifnum);
- return -1;
- }
+ 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);
+}
- dbglog("bundle_attach succeeded");
- return 0;
+/*
+ * 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 }
};
p += 2;
len -= 2;
proto = (p[0] << 8) + p[1];
- if (!multilink && proto != PPP_LCP)
+ if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
fd = ppp_dev_fd;
}
if (write(fd, p, len) < 0) {
nr = -1;
if (ppp_fd >= 0) {
nr = read(ppp_fd, buf, len);
- if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
+ if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
error("read: %m");
+ if (nr < 0 && errno == ENXIO)
+ return 0;
}
- if (nr < 0 && new_style_driver && !multilink) {
+ 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)
+ 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 (ifunit >= 0 && 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));
/*
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;
}
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
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;
- }
}
/********************************************************************
sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
kernel_version = KVERSION(osmaj, osmin, ospatch);
- if (kernel_version >= KVERSION(2,3,13)) {
- fd = open("/dev/ppp", O_RDWR);
+ 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,
- makedev(108, 0)) >= 0) {
- fd = open("/dev/ppp", O_RDWR);
- if (fd >= 0)
- info("Created /dev/ppp device node");
- else
- unlink("/dev/ppp"); /* didn't work, undo the mknod */
- } else if (errno == EEXIST) {
- fd = open("/dev/ppp", O_RDWR);
- }
+ if (fd < 0 && errno == ENOENT) {
+ /* try making it and see if that helps. */
+ if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
+ makedev(108, 0)) >= 0) {
+ fd = open("/dev/ppp", O_RDWR);
+ if (fd >= 0)
+ info("Created /dev/ppp device node");
+ else
+ unlink("/dev/ppp"); /* didn't work, undo the mknod */
+ } else if (errno == EEXIST) {
+ fd = open("/dev/ppp", O_RDWR);
}
+ }
#endif /* 0 */
- if (fd >= 0) {
- new_style_driver = 1;
-
- /* XXX should get from driver */
- driver_version = 2;
- driver_modification = 4;
- driver_patch = 0;
- close(fd);
- return 1;
- }
+ if (fd >= 0) {
+ new_style_driver = 1;
+
+ /* XXX should get from driver */
+ driver_version = 2;
+ driver_modification = 4;
+ driver_patch = 0;
+ 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;
}
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) {
*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
open_ppp_loopback(void)
{
- int flags, x;
+ int flags;
looped = 1;
if (new_style_driver) {
/* allocate ourselves a ppp unit */
- 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)
- 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)
-{
- looped = 1;
- 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.
return 0;
}
if (multilink && !new_style_driver) {
- option_error("multilink is not supported by the kernel driver");
- return 0;
+ warn("Warning: multilink is not supported by the kernel driver");
+ multilink = 0;
}
return 1;
}
projects / ppp.git / blobdiff