2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1994-2004 Paul Mackerras. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
14 * 2. The name(s) of the authors of this software must not be used to
15 * endorse or promote products derived from this software without
16 * prior written permission.
18 * 3. Redistributions of any form whatsoever must retain the following
20 * "This product includes software developed by Paul Mackerras
21 * <paulus@samba.org>".
23 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
24 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
25 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
26 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
27 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
28 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
29 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
31 * Derived from main.c and pppd.h, which are:
33 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
47 * 3. The name "Carnegie Mellon University" must not be used to
48 * endorse or promote products derived from this software without
49 * prior written permission. For permission or any legal
50 * details, please contact
51 * Office of Technology Transfer
52 * Carnegie Mellon University
54 * Pittsburgh, PA 15213-3890
55 * (412) 268-4387, fax: (412) 268-7395
56 * tech-transfer@andrew.cmu.edu
58 * 4. Redistributions of any form whatsoever must retain the following
60 * "This product includes software developed by Computing Services
61 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
63 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
64 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
65 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
66 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
67 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
68 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
69 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
76 #include <sys/ioctl.h>
77 #include <sys/types.h>
78 #include <sys/socket.h>
82 #include <sys/utsname.h>
83 #include <sys/sysmacros.h>
103 /* This is in netdevice.h. However, this compile will fail miserably if
104 you attempt to include netdevice.h because it has so many references
105 to __memcpy functions which it should not attempt to do. So, since I
106 really don't use it, but it must be defined, define it now. */
109 #define MAX_ADDR_LEN 7
112 #if !defined(__GLIBC__) || __GLIBC__ >= 2
113 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
115 #include <net/if_arp.h>
116 #include <net/route.h>
117 #include <netinet/if_ether.h>
119 #include <linux/types.h>
120 #include <linux/if.h>
121 #include <linux/if_arp.h>
122 #include <linux/route.h>
123 #include <linux/if_ether.h>
125 #include <netinet/in.h>
126 #include <arpa/inet.h>
128 #include <linux/ppp_defs.h>
129 #include <linux/if_ppp.h>
131 #include <linux/netlink.h>
132 #include <linux/rtnetlink.h>
133 #include <linux/if_link.h>
136 #include <linux/if_addr.h>
139 /* Attempt at retaining compile-support with older than 4.7 kernels, or kernels
140 * where RTM_NEWSTATS isn't defined for whatever reason.
143 #define RTM_NEWSTATS 92
144 #define RTM_GETSTATS 94
145 #define IFLA_STATS_LINK_64 1
148 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
150 #define SOL_NETLINK 270
153 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
154 #ifndef NETLINK_CAP_ACK
155 #define NETLINK_CAP_ACK 10
158 /* linux kernel versions prior to 4.7 do not define/support IFLA_PPP_DEV_FD */
160 /* IFLA_PPP_DEV_FD is declared as enum when IFLA_PPP_MAX is defined */
161 #define IFLA_PPP_DEV_FD 1
169 #include <pcap-bpf.h>
170 #include <linux/filter.h>
171 #endif /* PPP_FILTER */
174 #include <sys/locks.h>
178 * Instead of system header file <termios.h> use local "termios_linux.h" header
179 * file as it provides additional support for arbitrary baud rates via BOTHER.
181 #include "termios_linux.h"
186 * This is in linux/include/net/ipv6.h.
190 struct in6_addr ifr6_addr;
191 __u32 ifr6_prefixlen;
192 unsigned int ifr6_ifindex;
196 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
197 memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr)); \
198 (sin6).s6_addr16[0] = htons(0xfe80); \
199 eui64_copy(eui64, (sin6).s6_addr32[2]); \
202 static const eui64_t nulleui64;
205 /* We can get an EIO error on an ioctl if the modem has hung up */
206 #define ok_error(num) ((num)==EIO)
208 static int tty_disc = N_TTY; /* The TTY discipline */
209 static int ppp_disc = N_PPP; /* The PPP discpline */
210 static int initfdflags = -1; /* Initial file descriptor flags for fd */
211 static int ppp_fd = -1; /* fd which is set to PPP discipline */
212 static int sock_fd = -1; /* socket for doing interface ioctls */
213 static int slave_fd = -1; /* pty for old-style demand mode, slave */
214 static int master_fd = -1; /* pty for old-style demand mode, master */
216 static int sock6_fd = -1;
220 * For the old-style kernel driver, this is the same as ppp_fd.
221 * For the new-style driver, it is the fd of an instance of /dev/ppp
222 * which is attached to the ppp unit and is used for controlling it.
224 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
226 static int chindex; /* channel index (new style driver) */
228 static fd_set in_fds; /* set of fds that wait_input waits for */
229 static int max_in_fd; /* highest fd set in in_fds */
231 static int has_proxy_arp = 0;
232 static int driver_version = 0;
233 static int driver_modification = 0;
234 static int driver_patch = 0;
235 static int driver_is_old = 0;
236 static int restore_term = 0; /* 1 => we've munged the terminal */
237 static struct termios inittermios; /* Initial TTY termios */
239 int new_style_driver = 0;
241 static char loop_name[20];
242 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
244 static int if_is_up; /* Interface has been marked up */
245 static int if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
246 static int have_default_route; /* Gateway for default route added */
247 static int have_default_route6; /* Gateway for default IPv6 route added */
248 static struct rtentry old_def_rt; /* Old default route */
249 static int default_rt_repl_rest; /* replace and restore old default rt */
250 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
251 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
252 static u_int32_t our_old_addr; /* for detecting address changes */
253 static int dynaddr_set; /* 1 if ip_dynaddr set */
254 static int looped; /* 1 if using loop */
255 static int link_mtu; /* mtu for the link (not bundle) */
257 static struct utsname utsname; /* for the kernel version */
258 static int kernel_version;
259 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
263 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
264 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
265 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
267 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
269 /* Prototypes for procedures local to this file. */
270 static int modify_flags(int fd, int clear_bits, int set_bits);
271 static int translate_speed (int bps);
272 static int baud_rate_of (int speed);
273 static void close_route_table (void);
274 static int open_route_table (void);
275 static int read_route_table (struct rtentry *rt);
276 static int defaultroute_exists (struct rtentry *rt, int metric);
277 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
278 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
279 char *name, int namelen);
280 static void decode_version (char *buf, int *version, int *mod, int *patch);
281 static int set_kdebugflag(int level);
282 static int ppp_registered(void);
283 static int make_ppp_unit(void);
284 static int setifstate (int u, int state);
286 extern u_char inpacket_buf[]; /* borrowed from main.c */
288 extern int dfl_route_metric;
291 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
295 #define SET_SA_FAMILY(addr, family) \
296 memset ((char *) &(addr), '\0', sizeof(addr)); \
297 addr.sa_family = (family);
300 * Determine if the PPP connection should still be present.
305 /* new_fd is the fd of a tty */
306 static void set_ppp_fd (int new_fd)
309 if (!new_style_driver)
313 static int still_ppp(void)
315 if (new_style_driver)
316 return !hungup && ppp_fd >= 0;
317 if (!hungup || ppp_fd == slave_fd)
320 set_ppp_fd(slave_fd);
327 * modify_flags - set and clear flag bits controlling the kernel
330 static int modify_flags(int fd, int clear_bits, int set_bits)
334 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
336 flags = (flags & ~clear_bits) | set_bits;
337 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
344 error("Failed to set PPP kernel option flags: %m");
348 /********************************************************************
350 * sys_init - System-dependent initialization.
355 /* Get an internet socket for doing socket ioctls. */
356 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
358 fatal("Couldn't create IP socket: %m(%d)", errno);
361 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
363 sock6_fd = -errno; /* save errno for later */
370 /********************************************************************
372 * sys_cleanup - restore any system state we modified before exiting:
373 * mark the interface down, delete default route and/or proxy arp entry.
374 * This shouldn't call die() because it's called from die().
377 void sys_cleanup(void)
380 * Take down the device
390 * Delete any routes through the device.
392 if (have_default_route)
393 cifdefaultroute(0, 0, 0);
395 if (have_default_route6)
396 cif6defaultroute(0, nulleui64, nulleui64);
400 cifproxyarp(0, proxy_arp_addr);
403 /********************************************************************
405 * sys_close - Clean up in a child process before execing.
410 if (new_style_driver && ppp_dev_fd >= 0)
424 /********************************************************************
426 * set_kdebugflag - Define the debugging level for the kernel
429 static int set_kdebugflag (int requested_level)
433 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
434 if ( ! ok_error (errno) )
435 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
441 /********************************************************************
443 * tty_establish_ppp - Turn the serial port into a ppp interface.
446 int tty_establish_ppp (int tty_fd)
451 * Ensure that the tty device is in exclusive mode.
453 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
454 if ( ! ok_error ( errno ))
455 warn("Couldn't make tty exclusive: %m");
458 * Demand mode - prime the old ppp device to relinquish the unit.
460 if (!new_style_driver && looped
461 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
462 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
466 * Set the current tty to the PPP discpline
470 #define N_SYNC_PPP 14
472 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
473 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
474 if ( ! ok_error (errno) ) {
475 error("Couldn't set tty to PPP discipline: %m");
480 ret_fd = generic_establish_ppp(tty_fd);
482 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
483 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
487 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
488 (kdebugflag * SC_DEBUG) & SC_LOGB);
490 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
491 warn("Couldn't reset tty to normal line discipline: %m");
497 /********************************************************************
499 * generic_establish_ppp - Turn the fd into a ppp interface.
501 int generic_establish_ppp (int fd)
505 if (new_style_driver) {
508 /* If a ppp_fd is already open, close it first */
515 /* Open an instance of /dev/ppp and connect the channel to it */
516 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
517 error("Couldn't get channel number: %m");
520 dbglog("using channel %d", chindex);
521 fd = open("/dev/ppp", O_RDWR);
523 error("Couldn't reopen /dev/ppp: %m");
526 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
527 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
528 error("Couldn't attach to channel %d: %m", chindex);
531 flags = fcntl(fd, F_GETFL);
532 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
533 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
538 if (!looped && !multilink) {
540 * Create a new PPP unit.
542 if (make_ppp_unit() < 0)
547 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
551 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
552 error("Couldn't attach to PPP unit %d: %m", ifunit);
559 * Old-style driver: find out which interface we were given.
562 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
563 if (ok_error (errno))
565 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
567 /* Check that we got the same unit again. */
568 if (looped && x != ifunit)
569 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
573 * Fetch the initial file flags and reset blocking mode on the file.
575 initfdflags = fcntl(fd, F_GETFL);
576 if (initfdflags == -1 ||
577 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
578 if ( ! ok_error (errno))
579 warn("Couldn't set device to non-blocking mode: %m");
584 * Enable debug in the driver if requested.
587 set_kdebugflag (kdebugflag);
599 /********************************************************************
601 * tty_disestablish_ppp - Restore the serial port to normal operation.
602 * This shouldn't call die() because it's called from die().
605 void tty_disestablish_ppp(int tty_fd)
609 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
611 if (tcflush(tty_fd, TCIOFLUSH) < 0)
613 warn("tcflush failed: %m");
617 * Restore the previous line discipline
619 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
620 if ( ! ok_error (errno))
621 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
624 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
625 if ( ! ok_error (errno))
626 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
629 /* Reset non-blocking mode on fd. */
630 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
631 if ( ! ok_error (errno))
632 warn("Couldn't restore device fd flags: %m");
638 generic_disestablish_ppp(tty_fd);
641 /********************************************************************
643 * generic_disestablish_ppp - Restore device components to normal
644 * operation, and reconnect the ppp unit to the loopback if in demand
645 * mode. This shouldn't call die() because it's called from die().
647 void generic_disestablish_ppp(int dev_fd)
649 if (new_style_driver) {
653 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
655 } else if (!doing_multilink && ppp_dev_fd >= 0) {
657 remove_fd(ppp_dev_fd);
661 /* old-style driver */
663 set_ppp_fd(slave_fd);
670 * make_ppp_unit_rtnetlink - register a new ppp network interface for ppp_dev_fd
671 * with specified req_ifname via rtnetlink. Interface name req_ifname must not
672 * be empty. Custom ppp unit id req_unit is ignored and kernel choose some free.
674 static int make_ppp_unit_rtnetlink(void)
678 struct ifinfomsg ifm;
681 char ifname[IFNAMSIZ];
687 char ifkind[sizeof("ppp")];
702 struct nlmsgerr nlerr;
704 struct sockaddr_nl nladdr;
711 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
713 error("make_ppp_unit_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
717 /* Tell kernel to not send to us payload of acknowledgment error message. */
719 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
721 memset(&nladdr, 0, sizeof(nladdr));
722 nladdr.nl_family = AF_NETLINK;
724 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
725 error("make_ppp_unit_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
730 memset(&nlreq, 0, sizeof(nlreq));
731 nlreq.nlh.nlmsg_len = sizeof(nlreq);
732 nlreq.nlh.nlmsg_type = RTM_NEWLINK;
733 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
734 nlreq.ifm.ifi_family = AF_UNSPEC;
735 nlreq.ifm.ifi_type = ARPHRD_NETROM;
736 nlreq.ifn.rta.rta_len = sizeof(nlreq.ifn);
737 nlreq.ifn.rta.rta_type = IFLA_IFNAME;
738 strlcpy(nlreq.ifn.ifname, req_ifname, sizeof(nlreq.ifn.ifname));
739 nlreq.ifli.rta.rta_len = sizeof(nlreq.ifli);
740 nlreq.ifli.rta.rta_type = IFLA_LINKINFO;
741 nlreq.ifli.ifik.rta.rta_len = sizeof(nlreq.ifli.ifik);
742 nlreq.ifli.ifik.rta.rta_type = IFLA_INFO_KIND;
743 strcpy(nlreq.ifli.ifik.ifkind, "ppp");
744 nlreq.ifli.ifid.rta.rta_len = sizeof(nlreq.ifli.ifid);
745 nlreq.ifli.ifid.rta.rta_type = IFLA_INFO_DATA;
746 nlreq.ifli.ifid.ifdata[0].rta.rta_len = sizeof(nlreq.ifli.ifid.ifdata[0]);
747 nlreq.ifli.ifid.ifdata[0].rta.rta_type = IFLA_PPP_DEV_FD;
748 nlreq.ifli.ifid.ifdata[0].ppp.ppp_dev_fd = ppp_dev_fd;
750 memset(&nladdr, 0, sizeof(nladdr));
751 nladdr.nl_family = AF_NETLINK;
753 memset(&iov, 0, sizeof(iov));
754 iov.iov_base = &nlreq;
755 iov.iov_len = sizeof(nlreq);
757 memset(&msg, 0, sizeof(msg));
758 msg.msg_name = &nladdr;
759 msg.msg_namelen = sizeof(nladdr);
763 if (sendmsg(fd, &msg, 0) < 0) {
764 error("make_ppp_unit_rtnetlink: sendmsg(RTM_NEWLINK/NLM_F_CREATE): %m (line %d)", __LINE__);
769 memset(&iov, 0, sizeof(iov));
770 iov.iov_base = &nlresp;
771 iov.iov_len = sizeof(nlresp);
773 memset(&msg, 0, sizeof(msg));
774 msg.msg_name = &nladdr;
775 msg.msg_namelen = sizeof(nladdr);
779 nlresplen = recvmsg(fd, &msg, 0);
782 error("make_ppp_unit_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
789 if (nladdr.nl_family != AF_NETLINK) {
790 error("make_ppp_unit_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
794 if ((size_t)nlresplen < sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
795 error("make_ppp_unit_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
799 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
800 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
801 error("make_ppp_unit_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
805 /* error == 0 indicates success, negative value is errno code */
806 if (nlresp.nlerr.error != 0) {
808 * Linux kernel versions prior to 4.7 do not support creating ppp
809 * interfaces via rtnetlink API and therefore error response is
810 * expected. On older kernel versions do not show this error message.
811 * When error is different than EEXIST then pppd tries to fallback to
812 * the old ioctl method.
814 errno = (nlresp.nlerr.error < 0) ? -nlresp.nlerr.error : EINVAL;
815 if (kernel_version >= KVERSION(4,7,0))
816 error("Couldn't create ppp interface %s: %m", req_ifname);
824 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
825 * Assumes new_style_driver.
827 static int make_ppp_unit(void)
831 if (ppp_dev_fd >= 0) {
832 dbglog("in make_ppp_unit, already had /dev/ppp open?");
835 ppp_dev_fd = open("/dev/ppp", O_RDWR);
837 fatal("Couldn't open /dev/ppp: %m");
838 flags = fcntl(ppp_dev_fd, F_GETFL);
840 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
841 warn("Couldn't set /dev/ppp to nonblock: %m");
844 * Via rtnetlink it is possible to create ppp network interface with
845 * custom ifname atomically. But it is not possible to specify custom
848 * Tools like systemd, udev or NetworkManager are trying to query
849 * interface attributes based on interface name immediately when new
850 * network interface is created. And therefore immediate interface
851 * renaming is causing issues.
853 * So use rtnetlink API only when user requested custom ifname. It will
854 * avoid system issues with interface renaming.
856 if (req_unit == -1 && req_ifname[0] != '\0' && kernel_version >= KVERSION(2,1,16)) {
857 if (make_ppp_unit_rtnetlink()) {
858 if (ioctl(ppp_dev_fd, PPPIOCGUNIT, &ifunit))
859 fatal("Couldn't retrieve PPP unit id: %m");
863 * If interface with requested name already exist return error
864 * otherwise fallback to old ioctl method.
871 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
872 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
873 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
875 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
878 error("Couldn't create new ppp unit: %m");
880 if (x == 0 && req_ifname[0] != '\0') {
883 memset(&ifr, 0, sizeof(struct ifreq));
884 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
885 strlcpy(ifr.ifr_name, t, IFNAMSIZ);
886 strlcpy(ifr.ifr_newname, req_ifname, IFNAMSIZ);
887 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
889 error("Couldn't rename interface %s to %s: %m", t, req_ifname);
891 info("Renamed interface %s to %s", t, req_ifname);
898 * cfg_bundle - configure the existing bundle.
899 * Used in demand mode.
901 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
903 if (!new_style_driver)
906 /* set the mrru, mtu and flags */
907 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
908 error("Couldn't set MRRU: %m");
910 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
911 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
912 | (mrru? SC_MULTILINK: 0)));
914 /* connect up the channel */
915 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
916 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
921 * make_new_bundle - create a new PPP unit (i.e. a bundle)
922 * and connect our channel to it. This should only get called
923 * if `multilink' was set at the time establish_ppp was called.
924 * In demand mode this uses our existing bundle instead of making
927 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
929 if (!new_style_driver)
932 /* make us a ppp unit */
933 if (make_ppp_unit() < 0)
936 /* set the mrru and flags */
937 cfg_bundle(mrru, mtru, rssn, tssn);
941 * bundle_attach - attach our link to a given PPP unit.
942 * We assume the unit is controlled by another pppd.
944 int bundle_attach(int ifnum)
948 if (!new_style_driver)
951 master_fd = open("/dev/ppp", O_RDWR);
953 fatal("Couldn't open /dev/ppp: %m");
954 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
955 if (errno == ENXIO) {
957 return 0; /* doesn't still exist */
959 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
961 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
962 fatal("Couldn't connect to interface unit %d: %m", ifnum);
963 modify_flags(master_fd, 0, SC_MULTILINK);
971 * destroy_bundle - tell the driver to destroy our bundle.
973 void destroy_bundle(void)
975 if (ppp_dev_fd >= 0) {
977 remove_fd(ppp_dev_fd);
982 /********************************************************************
984 * clean_check - Fetch the flags for the device and generate
985 * appropriate error messages.
987 void clean_check(void)
993 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
995 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
997 s = "all had bit 7 set to 1";
1001 s = "all had bit 7 set to 0";
1005 s = "all had odd parity";
1009 s = "all had even parity";
1014 warn("Receive serial link is not 8-bit clean:");
1015 warn("Problem: %s", s);
1023 * List of valid speeds.
1027 int speed_int, speed_val;
1090 { 115200, B115200 },
1093 { 153600, B153600 },
1102 { 230400, B230400 },
1105 { 307200, B307200 },
1108 { 460800, B460800 },
1111 { 500000, B500000 },
1114 { 576000, B576000 },
1117 { 614400, B614400 },
1120 { 921600, B921600 },
1123 { 1000000, B1000000 },
1126 { 1152000, B1152000 },
1129 { 1500000, B1500000 },
1132 { 2000000, B2000000 },
1135 { 2500000, B2500000 },
1138 { 3000000, B3000000 },
1141 { 3500000, B3500000 },
1144 { 4000000, B4000000 },
1149 /********************************************************************
1151 * Translate from bits/second to a speed_t.
1154 static int translate_speed (int bps)
1156 struct speed *speedp;
1159 for (speedp = speeds; speedp->speed_int; speedp++) {
1160 if (bps == speedp->speed_int)
1161 return speedp->speed_val;
1167 /********************************************************************
1169 * Translate from a speed_t to bits/second.
1172 static int baud_rate_of (int speed)
1174 struct speed *speedp;
1177 for (speedp = speeds; speedp->speed_int; speedp++) {
1178 if (speed == speedp->speed_val)
1179 return speedp->speed_int;
1185 /********************************************************************
1187 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
1188 * at the requested speed, etc. If `local' is true, set CLOCAL
1189 * regardless of whether the modem option was specified.
1192 void set_up_tty(int tty_fd, int local)
1195 struct termios tios;
1198 if (tcgetattr(tty_fd, &tios) < 0) {
1199 if (!ok_error(errno))
1200 fatal("tcgetattr: %m (line %d)", __LINE__);
1207 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1208 tios.c_cflag |= CS8 | CREAD | HUPCL;
1210 tios.c_iflag = IGNBRK | IGNPAR;
1213 tios.c_cc[VMIN] = 1;
1214 tios.c_cc[VTIME] = 0;
1216 if (local || !modem)
1217 tios.c_cflag ^= (CLOCAL | HUPCL);
1221 tios.c_cflag |= CRTSCTS;
1225 tios.c_iflag |= IXON | IXOFF;
1226 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
1227 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
1231 tios.c_cflag &= ~CRTSCTS;
1239 tios.c_cflag |= CSTOPB;
1242 speed = translate_speed(inspeed);
1244 cfsetospeed (&tios, speed);
1245 cfsetispeed (&tios, speed);
1246 speed = cfgetospeed(&tios);
1247 baud_rate = baud_rate_of(speed);
1250 tios.c_cflag &= ~CBAUD;
1251 tios.c_cflag |= BOTHER;
1252 tios.c_ospeed = inspeed;
1254 /* B0 sets input baudrate to the output baudrate */
1255 tios.c_cflag &= ~(CBAUD << IBSHIFT);
1256 tios.c_cflag |= B0 << IBSHIFT;
1257 tios.c_ispeed = inspeed;
1259 baud_rate = inspeed;
1266 speed = cfgetospeed(&tios);
1267 baud_rate = baud_rate_of(speed);
1270 baud_rate = tios.c_ospeed;
1275 * We can't proceed if the serial port baud rate is unknown,
1276 * since that implies that the serial port is disabled.
1280 fatal("speed %d not supported", inspeed);
1282 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1285 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1287 fatal("tcsetattr: %m (line %d)", __LINE__);
1291 /********************************************************************
1293 * setdtr - control the DTR line on the serial port.
1294 * This is called from die(), so it shouldn't call die().
1297 void setdtr (int tty_fd, int on)
1299 int modembits = TIOCM_DTR;
1301 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1304 /********************************************************************
1306 * restore_tty - restore the terminal to the saved settings.
1309 void restore_tty (int tty_fd)
1314 * Turn off echoing, because otherwise we can get into
1315 * a loop with the tty and the modem echoing to each other.
1316 * We presume we are the sole user of this tty device, so
1317 * when we close it, it will revert to its defaults anyway.
1319 if (!default_device)
1320 inittermios.c_lflag &= ~(ECHO | ECHONL);
1322 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1323 if (! ok_error (errno))
1324 warn("tcsetattr: %m (line %d)", __LINE__);
1329 /********************************************************************
1331 * output - Output PPP packet.
1334 void output (int unit, unsigned char *p, int len)
1339 dump_packet("sent", p, len);
1340 if (snoop_send_hook) snoop_send_hook(p, len);
1342 if (len < PPP_HDRLEN)
1344 if (new_style_driver) {
1347 proto = (p[0] << 8) + p[1];
1348 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1351 if (write(fd, p, len) < 0) {
1352 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1353 || errno == ENXIO || errno == EIO || errno == EINTR)
1354 warn("write: warning: %m (%d)", errno);
1356 error("write: %m (%d)", errno);
1360 /********************************************************************
1362 * wait_input - wait until there is data available,
1363 * for the length of time specified by *timo (indefinite
1367 void wait_input(struct timeval *timo)
1374 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1375 if (n < 0 && errno != EINTR)
1376 fatal("select: %m");
1380 * add_fd - add an fd to the set that wait_input waits for.
1384 if (fd >= FD_SETSIZE)
1385 fatal("internal error: file descriptor too large (%d)", fd);
1386 FD_SET(fd, &in_fds);
1392 * remove_fd - remove an fd from the set that wait_input waits for.
1394 void remove_fd(int fd)
1396 FD_CLR(fd, &in_fds);
1400 /********************************************************************
1402 * read_packet - get a PPP packet from the serial device.
1405 int read_packet (unsigned char *buf)
1409 len = PPP_MRU + PPP_HDRLEN;
1410 if (new_style_driver) {
1411 *buf++ = PPP_ALLSTATIONS;
1417 nr = read(ppp_fd, buf, len);
1418 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1419 && errno != EIO && errno != EINTR)
1421 if (nr < 0 && errno == ENXIO)
1424 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1425 /* N.B. we read ppp_fd first since LCP packets come in there. */
1426 nr = read(ppp_dev_fd, buf, len);
1427 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1428 && errno != EIO && errno != EINTR)
1429 error("read /dev/ppp: %m");
1430 if (nr < 0 && errno == ENXIO)
1432 if (nr == 0 && doing_multilink) {
1433 remove_fd(ppp_dev_fd);
1437 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1439 return (new_style_driver && nr > 0)? nr+2: nr;
1442 /********************************************************************
1444 * get_loop_output - get outgoing packets from the ppp device,
1445 * and detect when we want to bring the real link up.
1446 * Return value is 1 if we need to bring up the link, 0 otherwise.
1449 get_loop_output(void)
1454 if (new_style_driver) {
1455 while ((n = read_packet(inpacket_buf)) > 0)
1456 if (loop_frame(inpacket_buf, n))
1461 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1462 if (loop_chars(inbuf, n))
1466 fatal("eof on loopback");
1468 if (errno != EWOULDBLOCK && errno != EAGAIN)
1469 fatal("read from loopback: %m(%d)", errno);
1475 * netif_set_mtu - set the MTU on the PPP network interface.
1478 netif_set_mtu(int unit, int mtu)
1482 memset (&ifr, '\0', sizeof (ifr));
1483 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1486 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1487 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1491 * netif_get_mtu - get the MTU on the PPP network interface.
1494 netif_get_mtu(int unit)
1498 memset (&ifr, '\0', sizeof (ifr));
1499 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1501 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1502 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1508 /********************************************************************
1510 * tty_send_config - configure the transmit characteristics of
1511 * the ppp interface.
1514 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1521 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1522 if (errno != EIO && errno != ENOTTY)
1523 error("Couldn't set transmit async character map: %m");
1528 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1529 | (sync_serial? SC_SYNC: 0);
1530 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1533 /********************************************************************
1535 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1538 void tty_set_xaccm (ext_accm accm)
1542 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1543 if ( ! ok_error (errno))
1544 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1548 /********************************************************************
1550 * tty_recv_config - configure the receive-side characteristics of
1551 * the ppp interface.
1554 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1557 * If we were called because the link has gone down then there is nothing
1558 * which may be done. Just return without incident.
1563 * Set the receiver parameters
1565 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1566 if (errno != EIO && errno != ENOTTY)
1567 error("Couldn't set channel receive MRU: %m");
1569 if (new_style_driver && ppp_dev_fd >= 0
1570 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1571 error("Couldn't set MRU in generic PPP layer: %m");
1573 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1574 if (errno != EIO && errno != ENOTTY)
1575 error("Couldn't set channel receive asyncmap: %m");
1579 /********************************************************************
1581 * ccp_test - ask kernel whether a given compression method
1582 * is acceptable for use.
1586 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1588 struct ppp_option_data data;
1590 memset (&data, '\0', sizeof (data));
1592 data.length = opt_len;
1593 data.transmit = for_transmit;
1595 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1598 return (errno == ENOBUFS)? 0: -1;
1601 /********************************************************************
1603 * ccp_flags_set - inform kernel about the current state of CCP.
1606 void ccp_flags_set (int unit, int isopen, int isup)
1610 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1611 if (still_ppp() && ppp_dev_fd >= 0)
1612 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1617 * set_filters - set the active and pass filters in the kernel driver.
1619 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1621 struct sock_fprog fp;
1623 fp.len = pass->bf_len;
1624 fp.filter = (struct sock_filter *) pass->bf_insns;
1625 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1626 if (errno == ENOTTY)
1627 warn("kernel does not support PPP filtering");
1629 error("Couldn't set pass-filter in kernel: %m");
1632 fp.len = active->bf_len;
1633 fp.filter = (struct sock_filter *) active->bf_insns;
1634 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1635 error("Couldn't set active-filter in kernel: %m");
1640 #endif /* PPP_FILTER */
1642 /********************************************************************
1644 * get_idle_time - return how long the link has been idle.
1647 get_idle_time(int u, struct ppp_idle *ip)
1649 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1652 /********************************************************************
1654 * get_ppp_stats_iocl - return statistics for the link, using the ioctl() method,
1655 * this only supports 32-bit counters, so need to count the wraps.
1658 get_ppp_stats_ioctl(int u, struct pppd_stats *stats)
1660 static u_int32_t previbytes = 0;
1661 static u_int32_t prevobytes = 0;
1662 static u_int32_t iwraps = 0;
1663 static u_int32_t owraps = 0;
1665 struct ifpppstatsreq req;
1667 memset (&req, 0, sizeof (req));
1669 req.stats_ptr = (caddr_t) &req.stats;
1670 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1671 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1672 error("Couldn't get PPP statistics: %m");
1675 stats->bytes_in = req.stats.p.ppp_ibytes;
1676 stats->bytes_out = req.stats.p.ppp_obytes;
1677 stats->pkts_in = req.stats.p.ppp_ipackets;
1678 stats->pkts_out = req.stats.p.ppp_opackets;
1680 if (stats->bytes_in < previbytes)
1682 if (stats->bytes_out < prevobytes)
1685 previbytes = stats->bytes_in;
1686 prevobytes = stats->bytes_out;
1688 stats->bytes_in += (uint64_t)iwraps << 32;
1689 stats->bytes_out += (uint64_t)owraps << 32;
1694 /********************************************************************
1695 * get_ppp_stats_rtnetlink - return statistics for the link, using rtnetlink
1696 * This provides native 64-bit counters.
1699 get_ppp_stats_rtnetlink(int u, struct pppd_stats *stats)
1701 static int rtnl_fd = -1;
1703 struct sockaddr_nl nladdr;
1705 struct nlmsghdr nlh;
1706 struct if_stats_msg ifsm;
1709 struct nlmsghdr nlh;
1712 struct nlmsgerr nlerr;
1718 /* We only case about these first fields from rtnl_link_stats64 */
1719 uint64_t rx_packets;
1720 uint64_t tx_packets;
1724 char __end_stats[0];
1732 memset(&nladdr, 0, sizeof(nladdr));
1733 nladdr.nl_family = AF_NETLINK;
1736 rtnl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1738 error("get_ppp_stats_rtnetlink: error creating NETLINK socket: %m (line %d)", __LINE__);
1742 if (bind(rtnl_fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
1743 error("get_ppp_stats_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
1748 memset(&nlreq, 0, sizeof(nlreq));
1749 nlreq.nlh.nlmsg_len = sizeof(nlreq);
1750 nlreq.nlh.nlmsg_type = RTM_GETSTATS;
1751 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST;
1753 nlreq.ifsm.ifindex = if_nametoindex(ifname);
1754 nlreq.ifsm.filter_mask = IFLA_STATS_LINK_64;
1756 memset(&iov, 0, sizeof(iov));
1757 iov.iov_base = &nlreq;
1758 iov.iov_len = sizeof(nlreq);
1760 memset(&msg, 0, sizeof(msg));
1761 msg.msg_name = &nladdr;
1762 msg.msg_namelen = sizeof(nladdr);
1766 if (sendmsg(rtnl_fd, &msg, 0) < 0) {
1767 error("get_ppp_stats_rtnetlink: sendmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1771 /* We just need to repoint to IOV ... everything else stays the same */
1772 iov.iov_base = &nlresp;
1773 iov.iov_len = sizeof(nlresp);
1775 nlresplen = recvmsg(rtnl_fd, &msg, 0);
1777 if (nlresplen < 0) {
1778 error("get_ppp_stats_rtnetlink: recvmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1782 if (nlresplen < sizeof(nlresp.nlh)) {
1783 error("get_ppp_stats_rtnetlink: Netlink response message was incomplete (line %d)", __LINE__);
1787 if (nlresp.nlh.nlmsg_type == NLMSG_ERROR) {
1788 if (nlresplen < offsetof(struct nlresp, __end_err)) {
1789 if (kernel_version >= KVERSION(4,7,0))
1790 error("get_ppp_stats_rtnetlink: Netlink responded with error: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
1792 error("get_ppp_stats_rtnetlink: Netlink responded with an error message, but the nlmsgerr structure is incomplete (line %d).",
1798 if (nlresp.nlh.nlmsg_type != RTM_NEWSTATS) {
1799 error("get_ppp_stats_rtnetlink: Expected RTM_NEWSTATS response, found something else (mlmsg_type %d, line %d)",
1800 nlresp.nlh.nlmsg_type, __LINE__);
1804 if (nlresplen < offsetof(struct nlresp, __end_stats)) {
1805 error("get_ppp_stats_rtnetlink: Obtained an insufficiently sized rtnl_link_stats64 struct from the kernel (line %d).", __LINE__);
1809 stats->bytes_in = nlresp.stats.rx_bytes;
1810 stats->bytes_out = nlresp.stats.tx_bytes;
1811 stats->pkts_in = nlresp.stats.rx_packets;
1812 stats->pkts_out = nlresp.stats.tx_packets;
1821 /********************************************************************
1822 * get_ppp_stats_sysfs - return statistics for the link, using the files in sysfs,
1823 * this provides native 64-bit counters.
1826 get_ppp_stats_sysfs(int u, struct pppd_stats *stats)
1828 char fname[PATH_MAX+1];
1829 char buf[21], *err; /* 2^64 < 10^20 */
1831 unsigned long long val;
1838 #define statfield(fn, field) { .fname = #fn, .ptr = &stats->field, .size = sizeof(stats->field) }
1839 statfield(rx_bytes, bytes_in),
1840 statfield(tx_bytes, bytes_out),
1841 statfield(rx_packets, pkts_in),
1842 statfield(tx_packets, pkts_out),
1846 blen = snprintf(fname, sizeof(fname), "/sys/class/net/%s/statistics/", ifname);
1847 if (blen >= sizeof(fname))
1848 return 0; /* ifname max 15, so this should be impossible */
1850 for (int i = 0; i < sizeof(slist) / sizeof(*slist); ++i) {
1851 if (snprintf(fname + blen, sizeof(fname) - blen, "%s", slist[i].fname) >= sizeof(fname) - blen) {
1853 error("sysfs stats: filename %s/%s overflowed PATH_MAX", fname, slist[i].fname);
1857 fd = open(fname, O_RDONLY);
1859 error("%s: %m", fname);
1863 rlen = read(fd, buf, sizeof(buf) - 1);
1866 error("%s: %m", fname);
1869 /* trim trailing \n if present */
1870 while (rlen > 0 && buf[rlen-1] == '\n')
1875 val = strtoull(buf, &err, 10);
1876 if (*buf < '0' || *buf > '9' || errno != 0 || *err) {
1877 error("string to number conversion error converting %s (from %s) for remaining string %s%s%s",
1878 buf, fname, err, errno ? ": " : "", errno ? strerror(errno) : "");
1881 switch (slist[i].size) {
1882 #define stattype(type) case sizeof(type): *(type*)slist[i].ptr = (type)val; break
1889 error("Don't know how to store stats for %s of size %u", slist[i].fname, slist[i].size);
1897 /********************************************************************
1898 * Periodic timer function to be used to keep stats up to date in case of ioctl
1901 * Given the 25s interval this should be fine up to data rates of 1.37Gbps.
1902 * If you do change the timer, remember to also bring the get_ppp_stats (which
1903 * sets up the initial trigger) as well.
1906 ppp_stats_poller(void* u)
1908 struct pppd_stats dummy;
1909 get_ppp_stats_ioctl((long)u, &dummy);
1910 TIMEOUT(ppp_stats_poller, u, 25);
1913 /********************************************************************
1914 * get_ppp_stats - return statistics for the link.
1916 int get_ppp_stats(int u, struct pppd_stats *stats)
1918 static int (*func)(int, struct pppd_stats*) = NULL;
1921 if (get_ppp_stats_rtnetlink(u, stats)) {
1922 func = get_ppp_stats_rtnetlink;
1925 if (get_ppp_stats_sysfs(u, stats)) {
1926 func = get_ppp_stats_sysfs;
1929 warn("statistics falling back to ioctl which only supports 32-bit counters");
1930 func = get_ppp_stats_ioctl;
1931 TIMEOUT(ppp_stats_poller, (void*)(long)u, 25);
1934 return func(u, stats);
1937 /********************************************************************
1939 * ccp_fatal_error - returns 1 if decompression was disabled as a
1940 * result of an error detected after decompression of a packet,
1941 * 0 otherwise. This is necessary because of patent nonsense.
1944 int ccp_fatal_error (int unit)
1948 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1949 error("Couldn't read compression error flags: %m");
1952 return flags & SC_DC_FERROR;
1955 /********************************************************************
1957 * path_to_procfs - find the path to the proc file system mount point
1959 static char proc_path[MAXPATHLEN];
1960 static int proc_path_len;
1962 static char *path_to_procfs(const char *tail)
1964 struct mntent *mntent;
1967 if (proc_path_len == 0) {
1968 /* Default the mount location of /proc */
1969 strlcpy (proc_path, "/proc", sizeof(proc_path));
1971 fp = fopen(MOUNTED, "r");
1973 while ((mntent = getmntent(fp)) != NULL) {
1974 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1976 if (strcmp(mntent->mnt_type, "proc") == 0) {
1977 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1978 proc_path_len = strlen(proc_path);
1986 strlcpy(proc_path + proc_path_len, tail,
1987 sizeof(proc_path) - proc_path_len);
1992 * /proc/net/route parsing stuff.
1994 #define ROUTE_MAX_COLS 12
1995 FILE *route_fd = (FILE *) 0;
1996 static char route_buffer[512];
1997 static int route_dev_col, route_dest_col, route_gw_col;
1998 static int route_flags_col, route_metric_col, route_mask_col;
1999 static int route_num_cols;
2001 static int open_route_table (void);
2002 static void close_route_table (void);
2003 static int read_route_table (struct rtentry *rt);
2005 /********************************************************************
2007 * close_route_table - close the interface to the route table
2010 static void close_route_table (void)
2012 if (route_fd != (FILE *) 0) {
2014 route_fd = (FILE *) 0;
2018 /********************************************************************
2020 * open_route_table - open the interface to the route table
2022 static char route_delims[] = " \t\n";
2024 static int open_route_table (void)
2028 close_route_table();
2030 path = path_to_procfs("/net/route");
2031 route_fd = fopen (path, "r");
2032 if (route_fd == NULL) {
2033 error("can't open routing table %s: %m", path);
2037 route_dev_col = 0; /* default to usual columns */
2040 route_flags_col = 3;
2041 route_metric_col = 6;
2045 /* parse header line */
2046 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
2047 char *p = route_buffer, *q;
2049 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
2051 if ((q = strtok(p, route_delims)) == 0)
2053 if (strcasecmp(q, "iface") == 0)
2054 route_dev_col = col;
2055 else if (strcasecmp(q, "destination") == 0)
2056 route_dest_col = col;
2057 else if (strcasecmp(q, "gateway") == 0)
2059 else if (strcasecmp(q, "flags") == 0)
2060 route_flags_col = col;
2061 else if (strcasecmp(q, "mask") == 0)
2062 route_mask_col = col;
2065 if (used && col >= route_num_cols)
2066 route_num_cols = col + 1;
2074 /********************************************************************
2076 * read_route_table - read the next entry from the route table
2079 static int read_route_table(struct rtentry *rt)
2081 char *cols[ROUTE_MAX_COLS], *p;
2084 memset (rt, '\0', sizeof (struct rtentry));
2086 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
2090 for (col = 0; col < route_num_cols; ++col) {
2091 cols[col] = strtok(p, route_delims);
2092 if (cols[col] == NULL)
2093 return 0; /* didn't get enough columns */
2097 SET_SA_FAMILY (rt->rt_dst, AF_INET);
2098 SET_SA_FAMILY (rt->rt_gateway, AF_INET);
2100 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
2101 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
2102 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
2104 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
2105 rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
2106 rt->rt_dev = cols[route_dev_col];
2111 /********************************************************************
2113 * defaultroute_exists - determine if there is a default route
2114 * with the given metric (or negative for any)
2117 static int defaultroute_exists (struct rtentry *rt, int metric)
2121 if (!open_route_table())
2124 while (read_route_table(rt) != 0) {
2125 if ((rt->rt_flags & RTF_UP) == 0)
2128 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
2130 if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
2131 || rt->rt_metric == metric)) {
2137 close_route_table();
2142 * have_route_to - determine if the system has any route to
2143 * a given IP address. `addr' is in network byte order.
2144 * Return value is 1 if yes, 0 if no, -1 if don't know.
2145 * For demand mode to work properly, we have to ignore routes
2146 * through our own interface.
2148 int have_route_to(u_int32_t addr)
2153 if (!open_route_table())
2154 return -1; /* don't know */
2156 while (read_route_table(&rt)) {
2157 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
2159 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
2165 close_route_table();
2169 /********************************************************************
2171 * sifdefaultroute - assign a default route through the address given.
2173 * If the global default_rt_repl_rest flag is set, then this function
2174 * already replaced the original system defaultroute with some other
2175 * route and it should just replace the current defaultroute with
2176 * another one, without saving the current route. Use: demand mode,
2177 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
2178 * and then changes the temporary addresses to the addresses for the real
2179 * ppp connection when it has come up.
2182 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
2184 struct rtentry rt, tmp_rt;
2185 struct rtentry *del_rt = NULL;
2187 if (default_rt_repl_rest) {
2188 /* We have already replaced the original defaultroute, if we
2189 * are called again, we will delete the current default route
2190 * and set the new default route in this function.
2191 * - this is normally only the case the doing demand: */
2192 if (defaultroute_exists(&tmp_rt, -1))
2194 } else if (defaultroute_exists(&old_def_rt, -1 ) &&
2195 strcmp( old_def_rt.rt_dev, ifname) != 0) {
2197 * We did not yet replace an existing default route, let's
2198 * check if we should save and replace a default route:
2200 u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
2202 if (old_gateway != gateway) {
2204 error("not replacing default route to %s [%I]",
2205 old_def_rt.rt_dev, old_gateway);
2208 /* we need to copy rt_dev because we need it permanent too: */
2209 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
2210 strcpy(tmp_dev, old_def_rt.rt_dev);
2211 old_def_rt.rt_dev = tmp_dev;
2213 notice("replacing old default route to %s [%I]",
2214 old_def_rt.rt_dev, old_gateway);
2215 default_rt_repl_rest = 1;
2216 del_rt = &old_def_rt;
2221 memset (&rt, 0, sizeof (rt));
2222 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2225 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2227 if (kernel_version > KVERSION(2,1,0)) {
2228 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2229 SIN_ADDR(rt.rt_genmask) = 0L;
2232 rt.rt_flags = RTF_UP;
2233 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2234 if ( ! ok_error ( errno ))
2235 error("default route ioctl(SIOCADDRT): %m");
2238 if (default_rt_repl_rest && del_rt)
2239 if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
2240 if ( ! ok_error ( errno ))
2241 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
2245 have_default_route = 1;
2249 /********************************************************************
2251 * cifdefaultroute - delete a default route through the address given.
2254 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
2258 have_default_route = 0;
2260 memset (&rt, '\0', sizeof (rt));
2261 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2262 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2267 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2269 if (kernel_version > KVERSION(2,1,0)) {
2270 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2271 SIN_ADDR(rt.rt_genmask) = 0L;
2274 rt.rt_flags = RTF_UP;
2275 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2277 if ( ! ok_error ( errno ))
2278 error("default route ioctl(SIOCDELRT): %m");
2282 if (default_rt_repl_rest) {
2283 notice("restoring old default route to %s [%I]",
2284 old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
2285 if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
2286 if ( ! ok_error ( errno ))
2287 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
2290 default_rt_repl_rest = 0;
2298 * /proc/net/ipv6_route parsing stuff.
2300 static int route_dest_plen_col;
2301 static int open_route6_table (void);
2302 static int read_route6_table (struct in6_rtmsg *rt);
2304 /********************************************************************
2306 * open_route6_table - open the interface to the route table
2308 static int open_route6_table (void)
2312 close_route_table();
2314 path = path_to_procfs("/net/ipv6_route");
2315 route_fd = fopen (path, "r");
2316 if (route_fd == NULL) {
2317 error("can't open routing table %s: %m", path);
2321 /* default to usual columns */
2323 route_dest_plen_col = 1;
2325 route_metric_col = 5;
2326 route_flags_col = 8;
2328 route_num_cols = 10;
2333 /********************************************************************
2335 * read_route6_table - read the next entry from the route table
2338 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
2345 for (i = 0; i < 4; i++) {
2346 memcpy(hex8, s + 8*i, 8);
2347 v = strtoul(hex8, NULL, 16);
2348 addr->s6_addr32[i] = v;
2352 static int read_route6_table(struct in6_rtmsg *rt)
2354 char *cols[ROUTE_MAX_COLS], *p;
2357 memset (rt, '\0', sizeof (struct in6_rtmsg));
2359 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
2363 for (col = 0; col < route_num_cols; ++col) {
2364 cols[col] = strtok(p, route_delims);
2365 if (cols[col] == NULL)
2366 return 0; /* didn't get enough columns */
2370 hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
2371 rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
2372 hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
2374 rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
2375 rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
2376 rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
2381 /********************************************************************
2383 * defaultroute6_exists - determine if there is a default route
2386 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
2390 if (!open_route6_table())
2393 while (read_route6_table(rt) != 0) {
2394 if ((rt->rtmsg_flags & RTF_UP) == 0)
2397 if (rt->rtmsg_dst_len != 0)
2399 if (rt->rtmsg_dst.s6_addr32[0] == 0L
2400 && rt->rtmsg_dst.s6_addr32[1] == 0L
2401 && rt->rtmsg_dst.s6_addr32[2] == 0L
2402 && rt->rtmsg_dst.s6_addr32[3] == 0L
2403 && (metric < 0 || rt->rtmsg_metric == metric)) {
2409 close_route_table();
2413 /********************************************************************
2415 * sif6defaultroute - assign a default route through the address given.
2417 * If the global default_rt_repl_rest flag is set, then this function
2418 * already replaced the original system defaultroute with some other
2419 * route and it should just replace the current defaultroute with
2420 * another one, without saving the current route. Use: demand mode,
2421 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
2422 * and then changes the temporary addresses to the addresses for the real
2423 * ppp connection when it has come up.
2426 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2428 struct in6_rtmsg rt;
2429 char buf[IF_NAMESIZE];
2431 if (defaultroute6_exists(&rt, dfl_route_metric) &&
2432 rt.rtmsg_ifindex != if_nametoindex(ifname)) {
2433 if (rt.rtmsg_flags & RTF_GATEWAY)
2434 error("not replacing existing default route via gateway");
2436 error("not replacing existing default route through %s",
2437 if_indextoname(rt.rtmsg_ifindex, buf));
2441 memset (&rt, 0, sizeof (rt));
2443 rt.rtmsg_ifindex = if_nametoindex(ifname);
2444 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2445 rt.rtmsg_dst_len = 0;
2447 rt.rtmsg_flags = RTF_UP;
2448 if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
2449 if ( ! ok_error ( errno ))
2450 error("default route ioctl(SIOCADDRT): %m");
2454 have_default_route6 = 1;
2458 /********************************************************************
2460 * cif6defaultroute - delete a default route through the address given.
2463 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2465 struct in6_rtmsg rt;
2467 have_default_route6 = 0;
2469 memset (&rt, '\0', sizeof (rt));
2471 rt.rtmsg_ifindex = if_nametoindex(ifname);
2472 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2473 rt.rtmsg_dst_len = 0;
2475 rt.rtmsg_flags = RTF_UP;
2476 if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2478 if ( ! ok_error ( errno ))
2479 error("default route ioctl(SIOCDELRT): %m");
2488 /********************************************************************
2490 * sifproxyarp - Make a proxy ARP entry for the peer.
2493 int sifproxyarp (int unit, u_int32_t his_adr)
2495 struct arpreq arpreq;
2498 if (has_proxy_arp == 0) {
2499 memset (&arpreq, '\0', sizeof(arpreq));
2501 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2502 SIN_ADDR(arpreq.arp_pa) = his_adr;
2503 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2505 * Get the hardware address of an interface on the same subnet
2506 * as our local address.
2508 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2509 sizeof(proxy_arp_dev))) {
2510 error("Cannot determine ethernet address for proxy ARP");
2513 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2515 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2516 if ( ! ok_error ( errno ))
2517 error("ioctl(SIOCSARP): %m");
2520 proxy_arp_addr = his_adr;
2524 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2525 if (forw_path != 0) {
2526 int fd = open(forw_path, O_WRONLY);
2528 if (write(fd, "1", 1) != 1)
2529 error("Couldn't enable IP forwarding: %m");
2539 /********************************************************************
2541 * cifproxyarp - Delete the proxy ARP entry for the peer.
2544 int cifproxyarp (int unit, u_int32_t his_adr)
2546 struct arpreq arpreq;
2548 if (has_proxy_arp) {
2550 memset (&arpreq, '\0', sizeof(arpreq));
2551 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2552 SIN_ADDR(arpreq.arp_pa) = his_adr;
2553 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2554 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2556 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2557 if ( ! ok_error ( errno ))
2558 warn("ioctl(SIOCDARP): %m");
2565 /********************************************************************
2567 * get_ether_addr - get the hardware address of an interface on the
2568 * the same subnet as ipaddr.
2571 static int get_ether_addr (u_int32_t ipaddr,
2572 struct sockaddr *hwaddr,
2573 char *name, int namelen)
2575 struct ifreq *ifr, *ifend;
2576 u_int32_t ina, mask;
2578 struct ifreq ifreq, bestifreq;
2580 struct ifreq ifs[MAX_IFS];
2582 u_int32_t bestmask=0;
2583 int found_interface = 0;
2585 ifc.ifc_len = sizeof(ifs);
2587 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2588 if ( ! ok_error ( errno ))
2589 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2594 * Scan through looking for an interface with an Internet
2595 * address on the same subnet as `ipaddr'.
2597 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2598 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2599 if (ifr->ifr_addr.sa_family == AF_INET) {
2600 ina = SIN_ADDR(ifr->ifr_addr);
2601 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2603 * Check that the interface is up, and not point-to-point
2606 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2609 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2612 * Get its netmask and check that it's on the right subnet.
2614 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2617 mask = SIN_ADDR(ifreq.ifr_addr);
2619 if (((ipaddr ^ ina) & mask) != 0)
2620 continue; /* no match */
2622 if (mask >= bestmask) {
2623 /* Compare using >= instead of > -- it is possible for
2624 an interface to have a netmask of 0.0.0.0 */
2625 found_interface = 1;
2632 if (!found_interface) return 0;
2634 strlcpy(name, bestifreq.ifr_name, namelen);
2636 /* trim off the :1 in eth0:1 */
2637 aliasp = strchr(name, ':');
2641 info("found interface %s for proxy arp", name);
2643 * Now get the hardware address.
2645 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2646 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2647 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2652 &bestifreq.ifr_hwaddr,
2653 sizeof (struct sockaddr));
2659 * get_if_hwaddr - get the hardware address for the specified
2660 * network interface device.
2663 get_if_hwaddr(u_char *addr, char *name)
2668 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2671 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2672 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2673 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2676 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2681 * get_first_ether_hwaddr - get the hardware address for the first
2682 * ethernet-style interface on this system.
2685 get_first_ether_hwaddr(u_char *addr)
2687 struct if_nameindex *if_ni, *i;
2691 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2695 if_ni = if_nameindex();
2703 for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2704 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2705 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2706 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2707 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2708 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2714 if_freenameindex(if_ni);
2720 /********************************************************************
2722 * Return user specified netmask, modified by any mask we might determine
2723 * for address `addr' (in network byte order).
2724 * Here we scan through the system's list of interfaces, looking for
2725 * any non-point-to-point interfaces which might appear to be on the same
2726 * network as `addr'. If we find any, we OR in their netmask to the
2727 * user-specified netmask.
2730 u_int32_t GetMask (u_int32_t addr)
2732 u_int32_t mask, nmask, ina;
2733 struct ifreq *ifr, *ifend, ifreq;
2735 struct ifreq ifs[MAX_IFS];
2739 if (IN_CLASSA(addr)) /* determine network mask for address class */
2740 nmask = IN_CLASSA_NET;
2741 else if (IN_CLASSB(addr))
2742 nmask = IN_CLASSB_NET;
2744 nmask = IN_CLASSC_NET;
2746 /* class D nets are disallowed by bad_ip_adrs */
2747 mask = netmask | htonl(nmask);
2749 * Scan through the system's network interfaces.
2751 ifc.ifc_len = sizeof(ifs);
2753 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2754 if ( ! ok_error ( errno ))
2755 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2759 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2760 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2762 * Check the interface's internet address.
2764 if (ifr->ifr_addr.sa_family != AF_INET)
2766 ina = SIN_ADDR(ifr->ifr_addr);
2767 if (((ntohl(ina) ^ addr) & nmask) != 0)
2770 * Check that the interface is up, and not point-to-point nor loopback.
2772 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2773 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2776 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2779 * Get its netmask and OR it into our mask.
2781 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2783 mask |= SIN_ADDR(ifreq.ifr_addr);
2789 /********************************************************************
2791 * Internal routine to decode the version.modification.patch level
2794 static void decode_version (char *buf, int *version,
2795 int *modification, int *patch)
2799 *version = (int) strtoul (buf, &endp, 10);
2803 if (endp != buf && *endp == '.') {
2805 *modification = (int) strtoul (buf, &endp, 10);
2806 if (endp != buf && *endp == '.') {
2808 *patch = (int) strtoul (buf, &buf, 10);
2813 /********************************************************************
2815 * Procedure to determine if the PPP line discipline is registered.
2819 ppp_registered(void)
2827 * We used to open the serial device and set it to the ppp line
2828 * discipline here, in order to create a ppp unit. But that is
2829 * not a good idea - the user might have specified a device that
2830 * they can't open (permission, or maybe it doesn't really exist).
2831 * So we grab a pty master/slave pair and use that.
2833 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2834 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2839 * Try to put the device into the PPP discipline.
2841 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2842 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2851 /********************************************************************
2853 * ppp_available - check whether the system has any ppp interfaces
2854 * (in fact we check whether we can do an ioctl on ppp0).
2857 int ppp_available(void)
2862 int my_version, my_modification, my_patch;
2863 int osmaj, osmin, ospatch;
2865 /* get the kernel version now, since we are called before sys_init */
2867 osmaj = osmin = ospatch = 0;
2868 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2869 kernel_version = KVERSION(osmaj, osmin, ospatch);
2871 fd = open("/dev/ppp", O_RDWR);
2873 new_style_driver = 1;
2875 /* XXX should get from driver */
2877 driver_modification = 4;
2883 if (kernel_version >= KVERSION(2,3,13)) {
2884 error("Couldn't open the /dev/ppp device: %m");
2885 if (errno == ENOENT)
2887 "You need to create the /dev/ppp device node by\n"
2888 "executing the following command as root:\n"
2889 " mknod /dev/ppp c 108 0\n";
2890 else if (errno == ENODEV || errno == ENXIO)
2892 "Please load the ppp_generic kernel module.\n";
2896 /* we are running on a really really old kernel */
2898 "This system lacks kernel support for PPP. This could be because\n"
2899 "the PPP kernel module could not be loaded, or because PPP was not\n"
2900 "included in the kernel configuration. If PPP was included as a\n"
2901 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2902 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2903 "See README.linux file in the ppp distribution for more details.\n";
2906 * Open a socket for doing the ioctl operations.
2908 s = socket(AF_INET, SOCK_DGRAM, 0);
2912 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2913 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2915 * If the device did not exist then attempt to create one by putting the
2916 * current tty into the PPP discipline. If this works then obtain the
2917 * flags for the device again.
2920 if (ppp_registered()) {
2921 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2922 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2926 * Ensure that the hardware address is for PPP and not something else
2929 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2931 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2935 * This is the PPP device. Validate the version of the driver at this
2936 * point to ensure that this program will work with the driver.
2939 char abBuffer [1024];
2941 ifr.ifr_data = abBuffer;
2942 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2944 error("Couldn't read driver version: %m");
2946 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2949 decode_version(abBuffer,
2951 &driver_modification,
2954 * Validate the version of the driver against the version that we used.
2956 decode_version(VERSION,
2961 /* The version numbers must match */
2962 if (driver_version != my_version)
2965 /* The modification levels must be legal */
2966 if (driver_modification < 3) {
2967 if (driver_modification >= 2) {
2968 /* we can cope with 2.2.0 and above */
2976 slprintf(route_buffer, sizeof(route_buffer),
2977 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2978 driver_version, driver_modification, driver_patch);
2980 no_ppp_msg = route_buffer;
2988 #ifndef HAVE_LOGWTMP
2989 /********************************************************************
2991 * Update the wtmp file with the appropriate user name and tty device.
2994 void logwtmp (const char *line, const char *name, const char *host)
2996 struct utmp ut, *utp;
2997 pid_t mypid = getpid();
3003 * Update the signon database for users.
3004 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
3006 utmpname(_PATH_UTMP);
3008 while ((utp = getutent()) && (utp->ut_pid != mypid))
3012 memcpy(&ut, utp, sizeof(ut));
3014 /* some gettys/telnetds don't initialize utmp... */
3015 memset(&ut, 0, sizeof(ut));
3017 if (ut.ut_id[0] == 0)
3018 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
3020 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
3021 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
3025 ut.ut_type = USER_PROCESS;
3028 /* Insert the host name if one is supplied */
3030 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
3032 /* Insert the IP address of the remote system if IP is enabled */
3033 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
3034 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
3035 sizeof(ut.ut_addr));
3037 /* CL: Makes sure that the logout works */
3038 if (*host == 0 && *name==0)
3044 * Update the wtmp file.
3047 updwtmp(_PATH_WTMP, &ut);
3049 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
3051 flock(wtmp, LOCK_EX);
3053 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
3054 warn("error writing %s: %m", _PATH_WTMP);
3056 flock(wtmp, LOCK_UN);
3062 #endif /* HAVE_LOGWTMP */
3064 /********************************************************************
3066 * sifvjcomp - config tcp header compression
3069 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
3074 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
3075 error("Couldn't set up TCP header compression: %m");
3080 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
3081 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
3086 /********************************************************************
3088 * sifup - Config the interface up and enable IP packets to pass.
3095 if ((ret = setifstate(u, 1)))
3101 /********************************************************************
3103 * sifdown - Disable the indicated protocol and config the interface
3104 * down if there are no remaining protocols.
3109 if (if_is_up && --if_is_up > 0)
3117 return setifstate(u, 0);
3121 /********************************************************************
3123 * sif6up - Config the interface up for IPv6
3130 if ((ret = setifstate(u, 1)))
3136 /********************************************************************
3138 * sif6down - Disable the IPv6CP protocol and config the interface
3139 * down if there are no remaining protocols.
3142 int sif6down (int u)
3149 return setifstate(u, 0);
3153 /********************************************************************
3155 * setifstate - Config the interface up or down
3158 static int setifstate (int u, int state)
3162 memset (&ifr, '\0', sizeof (ifr));
3163 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
3164 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
3165 if (! ok_error (errno))
3166 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
3171 ifr.ifr_flags |= IFF_UP;
3173 ifr.ifr_flags &= ~IFF_UP;
3174 ifr.ifr_flags |= IFF_POINTOPOINT;
3175 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
3176 if (! ok_error (errno))
3177 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
3183 /********************************************************************
3185 * sifaddr - Config the interface IP addresses and netmask.
3188 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
3194 memset (&ifr, '\0', sizeof (ifr));
3195 memset (&rt, '\0', sizeof (rt));
3197 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
3198 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
3199 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
3201 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
3203 * Set our IP address
3205 SIN_ADDR(ifr.ifr_addr) = our_adr;
3206 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3207 if (errno != EEXIST) {
3208 if (! ok_error (errno))
3209 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3212 warn("ioctl(SIOCSIFADDR): Address already exists");
3217 * Set the gateway address
3220 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
3221 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
3222 if (! ok_error (errno))
3223 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
3229 * For recent kernels, force the netmask to 255.255.255.255.
3231 if (kernel_version >= KVERSION(2,1,16))
3233 if (net_mask != 0) {
3234 SIN_ADDR(ifr.ifr_netmask) = net_mask;
3235 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
3236 if (! ok_error (errno))
3237 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
3242 * Add the device route
3244 if (kernel_version < KVERSION(2,1,16)) {
3245 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3246 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3249 SIN_ADDR(rt.rt_gateway) = 0L;
3250 SIN_ADDR(rt.rt_dst) = his_adr;
3251 rt.rt_flags = RTF_UP | RTF_HOST;
3253 if (kernel_version > KVERSION(2,1,0)) {
3254 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3255 SIN_ADDR(rt.rt_genmask) = -1L;
3258 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
3259 if (! ok_error (errno))
3260 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
3265 /* set ip_dynaddr in demand mode if address changes */
3266 if (demand && tune_kernel && !dynaddr_set
3267 && our_old_addr && our_old_addr != our_adr) {
3268 /* set ip_dynaddr if possible */
3272 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
3273 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
3274 if (write(fd, "1", 1) != 1)
3275 error("Couldn't enable dynamic IP addressing: %m");
3278 dynaddr_set = 1; /* only 1 attempt */
3285 /********************************************************************
3287 * cifaddr - Clear the interface IP addresses, and delete routes
3288 * through the interface if possible.
3291 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
3295 if (kernel_version < KVERSION(2,1,16)) {
3297 * Delete the route through the device
3300 memset (&rt, '\0', sizeof (rt));
3302 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3303 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3306 SIN_ADDR(rt.rt_gateway) = 0;
3307 SIN_ADDR(rt.rt_dst) = his_adr;
3308 rt.rt_flags = RTF_UP | RTF_HOST;
3310 if (kernel_version > KVERSION(2,1,0)) {
3311 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3312 SIN_ADDR(rt.rt_genmask) = -1L;
3315 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
3316 if (still_ppp() && ! ok_error (errno))
3317 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
3322 /* This way it is possible to have an IPv6-only interface */
3323 memset(&ifr, 0, sizeof(ifr));
3324 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
3325 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3327 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3328 if (! ok_error (errno)) {
3329 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3334 our_old_addr = our_adr;
3340 /********************************************************************
3342 * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
3344 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
3347 struct nlmsghdr nlh;
3348 struct ifaddrmsg ifa;
3351 struct in6_addr addr;
3355 struct nlmsghdr nlh;
3356 struct nlmsgerr nlerr;
3358 struct sockaddr_nl nladdr;
3365 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
3367 error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
3372 * Tell kernel to not send to us payload of acknowledgment error message.
3373 * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
3374 * older kernel versions always send full payload in acknowledgment netlink
3375 * message. We ignore payload of this message as we need only error code,
3376 * to check if our set remote peer address request succeeded or failed.
3377 * So ignore return value from the following setsockopt() call as setting
3378 * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
3381 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
3383 memset(&nladdr, 0, sizeof(nladdr));
3384 nladdr.nl_family = AF_NETLINK;
3386 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
3387 error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
3392 memset(&nlreq, 0, sizeof(nlreq));
3393 nlreq.nlh.nlmsg_len = sizeof(nlreq);
3394 nlreq.nlh.nlmsg_type = RTM_NEWADDR;
3395 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
3396 nlreq.ifa.ifa_family = AF_INET6;
3397 nlreq.ifa.ifa_prefixlen = 128;
3398 nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
3399 nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
3400 nlreq.ifa.ifa_index = iface;
3401 nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
3402 nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
3403 IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
3404 nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
3405 nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
3408 * To set only local address, older kernel expects that local address is
3409 * in IFA_ADDRESS field (not IFA_LOCAL). New kernels with support for peer
3410 * address, ignore IFA_ADDRESS if is same as IFA_LOCAL. So for backward
3411 * compatibility when setting only local address, set it via both IFA_LOCAL
3412 * and IFA_ADDRESS fields. Same logic is implemented in 'ip address' command
3413 * from iproute2 project.
3415 if (!eui64_iszero(his_eui64))
3416 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
3418 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, our_eui64);
3420 memset(&nladdr, 0, sizeof(nladdr));
3421 nladdr.nl_family = AF_NETLINK;
3423 memset(&iov, 0, sizeof(iov));
3424 iov.iov_base = &nlreq;
3425 iov.iov_len = sizeof(nlreq);
3427 memset(&msg, 0, sizeof(msg));
3428 msg.msg_name = &nladdr;
3429 msg.msg_namelen = sizeof(nladdr);
3433 if (sendmsg(fd, &msg, 0) < 0) {
3434 error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
3439 memset(&iov, 0, sizeof(iov));
3440 iov.iov_base = &nlresp;
3441 iov.iov_len = sizeof(nlresp);
3443 memset(&msg, 0, sizeof(msg));
3444 msg.msg_name = &nladdr;
3445 msg.msg_namelen = sizeof(nladdr);
3449 nlresplen = recvmsg(fd, &msg, 0);
3451 if (nlresplen < 0) {
3452 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
3459 if (nladdr.nl_family != AF_NETLINK) {
3460 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
3464 if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
3465 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
3469 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
3470 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
3471 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
3475 /* error == 0 indicates success, negative value is errno code */
3476 if (nlresp.nlerr.error != 0) {
3478 * Linux kernel versions prior 3.11 do not support setting IPv6 peer
3479 * addresses and error response is expected. On older kernel versions
3480 * do not show this error message. On error pppd tries to fallback to
3481 * the old IOCTL method.
3483 if (kernel_version >= KVERSION(3,11,0))
3484 error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
3491 /********************************************************************
3493 * sif6addr - Config the interface with an IPv6 link-local address
3495 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3497 struct in6_ifreq ifr6;
3499 struct in6_rtmsg rt6;
3504 error("IPv6 socket creation failed: %m");
3507 memset(&ifr, 0, sizeof (ifr));
3508 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3509 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3510 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3514 if (kernel_version >= KVERSION(2,1,16)) {
3515 /* Set both local address and remote peer address (with route for it) via rtnetlink */
3516 ret = sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
3522 * Linux kernel versions prior 3.11 do not support setting IPv6 peer address
3523 * via rtnetlink. So if sif6addr_rtnetlink() fails then try old IOCTL method.
3526 /* Local interface */
3527 memset(&ifr6, 0, sizeof(ifr6));
3528 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3529 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3530 ifr6.ifr6_prefixlen = 128;
3532 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3533 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3538 if (!ret && !eui64_iszero(his_eui64)) {
3540 * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3541 * setting remote peer host address, so set only route to remote host.
3544 /* Route to remote host */
3545 memset(&rt6, 0, sizeof(rt6));
3546 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3547 rt6.rtmsg_flags = RTF_UP;
3548 rt6.rtmsg_dst_len = 128;
3549 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3550 rt6.rtmsg_metric = 1;
3552 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3553 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3562 /********************************************************************
3564 * cif6addr - Remove IPv6 address from interface
3566 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3569 struct in6_ifreq ifr6;
3573 error("IPv6 socket creation failed: %m");
3576 memset(&ifr, 0, sizeof(ifr));
3577 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3578 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3579 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3583 memset(&ifr6, 0, sizeof(ifr6));
3584 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3585 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3586 ifr6.ifr6_prefixlen = 128;
3588 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3589 if (errno != EADDRNOTAVAIL) {
3590 if (! ok_error (errno))
3591 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3594 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3603 * get_pty - get a pty master/slave pair and chown the slave side
3604 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
3607 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3609 int i, mfd, ret, sfd = -1;
3611 struct termios tios;
3615 * Try the unix98 way first.
3617 mfd = open("/dev/ptmx", O_RDWR);
3620 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3621 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3622 chmod(pty_name, S_IRUSR | S_IWUSR);
3625 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3626 warn("Couldn't unlock pty slave %s: %m", pty_name);
3628 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3630 warn("Couldn't open pty slave %s: %m", pty_name);
3635 #endif /* TIOCGPTN */
3638 /* the old way - scan through the pty name space */
3639 for (i = 0; i < 64; ++i) {
3640 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3641 'p' + i / 16, i % 16);
3642 mfd = open(pty_name, O_RDWR, 0);
3645 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3647 ret = fchown(sfd, uid, -1);
3649 warn("Couldn't change ownership of %s, %m", pty_name);
3651 ret = fchmod(sfd, S_IRUSR | S_IWUSR);
3653 warn("Couldn't change permissions of %s, %m", pty_name);
3665 strlcpy(slave_name, pty_name, 16);
3668 if (tcgetattr(sfd, &tios) == 0) {
3669 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3670 tios.c_cflag |= CS8 | CREAD | CLOCAL;
3671 tios.c_iflag = IGNPAR;
3674 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3675 warn("couldn't set attributes on pty: %m");
3677 warn("couldn't get attributes on pty: %m");
3682 /********************************************************************
3684 * open_loopback - open the device we use for getting packets
3685 * in demand mode. Under Linux, we use a pty master/slave pair.
3688 open_ppp_loopback(void)
3693 if (new_style_driver) {
3694 /* allocate ourselves a ppp unit */
3695 if (make_ppp_unit() < 0)
3697 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3698 set_kdebugflag(kdebugflag);
3703 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3704 fatal("No free pty for loopback");
3706 set_ppp_fd(slave_fd);
3708 flags = fcntl(master_fd, F_GETFL);
3710 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3711 warn("couldn't set master loopback to nonblock: %m");
3713 flags = fcntl(ppp_fd, F_GETFL);
3715 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3716 warn("couldn't set slave loopback to nonblock: %m");
3718 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3719 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3721 * Find out which interface we were given.
3723 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3724 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3726 * Enable debug in the driver if requested.
3728 set_kdebugflag (kdebugflag);
3733 /********************************************************************
3735 * sifnpmode - Set the mode for handling packets for a given NP.
3739 sifnpmode(int u, int proto, enum NPmode mode)
3743 npi.protocol = proto;
3745 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3746 if (! ok_error (errno))
3747 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3754 * Use the hostname as part of the random number seed.
3763 for (p = hostname; *p != 0; ++p)
3768 /********************************************************************
3770 * sys_check_options - check the options that the user specified
3774 sys_check_options(void)
3776 if (demand && driver_is_old) {
3777 option_error("demand dialling is not supported by kernel driver "
3778 "version %d.%d.%d", driver_version, driver_modification,
3782 if (multilink && !new_style_driver) {
3783 warn("Warning: multilink is not supported by the kernel driver");
3789 /********************************************************************
3791 * get_time - Get current time, monotonic if possible.
3794 get_time(struct timeval *tv)
3796 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3797 * Runtime checking makes it safe. */
3798 #ifndef CLOCK_MONOTONIC
3799 #define CLOCK_MONOTONIC 1
3801 static int monotonic = -1;
3806 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3810 tv->tv_sec = ts.tv_sec;
3811 tv->tv_usec = ts.tv_nsec / 1000;
3814 } else if (monotonic > 0)
3818 warn("Couldn't use monotonic clock source: %m");
3821 return gettimeofday(tv, NULL);