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>
84 #include <sys/param.h>
104 /* This is in netdevice.h. However, this compile will fail miserably if
105 you attempt to include netdevice.h because it has so many references
106 to __memcpy functions which it should not attempt to do. So, since I
107 really don't use it, but it must be defined, define it now. */
110 #define MAX_ADDR_LEN 7
113 #if !defined(__GLIBC__) || __GLIBC__ >= 2
114 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
116 #include <net/if_arp.h>
117 #include <net/route.h>
118 #include <netinet/if_ether.h>
120 #include <linux/types.h>
121 #include <linux/if.h>
122 #include <linux/if_arp.h>
123 #include <linux/route.h>
124 #include <linux/if_ether.h>
126 #include <netinet/in.h>
127 #include <arpa/inet.h>
129 #include <linux/ppp_defs.h>
130 #include <linux/if_ppp.h>
132 #ifdef PPP_WITH_IPV6CP
133 #include <linux/netlink.h>
134 #include <linux/rtnetlink.h>
135 #include <linux/if_link.h>
136 /* Attempt at retaining compile-support with older than 4.7 kernels, or kernels
137 * where RTM_NEWSTATS isn't defined for whatever reason.
140 #define RTM_NEWSTATS 92
141 #define RTM_GETSTATS 94
142 #define IFLA_STATS_LINK_64 1
143 #endif /* PPP_WITH_IPV6CP */
145 #include <linux/if_addr.h>
146 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
148 #define SOL_NETLINK 270
151 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
152 #ifndef NETLINK_CAP_ACK
153 #define NETLINK_CAP_ACK 10
161 #ifdef PPP_WITH_FILTER
162 #include <pcap-bpf.h>
163 #include <linux/filter.h>
164 #endif /* PPP_WITH_FILTER */
167 #include <sys/locks.h>
171 * Instead of system header file <termios.h> use local "termios_linux.h" header
172 * file as it provides additional support for arbitrary baud rates via BOTHER.
174 #include "termios_linux.h"
176 #ifdef PPP_WITH_IPV6CP
179 * This is in linux/include/net/ipv6.h.
183 struct in6_addr ifr6_addr;
184 __u32 ifr6_prefixlen;
185 unsigned int ifr6_ifindex;
189 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
190 memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr)); \
191 (sin6).s6_addr16[0] = htons(0xfe80); \
192 eui64_copy(eui64, (sin6).s6_addr32[2]); \
195 static const eui64_t nulleui64;
196 #endif /* PPP_WITH_IPV6CP */
198 /* We can get an EIO error on an ioctl if the modem has hung up */
199 #define ok_error(num) ((num)==EIO)
201 static int tty_disc = N_TTY; /* The TTY discipline */
202 static int ppp_disc = N_PPP; /* The PPP discpline */
203 static int initfdflags = -1; /* Initial file descriptor flags for fd */
204 static int ppp_fd = -1; /* fd which is set to PPP discipline */
205 static int sock_fd = -1; /* socket for doing interface ioctls */
206 static int slave_fd = -1; /* pty for old-style demand mode, slave */
207 static int master_fd = -1; /* pty for old-style demand mode, master */
208 #ifdef PPP_WITH_IPV6CP
209 static int sock6_fd = -1;
210 #endif /* PPP_WITH_IPV6CP */
213 * For the old-style kernel driver, this is the same as ppp_fd.
214 * For the new-style driver, it is the fd of an instance of /dev/ppp
215 * which is attached to the ppp unit and is used for controlling it.
217 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
219 static int chindex; /* channel index (new style driver) */
221 static fd_set in_fds; /* set of fds that wait_input waits for */
222 static int max_in_fd; /* highest fd set in in_fds */
224 static int has_proxy_arp = 0;
225 static int driver_version = 0;
226 static int driver_modification = 0;
227 static int driver_patch = 0;
228 static int driver_is_old = 0;
229 static int restore_term = 0; /* 1 => we've munged the terminal */
230 static struct termios inittermios; /* Initial TTY termios */
232 int new_style_driver = 0;
234 static char loop_name[20];
235 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
237 static int if_is_up; /* Interface has been marked up */
238 static int if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
239 static int have_default_route; /* Gateway for default route added */
240 static int have_default_route6; /* Gateway for default IPv6 route added */
241 static struct rtentry old_def_rt; /* Old default route */
242 static int default_rt_repl_rest; /* replace and restore old default rt */
243 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
244 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
245 static u_int32_t our_old_addr; /* for detecting address changes */
246 static int dynaddr_set; /* 1 if ip_dynaddr set */
247 static int looped; /* 1 if using loop */
248 static int link_mtu; /* mtu for the link (not bundle) */
250 static struct utsname utsname; /* for the kernel version */
251 static int kernel_version;
252 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
256 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
257 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
258 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
260 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
262 /* Prototypes for procedures local to this file. */
263 static int modify_flags(int fd, int clear_bits, int set_bits);
264 static int translate_speed (int bps);
265 static int baud_rate_of (int speed);
266 static void close_route_table (void);
267 static int open_route_table (void);
268 static int read_route_table (struct rtentry *rt);
269 static int defaultroute_exists (struct rtentry *rt, int metric);
270 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
271 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
272 char *name, int namelen);
273 static void decode_version (char *buf, int *version, int *mod, int *patch);
274 static int set_kdebugflag(int level);
275 static int ppp_registered(void);
276 static int make_ppp_unit(void);
277 static int setifstate (int u, int state);
279 extern u_char inpacket_buf[]; /* borrowed from main.c */
281 extern int dfl_route_metric;
284 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
288 #define SET_SA_FAMILY(addr, family) \
289 memset ((char *) &(addr), '\0', sizeof(addr)); \
290 addr.sa_family = (family);
293 * Determine if the PPP connection should still be present.
298 /* new_fd is the fd of a tty */
299 static void set_ppp_fd (int new_fd)
302 if (!new_style_driver)
306 static int still_ppp(void)
308 if (new_style_driver)
309 return !hungup && ppp_fd >= 0;
310 if (!hungup || ppp_fd == slave_fd)
313 set_ppp_fd(slave_fd);
320 * modify_flags - set and clear flag bits controlling the kernel
323 static int modify_flags(int fd, int clear_bits, int set_bits)
327 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
329 flags = (flags & ~clear_bits) | set_bits;
330 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
337 error("Failed to set PPP kernel option flags: %m");
341 /********************************************************************
343 * sys_init - System-dependent initialization.
348 /* Get an internet socket for doing socket ioctls. */
349 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
351 fatal("Couldn't create IP socket: %m(%d)", errno);
353 #ifdef PPP_WITH_IPV6CP
354 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
356 sock6_fd = -errno; /* save errno for later */
363 /********************************************************************
365 * sys_cleanup - restore any system state we modified before exiting:
366 * mark the interface down, delete default route and/or proxy arp entry.
367 * This shouldn't call die() because it's called from die().
370 void sys_cleanup(void)
373 * Take down the device
379 #ifdef PPP_WITH_IPV6CP
385 * Delete any routes through the device.
387 if (have_default_route)
388 cifdefaultroute(0, 0, 0);
389 #ifdef PPP_WITH_IPV6CP
390 if (have_default_route6)
391 cif6defaultroute(0, nulleui64, nulleui64);
395 cifproxyarp(0, proxy_arp_addr);
398 /********************************************************************
400 * sys_close - Clean up in a child process before execing.
405 if (new_style_driver && ppp_dev_fd >= 0)
409 #ifdef PPP_WITH_IPV6CP
419 /********************************************************************
421 * set_kdebugflag - Define the debugging level for the kernel
424 static int set_kdebugflag (int requested_level)
428 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
429 if ( ! ok_error (errno) )
430 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
436 /********************************************************************
438 * tty_establish_ppp - Turn the serial port into a ppp interface.
441 int tty_establish_ppp (int tty_fd)
446 * Ensure that the tty device is in exclusive mode.
448 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
449 if ( ! ok_error ( errno ))
450 warn("Couldn't make tty exclusive: %m");
453 * Demand mode - prime the old ppp device to relinquish the unit.
455 if (!new_style_driver && looped
456 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
457 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
461 * Set the current tty to the PPP discpline
465 #define N_SYNC_PPP 14
467 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
468 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
469 if ( ! ok_error (errno) ) {
470 error("Couldn't set tty to PPP discipline: %m");
475 ret_fd = generic_establish_ppp(tty_fd);
477 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
478 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
482 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
483 (kdebugflag * SC_DEBUG) & SC_LOGB);
485 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
486 warn("Couldn't reset tty to normal line discipline: %m");
492 /********************************************************************
494 * generic_establish_ppp - Turn the fd into a ppp interface.
496 int generic_establish_ppp (int fd)
500 if (new_style_driver) {
503 /* If a ppp_fd is already open, close it first */
510 /* Open an instance of /dev/ppp and connect the channel to it */
511 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
512 error("Couldn't get channel number: %m");
515 dbglog("using channel %d", chindex);
516 fd = open("/dev/ppp", O_RDWR);
518 error("Couldn't reopen /dev/ppp: %m");
521 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
522 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
523 error("Couldn't attach to channel %d: %m", chindex);
526 flags = fcntl(fd, F_GETFL);
527 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
528 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
533 if (!looped && !multilink) {
535 * Create a new PPP unit.
537 if (make_ppp_unit() < 0)
542 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
546 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
547 error("Couldn't attach to PPP unit %d: %m", ifunit);
554 * Old-style driver: find out which interface we were given.
557 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
558 if (ok_error (errno))
560 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
562 /* Check that we got the same unit again. */
563 if (looped && x != ifunit)
564 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
568 * Fetch the initial file flags and reset blocking mode on the file.
570 initfdflags = fcntl(fd, F_GETFL);
571 if (initfdflags == -1 ||
572 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
573 if ( ! ok_error (errno))
574 warn("Couldn't set device to non-blocking mode: %m");
579 * Enable debug in the driver if requested.
582 set_kdebugflag (kdebugflag);
594 /********************************************************************
596 * tty_disestablish_ppp - Restore the serial port to normal operation.
597 * This shouldn't call die() because it's called from die().
600 void tty_disestablish_ppp(int tty_fd)
604 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
606 if (tcflush(tty_fd, TCIOFLUSH) < 0)
608 warn("tcflush failed: %m");
612 * Restore the previous line discipline
614 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
615 if ( ! ok_error (errno))
616 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
619 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
620 if ( ! ok_error (errno))
621 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
624 /* Reset non-blocking mode on fd. */
625 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
626 if ( ! ok_error (errno))
627 warn("Couldn't restore device fd flags: %m");
633 generic_disestablish_ppp(tty_fd);
636 /********************************************************************
638 * generic_disestablish_ppp - Restore device components to normal
639 * operation, and reconnect the ppp unit to the loopback if in demand
640 * mode. This shouldn't call die() because it's called from die().
642 void generic_disestablish_ppp(int dev_fd)
644 if (new_style_driver) {
648 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
650 } else if (!doing_multilink && ppp_dev_fd >= 0) {
652 remove_fd(ppp_dev_fd);
656 /* old-style driver */
658 set_ppp_fd(slave_fd);
665 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
666 * Assumes new_style_driver.
668 static int make_ppp_unit(void)
672 if (ppp_dev_fd >= 0) {
673 dbglog("in make_ppp_unit, already had /dev/ppp open?");
676 ppp_dev_fd = open("/dev/ppp", O_RDWR);
678 fatal("Couldn't open /dev/ppp: %m");
679 flags = fcntl(ppp_dev_fd, F_GETFL);
681 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
682 warn("Couldn't set /dev/ppp to nonblock: %m");
685 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
686 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
687 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
689 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
692 error("Couldn't create new ppp unit: %m");
694 if (x == 0 && req_ifname[0] != '\0') {
697 memset(&ifr, 0, sizeof(struct ifreq));
698 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
699 strlcpy(ifr.ifr_name, t, IFNAMSIZ);
700 strlcpy(ifr.ifr_newname, req_ifname, IFNAMSIZ);
701 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
703 error("Couldn't rename interface %s to %s: %m", t, req_ifname);
705 info("Renamed interface %s to %s", t, req_ifname);
712 * cfg_bundle - configure the existing bundle.
713 * Used in demand mode.
715 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
717 if (!new_style_driver)
720 /* set the mrru, mtu and flags */
721 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
722 error("Couldn't set MRRU: %m");
724 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
725 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
726 | (mrru? SC_MULTILINK: 0)));
728 /* connect up the channel */
729 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
730 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
735 * make_new_bundle - create a new PPP unit (i.e. a bundle)
736 * and connect our channel to it. This should only get called
737 * if `multilink' was set at the time establish_ppp was called.
738 * In demand mode this uses our existing bundle instead of making
741 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
743 if (!new_style_driver)
746 /* make us a ppp unit */
747 if (make_ppp_unit() < 0)
750 /* set the mrru and flags */
751 cfg_bundle(mrru, mtru, rssn, tssn);
755 * bundle_attach - attach our link to a given PPP unit.
756 * We assume the unit is controlled by another pppd.
758 int bundle_attach(int ifnum)
762 if (!new_style_driver)
765 master_fd = open("/dev/ppp", O_RDWR);
767 fatal("Couldn't open /dev/ppp: %m");
768 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
769 if (errno == ENXIO) {
771 return 0; /* doesn't still exist */
773 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
775 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
776 fatal("Couldn't connect to interface unit %d: %m", ifnum);
777 modify_flags(master_fd, 0, SC_MULTILINK);
785 * destroy_bundle - tell the driver to destroy our bundle.
787 void destroy_bundle(void)
789 if (ppp_dev_fd >= 0) {
791 remove_fd(ppp_dev_fd);
796 /********************************************************************
798 * clean_check - Fetch the flags for the device and generate
799 * appropriate error messages.
801 void clean_check(void)
807 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
809 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
811 s = "all had bit 7 set to 1";
815 s = "all had bit 7 set to 0";
819 s = "all had odd parity";
823 s = "all had even parity";
828 warn("Receive serial link is not 8-bit clean:");
829 warn("Problem: %s", s);
837 * List of valid speeds.
841 int speed_int, speed_val;
937 { 1000000, B1000000 },
940 { 1152000, B1152000 },
943 { 1500000, B1500000 },
946 { 2000000, B2000000 },
949 { 2500000, B2500000 },
952 { 3000000, B3000000 },
955 { 3500000, B3500000 },
958 { 4000000, B4000000 },
963 /********************************************************************
965 * Translate from bits/second to a speed_t.
968 static int translate_speed (int bps)
970 struct speed *speedp;
973 for (speedp = speeds; speedp->speed_int; speedp++) {
974 if (bps == speedp->speed_int)
975 return speedp->speed_val;
981 /********************************************************************
983 * Translate from a speed_t to bits/second.
986 static int baud_rate_of (int speed)
988 struct speed *speedp;
991 for (speedp = speeds; speedp->speed_int; speedp++) {
992 if (speed == speedp->speed_val)
993 return speedp->speed_int;
999 /********************************************************************
1001 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
1002 * at the requested speed, etc. If `local' is true, set CLOCAL
1003 * regardless of whether the modem option was specified.
1006 void set_up_tty(int tty_fd, int local)
1009 struct termios tios;
1012 if (tcgetattr(tty_fd, &tios) < 0) {
1013 if (!ok_error(errno))
1014 fatal("tcgetattr: %m (line %d)", __LINE__);
1021 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1022 tios.c_cflag |= CS8 | CREAD | HUPCL;
1024 tios.c_iflag = IGNBRK | IGNPAR;
1027 tios.c_cc[VMIN] = 1;
1028 tios.c_cc[VTIME] = 0;
1030 if (local || !modem)
1031 tios.c_cflag ^= (CLOCAL | HUPCL);
1035 tios.c_cflag |= CRTSCTS;
1039 tios.c_iflag |= IXON | IXOFF;
1040 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
1041 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
1045 tios.c_cflag &= ~CRTSCTS;
1053 tios.c_cflag |= CSTOPB;
1056 speed = translate_speed(inspeed);
1058 cfsetospeed (&tios, speed);
1059 cfsetispeed (&tios, speed);
1060 speed = cfgetospeed(&tios);
1061 baud_rate = baud_rate_of(speed);
1064 tios.c_cflag &= ~CBAUD;
1065 tios.c_cflag |= BOTHER;
1066 tios.c_ospeed = inspeed;
1068 /* B0 sets input baudrate to the output baudrate */
1069 tios.c_cflag &= ~(CBAUD << IBSHIFT);
1070 tios.c_cflag |= B0 << IBSHIFT;
1071 tios.c_ispeed = inspeed;
1073 baud_rate = inspeed;
1080 speed = cfgetospeed(&tios);
1081 baud_rate = baud_rate_of(speed);
1084 baud_rate = tios.c_ospeed;
1089 * We can't proceed if the serial port baud rate is unknown,
1090 * since that implies that the serial port is disabled.
1094 fatal("speed %d not supported", inspeed);
1096 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1099 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1101 fatal("tcsetattr: %m (line %d)", __LINE__);
1105 /********************************************************************
1107 * setdtr - control the DTR line on the serial port.
1108 * This is called from die(), so it shouldn't call die().
1111 void setdtr (int tty_fd, int on)
1113 int modembits = TIOCM_DTR;
1115 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1118 /********************************************************************
1120 * restore_tty - restore the terminal to the saved settings.
1123 void restore_tty (int tty_fd)
1128 * Turn off echoing, because otherwise we can get into
1129 * a loop with the tty and the modem echoing to each other.
1130 * We presume we are the sole user of this tty device, so
1131 * when we close it, it will revert to its defaults anyway.
1133 if (!default_device)
1134 inittermios.c_lflag &= ~(ECHO | ECHONL);
1136 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1137 if (! ok_error (errno))
1138 warn("tcsetattr: %m (line %d)", __LINE__);
1143 /********************************************************************
1145 * output - Output PPP packet.
1148 void output (int unit, unsigned char *p, int len)
1153 dump_packet("sent", p, len);
1154 if (snoop_send_hook) snoop_send_hook(p, len);
1156 if (len < PPP_HDRLEN)
1158 if (new_style_driver) {
1161 proto = (p[0] << 8) + p[1];
1162 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1165 if (write(fd, p, len) < 0) {
1166 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1167 || errno == ENXIO || errno == EIO || errno == EINTR)
1168 warn("write: warning: %m (%d)", errno);
1170 error("write: %m (%d)", errno);
1174 /********************************************************************
1176 * wait_input - wait until there is data available,
1177 * for the length of time specified by *timo (indefinite
1181 void wait_input(struct timeval *timo)
1188 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1189 if (n < 0 && errno != EINTR)
1190 fatal("select: %m");
1194 * add_fd - add an fd to the set that wait_input waits for.
1198 if (fd >= FD_SETSIZE)
1199 fatal("internal error: file descriptor too large (%d)", fd);
1200 FD_SET(fd, &in_fds);
1206 * remove_fd - remove an fd from the set that wait_input waits for.
1208 void remove_fd(int fd)
1210 FD_CLR(fd, &in_fds);
1214 /********************************************************************
1216 * read_packet - get a PPP packet from the serial device.
1219 int read_packet (unsigned char *buf)
1223 len = PPP_MRU + PPP_HDRLEN;
1224 if (new_style_driver) {
1225 *buf++ = PPP_ALLSTATIONS;
1231 nr = read(ppp_fd, buf, len);
1232 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1233 && errno != EIO && errno != EINTR)
1235 if (nr < 0 && errno == ENXIO)
1238 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1239 /* N.B. we read ppp_fd first since LCP packets come in there. */
1240 nr = read(ppp_dev_fd, buf, len);
1241 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1242 && errno != EIO && errno != EINTR)
1243 error("read /dev/ppp: %m");
1244 if (nr < 0 && errno == ENXIO)
1246 if (nr == 0 && doing_multilink) {
1247 remove_fd(ppp_dev_fd);
1251 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1253 return (new_style_driver && nr > 0)? nr+2: nr;
1256 /********************************************************************
1258 * get_loop_output - get outgoing packets from the ppp device,
1259 * and detect when we want to bring the real link up.
1260 * Return value is 1 if we need to bring up the link, 0 otherwise.
1263 get_loop_output(void)
1268 if (new_style_driver) {
1269 while ((n = read_packet(inpacket_buf)) > 0)
1270 if (loop_frame(inpacket_buf, n))
1275 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1276 if (loop_chars(inbuf, n))
1280 fatal("eof on loopback");
1282 if (errno != EWOULDBLOCK && errno != EAGAIN)
1283 fatal("read from loopback: %m(%d)", errno);
1289 * netif_set_mtu - set the MTU on the PPP network interface.
1292 netif_set_mtu(int unit, int mtu)
1296 memset (&ifr, '\0', sizeof (ifr));
1297 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1300 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1301 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1305 * netif_get_mtu - get the MTU on the PPP network interface.
1308 netif_get_mtu(int unit)
1312 memset (&ifr, '\0', sizeof (ifr));
1313 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1315 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1316 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1322 /********************************************************************
1324 * tty_send_config - configure the transmit characteristics of
1325 * the ppp interface.
1328 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1335 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1336 if (errno != EIO && errno != ENOTTY)
1337 error("Couldn't set transmit async character map: %m");
1342 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1343 | (sync_serial? SC_SYNC: 0);
1344 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1347 /********************************************************************
1349 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1352 void tty_set_xaccm (ext_accm accm)
1356 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1357 if ( ! ok_error (errno))
1358 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1362 /********************************************************************
1364 * tty_recv_config - configure the receive-side characteristics of
1365 * the ppp interface.
1368 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1371 * If we were called because the link has gone down then there is nothing
1372 * which may be done. Just return without incident.
1377 * Set the receiver parameters
1379 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1380 if (errno != EIO && errno != ENOTTY)
1381 error("Couldn't set channel receive MRU: %m");
1383 if (new_style_driver && ppp_dev_fd >= 0
1384 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1385 error("Couldn't set MRU in generic PPP layer: %m");
1387 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1388 if (errno != EIO && errno != ENOTTY)
1389 error("Couldn't set channel receive asyncmap: %m");
1393 /********************************************************************
1395 * ccp_test - ask kernel whether a given compression method
1396 * is acceptable for use.
1400 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1402 struct ppp_option_data data;
1404 memset (&data, '\0', sizeof (data));
1406 data.length = opt_len;
1407 data.transmit = for_transmit;
1409 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1412 return (errno == ENOBUFS)? 0: -1;
1415 /********************************************************************
1417 * ccp_flags_set - inform kernel about the current state of CCP.
1420 void ccp_flags_set (int unit, int isopen, int isup)
1424 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1425 if (still_ppp() && ppp_dev_fd >= 0)
1426 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1429 #ifdef PPP_WITH_FILTER
1431 * set_filters - set the active and pass filters in the kernel driver.
1433 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1435 struct sock_fprog fp;
1437 fp.len = pass->bf_len;
1438 fp.filter = (struct sock_filter *) pass->bf_insns;
1439 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1440 if (errno == ENOTTY)
1441 warn("kernel does not support PPP filtering");
1443 error("Couldn't set pass-filter in kernel: %m");
1446 fp.len = active->bf_len;
1447 fp.filter = (struct sock_filter *) active->bf_insns;
1448 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1449 error("Couldn't set active-filter in kernel: %m");
1454 #endif /* PPP_WITH_FILTER */
1456 /********************************************************************
1458 * get_idle_time - return how long the link has been idle.
1461 get_idle_time(int u, struct ppp_idle *ip)
1463 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1466 /********************************************************************
1468 * get_ppp_stats_iocl - return statistics for the link, using the ioctl() method,
1469 * this only supports 32-bit counters, so need to count the wraps.
1472 get_ppp_stats_ioctl(int u, struct pppd_stats *stats)
1474 static u_int32_t previbytes = 0;
1475 static u_int32_t prevobytes = 0;
1476 static u_int32_t iwraps = 0;
1477 static u_int32_t owraps = 0;
1479 struct ifpppstatsreq req;
1481 memset (&req, 0, sizeof (req));
1483 req.stats_ptr = (caddr_t) &req.stats;
1484 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1485 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1486 error("Couldn't get PPP statistics: %m");
1489 stats->bytes_in = req.stats.p.ppp_ibytes;
1490 stats->bytes_out = req.stats.p.ppp_obytes;
1491 stats->pkts_in = req.stats.p.ppp_ipackets;
1492 stats->pkts_out = req.stats.p.ppp_opackets;
1494 if (stats->bytes_in < previbytes)
1496 if (stats->bytes_out < prevobytes)
1499 previbytes = stats->bytes_in;
1500 prevobytes = stats->bytes_out;
1502 stats->bytes_in += (uint64_t)iwraps << 32;
1503 stats->bytes_out += (uint64_t)owraps << 32;
1508 /********************************************************************
1509 * get_ppp_stats_rtnetlink - return statistics for the link, using rtnetlink
1510 * This provides native 64-bit counters.
1513 get_ppp_stats_rtnetlink(int u, struct pppd_stats *stats)
1515 static int rtnl_fd = -1;
1517 struct sockaddr_nl nladdr;
1519 struct nlmsghdr nlh;
1520 struct if_stats_msg ifsm;
1523 struct nlmsghdr nlh;
1526 struct nlmsgerr nlerr;
1532 /* We only case about these first fields from rtnl_link_stats64 */
1533 uint64_t rx_packets;
1534 uint64_t tx_packets;
1538 char __end_stats[0];
1546 memset(&nladdr, 0, sizeof(nladdr));
1547 nladdr.nl_family = AF_NETLINK;
1550 rtnl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1552 error("get_ppp_stats_rtnetlink: error creating NETLINK socket: %m (line %d)", __LINE__);
1556 if (bind(rtnl_fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
1557 error("get_ppp_stats_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
1562 memset(&nlreq, 0, sizeof(nlreq));
1563 nlreq.nlh.nlmsg_len = sizeof(nlreq);
1564 nlreq.nlh.nlmsg_type = RTM_GETSTATS;
1565 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST;
1567 nlreq.ifsm.ifindex = if_nametoindex(ifname);
1568 nlreq.ifsm.filter_mask = IFLA_STATS_LINK_64;
1570 memset(&iov, 0, sizeof(iov));
1571 iov.iov_base = &nlreq;
1572 iov.iov_len = sizeof(nlreq);
1574 memset(&msg, 0, sizeof(msg));
1575 msg.msg_name = &nladdr;
1576 msg.msg_namelen = sizeof(nladdr);
1580 if (sendmsg(rtnl_fd, &msg, 0) < 0) {
1581 error("get_ppp_stats_rtnetlink: sendmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1585 /* We just need to repoint to IOV ... everything else stays the same */
1586 iov.iov_base = &nlresp;
1587 iov.iov_len = sizeof(nlresp);
1589 nlresplen = recvmsg(rtnl_fd, &msg, 0);
1591 if (nlresplen < 0) {
1592 error("get_ppp_stats_rtnetlink: recvmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1596 if (nlresplen < sizeof(nlresp.nlh)) {
1597 error("get_ppp_stats_rtnetlink: Netlink response message was incomplete (line %d)", __LINE__);
1601 if (nlresp.nlh.nlmsg_type == NLMSG_ERROR) {
1602 if (nlresplen < offsetof(struct nlresp, __end_err)) {
1603 if (kernel_version >= KVERSION(4,7,0))
1604 error("get_ppp_stats_rtnetlink: Netlink responded with error: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
1606 error("get_ppp_stats_rtnetlink: Netlink responded with an error message, but the nlmsgerr structure is incomplete (line %d).",
1612 if (nlresp.nlh.nlmsg_type != RTM_NEWSTATS) {
1613 error("get_ppp_stats_rtnetlink: Expected RTM_NEWSTATS response, found something else (mlmsg_type %d, line %d)",
1614 nlresp.nlh.nlmsg_type, __LINE__);
1618 if (nlresplen < offsetof(struct nlresp, __end_stats)) {
1619 error("get_ppp_stats_rtnetlink: Obtained an insufficiently sized rtnl_link_stats64 struct from the kernel (line %d).", __LINE__);
1623 stats->bytes_in = nlresp.stats.rx_bytes;
1624 stats->bytes_out = nlresp.stats.tx_bytes;
1625 stats->pkts_in = nlresp.stats.rx_packets;
1626 stats->pkts_out = nlresp.stats.tx_packets;
1635 /********************************************************************
1636 * get_ppp_stats_sysfs - return statistics for the link, using the files in sysfs,
1637 * this provides native 64-bit counters.
1640 get_ppp_stats_sysfs(int u, struct pppd_stats *stats)
1642 char fname[PATH_MAX+1];
1643 char buf[21], *err; /* 2^64 < 10^20 */
1645 unsigned long long val;
1652 #define statfield(fn, field) { .fname = #fn, .ptr = &stats->field, .size = sizeof(stats->field) }
1653 statfield(rx_bytes, bytes_in),
1654 statfield(tx_bytes, bytes_out),
1655 statfield(rx_packets, pkts_in),
1656 statfield(tx_packets, pkts_out),
1660 blen = snprintf(fname, sizeof(fname), "/sys/class/net/%s/statistics/", ifname);
1661 if (blen >= sizeof(fname))
1662 return 0; /* ifname max 15, so this should be impossible */
1664 for (int i = 0; i < sizeof(slist) / sizeof(*slist); ++i) {
1665 if (snprintf(fname + blen, sizeof(fname) - blen, "%s", slist[i].fname) >= sizeof(fname) - blen) {
1667 error("sysfs stats: filename %s/%s overflowed PATH_MAX", fname, slist[i].fname);
1671 fd = open(fname, O_RDONLY);
1673 error("%s: %m", fname);
1677 rlen = read(fd, buf, sizeof(buf) - 1);
1680 error("%s: %m", fname);
1683 /* trim trailing \n if present */
1684 while (rlen > 0 && buf[rlen-1] == '\n')
1689 val = strtoull(buf, &err, 10);
1690 if (*buf < '0' || *buf > '9' || errno != 0 || *err) {
1691 error("string to number conversion error converting %s (from %s) for remaining string %s%s%s",
1692 buf, fname, err, errno ? ": " : "", errno ? strerror(errno) : "");
1695 switch (slist[i].size) {
1696 #define stattype(type) case sizeof(type): *(type*)slist[i].ptr = (type)val; break
1703 error("Don't know how to store stats for %s of size %u", slist[i].fname, slist[i].size);
1711 /********************************************************************
1712 * Periodic timer function to be used to keep stats up to date in case of ioctl
1715 * Given the 25s interval this should be fine up to data rates of 1.37Gbps.
1716 * If you do change the timer, remember to also bring the get_ppp_stats (which
1717 * sets up the initial trigger) as well.
1720 ppp_stats_poller(void* u)
1722 struct pppd_stats dummy;
1723 get_ppp_stats_ioctl((long)u, &dummy);
1724 TIMEOUT(ppp_stats_poller, u, 25);
1727 /********************************************************************
1728 * get_ppp_stats - return statistics for the link.
1730 int get_ppp_stats(int u, struct pppd_stats *stats)
1732 static int (*func)(int, struct pppd_stats*) = NULL;
1735 if (get_ppp_stats_rtnetlink(u, stats)) {
1736 func = get_ppp_stats_rtnetlink;
1739 if (get_ppp_stats_sysfs(u, stats)) {
1740 func = get_ppp_stats_sysfs;
1743 warn("statistics falling back to ioctl which only supports 32-bit counters");
1744 func = get_ppp_stats_ioctl;
1745 TIMEOUT(ppp_stats_poller, (void*)(long)u, 25);
1748 return func(u, stats);
1751 /********************************************************************
1753 * ccp_fatal_error - returns 1 if decompression was disabled as a
1754 * result of an error detected after decompression of a packet,
1755 * 0 otherwise. This is necessary because of patent nonsense.
1758 int ccp_fatal_error (int unit)
1762 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1763 error("Couldn't read compression error flags: %m");
1766 return flags & SC_DC_FERROR;
1769 /********************************************************************
1771 * path_to_procfs - find the path to the proc file system mount point
1773 static char proc_path[MAXPATHLEN];
1774 static int proc_path_len;
1776 static char *path_to_procfs(const char *tail)
1778 struct mntent *mntent;
1781 if (proc_path_len == 0) {
1782 /* Default the mount location of /proc */
1783 strlcpy (proc_path, "/proc", sizeof(proc_path));
1785 fp = fopen(MOUNTED, "r");
1787 while ((mntent = getmntent(fp)) != NULL) {
1788 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1790 if (strcmp(mntent->mnt_type, "proc") == 0) {
1791 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1792 proc_path_len = strlen(proc_path);
1800 strlcpy(proc_path + proc_path_len, tail,
1801 sizeof(proc_path) - proc_path_len);
1806 * /proc/net/route parsing stuff.
1808 #define ROUTE_MAX_COLS 12
1809 FILE *route_fd = (FILE *) 0;
1810 static char route_buffer[512];
1811 static int route_dev_col, route_dest_col, route_gw_col;
1812 static int route_flags_col, route_metric_col, route_mask_col;
1813 static int route_num_cols;
1815 static int open_route_table (void);
1816 static void close_route_table (void);
1817 static int read_route_table (struct rtentry *rt);
1819 /********************************************************************
1821 * close_route_table - close the interface to the route table
1824 static void close_route_table (void)
1826 if (route_fd != (FILE *) 0) {
1828 route_fd = (FILE *) 0;
1832 /********************************************************************
1834 * open_route_table - open the interface to the route table
1836 static char route_delims[] = " \t\n";
1838 static int open_route_table (void)
1842 close_route_table();
1844 path = path_to_procfs("/net/route");
1845 route_fd = fopen (path, "r");
1846 if (route_fd == NULL) {
1847 error("can't open routing table %s: %m", path);
1851 route_dev_col = 0; /* default to usual columns */
1854 route_flags_col = 3;
1855 route_metric_col = 6;
1859 /* parse header line */
1860 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1861 char *p = route_buffer, *q;
1863 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1865 if ((q = strtok(p, route_delims)) == 0)
1867 if (strcasecmp(q, "iface") == 0)
1868 route_dev_col = col;
1869 else if (strcasecmp(q, "destination") == 0)
1870 route_dest_col = col;
1871 else if (strcasecmp(q, "gateway") == 0)
1873 else if (strcasecmp(q, "flags") == 0)
1874 route_flags_col = col;
1875 else if (strcasecmp(q, "mask") == 0)
1876 route_mask_col = col;
1879 if (used && col >= route_num_cols)
1880 route_num_cols = col + 1;
1888 /********************************************************************
1890 * read_route_table - read the next entry from the route table
1893 static int read_route_table(struct rtentry *rt)
1895 char *cols[ROUTE_MAX_COLS], *p;
1898 memset (rt, '\0', sizeof (struct rtentry));
1900 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1904 for (col = 0; col < route_num_cols; ++col) {
1905 cols[col] = strtok(p, route_delims);
1906 if (cols[col] == NULL)
1907 return 0; /* didn't get enough columns */
1911 SET_SA_FAMILY (rt->rt_dst, AF_INET);
1912 SET_SA_FAMILY (rt->rt_gateway, AF_INET);
1914 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1915 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1916 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1918 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1919 rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
1920 rt->rt_dev = cols[route_dev_col];
1925 /********************************************************************
1927 * defaultroute_exists - determine if there is a default route
1928 * with the given metric (or negative for any)
1931 static int defaultroute_exists (struct rtentry *rt, int metric)
1935 if (!open_route_table())
1938 while (read_route_table(rt) != 0) {
1939 if ((rt->rt_flags & RTF_UP) == 0)
1942 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1944 if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
1945 || rt->rt_metric == metric)) {
1951 close_route_table();
1956 * have_route_to - determine if the system has any route to
1957 * a given IP address. `addr' is in network byte order.
1958 * Return value is 1 if yes, 0 if no, -1 if don't know.
1959 * For demand mode to work properly, we have to ignore routes
1960 * through our own interface.
1962 int have_route_to(u_int32_t addr)
1967 if (!open_route_table())
1968 return -1; /* don't know */
1970 while (read_route_table(&rt)) {
1971 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1973 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1979 close_route_table();
1983 /********************************************************************
1985 * sifdefaultroute - assign a default route through the address given.
1987 * If the global default_rt_repl_rest flag is set, then this function
1988 * already replaced the original system defaultroute with some other
1989 * route and it should just replace the current defaultroute with
1990 * another one, without saving the current route. Use: demand mode,
1991 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1992 * and then changes the temporary addresses to the addresses for the real
1993 * ppp connection when it has come up.
1996 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
1998 struct rtentry rt, tmp_rt;
1999 struct rtentry *del_rt = NULL;
2001 if (default_rt_repl_rest) {
2002 /* We have already replaced the original defaultroute, if we
2003 * are called again, we will delete the current default route
2004 * and set the new default route in this function.
2005 * - this is normally only the case the doing demand: */
2006 if (defaultroute_exists(&tmp_rt, -1))
2008 } else if (defaultroute_exists(&old_def_rt, -1 ) &&
2009 strcmp( old_def_rt.rt_dev, ifname) != 0) {
2011 * We did not yet replace an existing default route, let's
2012 * check if we should save and replace a default route:
2014 u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
2016 if (old_gateway != gateway) {
2018 error("not replacing default route to %s [%I]",
2019 old_def_rt.rt_dev, old_gateway);
2022 /* we need to copy rt_dev because we need it permanent too: */
2023 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
2024 strcpy(tmp_dev, old_def_rt.rt_dev);
2025 old_def_rt.rt_dev = tmp_dev;
2027 notice("replacing old default route to %s [%I]",
2028 old_def_rt.rt_dev, old_gateway);
2029 default_rt_repl_rest = 1;
2030 del_rt = &old_def_rt;
2035 memset (&rt, 0, sizeof (rt));
2036 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2039 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2041 if (kernel_version > KVERSION(2,1,0)) {
2042 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2043 SIN_ADDR(rt.rt_genmask) = 0L;
2046 rt.rt_flags = RTF_UP;
2047 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2048 if ( ! ok_error ( errno ))
2049 error("default route ioctl(SIOCADDRT): %m");
2052 if (default_rt_repl_rest && del_rt)
2053 if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
2054 if ( ! ok_error ( errno ))
2055 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
2059 have_default_route = 1;
2063 /********************************************************************
2065 * cifdefaultroute - delete a default route through the address given.
2068 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
2072 have_default_route = 0;
2074 memset (&rt, '\0', sizeof (rt));
2075 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2076 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2081 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2083 if (kernel_version > KVERSION(2,1,0)) {
2084 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2085 SIN_ADDR(rt.rt_genmask) = 0L;
2088 rt.rt_flags = RTF_UP;
2089 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2091 if ( ! ok_error ( errno ))
2092 error("default route ioctl(SIOCDELRT): %m");
2096 if (default_rt_repl_rest) {
2097 notice("restoring old default route to %s [%I]",
2098 old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
2099 if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
2100 if ( ! ok_error ( errno ))
2101 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
2104 default_rt_repl_rest = 0;
2110 #ifdef PPP_WITH_IPV6CP
2112 * /proc/net/ipv6_route parsing stuff.
2114 static int route_dest_plen_col;
2115 static int open_route6_table (void);
2116 static int read_route6_table (struct in6_rtmsg *rt);
2118 /********************************************************************
2120 * open_route6_table - open the interface to the route table
2122 static int open_route6_table (void)
2126 close_route_table();
2128 path = path_to_procfs("/net/ipv6_route");
2129 route_fd = fopen (path, "r");
2130 if (route_fd == NULL) {
2131 error("can't open routing table %s: %m", path);
2135 /* default to usual columns */
2137 route_dest_plen_col = 1;
2139 route_metric_col = 5;
2140 route_flags_col = 8;
2142 route_num_cols = 10;
2147 /********************************************************************
2149 * read_route6_table - read the next entry from the route table
2152 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
2159 for (i = 0; i < 4; i++) {
2160 memcpy(hex8, s + 8*i, 8);
2161 v = strtoul(hex8, NULL, 16);
2162 addr->s6_addr32[i] = v;
2166 static int read_route6_table(struct in6_rtmsg *rt)
2168 char *cols[ROUTE_MAX_COLS], *p;
2171 memset (rt, '\0', sizeof (struct in6_rtmsg));
2173 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
2177 for (col = 0; col < route_num_cols; ++col) {
2178 cols[col] = strtok(p, route_delims);
2179 if (cols[col] == NULL)
2180 return 0; /* didn't get enough columns */
2184 hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
2185 rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
2186 hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
2188 rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
2189 rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
2190 rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
2195 /********************************************************************
2197 * defaultroute6_exists - determine if there is a default route
2200 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
2204 if (!open_route6_table())
2207 while (read_route6_table(rt) != 0) {
2208 if ((rt->rtmsg_flags & RTF_UP) == 0)
2211 if (rt->rtmsg_dst_len != 0)
2213 if (rt->rtmsg_dst.s6_addr32[0] == 0L
2214 && rt->rtmsg_dst.s6_addr32[1] == 0L
2215 && rt->rtmsg_dst.s6_addr32[2] == 0L
2216 && rt->rtmsg_dst.s6_addr32[3] == 0L
2217 && (metric < 0 || rt->rtmsg_metric == metric)) {
2223 close_route_table();
2227 /********************************************************************
2229 * sif6defaultroute - assign a default route through the address given.
2231 * If the global default_rt_repl_rest flag is set, then this function
2232 * already replaced the original system defaultroute with some other
2233 * route and it should just replace the current defaultroute with
2234 * another one, without saving the current route. Use: demand mode,
2235 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
2236 * and then changes the temporary addresses to the addresses for the real
2237 * ppp connection when it has come up.
2240 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2242 struct in6_rtmsg rt;
2243 char buf[IF_NAMESIZE];
2245 if (defaultroute6_exists(&rt, dfl_route_metric) &&
2246 rt.rtmsg_ifindex != if_nametoindex(ifname)) {
2247 if (rt.rtmsg_flags & RTF_GATEWAY)
2248 error("not replacing existing default route via gateway");
2250 error("not replacing existing default route through %s",
2251 if_indextoname(rt.rtmsg_ifindex, buf));
2255 memset (&rt, 0, sizeof (rt));
2257 rt.rtmsg_ifindex = if_nametoindex(ifname);
2258 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2259 rt.rtmsg_dst_len = 0;
2261 rt.rtmsg_flags = RTF_UP;
2262 if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
2263 if ( ! ok_error ( errno ))
2264 error("default route ioctl(SIOCADDRT): %m");
2268 have_default_route6 = 1;
2272 /********************************************************************
2274 * cif6defaultroute - delete a default route through the address given.
2277 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2279 struct in6_rtmsg rt;
2281 have_default_route6 = 0;
2283 memset (&rt, '\0', sizeof (rt));
2285 rt.rtmsg_ifindex = if_nametoindex(ifname);
2286 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2287 rt.rtmsg_dst_len = 0;
2289 rt.rtmsg_flags = RTF_UP;
2290 if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2292 if ( ! ok_error ( errno ))
2293 error("default route ioctl(SIOCDELRT): %m");
2300 #endif /* PPP_WITH_IPV6CP */
2302 /********************************************************************
2304 * sifproxyarp - Make a proxy ARP entry for the peer.
2307 int sifproxyarp (int unit, u_int32_t his_adr)
2309 struct arpreq arpreq;
2312 if (has_proxy_arp == 0) {
2313 memset (&arpreq, '\0', sizeof(arpreq));
2315 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2316 SIN_ADDR(arpreq.arp_pa) = his_adr;
2317 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2319 * Get the hardware address of an interface on the same subnet
2320 * as our local address.
2322 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2323 sizeof(proxy_arp_dev))) {
2324 error("Cannot determine ethernet address for proxy ARP");
2327 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2329 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2330 if ( ! ok_error ( errno ))
2331 error("ioctl(SIOCSARP): %m");
2334 proxy_arp_addr = his_adr;
2338 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2339 if (forw_path != 0) {
2340 int fd = open(forw_path, O_WRONLY);
2342 if (write(fd, "1", 1) != 1)
2343 error("Couldn't enable IP forwarding: %m");
2353 /********************************************************************
2355 * cifproxyarp - Delete the proxy ARP entry for the peer.
2358 int cifproxyarp (int unit, u_int32_t his_adr)
2360 struct arpreq arpreq;
2362 if (has_proxy_arp) {
2364 memset (&arpreq, '\0', sizeof(arpreq));
2365 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2366 SIN_ADDR(arpreq.arp_pa) = his_adr;
2367 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2368 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2370 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2371 if ( ! ok_error ( errno ))
2372 warn("ioctl(SIOCDARP): %m");
2379 /********************************************************************
2381 * get_ether_addr - get the hardware address of an interface on the
2382 * the same subnet as ipaddr.
2385 static int get_ether_addr (u_int32_t ipaddr,
2386 struct sockaddr *hwaddr,
2387 char *name, int namelen)
2389 struct ifreq *ifr, *ifend;
2390 u_int32_t ina, mask;
2392 struct ifreq ifreq, bestifreq;
2394 struct ifreq ifs[MAX_IFS];
2396 u_int32_t bestmask=0;
2397 int found_interface = 0;
2399 ifc.ifc_len = sizeof(ifs);
2401 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2402 if ( ! ok_error ( errno ))
2403 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2408 * Scan through looking for an interface with an Internet
2409 * address on the same subnet as `ipaddr'.
2411 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2412 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2413 if (ifr->ifr_addr.sa_family == AF_INET) {
2414 ina = SIN_ADDR(ifr->ifr_addr);
2415 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2417 * Check that the interface is up, and not point-to-point
2420 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2423 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2426 * Get its netmask and check that it's on the right subnet.
2428 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2431 mask = SIN_ADDR(ifreq.ifr_addr);
2433 if (((ipaddr ^ ina) & mask) != 0)
2434 continue; /* no match */
2436 if (mask >= bestmask) {
2437 /* Compare using >= instead of > -- it is possible for
2438 an interface to have a netmask of 0.0.0.0 */
2439 found_interface = 1;
2446 if (!found_interface) return 0;
2448 strlcpy(name, bestifreq.ifr_name, namelen);
2450 /* trim off the :1 in eth0:1 */
2451 aliasp = strchr(name, ':');
2455 info("found interface %s for proxy arp", name);
2457 * Now get the hardware address.
2459 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2460 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2461 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2466 &bestifreq.ifr_hwaddr,
2467 sizeof (struct sockaddr));
2473 * get_if_hwaddr - get the hardware address for the specified
2474 * network interface device.
2477 get_if_hwaddr(u_char *addr, char *name)
2482 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2485 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2486 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2487 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2490 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2495 * get_first_ether_hwaddr - get the hardware address for the first
2496 * ethernet-style interface on this system.
2499 get_first_ether_hwaddr(u_char *addr)
2501 struct if_nameindex *if_ni, *i;
2505 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2509 if_ni = if_nameindex();
2517 for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2518 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2519 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2520 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2521 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2522 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2528 if_freenameindex(if_ni);
2534 /********************************************************************
2536 * Return user specified netmask, modified by any mask we might determine
2537 * for address `addr' (in network byte order).
2538 * Here we scan through the system's list of interfaces, looking for
2539 * any non-point-to-point interfaces which might appear to be on the same
2540 * network as `addr'. If we find any, we OR in their netmask to the
2541 * user-specified netmask.
2544 u_int32_t GetMask (u_int32_t addr)
2546 u_int32_t mask, nmask, ina;
2547 struct ifreq *ifr, *ifend, ifreq;
2549 struct ifreq ifs[MAX_IFS];
2553 if (IN_CLASSA(addr)) /* determine network mask for address class */
2554 nmask = IN_CLASSA_NET;
2555 else if (IN_CLASSB(addr))
2556 nmask = IN_CLASSB_NET;
2558 nmask = IN_CLASSC_NET;
2560 /* class D nets are disallowed by bad_ip_adrs */
2561 mask = netmask | htonl(nmask);
2563 * Scan through the system's network interfaces.
2565 ifc.ifc_len = sizeof(ifs);
2567 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2568 if ( ! ok_error ( errno ))
2569 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2573 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2574 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2576 * Check the interface's internet address.
2578 if (ifr->ifr_addr.sa_family != AF_INET)
2580 ina = SIN_ADDR(ifr->ifr_addr);
2581 if (((ntohl(ina) ^ addr) & nmask) != 0)
2584 * Check that the interface is up, and not point-to-point nor loopback.
2586 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2587 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2590 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2593 * Get its netmask and OR it into our mask.
2595 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2597 mask |= SIN_ADDR(ifreq.ifr_addr);
2603 /********************************************************************
2605 * Internal routine to decode the version.modification.patch level
2608 static void decode_version (char *buf, int *version,
2609 int *modification, int *patch)
2613 *version = (int) strtoul (buf, &endp, 10);
2617 if (endp != buf && *endp == '.') {
2619 *modification = (int) strtoul (buf, &endp, 10);
2620 if (endp != buf && *endp == '.') {
2622 *patch = (int) strtoul (buf, &buf, 10);
2627 /********************************************************************
2629 * Procedure to determine if the PPP line discipline is registered.
2633 ppp_registered(void)
2641 * We used to open the serial device and set it to the ppp line
2642 * discipline here, in order to create a ppp unit. But that is
2643 * not a good idea - the user might have specified a device that
2644 * they can't open (permission, or maybe it doesn't really exist).
2645 * So we grab a pty master/slave pair and use that.
2647 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2648 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2653 * Try to put the device into the PPP discipline.
2655 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2656 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2665 /********************************************************************
2667 * ppp_available - check whether the system has any ppp interfaces
2668 * (in fact we check whether we can do an ioctl on ppp0).
2671 int ppp_available(void)
2676 int my_version, my_modification, my_patch;
2677 int osmaj, osmin, ospatch;
2679 /* get the kernel version now, since we are called before sys_init */
2681 osmaj = osmin = ospatch = 0;
2682 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2683 kernel_version = KVERSION(osmaj, osmin, ospatch);
2685 fd = open("/dev/ppp", O_RDWR);
2687 new_style_driver = 1;
2689 /* XXX should get from driver */
2691 driver_modification = 4;
2697 if (kernel_version >= KVERSION(2,3,13)) {
2698 error("Couldn't open the /dev/ppp device: %m");
2699 if (errno == ENOENT)
2701 "You need to create the /dev/ppp device node by\n"
2702 "executing the following command as root:\n"
2703 " mknod /dev/ppp c 108 0\n";
2704 else if (errno == ENODEV || errno == ENXIO)
2706 "Please load the ppp_generic kernel module.\n";
2710 /* we are running on a really really old kernel */
2712 "This system lacks kernel support for PPP. This could be because\n"
2713 "the PPP kernel module could not be loaded, or because PPP was not\n"
2714 "included in the kernel configuration. If PPP was included as a\n"
2715 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2716 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2717 "See README.linux file in the ppp distribution for more details.\n";
2720 * Open a socket for doing the ioctl operations.
2722 s = socket(AF_INET, SOCK_DGRAM, 0);
2726 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2727 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2729 * If the device did not exist then attempt to create one by putting the
2730 * current tty into the PPP discipline. If this works then obtain the
2731 * flags for the device again.
2734 if (ppp_registered()) {
2735 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2736 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2740 * Ensure that the hardware address is for PPP and not something else
2743 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2745 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2749 * This is the PPP device. Validate the version of the driver at this
2750 * point to ensure that this program will work with the driver.
2753 char abBuffer [1024];
2755 ifr.ifr_data = abBuffer;
2756 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2758 error("Couldn't read driver version: %m");
2760 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2763 decode_version(abBuffer,
2765 &driver_modification,
2768 * Validate the version of the driver against the version that we used.
2770 decode_version(VERSION,
2775 /* The version numbers must match */
2776 if (driver_version != my_version)
2779 /* The modification levels must be legal */
2780 if (driver_modification < 3) {
2781 if (driver_modification >= 2) {
2782 /* we can cope with 2.2.0 and above */
2790 slprintf(route_buffer, sizeof(route_buffer),
2791 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2792 driver_version, driver_modification, driver_patch);
2794 no_ppp_msg = route_buffer;
2802 #ifndef HAVE_LOGWTMP
2803 /********************************************************************
2805 * Update the wtmp file with the appropriate user name and tty device.
2808 void logwtmp (const char *line, const char *name, const char *host)
2810 struct utmp ut, *utp;
2811 pid_t mypid = getpid();
2817 * Update the signon database for users.
2818 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2820 utmpname(_PATH_UTMP);
2822 while ((utp = getutent()) && (utp->ut_pid != mypid))
2826 memcpy(&ut, utp, sizeof(ut));
2828 /* some gettys/telnetds don't initialize utmp... */
2829 memset(&ut, 0, sizeof(ut));
2831 if (ut.ut_id[0] == 0)
2832 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2834 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2835 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2839 ut.ut_type = USER_PROCESS;
2842 /* Insert the host name if one is supplied */
2844 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2846 /* Insert the IP address of the remote system if IP is enabled */
2847 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2848 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2849 sizeof(ut.ut_addr));
2851 /* CL: Makes sure that the logout works */
2852 if (*host == 0 && *name==0)
2858 * Update the wtmp file.
2861 updwtmp(_PATH_WTMP, &ut);
2863 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2865 flock(wtmp, LOCK_EX);
2867 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2868 warn("error writing %s: %m", _PATH_WTMP);
2870 flock(wtmp, LOCK_UN);
2876 #endif /* HAVE_LOGWTMP */
2878 /********************************************************************
2880 * sifvjcomp - config tcp header compression
2883 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2888 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2889 error("Couldn't set up TCP header compression: %m");
2894 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2895 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2900 /********************************************************************
2902 * sifup - Config the interface up and enable IP packets to pass.
2909 if ((ret = setifstate(u, 1)))
2915 /********************************************************************
2917 * sifdown - Disable the indicated protocol and config the interface
2918 * down if there are no remaining protocols.
2923 if (if_is_up && --if_is_up > 0)
2926 #ifdef PPP_WITH_IPV6CP
2929 #endif /* PPP_WITH_IPV6CP */
2931 return setifstate(u, 0);
2934 #ifdef PPP_WITH_IPV6CP
2935 /********************************************************************
2937 * sif6up - Config the interface up for IPv6
2944 if ((ret = setifstate(u, 1)))
2950 /********************************************************************
2952 * sif6down - Disable the IPv6CP protocol and config the interface
2953 * down if there are no remaining protocols.
2956 int sif6down (int u)
2963 return setifstate(u, 0);
2965 #endif /* PPP_WITH_IPV6CP */
2967 /********************************************************************
2969 * setifstate - Config the interface up or down
2972 static int setifstate (int u, int state)
2976 memset (&ifr, '\0', sizeof (ifr));
2977 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2978 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2979 if (! ok_error (errno))
2980 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2985 ifr.ifr_flags |= IFF_UP;
2987 ifr.ifr_flags &= ~IFF_UP;
2988 ifr.ifr_flags |= IFF_POINTOPOINT;
2989 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2990 if (! ok_error (errno))
2991 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2997 /********************************************************************
2999 * sifaddr - Config the interface IP addresses and netmask.
3002 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
3008 memset (&ifr, '\0', sizeof (ifr));
3009 memset (&rt, '\0', sizeof (rt));
3011 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
3012 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
3013 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
3015 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
3017 * Set our IP address
3019 SIN_ADDR(ifr.ifr_addr) = our_adr;
3020 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3021 if (errno != EEXIST) {
3022 if (! ok_error (errno))
3023 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3026 warn("ioctl(SIOCSIFADDR): Address already exists");
3031 * Set the gateway address
3034 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
3035 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
3036 if (! ok_error (errno))
3037 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
3043 * For recent kernels, force the netmask to 255.255.255.255.
3045 if (kernel_version >= KVERSION(2,1,16))
3047 if (net_mask != 0) {
3048 SIN_ADDR(ifr.ifr_netmask) = net_mask;
3049 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
3050 if (! ok_error (errno))
3051 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
3056 * Add the device route
3058 if (kernel_version < KVERSION(2,1,16)) {
3059 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3060 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3063 SIN_ADDR(rt.rt_gateway) = 0L;
3064 SIN_ADDR(rt.rt_dst) = his_adr;
3065 rt.rt_flags = RTF_UP | RTF_HOST;
3067 if (kernel_version > KVERSION(2,1,0)) {
3068 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3069 SIN_ADDR(rt.rt_genmask) = -1L;
3072 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
3073 if (! ok_error (errno))
3074 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
3079 /* set ip_dynaddr in demand mode if address changes */
3080 if (demand && tune_kernel && !dynaddr_set
3081 && our_old_addr && our_old_addr != our_adr) {
3082 /* set ip_dynaddr if possible */
3086 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
3087 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
3088 if (write(fd, "1", 1) != 1)
3089 error("Couldn't enable dynamic IP addressing: %m");
3092 dynaddr_set = 1; /* only 1 attempt */
3099 /********************************************************************
3101 * cifaddr - Clear the interface IP addresses, and delete routes
3102 * through the interface if possible.
3105 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
3109 if (kernel_version < KVERSION(2,1,16)) {
3111 * Delete the route through the device
3114 memset (&rt, '\0', sizeof (rt));
3116 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3117 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3120 SIN_ADDR(rt.rt_gateway) = 0;
3121 SIN_ADDR(rt.rt_dst) = his_adr;
3122 rt.rt_flags = RTF_UP | RTF_HOST;
3124 if (kernel_version > KVERSION(2,1,0)) {
3125 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3126 SIN_ADDR(rt.rt_genmask) = -1L;
3129 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
3130 if (still_ppp() && ! ok_error (errno))
3131 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
3136 /* This way it is possible to have an IPv6-only interface */
3137 memset(&ifr, 0, sizeof(ifr));
3138 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
3139 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3141 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3142 if (! ok_error (errno)) {
3143 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3148 our_old_addr = our_adr;
3153 #ifdef PPP_WITH_IPV6CP
3154 /********************************************************************
3156 * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
3158 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
3161 struct nlmsghdr nlh;
3162 struct ifaddrmsg ifa;
3165 struct in6_addr addr;
3169 struct nlmsghdr nlh;
3170 struct nlmsgerr nlerr;
3172 struct sockaddr_nl nladdr;
3179 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
3181 error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
3186 * Tell kernel to not send to us payload of acknowledgment error message.
3187 * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
3188 * older kernel versions always send full payload in acknowledgment netlink
3189 * message. We ignore payload of this message as we need only error code,
3190 * to check if our set remote peer address request succeeded or failed.
3191 * So ignore return value from the following setsockopt() call as setting
3192 * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
3195 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
3197 memset(&nladdr, 0, sizeof(nladdr));
3198 nladdr.nl_family = AF_NETLINK;
3200 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
3201 error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
3206 memset(&nlreq, 0, sizeof(nlreq));
3207 nlreq.nlh.nlmsg_len = sizeof(nlreq);
3208 nlreq.nlh.nlmsg_type = RTM_NEWADDR;
3209 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
3210 nlreq.ifa.ifa_family = AF_INET6;
3211 nlreq.ifa.ifa_prefixlen = 128;
3212 nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
3213 nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
3214 nlreq.ifa.ifa_index = iface;
3215 nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
3216 nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
3217 IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
3218 nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
3219 nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
3222 * To set only local address, older kernel expects that local address is
3223 * in IFA_ADDRESS field (not IFA_LOCAL). New kernels with support for peer
3224 * address, ignore IFA_ADDRESS if is same as IFA_LOCAL. So for backward
3225 * compatibility when setting only local address, set it via both IFA_LOCAL
3226 * and IFA_ADDRESS fields. Same logic is implemented in 'ip address' command
3227 * from iproute2 project.
3229 if (!eui64_iszero(his_eui64))
3230 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
3232 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, our_eui64);
3234 memset(&nladdr, 0, sizeof(nladdr));
3235 nladdr.nl_family = AF_NETLINK;
3237 memset(&iov, 0, sizeof(iov));
3238 iov.iov_base = &nlreq;
3239 iov.iov_len = sizeof(nlreq);
3241 memset(&msg, 0, sizeof(msg));
3242 msg.msg_name = &nladdr;
3243 msg.msg_namelen = sizeof(nladdr);
3247 if (sendmsg(fd, &msg, 0) < 0) {
3248 error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
3253 memset(&iov, 0, sizeof(iov));
3254 iov.iov_base = &nlresp;
3255 iov.iov_len = sizeof(nlresp);
3257 memset(&msg, 0, sizeof(msg));
3258 msg.msg_name = &nladdr;
3259 msg.msg_namelen = sizeof(nladdr);
3263 nlresplen = recvmsg(fd, &msg, 0);
3265 if (nlresplen < 0) {
3266 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
3273 if (nladdr.nl_family != AF_NETLINK) {
3274 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
3278 if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
3279 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
3283 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
3284 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
3285 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
3289 /* error == 0 indicates success, negative value is errno code */
3290 if (nlresp.nlerr.error != 0) {
3292 * Linux kernel versions prior 3.11 do not support setting IPv6 peer
3293 * addresses and error response is expected. On older kernel versions
3294 * do not show this error message. On error pppd tries to fallback to
3295 * the old IOCTL method.
3297 if (kernel_version >= KVERSION(3,11,0))
3298 error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
3305 /********************************************************************
3307 * sif6addr - Config the interface with an IPv6 link-local address
3309 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3311 struct in6_ifreq ifr6;
3313 struct in6_rtmsg rt6;
3318 error("IPv6 socket creation failed: %m");
3321 memset(&ifr, 0, sizeof (ifr));
3322 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3323 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3324 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3328 if (kernel_version >= KVERSION(2,1,16)) {
3329 /* Set both local address and remote peer address (with route for it) via rtnetlink */
3330 ret = sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
3336 * Linux kernel versions prior 3.11 do not support setting IPv6 peer address
3337 * via rtnetlink. So if sif6addr_rtnetlink() fails then try old IOCTL method.
3340 /* Local interface */
3341 memset(&ifr6, 0, sizeof(ifr6));
3342 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3343 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3344 ifr6.ifr6_prefixlen = 128;
3346 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3347 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3352 if (!ret && !eui64_iszero(his_eui64)) {
3354 * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3355 * setting remote peer host address, so set only route to remote host.
3358 /* Route to remote host */
3359 memset(&rt6, 0, sizeof(rt6));
3360 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3361 rt6.rtmsg_flags = RTF_UP;
3362 rt6.rtmsg_dst_len = 128;
3363 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3364 rt6.rtmsg_metric = 1;
3366 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3367 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3376 /********************************************************************
3378 * cif6addr - Remove IPv6 address from interface
3380 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3383 struct in6_ifreq ifr6;
3387 error("IPv6 socket creation failed: %m");
3390 memset(&ifr, 0, sizeof(ifr));
3391 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3392 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3393 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3397 memset(&ifr6, 0, sizeof(ifr6));
3398 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3399 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3400 ifr6.ifr6_prefixlen = 128;
3402 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3403 if (errno != EADDRNOTAVAIL) {
3404 if (! ok_error (errno))
3405 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3408 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3414 #endif /* PPP_WITH_IPV6CP */
3417 * get_pty - get a pty master/slave pair and chown the slave side
3418 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
3421 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3423 int i, mfd, ret, sfd = -1;
3425 struct termios tios;
3429 * Try the unix98 way first.
3431 mfd = open("/dev/ptmx", O_RDWR);
3434 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3435 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3436 chmod(pty_name, S_IRUSR | S_IWUSR);
3439 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3440 warn("Couldn't unlock pty slave %s: %m", pty_name);
3442 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3444 warn("Couldn't open pty slave %s: %m", pty_name);
3449 #endif /* TIOCGPTN */
3452 /* the old way - scan through the pty name space */
3453 for (i = 0; i < 64; ++i) {
3454 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3455 'p' + i / 16, i % 16);
3456 mfd = open(pty_name, O_RDWR, 0);
3459 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3461 ret = fchown(sfd, uid, -1);
3463 warn("Couldn't change ownership of %s, %m", pty_name);
3465 ret = fchmod(sfd, S_IRUSR | S_IWUSR);
3467 warn("Couldn't change permissions of %s, %m", pty_name);
3479 strlcpy(slave_name, pty_name, 16);
3482 if (tcgetattr(sfd, &tios) == 0) {
3483 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3484 tios.c_cflag |= CS8 | CREAD | CLOCAL;
3485 tios.c_iflag = IGNPAR;
3488 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3489 warn("couldn't set attributes on pty: %m");
3491 warn("couldn't get attributes on pty: %m");
3496 /********************************************************************
3498 * open_loopback - open the device we use for getting packets
3499 * in demand mode. Under Linux, we use a pty master/slave pair.
3502 open_ppp_loopback(void)
3507 if (new_style_driver) {
3508 /* allocate ourselves a ppp unit */
3509 if (make_ppp_unit() < 0)
3511 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3512 set_kdebugflag(kdebugflag);
3517 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3518 fatal("No free pty for loopback");
3520 set_ppp_fd(slave_fd);
3522 flags = fcntl(master_fd, F_GETFL);
3524 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3525 warn("couldn't set master loopback to nonblock: %m");
3527 flags = fcntl(ppp_fd, F_GETFL);
3529 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3530 warn("couldn't set slave loopback to nonblock: %m");
3532 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3533 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3535 * Find out which interface we were given.
3537 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3538 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3540 * Enable debug in the driver if requested.
3542 set_kdebugflag (kdebugflag);
3547 /********************************************************************
3549 * sifnpmode - Set the mode for handling packets for a given NP.
3553 sifnpmode(int u, int proto, enum NPmode mode)
3557 npi.protocol = proto;
3559 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3560 if (! ok_error (errno))
3561 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3568 * Use the hostname as part of the random number seed.
3577 for (p = hostname; *p != 0; ++p)
3582 /********************************************************************
3584 * sys_check_options - check the options that the user specified
3588 sys_check_options(void)
3590 if (demand && driver_is_old) {
3591 option_error("demand dialling is not supported by kernel driver "
3592 "version %d.%d.%d", driver_version, driver_modification,
3596 if (multilink && !new_style_driver) {
3597 warn("Warning: multilink is not supported by the kernel driver");
3603 /********************************************************************
3605 * get_time - Get current time, monotonic if possible.
3608 get_time(struct timeval *tv)
3610 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3611 * Runtime checking makes it safe. */
3612 #ifndef CLOCK_MONOTONIC
3613 #define CLOCK_MONOTONIC 1
3615 static int monotonic = -1;
3620 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3624 tv->tv_sec = ts.tv_sec;
3625 tv->tv_usec = ts.tv_nsec / 1000;
3628 } else if (monotonic > 0)
3632 warn("Couldn't use monotonic clock source: %m");
3635 return gettimeofday(tv, NULL);