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 #ifdef PPP_WITH_IPV6CP
132 #include <linux/netlink.h>
133 #include <linux/rtnetlink.h>
134 #include <linux/if_link.h>
135 /* Attempt at retaining compile-support with older than 4.7 kernels, or kernels
136 * where RTM_NEWSTATS isn't defined for whatever reason.
139 #define RTM_NEWSTATS 92
140 #define RTM_GETSTATS 94
141 #define IFLA_STATS_LINK_64 1
142 #endif /* PPP_WITH_IPV6CP */
144 #include <linux/if_addr.h>
145 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
147 #define SOL_NETLINK 270
150 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
151 #ifndef NETLINK_CAP_ACK
152 #define NETLINK_CAP_ACK 10
161 #include <pcap-bpf.h>
162 #include <linux/filter.h>
163 #endif /* PPP_FILTER */
166 #include <sys/locks.h>
170 * Instead of system header file <termios.h> use local "termios_linux.h" header
171 * file as it provides additional support for arbitrary baud rates via BOTHER.
173 #include "termios_linux.h"
175 #ifdef PPP_WITH_IPV6CP
178 * This is in linux/include/net/ipv6.h.
182 struct in6_addr ifr6_addr;
183 __u32 ifr6_prefixlen;
184 unsigned int ifr6_ifindex;
188 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
189 memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr)); \
190 (sin6).s6_addr16[0] = htons(0xfe80); \
191 eui64_copy(eui64, (sin6).s6_addr32[2]); \
194 static const eui64_t nulleui64;
195 #endif /* PPP_WITH_IPV6CP */
197 /* We can get an EIO error on an ioctl if the modem has hung up */
198 #define ok_error(num) ((num)==EIO)
200 static int tty_disc = N_TTY; /* The TTY discipline */
201 static int ppp_disc = N_PPP; /* The PPP discpline */
202 static int initfdflags = -1; /* Initial file descriptor flags for fd */
203 static int ppp_fd = -1; /* fd which is set to PPP discipline */
204 static int sock_fd = -1; /* socket for doing interface ioctls */
205 static int slave_fd = -1; /* pty for old-style demand mode, slave */
206 static int master_fd = -1; /* pty for old-style demand mode, master */
207 #ifdef PPP_WITH_IPV6CP
208 static int sock6_fd = -1;
209 #endif /* PPP_WITH_IPV6CP */
212 * For the old-style kernel driver, this is the same as ppp_fd.
213 * For the new-style driver, it is the fd of an instance of /dev/ppp
214 * which is attached to the ppp unit and is used for controlling it.
216 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
218 static int chindex; /* channel index (new style driver) */
220 static fd_set in_fds; /* set of fds that wait_input waits for */
221 static int max_in_fd; /* highest fd set in in_fds */
223 static int has_proxy_arp = 0;
224 static int driver_version = 0;
225 static int driver_modification = 0;
226 static int driver_patch = 0;
227 static int driver_is_old = 0;
228 static int restore_term = 0; /* 1 => we've munged the terminal */
229 static struct termios inittermios; /* Initial TTY termios */
231 int new_style_driver = 0;
233 static char loop_name[20];
234 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
236 static int if_is_up; /* Interface has been marked up */
237 static int if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
238 static int have_default_route; /* Gateway for default route added */
239 static int have_default_route6; /* Gateway for default IPv6 route added */
240 static struct rtentry old_def_rt; /* Old default route */
241 static int default_rt_repl_rest; /* replace and restore old default rt */
242 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
243 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
244 static u_int32_t our_old_addr; /* for detecting address changes */
245 static int dynaddr_set; /* 1 if ip_dynaddr set */
246 static int looped; /* 1 if using loop */
247 static int link_mtu; /* mtu for the link (not bundle) */
249 static struct utsname utsname; /* for the kernel version */
250 static int kernel_version;
251 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
255 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
256 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
257 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
259 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
261 /* Prototypes for procedures local to this file. */
262 static int modify_flags(int fd, int clear_bits, int set_bits);
263 static int translate_speed (int bps);
264 static int baud_rate_of (int speed);
265 static void close_route_table (void);
266 static int open_route_table (void);
267 static int read_route_table (struct rtentry *rt);
268 static int defaultroute_exists (struct rtentry *rt, int metric);
269 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
270 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
271 char *name, int namelen);
272 static void decode_version (char *buf, int *version, int *mod, int *patch);
273 static int set_kdebugflag(int level);
274 static int ppp_registered(void);
275 static int make_ppp_unit(void);
276 static int setifstate (int u, int state);
278 extern u_char inpacket_buf[]; /* borrowed from main.c */
280 extern int dfl_route_metric;
283 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
287 #define SET_SA_FAMILY(addr, family) \
288 memset ((char *) &(addr), '\0', sizeof(addr)); \
289 addr.sa_family = (family);
292 * Determine if the PPP connection should still be present.
297 /* new_fd is the fd of a tty */
298 static void set_ppp_fd (int new_fd)
301 if (!new_style_driver)
305 static int still_ppp(void)
307 if (new_style_driver)
308 return !hungup && ppp_fd >= 0;
309 if (!hungup || ppp_fd == slave_fd)
312 set_ppp_fd(slave_fd);
319 * modify_flags - set and clear flag bits controlling the kernel
322 static int modify_flags(int fd, int clear_bits, int set_bits)
326 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
328 flags = (flags & ~clear_bits) | set_bits;
329 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
336 error("Failed to set PPP kernel option flags: %m");
340 /********************************************************************
342 * sys_init - System-dependent initialization.
347 /* Get an internet socket for doing socket ioctls. */
348 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
350 fatal("Couldn't create IP socket: %m(%d)", errno);
352 #ifdef PPP_WITH_IPV6CP
353 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
355 sock6_fd = -errno; /* save errno for later */
362 /********************************************************************
364 * sys_cleanup - restore any system state we modified before exiting:
365 * mark the interface down, delete default route and/or proxy arp entry.
366 * This shouldn't call die() because it's called from die().
369 void sys_cleanup(void)
372 * Take down the device
378 #ifdef PPP_WITH_IPV6CP
384 * Delete any routes through the device.
386 if (have_default_route)
387 cifdefaultroute(0, 0, 0);
388 #ifdef PPP_WITH_IPV6CP
389 if (have_default_route6)
390 cif6defaultroute(0, nulleui64, nulleui64);
394 cifproxyarp(0, proxy_arp_addr);
397 /********************************************************************
399 * sys_close - Clean up in a child process before execing.
404 if (new_style_driver && ppp_dev_fd >= 0)
408 #ifdef PPP_WITH_IPV6CP
418 /********************************************************************
420 * set_kdebugflag - Define the debugging level for the kernel
423 static int set_kdebugflag (int requested_level)
427 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
428 if ( ! ok_error (errno) )
429 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
435 /********************************************************************
437 * tty_establish_ppp - Turn the serial port into a ppp interface.
440 int tty_establish_ppp (int tty_fd)
445 * Ensure that the tty device is in exclusive mode.
447 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
448 if ( ! ok_error ( errno ))
449 warn("Couldn't make tty exclusive: %m");
452 * Demand mode - prime the old ppp device to relinquish the unit.
454 if (!new_style_driver && looped
455 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
456 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
460 * Set the current tty to the PPP discpline
464 #define N_SYNC_PPP 14
466 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
467 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
468 if ( ! ok_error (errno) ) {
469 error("Couldn't set tty to PPP discipline: %m");
474 ret_fd = generic_establish_ppp(tty_fd);
476 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
477 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
481 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
482 (kdebugflag * SC_DEBUG) & SC_LOGB);
484 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
485 warn("Couldn't reset tty to normal line discipline: %m");
491 /********************************************************************
493 * generic_establish_ppp - Turn the fd into a ppp interface.
495 int generic_establish_ppp (int fd)
499 if (new_style_driver) {
502 /* If a ppp_fd is already open, close it first */
509 /* Open an instance of /dev/ppp and connect the channel to it */
510 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
511 error("Couldn't get channel number: %m");
514 dbglog("using channel %d", chindex);
515 fd = open("/dev/ppp", O_RDWR);
517 error("Couldn't reopen /dev/ppp: %m");
520 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
521 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
522 error("Couldn't attach to channel %d: %m", chindex);
525 flags = fcntl(fd, F_GETFL);
526 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
527 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
532 if (!looped && !multilink) {
534 * Create a new PPP unit.
536 if (make_ppp_unit() < 0)
541 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
545 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
546 error("Couldn't attach to PPP unit %d: %m", ifunit);
553 * Old-style driver: find out which interface we were given.
556 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
557 if (ok_error (errno))
559 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
561 /* Check that we got the same unit again. */
562 if (looped && x != ifunit)
563 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
567 * Fetch the initial file flags and reset blocking mode on the file.
569 initfdflags = fcntl(fd, F_GETFL);
570 if (initfdflags == -1 ||
571 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
572 if ( ! ok_error (errno))
573 warn("Couldn't set device to non-blocking mode: %m");
578 * Enable debug in the driver if requested.
581 set_kdebugflag (kdebugflag);
593 /********************************************************************
595 * tty_disestablish_ppp - Restore the serial port to normal operation.
596 * This shouldn't call die() because it's called from die().
599 void tty_disestablish_ppp(int tty_fd)
603 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
605 if (tcflush(tty_fd, TCIOFLUSH) < 0)
607 warn("tcflush failed: %m");
611 * Restore the previous line discipline
613 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
614 if ( ! ok_error (errno))
615 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
618 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
619 if ( ! ok_error (errno))
620 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
623 /* Reset non-blocking mode on fd. */
624 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
625 if ( ! ok_error (errno))
626 warn("Couldn't restore device fd flags: %m");
632 generic_disestablish_ppp(tty_fd);
635 /********************************************************************
637 * generic_disestablish_ppp - Restore device components to normal
638 * operation, and reconnect the ppp unit to the loopback if in demand
639 * mode. This shouldn't call die() because it's called from die().
641 void generic_disestablish_ppp(int dev_fd)
643 if (new_style_driver) {
647 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
649 } else if (!doing_multilink && ppp_dev_fd >= 0) {
651 remove_fd(ppp_dev_fd);
655 /* old-style driver */
657 set_ppp_fd(slave_fd);
664 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
665 * Assumes new_style_driver.
667 static int make_ppp_unit(void)
671 if (ppp_dev_fd >= 0) {
672 dbglog("in make_ppp_unit, already had /dev/ppp open?");
675 ppp_dev_fd = open("/dev/ppp", O_RDWR);
677 fatal("Couldn't open /dev/ppp: %m");
678 flags = fcntl(ppp_dev_fd, F_GETFL);
680 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
681 warn("Couldn't set /dev/ppp to nonblock: %m");
684 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
685 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
686 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
688 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
691 error("Couldn't create new ppp unit: %m");
693 if (x == 0 && req_ifname[0] != '\0') {
696 memset(&ifr, 0, sizeof(struct ifreq));
697 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
698 strlcpy(ifr.ifr_name, t, IFNAMSIZ);
699 strlcpy(ifr.ifr_newname, req_ifname, IFNAMSIZ);
700 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
702 error("Couldn't rename interface %s to %s: %m", t, req_ifname);
704 info("Renamed interface %s to %s", t, req_ifname);
711 * cfg_bundle - configure the existing bundle.
712 * Used in demand mode.
714 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
716 if (!new_style_driver)
719 /* set the mrru, mtu and flags */
720 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
721 error("Couldn't set MRRU: %m");
723 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
724 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
725 | (mrru? SC_MULTILINK: 0)));
727 /* connect up the channel */
728 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
729 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
734 * make_new_bundle - create a new PPP unit (i.e. a bundle)
735 * and connect our channel to it. This should only get called
736 * if `multilink' was set at the time establish_ppp was called.
737 * In demand mode this uses our existing bundle instead of making
740 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
742 if (!new_style_driver)
745 /* make us a ppp unit */
746 if (make_ppp_unit() < 0)
749 /* set the mrru and flags */
750 cfg_bundle(mrru, mtru, rssn, tssn);
754 * bundle_attach - attach our link to a given PPP unit.
755 * We assume the unit is controlled by another pppd.
757 int bundle_attach(int ifnum)
761 if (!new_style_driver)
764 master_fd = open("/dev/ppp", O_RDWR);
766 fatal("Couldn't open /dev/ppp: %m");
767 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
768 if (errno == ENXIO) {
770 return 0; /* doesn't still exist */
772 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
774 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
775 fatal("Couldn't connect to interface unit %d: %m", ifnum);
776 modify_flags(master_fd, 0, SC_MULTILINK);
784 * destroy_bundle - tell the driver to destroy our bundle.
786 void destroy_bundle(void)
788 if (ppp_dev_fd >= 0) {
790 remove_fd(ppp_dev_fd);
795 /********************************************************************
797 * clean_check - Fetch the flags for the device and generate
798 * appropriate error messages.
800 void clean_check(void)
806 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
808 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
810 s = "all had bit 7 set to 1";
814 s = "all had bit 7 set to 0";
818 s = "all had odd parity";
822 s = "all had even parity";
827 warn("Receive serial link is not 8-bit clean:");
828 warn("Problem: %s", s);
836 * List of valid speeds.
840 int speed_int, speed_val;
936 { 1000000, B1000000 },
939 { 1152000, B1152000 },
942 { 1500000, B1500000 },
945 { 2000000, B2000000 },
948 { 2500000, B2500000 },
951 { 3000000, B3000000 },
954 { 3500000, B3500000 },
957 { 4000000, B4000000 },
962 /********************************************************************
964 * Translate from bits/second to a speed_t.
967 static int translate_speed (int bps)
969 struct speed *speedp;
972 for (speedp = speeds; speedp->speed_int; speedp++) {
973 if (bps == speedp->speed_int)
974 return speedp->speed_val;
980 /********************************************************************
982 * Translate from a speed_t to bits/second.
985 static int baud_rate_of (int speed)
987 struct speed *speedp;
990 for (speedp = speeds; speedp->speed_int; speedp++) {
991 if (speed == speedp->speed_val)
992 return speedp->speed_int;
998 /********************************************************************
1000 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
1001 * at the requested speed, etc. If `local' is true, set CLOCAL
1002 * regardless of whether the modem option was specified.
1005 void set_up_tty(int tty_fd, int local)
1008 struct termios tios;
1011 if (tcgetattr(tty_fd, &tios) < 0) {
1012 if (!ok_error(errno))
1013 fatal("tcgetattr: %m (line %d)", __LINE__);
1020 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1021 tios.c_cflag |= CS8 | CREAD | HUPCL;
1023 tios.c_iflag = IGNBRK | IGNPAR;
1026 tios.c_cc[VMIN] = 1;
1027 tios.c_cc[VTIME] = 0;
1029 if (local || !modem)
1030 tios.c_cflag ^= (CLOCAL | HUPCL);
1034 tios.c_cflag |= CRTSCTS;
1038 tios.c_iflag |= IXON | IXOFF;
1039 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
1040 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
1044 tios.c_cflag &= ~CRTSCTS;
1052 tios.c_cflag |= CSTOPB;
1055 speed = translate_speed(inspeed);
1057 cfsetospeed (&tios, speed);
1058 cfsetispeed (&tios, speed);
1059 speed = cfgetospeed(&tios);
1060 baud_rate = baud_rate_of(speed);
1063 tios.c_cflag &= ~CBAUD;
1064 tios.c_cflag |= BOTHER;
1065 tios.c_ospeed = inspeed;
1067 /* B0 sets input baudrate to the output baudrate */
1068 tios.c_cflag &= ~(CBAUD << IBSHIFT);
1069 tios.c_cflag |= B0 << IBSHIFT;
1070 tios.c_ispeed = inspeed;
1072 baud_rate = inspeed;
1079 speed = cfgetospeed(&tios);
1080 baud_rate = baud_rate_of(speed);
1083 baud_rate = tios.c_ospeed;
1088 * We can't proceed if the serial port baud rate is unknown,
1089 * since that implies that the serial port is disabled.
1093 fatal("speed %d not supported", inspeed);
1095 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1098 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1100 fatal("tcsetattr: %m (line %d)", __LINE__);
1104 /********************************************************************
1106 * setdtr - control the DTR line on the serial port.
1107 * This is called from die(), so it shouldn't call die().
1110 void setdtr (int tty_fd, int on)
1112 int modembits = TIOCM_DTR;
1114 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1117 /********************************************************************
1119 * restore_tty - restore the terminal to the saved settings.
1122 void restore_tty (int tty_fd)
1127 * Turn off echoing, because otherwise we can get into
1128 * a loop with the tty and the modem echoing to each other.
1129 * We presume we are the sole user of this tty device, so
1130 * when we close it, it will revert to its defaults anyway.
1132 if (!default_device)
1133 inittermios.c_lflag &= ~(ECHO | ECHONL);
1135 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1136 if (! ok_error (errno))
1137 warn("tcsetattr: %m (line %d)", __LINE__);
1142 /********************************************************************
1144 * output - Output PPP packet.
1147 void output (int unit, unsigned char *p, int len)
1152 dump_packet("sent", p, len);
1153 if (snoop_send_hook) snoop_send_hook(p, len);
1155 if (len < PPP_HDRLEN)
1157 if (new_style_driver) {
1160 proto = (p[0] << 8) + p[1];
1161 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1164 if (write(fd, p, len) < 0) {
1165 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1166 || errno == ENXIO || errno == EIO || errno == EINTR)
1167 warn("write: warning: %m (%d)", errno);
1169 error("write: %m (%d)", errno);
1173 /********************************************************************
1175 * wait_input - wait until there is data available,
1176 * for the length of time specified by *timo (indefinite
1180 void wait_input(struct timeval *timo)
1187 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1188 if (n < 0 && errno != EINTR)
1189 fatal("select: %m");
1193 * add_fd - add an fd to the set that wait_input waits for.
1197 if (fd >= FD_SETSIZE)
1198 fatal("internal error: file descriptor too large (%d)", fd);
1199 FD_SET(fd, &in_fds);
1205 * remove_fd - remove an fd from the set that wait_input waits for.
1207 void remove_fd(int fd)
1209 FD_CLR(fd, &in_fds);
1213 /********************************************************************
1215 * read_packet - get a PPP packet from the serial device.
1218 int read_packet (unsigned char *buf)
1222 len = PPP_MRU + PPP_HDRLEN;
1223 if (new_style_driver) {
1224 *buf++ = PPP_ALLSTATIONS;
1230 nr = read(ppp_fd, buf, len);
1231 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1232 && errno != EIO && errno != EINTR)
1234 if (nr < 0 && errno == ENXIO)
1237 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1238 /* N.B. we read ppp_fd first since LCP packets come in there. */
1239 nr = read(ppp_dev_fd, buf, len);
1240 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1241 && errno != EIO && errno != EINTR)
1242 error("read /dev/ppp: %m");
1243 if (nr < 0 && errno == ENXIO)
1245 if (nr == 0 && doing_multilink) {
1246 remove_fd(ppp_dev_fd);
1250 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1252 return (new_style_driver && nr > 0)? nr+2: nr;
1255 /********************************************************************
1257 * get_loop_output - get outgoing packets from the ppp device,
1258 * and detect when we want to bring the real link up.
1259 * Return value is 1 if we need to bring up the link, 0 otherwise.
1262 get_loop_output(void)
1267 if (new_style_driver) {
1268 while ((n = read_packet(inpacket_buf)) > 0)
1269 if (loop_frame(inpacket_buf, n))
1274 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1275 if (loop_chars(inbuf, n))
1279 fatal("eof on loopback");
1281 if (errno != EWOULDBLOCK && errno != EAGAIN)
1282 fatal("read from loopback: %m(%d)", errno);
1288 * netif_set_mtu - set the MTU on the PPP network interface.
1291 netif_set_mtu(int unit, int mtu)
1295 memset (&ifr, '\0', sizeof (ifr));
1296 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1299 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1300 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1304 * netif_get_mtu - get the MTU on the PPP network interface.
1307 netif_get_mtu(int unit)
1311 memset (&ifr, '\0', sizeof (ifr));
1312 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1314 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1315 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1321 /********************************************************************
1323 * tty_send_config - configure the transmit characteristics of
1324 * the ppp interface.
1327 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1334 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1335 if (errno != EIO && errno != ENOTTY)
1336 error("Couldn't set transmit async character map: %m");
1341 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1342 | (sync_serial? SC_SYNC: 0);
1343 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1346 /********************************************************************
1348 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1351 void tty_set_xaccm (ext_accm accm)
1355 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1356 if ( ! ok_error (errno))
1357 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1361 /********************************************************************
1363 * tty_recv_config - configure the receive-side characteristics of
1364 * the ppp interface.
1367 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1370 * If we were called because the link has gone down then there is nothing
1371 * which may be done. Just return without incident.
1376 * Set the receiver parameters
1378 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1379 if (errno != EIO && errno != ENOTTY)
1380 error("Couldn't set channel receive MRU: %m");
1382 if (new_style_driver && ppp_dev_fd >= 0
1383 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1384 error("Couldn't set MRU in generic PPP layer: %m");
1386 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1387 if (errno != EIO && errno != ENOTTY)
1388 error("Couldn't set channel receive asyncmap: %m");
1392 /********************************************************************
1394 * ccp_test - ask kernel whether a given compression method
1395 * is acceptable for use.
1399 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1401 struct ppp_option_data data;
1403 memset (&data, '\0', sizeof (data));
1405 data.length = opt_len;
1406 data.transmit = for_transmit;
1408 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1411 return (errno == ENOBUFS)? 0: -1;
1414 /********************************************************************
1416 * ccp_flags_set - inform kernel about the current state of CCP.
1419 void ccp_flags_set (int unit, int isopen, int isup)
1423 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1424 if (still_ppp() && ppp_dev_fd >= 0)
1425 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1430 * set_filters - set the active and pass filters in the kernel driver.
1432 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1434 struct sock_fprog fp;
1436 fp.len = pass->bf_len;
1437 fp.filter = (struct sock_filter *) pass->bf_insns;
1438 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1439 if (errno == ENOTTY)
1440 warn("kernel does not support PPP filtering");
1442 error("Couldn't set pass-filter in kernel: %m");
1445 fp.len = active->bf_len;
1446 fp.filter = (struct sock_filter *) active->bf_insns;
1447 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1448 error("Couldn't set active-filter in kernel: %m");
1453 #endif /* PPP_FILTER */
1455 /********************************************************************
1457 * get_idle_time - return how long the link has been idle.
1460 get_idle_time(int u, struct ppp_idle *ip)
1462 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1465 /********************************************************************
1467 * get_ppp_stats_iocl - return statistics for the link, using the ioctl() method,
1468 * this only supports 32-bit counters, so need to count the wraps.
1471 get_ppp_stats_ioctl(int u, struct pppd_stats *stats)
1473 static u_int32_t previbytes = 0;
1474 static u_int32_t prevobytes = 0;
1475 static u_int32_t iwraps = 0;
1476 static u_int32_t owraps = 0;
1478 struct ifpppstatsreq req;
1480 memset (&req, 0, sizeof (req));
1482 req.stats_ptr = (caddr_t) &req.stats;
1483 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1484 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1485 error("Couldn't get PPP statistics: %m");
1488 stats->bytes_in = req.stats.p.ppp_ibytes;
1489 stats->bytes_out = req.stats.p.ppp_obytes;
1490 stats->pkts_in = req.stats.p.ppp_ipackets;
1491 stats->pkts_out = req.stats.p.ppp_opackets;
1493 if (stats->bytes_in < previbytes)
1495 if (stats->bytes_out < prevobytes)
1498 previbytes = stats->bytes_in;
1499 prevobytes = stats->bytes_out;
1501 stats->bytes_in += (uint64_t)iwraps << 32;
1502 stats->bytes_out += (uint64_t)owraps << 32;
1507 /********************************************************************
1508 * get_ppp_stats_rtnetlink - return statistics for the link, using rtnetlink
1509 * This provides native 64-bit counters.
1512 get_ppp_stats_rtnetlink(int u, struct pppd_stats *stats)
1514 static int rtnl_fd = -1;
1516 struct sockaddr_nl nladdr;
1518 struct nlmsghdr nlh;
1519 struct if_stats_msg ifsm;
1522 struct nlmsghdr nlh;
1525 struct nlmsgerr nlerr;
1531 /* We only case about these first fields from rtnl_link_stats64 */
1532 uint64_t rx_packets;
1533 uint64_t tx_packets;
1537 char __end_stats[0];
1545 memset(&nladdr, 0, sizeof(nladdr));
1546 nladdr.nl_family = AF_NETLINK;
1549 rtnl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1551 error("get_ppp_stats_rtnetlink: error creating NETLINK socket: %m (line %d)", __LINE__);
1555 if (bind(rtnl_fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
1556 error("get_ppp_stats_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
1561 memset(&nlreq, 0, sizeof(nlreq));
1562 nlreq.nlh.nlmsg_len = sizeof(nlreq);
1563 nlreq.nlh.nlmsg_type = RTM_GETSTATS;
1564 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST;
1566 nlreq.ifsm.ifindex = if_nametoindex(ifname);
1567 nlreq.ifsm.filter_mask = IFLA_STATS_LINK_64;
1569 memset(&iov, 0, sizeof(iov));
1570 iov.iov_base = &nlreq;
1571 iov.iov_len = sizeof(nlreq);
1573 memset(&msg, 0, sizeof(msg));
1574 msg.msg_name = &nladdr;
1575 msg.msg_namelen = sizeof(nladdr);
1579 if (sendmsg(rtnl_fd, &msg, 0) < 0) {
1580 error("get_ppp_stats_rtnetlink: sendmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1584 /* We just need to repoint to IOV ... everything else stays the same */
1585 iov.iov_base = &nlresp;
1586 iov.iov_len = sizeof(nlresp);
1588 nlresplen = recvmsg(rtnl_fd, &msg, 0);
1590 if (nlresplen < 0) {
1591 error("get_ppp_stats_rtnetlink: recvmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1595 if (nlresplen < sizeof(nlresp.nlh)) {
1596 error("get_ppp_stats_rtnetlink: Netlink response message was incomplete (line %d)", __LINE__);
1600 if (nlresp.nlh.nlmsg_type == NLMSG_ERROR) {
1601 if (nlresplen < offsetof(struct nlresp, __end_err)) {
1602 if (kernel_version >= KVERSION(4,7,0))
1603 error("get_ppp_stats_rtnetlink: Netlink responded with error: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
1605 error("get_ppp_stats_rtnetlink: Netlink responded with an error message, but the nlmsgerr structure is incomplete (line %d).",
1611 if (nlresp.nlh.nlmsg_type != RTM_NEWSTATS) {
1612 error("get_ppp_stats_rtnetlink: Expected RTM_NEWSTATS response, found something else (mlmsg_type %d, line %d)",
1613 nlresp.nlh.nlmsg_type, __LINE__);
1617 if (nlresplen < offsetof(struct nlresp, __end_stats)) {
1618 error("get_ppp_stats_rtnetlink: Obtained an insufficiently sized rtnl_link_stats64 struct from the kernel (line %d).", __LINE__);
1622 stats->bytes_in = nlresp.stats.rx_bytes;
1623 stats->bytes_out = nlresp.stats.tx_bytes;
1624 stats->pkts_in = nlresp.stats.rx_packets;
1625 stats->pkts_out = nlresp.stats.tx_packets;
1634 /********************************************************************
1635 * get_ppp_stats_sysfs - return statistics for the link, using the files in sysfs,
1636 * this provides native 64-bit counters.
1639 get_ppp_stats_sysfs(int u, struct pppd_stats *stats)
1641 char fname[PATH_MAX+1];
1642 char buf[21], *err; /* 2^64 < 10^20 */
1644 unsigned long long val;
1651 #define statfield(fn, field) { .fname = #fn, .ptr = &stats->field, .size = sizeof(stats->field) }
1652 statfield(rx_bytes, bytes_in),
1653 statfield(tx_bytes, bytes_out),
1654 statfield(rx_packets, pkts_in),
1655 statfield(tx_packets, pkts_out),
1659 blen = snprintf(fname, sizeof(fname), "/sys/class/net/%s/statistics/", ifname);
1660 if (blen >= sizeof(fname))
1661 return 0; /* ifname max 15, so this should be impossible */
1663 for (int i = 0; i < sizeof(slist) / sizeof(*slist); ++i) {
1664 if (snprintf(fname + blen, sizeof(fname) - blen, "%s", slist[i].fname) >= sizeof(fname) - blen) {
1666 error("sysfs stats: filename %s/%s overflowed PATH_MAX", fname, slist[i].fname);
1670 fd = open(fname, O_RDONLY);
1672 error("%s: %m", fname);
1676 rlen = read(fd, buf, sizeof(buf) - 1);
1679 error("%s: %m", fname);
1682 /* trim trailing \n if present */
1683 while (rlen > 0 && buf[rlen-1] == '\n')
1688 val = strtoull(buf, &err, 10);
1689 if (*buf < '0' || *buf > '9' || errno != 0 || *err) {
1690 error("string to number conversion error converting %s (from %s) for remaining string %s%s%s",
1691 buf, fname, err, errno ? ": " : "", errno ? strerror(errno) : "");
1694 switch (slist[i].size) {
1695 #define stattype(type) case sizeof(type): *(type*)slist[i].ptr = (type)val; break
1702 error("Don't know how to store stats for %s of size %u", slist[i].fname, slist[i].size);
1710 /********************************************************************
1711 * Periodic timer function to be used to keep stats up to date in case of ioctl
1714 * Given the 25s interval this should be fine up to data rates of 1.37Gbps.
1715 * If you do change the timer, remember to also bring the get_ppp_stats (which
1716 * sets up the initial trigger) as well.
1719 ppp_stats_poller(void* u)
1721 struct pppd_stats dummy;
1722 get_ppp_stats_ioctl((long)u, &dummy);
1723 TIMEOUT(ppp_stats_poller, u, 25);
1726 /********************************************************************
1727 * get_ppp_stats - return statistics for the link.
1729 int get_ppp_stats(int u, struct pppd_stats *stats)
1731 static int (*func)(int, struct pppd_stats*) = NULL;
1734 if (get_ppp_stats_rtnetlink(u, stats)) {
1735 func = get_ppp_stats_rtnetlink;
1738 if (get_ppp_stats_sysfs(u, stats)) {
1739 func = get_ppp_stats_sysfs;
1742 warn("statistics falling back to ioctl which only supports 32-bit counters");
1743 func = get_ppp_stats_ioctl;
1744 TIMEOUT(ppp_stats_poller, (void*)(long)u, 25);
1747 return func(u, stats);
1750 /********************************************************************
1752 * ccp_fatal_error - returns 1 if decompression was disabled as a
1753 * result of an error detected after decompression of a packet,
1754 * 0 otherwise. This is necessary because of patent nonsense.
1757 int ccp_fatal_error (int unit)
1761 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1762 error("Couldn't read compression error flags: %m");
1765 return flags & SC_DC_FERROR;
1768 /********************************************************************
1770 * path_to_procfs - find the path to the proc file system mount point
1772 static char proc_path[MAXPATHLEN];
1773 static int proc_path_len;
1775 static char *path_to_procfs(const char *tail)
1777 struct mntent *mntent;
1780 if (proc_path_len == 0) {
1781 /* Default the mount location of /proc */
1782 strlcpy (proc_path, "/proc", sizeof(proc_path));
1784 fp = fopen(MOUNTED, "r");
1786 while ((mntent = getmntent(fp)) != NULL) {
1787 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1789 if (strcmp(mntent->mnt_type, "proc") == 0) {
1790 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1791 proc_path_len = strlen(proc_path);
1799 strlcpy(proc_path + proc_path_len, tail,
1800 sizeof(proc_path) - proc_path_len);
1805 * /proc/net/route parsing stuff.
1807 #define ROUTE_MAX_COLS 12
1808 FILE *route_fd = (FILE *) 0;
1809 static char route_buffer[512];
1810 static int route_dev_col, route_dest_col, route_gw_col;
1811 static int route_flags_col, route_metric_col, route_mask_col;
1812 static int route_num_cols;
1814 static int open_route_table (void);
1815 static void close_route_table (void);
1816 static int read_route_table (struct rtentry *rt);
1818 /********************************************************************
1820 * close_route_table - close the interface to the route table
1823 static void close_route_table (void)
1825 if (route_fd != (FILE *) 0) {
1827 route_fd = (FILE *) 0;
1831 /********************************************************************
1833 * open_route_table - open the interface to the route table
1835 static char route_delims[] = " \t\n";
1837 static int open_route_table (void)
1841 close_route_table();
1843 path = path_to_procfs("/net/route");
1844 route_fd = fopen (path, "r");
1845 if (route_fd == NULL) {
1846 error("can't open routing table %s: %m", path);
1850 route_dev_col = 0; /* default to usual columns */
1853 route_flags_col = 3;
1854 route_metric_col = 6;
1858 /* parse header line */
1859 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1860 char *p = route_buffer, *q;
1862 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1864 if ((q = strtok(p, route_delims)) == 0)
1866 if (strcasecmp(q, "iface") == 0)
1867 route_dev_col = col;
1868 else if (strcasecmp(q, "destination") == 0)
1869 route_dest_col = col;
1870 else if (strcasecmp(q, "gateway") == 0)
1872 else if (strcasecmp(q, "flags") == 0)
1873 route_flags_col = col;
1874 else if (strcasecmp(q, "mask") == 0)
1875 route_mask_col = col;
1878 if (used && col >= route_num_cols)
1879 route_num_cols = col + 1;
1887 /********************************************************************
1889 * read_route_table - read the next entry from the route table
1892 static int read_route_table(struct rtentry *rt)
1894 char *cols[ROUTE_MAX_COLS], *p;
1897 memset (rt, '\0', sizeof (struct rtentry));
1899 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1903 for (col = 0; col < route_num_cols; ++col) {
1904 cols[col] = strtok(p, route_delims);
1905 if (cols[col] == NULL)
1906 return 0; /* didn't get enough columns */
1910 SET_SA_FAMILY (rt->rt_dst, AF_INET);
1911 SET_SA_FAMILY (rt->rt_gateway, AF_INET);
1913 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1914 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1915 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1917 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1918 rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
1919 rt->rt_dev = cols[route_dev_col];
1924 /********************************************************************
1926 * defaultroute_exists - determine if there is a default route
1927 * with the given metric (or negative for any)
1930 static int defaultroute_exists (struct rtentry *rt, int metric)
1934 if (!open_route_table())
1937 while (read_route_table(rt) != 0) {
1938 if ((rt->rt_flags & RTF_UP) == 0)
1941 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1943 if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
1944 || rt->rt_metric == metric)) {
1950 close_route_table();
1955 * have_route_to - determine if the system has any route to
1956 * a given IP address. `addr' is in network byte order.
1957 * Return value is 1 if yes, 0 if no, -1 if don't know.
1958 * For demand mode to work properly, we have to ignore routes
1959 * through our own interface.
1961 int have_route_to(u_int32_t addr)
1966 if (!open_route_table())
1967 return -1; /* don't know */
1969 while (read_route_table(&rt)) {
1970 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1972 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1978 close_route_table();
1982 /********************************************************************
1984 * sifdefaultroute - assign a default route through the address given.
1986 * If the global default_rt_repl_rest flag is set, then this function
1987 * already replaced the original system defaultroute with some other
1988 * route and it should just replace the current defaultroute with
1989 * another one, without saving the current route. Use: demand mode,
1990 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1991 * and then changes the temporary addresses to the addresses for the real
1992 * ppp connection when it has come up.
1995 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
1997 struct rtentry rt, tmp_rt;
1998 struct rtentry *del_rt = NULL;
2000 if (default_rt_repl_rest) {
2001 /* We have already replaced the original defaultroute, if we
2002 * are called again, we will delete the current default route
2003 * and set the new default route in this function.
2004 * - this is normally only the case the doing demand: */
2005 if (defaultroute_exists(&tmp_rt, -1))
2007 } else if (defaultroute_exists(&old_def_rt, -1 ) &&
2008 strcmp( old_def_rt.rt_dev, ifname) != 0) {
2010 * We did not yet replace an existing default route, let's
2011 * check if we should save and replace a default route:
2013 u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
2015 if (old_gateway != gateway) {
2017 error("not replacing default route to %s [%I]",
2018 old_def_rt.rt_dev, old_gateway);
2021 /* we need to copy rt_dev because we need it permanent too: */
2022 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
2023 strcpy(tmp_dev, old_def_rt.rt_dev);
2024 old_def_rt.rt_dev = tmp_dev;
2026 notice("replacing old default route to %s [%I]",
2027 old_def_rt.rt_dev, old_gateway);
2028 default_rt_repl_rest = 1;
2029 del_rt = &old_def_rt;
2034 memset (&rt, 0, sizeof (rt));
2035 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2038 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2040 if (kernel_version > KVERSION(2,1,0)) {
2041 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2042 SIN_ADDR(rt.rt_genmask) = 0L;
2045 rt.rt_flags = RTF_UP;
2046 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2047 if ( ! ok_error ( errno ))
2048 error("default route ioctl(SIOCADDRT): %m");
2051 if (default_rt_repl_rest && del_rt)
2052 if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
2053 if ( ! ok_error ( errno ))
2054 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
2058 have_default_route = 1;
2062 /********************************************************************
2064 * cifdefaultroute - delete a default route through the address given.
2067 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
2071 have_default_route = 0;
2073 memset (&rt, '\0', sizeof (rt));
2074 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2075 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2080 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2082 if (kernel_version > KVERSION(2,1,0)) {
2083 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2084 SIN_ADDR(rt.rt_genmask) = 0L;
2087 rt.rt_flags = RTF_UP;
2088 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2090 if ( ! ok_error ( errno ))
2091 error("default route ioctl(SIOCDELRT): %m");
2095 if (default_rt_repl_rest) {
2096 notice("restoring old default route to %s [%I]",
2097 old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
2098 if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
2099 if ( ! ok_error ( errno ))
2100 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
2103 default_rt_repl_rest = 0;
2109 #ifdef PPP_WITH_IPV6CP
2111 * /proc/net/ipv6_route parsing stuff.
2113 static int route_dest_plen_col;
2114 static int open_route6_table (void);
2115 static int read_route6_table (struct in6_rtmsg *rt);
2117 /********************************************************************
2119 * open_route6_table - open the interface to the route table
2121 static int open_route6_table (void)
2125 close_route_table();
2127 path = path_to_procfs("/net/ipv6_route");
2128 route_fd = fopen (path, "r");
2129 if (route_fd == NULL) {
2130 error("can't open routing table %s: %m", path);
2134 /* default to usual columns */
2136 route_dest_plen_col = 1;
2138 route_metric_col = 5;
2139 route_flags_col = 8;
2141 route_num_cols = 10;
2146 /********************************************************************
2148 * read_route6_table - read the next entry from the route table
2151 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
2158 for (i = 0; i < 4; i++) {
2159 memcpy(hex8, s + 8*i, 8);
2160 v = strtoul(hex8, NULL, 16);
2161 addr->s6_addr32[i] = v;
2165 static int read_route6_table(struct in6_rtmsg *rt)
2167 char *cols[ROUTE_MAX_COLS], *p;
2170 memset (rt, '\0', sizeof (struct in6_rtmsg));
2172 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
2176 for (col = 0; col < route_num_cols; ++col) {
2177 cols[col] = strtok(p, route_delims);
2178 if (cols[col] == NULL)
2179 return 0; /* didn't get enough columns */
2183 hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
2184 rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
2185 hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
2187 rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
2188 rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
2189 rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
2194 /********************************************************************
2196 * defaultroute6_exists - determine if there is a default route
2199 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
2203 if (!open_route6_table())
2206 while (read_route6_table(rt) != 0) {
2207 if ((rt->rtmsg_flags & RTF_UP) == 0)
2210 if (rt->rtmsg_dst_len != 0)
2212 if (rt->rtmsg_dst.s6_addr32[0] == 0L
2213 && rt->rtmsg_dst.s6_addr32[1] == 0L
2214 && rt->rtmsg_dst.s6_addr32[2] == 0L
2215 && rt->rtmsg_dst.s6_addr32[3] == 0L
2216 && (metric < 0 || rt->rtmsg_metric == metric)) {
2222 close_route_table();
2226 /********************************************************************
2228 * sif6defaultroute - assign a default route through the address given.
2230 * If the global default_rt_repl_rest flag is set, then this function
2231 * already replaced the original system defaultroute with some other
2232 * route and it should just replace the current defaultroute with
2233 * another one, without saving the current route. Use: demand mode,
2234 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
2235 * and then changes the temporary addresses to the addresses for the real
2236 * ppp connection when it has come up.
2239 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2241 struct in6_rtmsg rt;
2242 char buf[IF_NAMESIZE];
2244 if (defaultroute6_exists(&rt, dfl_route_metric) &&
2245 rt.rtmsg_ifindex != if_nametoindex(ifname)) {
2246 if (rt.rtmsg_flags & RTF_GATEWAY)
2247 error("not replacing existing default route via gateway");
2249 error("not replacing existing default route through %s",
2250 if_indextoname(rt.rtmsg_ifindex, buf));
2254 memset (&rt, 0, sizeof (rt));
2256 rt.rtmsg_ifindex = if_nametoindex(ifname);
2257 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2258 rt.rtmsg_dst_len = 0;
2260 rt.rtmsg_flags = RTF_UP;
2261 if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
2262 if ( ! ok_error ( errno ))
2263 error("default route ioctl(SIOCADDRT): %m");
2267 have_default_route6 = 1;
2271 /********************************************************************
2273 * cif6defaultroute - delete a default route through the address given.
2276 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2278 struct in6_rtmsg rt;
2280 have_default_route6 = 0;
2282 memset (&rt, '\0', sizeof (rt));
2284 rt.rtmsg_ifindex = if_nametoindex(ifname);
2285 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2286 rt.rtmsg_dst_len = 0;
2288 rt.rtmsg_flags = RTF_UP;
2289 if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2291 if ( ! ok_error ( errno ))
2292 error("default route ioctl(SIOCDELRT): %m");
2299 #endif /* PPP_WITH_IPV6CP */
2301 /********************************************************************
2303 * sifproxyarp - Make a proxy ARP entry for the peer.
2306 int sifproxyarp (int unit, u_int32_t his_adr)
2308 struct arpreq arpreq;
2311 if (has_proxy_arp == 0) {
2312 memset (&arpreq, '\0', sizeof(arpreq));
2314 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2315 SIN_ADDR(arpreq.arp_pa) = his_adr;
2316 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2318 * Get the hardware address of an interface on the same subnet
2319 * as our local address.
2321 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2322 sizeof(proxy_arp_dev))) {
2323 error("Cannot determine ethernet address for proxy ARP");
2326 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2328 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2329 if ( ! ok_error ( errno ))
2330 error("ioctl(SIOCSARP): %m");
2333 proxy_arp_addr = his_adr;
2337 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2338 if (forw_path != 0) {
2339 int fd = open(forw_path, O_WRONLY);
2341 if (write(fd, "1", 1) != 1)
2342 error("Couldn't enable IP forwarding: %m");
2352 /********************************************************************
2354 * cifproxyarp - Delete the proxy ARP entry for the peer.
2357 int cifproxyarp (int unit, u_int32_t his_adr)
2359 struct arpreq arpreq;
2361 if (has_proxy_arp) {
2363 memset (&arpreq, '\0', sizeof(arpreq));
2364 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2365 SIN_ADDR(arpreq.arp_pa) = his_adr;
2366 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2367 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2369 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2370 if ( ! ok_error ( errno ))
2371 warn("ioctl(SIOCDARP): %m");
2378 /********************************************************************
2380 * get_ether_addr - get the hardware address of an interface on the
2381 * the same subnet as ipaddr.
2384 static int get_ether_addr (u_int32_t ipaddr,
2385 struct sockaddr *hwaddr,
2386 char *name, int namelen)
2388 struct ifreq *ifr, *ifend;
2389 u_int32_t ina, mask;
2391 struct ifreq ifreq, bestifreq;
2393 struct ifreq ifs[MAX_IFS];
2395 u_int32_t bestmask=0;
2396 int found_interface = 0;
2398 ifc.ifc_len = sizeof(ifs);
2400 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2401 if ( ! ok_error ( errno ))
2402 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2407 * Scan through looking for an interface with an Internet
2408 * address on the same subnet as `ipaddr'.
2410 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2411 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2412 if (ifr->ifr_addr.sa_family == AF_INET) {
2413 ina = SIN_ADDR(ifr->ifr_addr);
2414 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2416 * Check that the interface is up, and not point-to-point
2419 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2422 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2425 * Get its netmask and check that it's on the right subnet.
2427 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2430 mask = SIN_ADDR(ifreq.ifr_addr);
2432 if (((ipaddr ^ ina) & mask) != 0)
2433 continue; /* no match */
2435 if (mask >= bestmask) {
2436 /* Compare using >= instead of > -- it is possible for
2437 an interface to have a netmask of 0.0.0.0 */
2438 found_interface = 1;
2445 if (!found_interface) return 0;
2447 strlcpy(name, bestifreq.ifr_name, namelen);
2449 /* trim off the :1 in eth0:1 */
2450 aliasp = strchr(name, ':');
2454 info("found interface %s for proxy arp", name);
2456 * Now get the hardware address.
2458 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2459 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2460 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2465 &bestifreq.ifr_hwaddr,
2466 sizeof (struct sockaddr));
2472 * get_if_hwaddr - get the hardware address for the specified
2473 * network interface device.
2476 get_if_hwaddr(u_char *addr, char *name)
2481 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2484 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2485 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2486 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2489 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2494 * get_first_ether_hwaddr - get the hardware address for the first
2495 * ethernet-style interface on this system.
2498 get_first_ether_hwaddr(u_char *addr)
2500 struct if_nameindex *if_ni, *i;
2504 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2508 if_ni = if_nameindex();
2516 for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2517 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2518 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2519 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2520 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2521 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2527 if_freenameindex(if_ni);
2533 /********************************************************************
2535 * Return user specified netmask, modified by any mask we might determine
2536 * for address `addr' (in network byte order).
2537 * Here we scan through the system's list of interfaces, looking for
2538 * any non-point-to-point interfaces which might appear to be on the same
2539 * network as `addr'. If we find any, we OR in their netmask to the
2540 * user-specified netmask.
2543 u_int32_t GetMask (u_int32_t addr)
2545 u_int32_t mask, nmask, ina;
2546 struct ifreq *ifr, *ifend, ifreq;
2548 struct ifreq ifs[MAX_IFS];
2552 if (IN_CLASSA(addr)) /* determine network mask for address class */
2553 nmask = IN_CLASSA_NET;
2554 else if (IN_CLASSB(addr))
2555 nmask = IN_CLASSB_NET;
2557 nmask = IN_CLASSC_NET;
2559 /* class D nets are disallowed by bad_ip_adrs */
2560 mask = netmask | htonl(nmask);
2562 * Scan through the system's network interfaces.
2564 ifc.ifc_len = sizeof(ifs);
2566 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2567 if ( ! ok_error ( errno ))
2568 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2572 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2573 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2575 * Check the interface's internet address.
2577 if (ifr->ifr_addr.sa_family != AF_INET)
2579 ina = SIN_ADDR(ifr->ifr_addr);
2580 if (((ntohl(ina) ^ addr) & nmask) != 0)
2583 * Check that the interface is up, and not point-to-point nor loopback.
2585 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2586 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2589 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2592 * Get its netmask and OR it into our mask.
2594 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2596 mask |= SIN_ADDR(ifreq.ifr_addr);
2602 /********************************************************************
2604 * Internal routine to decode the version.modification.patch level
2607 static void decode_version (char *buf, int *version,
2608 int *modification, int *patch)
2612 *version = (int) strtoul (buf, &endp, 10);
2616 if (endp != buf && *endp == '.') {
2618 *modification = (int) strtoul (buf, &endp, 10);
2619 if (endp != buf && *endp == '.') {
2621 *patch = (int) strtoul (buf, &buf, 10);
2626 /********************************************************************
2628 * Procedure to determine if the PPP line discipline is registered.
2632 ppp_registered(void)
2640 * We used to open the serial device and set it to the ppp line
2641 * discipline here, in order to create a ppp unit. But that is
2642 * not a good idea - the user might have specified a device that
2643 * they can't open (permission, or maybe it doesn't really exist).
2644 * So we grab a pty master/slave pair and use that.
2646 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2647 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2652 * Try to put the device into the PPP discipline.
2654 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2655 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2664 /********************************************************************
2666 * ppp_available - check whether the system has any ppp interfaces
2667 * (in fact we check whether we can do an ioctl on ppp0).
2670 int ppp_available(void)
2675 int my_version, my_modification, my_patch;
2676 int osmaj, osmin, ospatch;
2678 /* get the kernel version now, since we are called before sys_init */
2680 osmaj = osmin = ospatch = 0;
2681 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2682 kernel_version = KVERSION(osmaj, osmin, ospatch);
2684 fd = open("/dev/ppp", O_RDWR);
2686 new_style_driver = 1;
2688 /* XXX should get from driver */
2690 driver_modification = 4;
2696 if (kernel_version >= KVERSION(2,3,13)) {
2697 error("Couldn't open the /dev/ppp device: %m");
2698 if (errno == ENOENT)
2700 "You need to create the /dev/ppp device node by\n"
2701 "executing the following command as root:\n"
2702 " mknod /dev/ppp c 108 0\n";
2703 else if (errno == ENODEV || errno == ENXIO)
2705 "Please load the ppp_generic kernel module.\n";
2709 /* we are running on a really really old kernel */
2711 "This system lacks kernel support for PPP. This could be because\n"
2712 "the PPP kernel module could not be loaded, or because PPP was not\n"
2713 "included in the kernel configuration. If PPP was included as a\n"
2714 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2715 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2716 "See README.linux file in the ppp distribution for more details.\n";
2719 * Open a socket for doing the ioctl operations.
2721 s = socket(AF_INET, SOCK_DGRAM, 0);
2725 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2726 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2728 * If the device did not exist then attempt to create one by putting the
2729 * current tty into the PPP discipline. If this works then obtain the
2730 * flags for the device again.
2733 if (ppp_registered()) {
2734 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2735 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2739 * Ensure that the hardware address is for PPP and not something else
2742 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2744 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2748 * This is the PPP device. Validate the version of the driver at this
2749 * point to ensure that this program will work with the driver.
2752 char abBuffer [1024];
2754 ifr.ifr_data = abBuffer;
2755 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2757 error("Couldn't read driver version: %m");
2759 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2762 decode_version(abBuffer,
2764 &driver_modification,
2767 * Validate the version of the driver against the version that we used.
2769 decode_version(VERSION,
2774 /* The version numbers must match */
2775 if (driver_version != my_version)
2778 /* The modification levels must be legal */
2779 if (driver_modification < 3) {
2780 if (driver_modification >= 2) {
2781 /* we can cope with 2.2.0 and above */
2789 slprintf(route_buffer, sizeof(route_buffer),
2790 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2791 driver_version, driver_modification, driver_patch);
2793 no_ppp_msg = route_buffer;
2801 #ifndef HAVE_LOGWTMP
2802 /********************************************************************
2804 * Update the wtmp file with the appropriate user name and tty device.
2807 void logwtmp (const char *line, const char *name, const char *host)
2809 struct utmp ut, *utp;
2810 pid_t mypid = getpid();
2816 * Update the signon database for users.
2817 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2819 utmpname(_PATH_UTMP);
2821 while ((utp = getutent()) && (utp->ut_pid != mypid))
2825 memcpy(&ut, utp, sizeof(ut));
2827 /* some gettys/telnetds don't initialize utmp... */
2828 memset(&ut, 0, sizeof(ut));
2830 if (ut.ut_id[0] == 0)
2831 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2833 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2834 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2838 ut.ut_type = USER_PROCESS;
2841 /* Insert the host name if one is supplied */
2843 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2845 /* Insert the IP address of the remote system if IP is enabled */
2846 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2847 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2848 sizeof(ut.ut_addr));
2850 /* CL: Makes sure that the logout works */
2851 if (*host == 0 && *name==0)
2857 * Update the wtmp file.
2860 updwtmp(_PATH_WTMP, &ut);
2862 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2864 flock(wtmp, LOCK_EX);
2866 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2867 warn("error writing %s: %m", _PATH_WTMP);
2869 flock(wtmp, LOCK_UN);
2875 #endif /* HAVE_LOGWTMP */
2877 /********************************************************************
2879 * sifvjcomp - config tcp header compression
2882 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2887 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2888 error("Couldn't set up TCP header compression: %m");
2893 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2894 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2899 /********************************************************************
2901 * sifup - Config the interface up and enable IP packets to pass.
2908 if ((ret = setifstate(u, 1)))
2914 /********************************************************************
2916 * sifdown - Disable the indicated protocol and config the interface
2917 * down if there are no remaining protocols.
2922 if (if_is_up && --if_is_up > 0)
2925 #ifdef PPP_WITH_IPV6CP
2928 #endif /* PPP_WITH_IPV6CP */
2930 return setifstate(u, 0);
2933 #ifdef PPP_WITH_IPV6CP
2934 /********************************************************************
2936 * sif6up - Config the interface up for IPv6
2943 if ((ret = setifstate(u, 1)))
2949 /********************************************************************
2951 * sif6down - Disable the IPv6CP protocol and config the interface
2952 * down if there are no remaining protocols.
2955 int sif6down (int u)
2962 return setifstate(u, 0);
2964 #endif /* PPP_WITH_IPV6CP */
2966 /********************************************************************
2968 * setifstate - Config the interface up or down
2971 static int setifstate (int u, int state)
2975 memset (&ifr, '\0', sizeof (ifr));
2976 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2977 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2978 if (! ok_error (errno))
2979 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2984 ifr.ifr_flags |= IFF_UP;
2986 ifr.ifr_flags &= ~IFF_UP;
2987 ifr.ifr_flags |= IFF_POINTOPOINT;
2988 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2989 if (! ok_error (errno))
2990 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2996 /********************************************************************
2998 * sifaddr - Config the interface IP addresses and netmask.
3001 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
3007 memset (&ifr, '\0', sizeof (ifr));
3008 memset (&rt, '\0', sizeof (rt));
3010 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
3011 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
3012 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
3014 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
3016 * Set our IP address
3018 SIN_ADDR(ifr.ifr_addr) = our_adr;
3019 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3020 if (errno != EEXIST) {
3021 if (! ok_error (errno))
3022 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3025 warn("ioctl(SIOCSIFADDR): Address already exists");
3030 * Set the gateway address
3033 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
3034 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
3035 if (! ok_error (errno))
3036 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
3042 * For recent kernels, force the netmask to 255.255.255.255.
3044 if (kernel_version >= KVERSION(2,1,16))
3046 if (net_mask != 0) {
3047 SIN_ADDR(ifr.ifr_netmask) = net_mask;
3048 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
3049 if (! ok_error (errno))
3050 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
3055 * Add the device route
3057 if (kernel_version < KVERSION(2,1,16)) {
3058 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3059 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3062 SIN_ADDR(rt.rt_gateway) = 0L;
3063 SIN_ADDR(rt.rt_dst) = his_adr;
3064 rt.rt_flags = RTF_UP | RTF_HOST;
3066 if (kernel_version > KVERSION(2,1,0)) {
3067 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3068 SIN_ADDR(rt.rt_genmask) = -1L;
3071 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
3072 if (! ok_error (errno))
3073 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
3078 /* set ip_dynaddr in demand mode if address changes */
3079 if (demand && tune_kernel && !dynaddr_set
3080 && our_old_addr && our_old_addr != our_adr) {
3081 /* set ip_dynaddr if possible */
3085 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
3086 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
3087 if (write(fd, "1", 1) != 1)
3088 error("Couldn't enable dynamic IP addressing: %m");
3091 dynaddr_set = 1; /* only 1 attempt */
3098 /********************************************************************
3100 * cifaddr - Clear the interface IP addresses, and delete routes
3101 * through the interface if possible.
3104 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
3108 if (kernel_version < KVERSION(2,1,16)) {
3110 * Delete the route through the device
3113 memset (&rt, '\0', sizeof (rt));
3115 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3116 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3119 SIN_ADDR(rt.rt_gateway) = 0;
3120 SIN_ADDR(rt.rt_dst) = his_adr;
3121 rt.rt_flags = RTF_UP | RTF_HOST;
3123 if (kernel_version > KVERSION(2,1,0)) {
3124 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3125 SIN_ADDR(rt.rt_genmask) = -1L;
3128 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
3129 if (still_ppp() && ! ok_error (errno))
3130 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
3135 /* This way it is possible to have an IPv6-only interface */
3136 memset(&ifr, 0, sizeof(ifr));
3137 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
3138 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3140 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3141 if (! ok_error (errno)) {
3142 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3147 our_old_addr = our_adr;
3152 #ifdef PPP_WITH_IPV6CP
3153 /********************************************************************
3155 * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
3157 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
3160 struct nlmsghdr nlh;
3161 struct ifaddrmsg ifa;
3164 struct in6_addr addr;
3168 struct nlmsghdr nlh;
3169 struct nlmsgerr nlerr;
3171 struct sockaddr_nl nladdr;
3178 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
3180 error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
3185 * Tell kernel to not send to us payload of acknowledgment error message.
3186 * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
3187 * older kernel versions always send full payload in acknowledgment netlink
3188 * message. We ignore payload of this message as we need only error code,
3189 * to check if our set remote peer address request succeeded or failed.
3190 * So ignore return value from the following setsockopt() call as setting
3191 * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
3194 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
3196 memset(&nladdr, 0, sizeof(nladdr));
3197 nladdr.nl_family = AF_NETLINK;
3199 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
3200 error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
3205 memset(&nlreq, 0, sizeof(nlreq));
3206 nlreq.nlh.nlmsg_len = sizeof(nlreq);
3207 nlreq.nlh.nlmsg_type = RTM_NEWADDR;
3208 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
3209 nlreq.ifa.ifa_family = AF_INET6;
3210 nlreq.ifa.ifa_prefixlen = 128;
3211 nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
3212 nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
3213 nlreq.ifa.ifa_index = iface;
3214 nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
3215 nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
3216 IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
3217 nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
3218 nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
3221 * To set only local address, older kernel expects that local address is
3222 * in IFA_ADDRESS field (not IFA_LOCAL). New kernels with support for peer
3223 * address, ignore IFA_ADDRESS if is same as IFA_LOCAL. So for backward
3224 * compatibility when setting only local address, set it via both IFA_LOCAL
3225 * and IFA_ADDRESS fields. Same logic is implemented in 'ip address' command
3226 * from iproute2 project.
3228 if (!eui64_iszero(his_eui64))
3229 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
3231 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, our_eui64);
3233 memset(&nladdr, 0, sizeof(nladdr));
3234 nladdr.nl_family = AF_NETLINK;
3236 memset(&iov, 0, sizeof(iov));
3237 iov.iov_base = &nlreq;
3238 iov.iov_len = sizeof(nlreq);
3240 memset(&msg, 0, sizeof(msg));
3241 msg.msg_name = &nladdr;
3242 msg.msg_namelen = sizeof(nladdr);
3246 if (sendmsg(fd, &msg, 0) < 0) {
3247 error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
3252 memset(&iov, 0, sizeof(iov));
3253 iov.iov_base = &nlresp;
3254 iov.iov_len = sizeof(nlresp);
3256 memset(&msg, 0, sizeof(msg));
3257 msg.msg_name = &nladdr;
3258 msg.msg_namelen = sizeof(nladdr);
3262 nlresplen = recvmsg(fd, &msg, 0);
3264 if (nlresplen < 0) {
3265 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
3272 if (nladdr.nl_family != AF_NETLINK) {
3273 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
3277 if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
3278 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
3282 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
3283 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
3284 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
3288 /* error == 0 indicates success, negative value is errno code */
3289 if (nlresp.nlerr.error != 0) {
3291 * Linux kernel versions prior 3.11 do not support setting IPv6 peer
3292 * addresses and error response is expected. On older kernel versions
3293 * do not show this error message. On error pppd tries to fallback to
3294 * the old IOCTL method.
3296 if (kernel_version >= KVERSION(3,11,0))
3297 error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
3304 /********************************************************************
3306 * sif6addr - Config the interface with an IPv6 link-local address
3308 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3310 struct in6_ifreq ifr6;
3312 struct in6_rtmsg rt6;
3317 error("IPv6 socket creation failed: %m");
3320 memset(&ifr, 0, sizeof (ifr));
3321 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3322 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3323 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3327 if (kernel_version >= KVERSION(2,1,16)) {
3328 /* Set both local address and remote peer address (with route for it) via rtnetlink */
3329 ret = sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
3335 * Linux kernel versions prior 3.11 do not support setting IPv6 peer address
3336 * via rtnetlink. So if sif6addr_rtnetlink() fails then try old IOCTL method.
3339 /* Local interface */
3340 memset(&ifr6, 0, sizeof(ifr6));
3341 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3342 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3343 ifr6.ifr6_prefixlen = 128;
3345 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3346 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3351 if (!ret && !eui64_iszero(his_eui64)) {
3353 * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3354 * setting remote peer host address, so set only route to remote host.
3357 /* Route to remote host */
3358 memset(&rt6, 0, sizeof(rt6));
3359 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3360 rt6.rtmsg_flags = RTF_UP;
3361 rt6.rtmsg_dst_len = 128;
3362 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3363 rt6.rtmsg_metric = 1;
3365 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3366 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3375 /********************************************************************
3377 * cif6addr - Remove IPv6 address from interface
3379 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3382 struct in6_ifreq ifr6;
3386 error("IPv6 socket creation failed: %m");
3389 memset(&ifr, 0, sizeof(ifr));
3390 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3391 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3392 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3396 memset(&ifr6, 0, sizeof(ifr6));
3397 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3398 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3399 ifr6.ifr6_prefixlen = 128;
3401 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3402 if (errno != EADDRNOTAVAIL) {
3403 if (! ok_error (errno))
3404 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3407 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3413 #endif /* PPP_WITH_IPV6CP */
3416 * get_pty - get a pty master/slave pair and chown the slave side
3417 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
3420 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3422 int i, mfd, ret, sfd = -1;
3424 struct termios tios;
3428 * Try the unix98 way first.
3430 mfd = open("/dev/ptmx", O_RDWR);
3433 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3434 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3435 chmod(pty_name, S_IRUSR | S_IWUSR);
3438 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3439 warn("Couldn't unlock pty slave %s: %m", pty_name);
3441 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3443 warn("Couldn't open pty slave %s: %m", pty_name);
3448 #endif /* TIOCGPTN */
3451 /* the old way - scan through the pty name space */
3452 for (i = 0; i < 64; ++i) {
3453 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3454 'p' + i / 16, i % 16);
3455 mfd = open(pty_name, O_RDWR, 0);
3458 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3460 ret = fchown(sfd, uid, -1);
3462 warn("Couldn't change ownership of %s, %m", pty_name);
3464 ret = fchmod(sfd, S_IRUSR | S_IWUSR);
3466 warn("Couldn't change permissions of %s, %m", pty_name);
3478 strlcpy(slave_name, pty_name, 16);
3481 if (tcgetattr(sfd, &tios) == 0) {
3482 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3483 tios.c_cflag |= CS8 | CREAD | CLOCAL;
3484 tios.c_iflag = IGNPAR;
3487 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3488 warn("couldn't set attributes on pty: %m");
3490 warn("couldn't get attributes on pty: %m");
3495 /********************************************************************
3497 * open_loopback - open the device we use for getting packets
3498 * in demand mode. Under Linux, we use a pty master/slave pair.
3501 open_ppp_loopback(void)
3506 if (new_style_driver) {
3507 /* allocate ourselves a ppp unit */
3508 if (make_ppp_unit() < 0)
3510 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3511 set_kdebugflag(kdebugflag);
3516 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3517 fatal("No free pty for loopback");
3519 set_ppp_fd(slave_fd);
3521 flags = fcntl(master_fd, F_GETFL);
3523 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3524 warn("couldn't set master loopback to nonblock: %m");
3526 flags = fcntl(ppp_fd, F_GETFL);
3528 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3529 warn("couldn't set slave loopback to nonblock: %m");
3531 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3532 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3534 * Find out which interface we were given.
3536 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3537 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3539 * Enable debug in the driver if requested.
3541 set_kdebugflag (kdebugflag);
3546 /********************************************************************
3548 * sifnpmode - Set the mode for handling packets for a given NP.
3552 sifnpmode(int u, int proto, enum NPmode mode)
3556 npi.protocol = proto;
3558 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3559 if (! ok_error (errno))
3560 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3567 * Use the hostname as part of the random number seed.
3576 for (p = hostname; *p != 0; ++p)
3581 /********************************************************************
3583 * sys_check_options - check the options that the user specified
3587 sys_check_options(void)
3589 if (demand && driver_is_old) {
3590 option_error("demand dialling is not supported by kernel driver "
3591 "version %d.%d.%d", driver_version, driver_modification,
3595 if (multilink && !new_style_driver) {
3596 warn("Warning: multilink is not supported by the kernel driver");
3602 /********************************************************************
3604 * get_time - Get current time, monotonic if possible.
3607 get_time(struct timeval *tv)
3609 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3610 * Runtime checking makes it safe. */
3611 #ifndef CLOCK_MONOTONIC
3612 #define CLOCK_MONOTONIC 1
3614 static int monotonic = -1;
3619 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3623 tv->tv_sec = ts.tv_sec;
3624 tv->tv_usec = ts.tv_nsec / 1000;
3627 } else if (monotonic > 0)
3631 warn("Couldn't use monotonic clock source: %m");
3634 return gettimeofday(tv, NULL);