2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1994-2004 Paul Mackerras. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
14 * 2. The name(s) of the authors of this software must not be used to
15 * endorse or promote products derived from this software without
16 * prior written permission.
18 * 3. Redistributions of any form whatsoever must retain the following
20 * "This product includes software developed by Paul Mackerras
21 * <paulus@samba.org>".
23 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
24 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
25 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
26 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
27 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
28 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
29 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
31 * Derived from main.c and pppd.h, which are:
33 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
47 * 3. The name "Carnegie Mellon University" must not be used to
48 * endorse or promote products derived from this software without
49 * prior written permission. For permission or any legal
50 * details, please contact
51 * Office of Technology Transfer
52 * Carnegie Mellon University
54 * Pittsburgh, PA 15213-3890
55 * (412) 268-4387, fax: (412) 268-7395
56 * tech-transfer@andrew.cmu.edu
58 * 4. Redistributions of any form whatsoever must retain the following
60 * "This product includes software developed by Computing Services
61 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
63 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
64 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
65 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
66 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
67 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
68 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
69 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
76 #include <sys/ioctl.h>
77 #include <sys/types.h>
78 #include <sys/socket.h>
82 #include <sys/utsname.h>
83 #include <sys/sysmacros.h>
103 /* This is in netdevice.h. However, this compile will fail miserably if
104 you attempt to include netdevice.h because it has so many references
105 to __memcpy functions which it should not attempt to do. So, since I
106 really don't use it, but it must be defined, define it now. */
109 #define MAX_ADDR_LEN 7
112 #if !defined(__GLIBC__) || __GLIBC__ >= 2
113 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
115 #include <net/if_arp.h>
116 #include <net/route.h>
117 #include <netinet/if_ether.h>
119 #include <linux/types.h>
120 #include <linux/if.h>
121 #include <linux/if_arp.h>
122 #include <linux/route.h>
123 #include <linux/if_ether.h>
125 #include <netinet/in.h>
126 #include <arpa/inet.h>
128 #include <linux/ppp_defs.h>
129 #include <linux/if_ppp.h>
131 #include <linux/netlink.h>
132 #include <linux/rtnetlink.h>
133 #include <linux/if_link.h>
134 /* Attempt at retaining compile-support with older than 4.7 kernels, or kernels
135 * where RTM_NEWSTATS isn't defined for whatever reason.
138 #define RTM_NEWSTATS 92
139 #define RTM_GETSTATS 94
140 #define IFLA_STATS_LINK_64 1
144 #include <linux/if_addr.h>
145 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
147 #define SOL_NETLINK 270
149 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
150 #ifndef NETLINK_CAP_ACK
151 #define NETLINK_CAP_ACK 10
160 #include <pcap-bpf.h>
161 #include <linux/filter.h>
162 #endif /* PPP_FILTER */
165 #include <sys/locks.h>
169 * Instead of system header file <termios.h> use local "termios_linux.h" header
170 * file as it provides additional support for arbitrary baud rates via BOTHER.
172 #include "termios_linux.h"
177 * This is in linux/include/net/ipv6.h.
181 struct in6_addr ifr6_addr;
182 __u32 ifr6_prefixlen;
183 unsigned int ifr6_ifindex;
187 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
188 memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr)); \
189 (sin6).s6_addr16[0] = htons(0xfe80); \
190 eui64_copy(eui64, (sin6).s6_addr32[2]); \
193 static const eui64_t nulleui64;
196 /* We can get an EIO error on an ioctl if the modem has hung up */
197 #define ok_error(num) ((num)==EIO)
199 static int tty_disc = N_TTY; /* The TTY discipline */
200 static int ppp_disc = N_PPP; /* The PPP discpline */
201 static int initfdflags = -1; /* Initial file descriptor flags for fd */
202 static int ppp_fd = -1; /* fd which is set to PPP discipline */
203 static int sock_fd = -1; /* socket for doing interface ioctls */
204 static int slave_fd = -1; /* pty for old-style demand mode, slave */
205 static int master_fd = -1; /* pty for old-style demand mode, master */
207 static int sock6_fd = -1;
211 * For the old-style kernel driver, this is the same as ppp_fd.
212 * For the new-style driver, it is the fd of an instance of /dev/ppp
213 * which is attached to the ppp unit and is used for controlling it.
215 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
217 static int chindex; /* channel index (new style driver) */
219 static fd_set in_fds; /* set of fds that wait_input waits for */
220 static int max_in_fd; /* highest fd set in in_fds */
222 static int has_proxy_arp = 0;
223 static int driver_version = 0;
224 static int driver_modification = 0;
225 static int driver_patch = 0;
226 static int driver_is_old = 0;
227 static int restore_term = 0; /* 1 => we've munged the terminal */
228 static struct termios inittermios; /* Initial TTY termios */
230 int new_style_driver = 0;
232 static char loop_name[20];
233 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
235 static int if_is_up; /* Interface has been marked up */
236 static int if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
237 static int have_default_route; /* Gateway for default route added */
238 static int have_default_route6; /* Gateway for default IPv6 route added */
239 static struct rtentry old_def_rt; /* Old default route */
240 static int default_rt_repl_rest; /* replace and restore old default rt */
241 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
242 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
243 static u_int32_t our_old_addr; /* for detecting address changes */
244 static int dynaddr_set; /* 1 if ip_dynaddr set */
245 static int looped; /* 1 if using loop */
246 static int link_mtu; /* mtu for the link (not bundle) */
248 static struct utsname utsname; /* for the kernel version */
249 static int kernel_version;
250 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
254 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
255 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
256 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
258 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
260 /* Prototypes for procedures local to this file. */
261 static int modify_flags(int fd, int clear_bits, int set_bits);
262 static int translate_speed (int bps);
263 static int baud_rate_of (int speed);
264 static void close_route_table (void);
265 static int open_route_table (void);
266 static int read_route_table (struct rtentry *rt);
267 static int defaultroute_exists (struct rtentry *rt, int metric);
268 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
269 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
270 char *name, int namelen);
271 static void decode_version (char *buf, int *version, int *mod, int *patch);
272 static int set_kdebugflag(int level);
273 static int ppp_registered(void);
274 static int make_ppp_unit(void);
275 static int setifstate (int u, int state);
277 extern u_char inpacket_buf[]; /* borrowed from main.c */
279 extern int dfl_route_metric;
282 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
286 #define SET_SA_FAMILY(addr, family) \
287 memset ((char *) &(addr), '\0', sizeof(addr)); \
288 addr.sa_family = (family);
291 * Determine if the PPP connection should still be present.
296 /* new_fd is the fd of a tty */
297 static void set_ppp_fd (int new_fd)
300 if (!new_style_driver)
304 static int still_ppp(void)
306 if (new_style_driver)
307 return !hungup && ppp_fd >= 0;
308 if (!hungup || ppp_fd == slave_fd)
311 set_ppp_fd(slave_fd);
318 * modify_flags - set and clear flag bits controlling the kernel
321 static int modify_flags(int fd, int clear_bits, int set_bits)
325 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
327 flags = (flags & ~clear_bits) | set_bits;
328 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
335 error("Failed to set PPP kernel option flags: %m");
339 /********************************************************************
341 * sys_init - System-dependent initialization.
346 /* Get an internet socket for doing socket ioctls. */
347 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
349 fatal("Couldn't create IP socket: %m(%d)", errno);
352 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
354 sock6_fd = -errno; /* save errno for later */
361 /********************************************************************
363 * sys_cleanup - restore any system state we modified before exiting:
364 * mark the interface down, delete default route and/or proxy arp entry.
365 * This shouldn't call die() because it's called from die().
368 void sys_cleanup(void)
371 * Take down the device
381 * Delete any routes through the device.
383 if (have_default_route)
384 cifdefaultroute(0, 0, 0);
386 if (have_default_route6)
387 cif6defaultroute(0, nulleui64, nulleui64);
391 cifproxyarp(0, proxy_arp_addr);
394 /********************************************************************
396 * sys_close - Clean up in a child process before execing.
401 if (new_style_driver && ppp_dev_fd >= 0)
415 /********************************************************************
417 * set_kdebugflag - Define the debugging level for the kernel
420 static int set_kdebugflag (int requested_level)
424 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
425 if ( ! ok_error (errno) )
426 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
432 /********************************************************************
434 * tty_establish_ppp - Turn the serial port into a ppp interface.
437 int tty_establish_ppp (int tty_fd)
442 * Ensure that the tty device is in exclusive mode.
444 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
445 if ( ! ok_error ( errno ))
446 warn("Couldn't make tty exclusive: %m");
449 * Demand mode - prime the old ppp device to relinquish the unit.
451 if (!new_style_driver && looped
452 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
453 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
457 * Set the current tty to the PPP discpline
461 #define N_SYNC_PPP 14
463 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
464 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
465 if ( ! ok_error (errno) ) {
466 error("Couldn't set tty to PPP discipline: %m");
471 ret_fd = generic_establish_ppp(tty_fd);
473 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
474 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
478 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
479 (kdebugflag * SC_DEBUG) & SC_LOGB);
481 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
482 warn("Couldn't reset tty to normal line discipline: %m");
488 /********************************************************************
490 * generic_establish_ppp - Turn the fd into a ppp interface.
492 int generic_establish_ppp (int fd)
496 if (new_style_driver) {
499 /* If a ppp_fd is already open, close it first */
506 /* Open an instance of /dev/ppp and connect the channel to it */
507 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
508 error("Couldn't get channel number: %m");
511 dbglog("using channel %d", chindex);
512 fd = open("/dev/ppp", O_RDWR);
514 error("Couldn't reopen /dev/ppp: %m");
517 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
518 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
519 error("Couldn't attach to channel %d: %m", chindex);
522 flags = fcntl(fd, F_GETFL);
523 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
524 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
529 if (!looped && !multilink) {
531 * Create a new PPP unit.
533 if (make_ppp_unit() < 0)
538 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
542 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
543 error("Couldn't attach to PPP unit %d: %m", ifunit);
550 * Old-style driver: find out which interface we were given.
553 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
554 if (ok_error (errno))
556 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
558 /* Check that we got the same unit again. */
559 if (looped && x != ifunit)
560 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
564 * Fetch the initial file flags and reset blocking mode on the file.
566 initfdflags = fcntl(fd, F_GETFL);
567 if (initfdflags == -1 ||
568 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
569 if ( ! ok_error (errno))
570 warn("Couldn't set device to non-blocking mode: %m");
575 * Enable debug in the driver if requested.
578 set_kdebugflag (kdebugflag);
590 /********************************************************************
592 * tty_disestablish_ppp - Restore the serial port to normal operation.
593 * This shouldn't call die() because it's called from die().
596 void tty_disestablish_ppp(int tty_fd)
600 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
602 if (tcflush(tty_fd, TCIOFLUSH) < 0)
604 warn("tcflush failed: %m");
608 * Restore the previous line discipline
610 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
611 if ( ! ok_error (errno))
612 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
615 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
616 if ( ! ok_error (errno))
617 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
620 /* Reset non-blocking mode on fd. */
621 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
622 if ( ! ok_error (errno))
623 warn("Couldn't restore device fd flags: %m");
629 generic_disestablish_ppp(tty_fd);
632 /********************************************************************
634 * generic_disestablish_ppp - Restore device components to normal
635 * operation, and reconnect the ppp unit to the loopback if in demand
636 * mode. This shouldn't call die() because it's called from die().
638 void generic_disestablish_ppp(int dev_fd)
640 if (new_style_driver) {
644 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
646 } else if (!doing_multilink && ppp_dev_fd >= 0) {
648 remove_fd(ppp_dev_fd);
652 /* old-style driver */
654 set_ppp_fd(slave_fd);
661 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
662 * Assumes new_style_driver.
664 static int make_ppp_unit(void)
668 if (ppp_dev_fd >= 0) {
669 dbglog("in make_ppp_unit, already had /dev/ppp open?");
672 ppp_dev_fd = open("/dev/ppp", O_RDWR);
674 fatal("Couldn't open /dev/ppp: %m");
675 flags = fcntl(ppp_dev_fd, F_GETFL);
677 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
678 warn("Couldn't set /dev/ppp to nonblock: %m");
681 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
682 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
683 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
685 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
688 error("Couldn't create new ppp unit: %m");
690 if (x == 0 && req_ifname[0] != '\0') {
693 memset(&ifr, 0, sizeof(struct ifreq));
694 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
695 strlcpy(ifr.ifr_name, t, IFNAMSIZ);
696 strlcpy(ifr.ifr_newname, req_ifname, IFNAMSIZ);
697 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
699 error("Couldn't rename interface %s to %s: %m", t, req_ifname);
701 info("Renamed interface %s to %s", t, req_ifname);
708 * cfg_bundle - configure the existing bundle.
709 * Used in demand mode.
711 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
713 if (!new_style_driver)
716 /* set the mrru, mtu and flags */
717 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
718 error("Couldn't set MRRU: %m");
720 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
721 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
722 | (mrru? SC_MULTILINK: 0)));
724 /* connect up the channel */
725 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
726 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
731 * make_new_bundle - create a new PPP unit (i.e. a bundle)
732 * and connect our channel to it. This should only get called
733 * if `multilink' was set at the time establish_ppp was called.
734 * In demand mode this uses our existing bundle instead of making
737 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
739 if (!new_style_driver)
742 /* make us a ppp unit */
743 if (make_ppp_unit() < 0)
746 /* set the mrru and flags */
747 cfg_bundle(mrru, mtru, rssn, tssn);
751 * bundle_attach - attach our link to a given PPP unit.
752 * We assume the unit is controlled by another pppd.
754 int bundle_attach(int ifnum)
758 if (!new_style_driver)
761 master_fd = open("/dev/ppp", O_RDWR);
763 fatal("Couldn't open /dev/ppp: %m");
764 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
765 if (errno == ENXIO) {
767 return 0; /* doesn't still exist */
769 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
771 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
772 fatal("Couldn't connect to interface unit %d: %m", ifnum);
773 modify_flags(master_fd, 0, SC_MULTILINK);
781 * destroy_bundle - tell the driver to destroy our bundle.
783 void destroy_bundle(void)
785 if (ppp_dev_fd >= 0) {
787 remove_fd(ppp_dev_fd);
792 /********************************************************************
794 * clean_check - Fetch the flags for the device and generate
795 * appropriate error messages.
797 void clean_check(void)
803 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
805 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
807 s = "all had bit 7 set to 1";
811 s = "all had bit 7 set to 0";
815 s = "all had odd parity";
819 s = "all had even parity";
824 warn("Receive serial link is not 8-bit clean:");
825 warn("Problem: %s", s);
833 * List of valid speeds.
837 int speed_int, speed_val;
933 { 1000000, B1000000 },
936 { 1152000, B1152000 },
939 { 1500000, B1500000 },
942 { 2000000, B2000000 },
945 { 2500000, B2500000 },
948 { 3000000, B3000000 },
951 { 3500000, B3500000 },
954 { 4000000, B4000000 },
959 /********************************************************************
961 * Translate from bits/second to a speed_t.
964 static int translate_speed (int bps)
966 struct speed *speedp;
969 for (speedp = speeds; speedp->speed_int; speedp++) {
970 if (bps == speedp->speed_int)
971 return speedp->speed_val;
977 /********************************************************************
979 * Translate from a speed_t to bits/second.
982 static int baud_rate_of (int speed)
984 struct speed *speedp;
987 for (speedp = speeds; speedp->speed_int; speedp++) {
988 if (speed == speedp->speed_val)
989 return speedp->speed_int;
995 /********************************************************************
997 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
998 * at the requested speed, etc. If `local' is true, set CLOCAL
999 * regardless of whether the modem option was specified.
1002 void set_up_tty(int tty_fd, int local)
1005 struct termios tios;
1008 if (tcgetattr(tty_fd, &tios) < 0) {
1009 if (!ok_error(errno))
1010 fatal("tcgetattr: %m (line %d)", __LINE__);
1017 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1018 tios.c_cflag |= CS8 | CREAD | HUPCL;
1020 tios.c_iflag = IGNBRK | IGNPAR;
1023 tios.c_cc[VMIN] = 1;
1024 tios.c_cc[VTIME] = 0;
1026 if (local || !modem)
1027 tios.c_cflag ^= (CLOCAL | HUPCL);
1031 tios.c_cflag |= CRTSCTS;
1035 tios.c_iflag |= IXON | IXOFF;
1036 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
1037 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
1041 tios.c_cflag &= ~CRTSCTS;
1049 tios.c_cflag |= CSTOPB;
1052 speed = translate_speed(inspeed);
1054 cfsetospeed (&tios, speed);
1055 cfsetispeed (&tios, speed);
1056 speed = cfgetospeed(&tios);
1057 baud_rate = baud_rate_of(speed);
1060 tios.c_cflag &= ~CBAUD;
1061 tios.c_cflag |= BOTHER;
1062 tios.c_ospeed = inspeed;
1064 /* B0 sets input baudrate to the output baudrate */
1065 tios.c_cflag &= ~(CBAUD << IBSHIFT);
1066 tios.c_cflag |= B0 << IBSHIFT;
1067 tios.c_ispeed = inspeed;
1069 baud_rate = inspeed;
1076 speed = cfgetospeed(&tios);
1077 baud_rate = baud_rate_of(speed);
1080 baud_rate = tios.c_ospeed;
1085 * We can't proceed if the serial port baud rate is unknown,
1086 * since that implies that the serial port is disabled.
1090 fatal("speed %d not supported", inspeed);
1092 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1095 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1097 fatal("tcsetattr: %m (line %d)", __LINE__);
1101 /********************************************************************
1103 * setdtr - control the DTR line on the serial port.
1104 * This is called from die(), so it shouldn't call die().
1107 void setdtr (int tty_fd, int on)
1109 int modembits = TIOCM_DTR;
1111 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1114 /********************************************************************
1116 * restore_tty - restore the terminal to the saved settings.
1119 void restore_tty (int tty_fd)
1124 * Turn off echoing, because otherwise we can get into
1125 * a loop with the tty and the modem echoing to each other.
1126 * We presume we are the sole user of this tty device, so
1127 * when we close it, it will revert to its defaults anyway.
1129 if (!default_device)
1130 inittermios.c_lflag &= ~(ECHO | ECHONL);
1132 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1133 if (! ok_error (errno))
1134 warn("tcsetattr: %m (line %d)", __LINE__);
1139 /********************************************************************
1141 * output - Output PPP packet.
1144 void output (int unit, unsigned char *p, int len)
1149 dump_packet("sent", p, len);
1150 if (snoop_send_hook) snoop_send_hook(p, len);
1152 if (len < PPP_HDRLEN)
1154 if (new_style_driver) {
1157 proto = (p[0] << 8) + p[1];
1158 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1161 if (write(fd, p, len) < 0) {
1162 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1163 || errno == ENXIO || errno == EIO || errno == EINTR)
1164 warn("write: warning: %m (%d)", errno);
1166 error("write: %m (%d)", errno);
1170 /********************************************************************
1172 * wait_input - wait until there is data available,
1173 * for the length of time specified by *timo (indefinite
1177 void wait_input(struct timeval *timo)
1184 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1185 if (n < 0 && errno != EINTR)
1186 fatal("select: %m");
1190 * add_fd - add an fd to the set that wait_input waits for.
1194 if (fd >= FD_SETSIZE)
1195 fatal("internal error: file descriptor too large (%d)", fd);
1196 FD_SET(fd, &in_fds);
1202 * remove_fd - remove an fd from the set that wait_input waits for.
1204 void remove_fd(int fd)
1206 FD_CLR(fd, &in_fds);
1210 /********************************************************************
1212 * read_packet - get a PPP packet from the serial device.
1215 int read_packet (unsigned char *buf)
1219 len = PPP_MRU + PPP_HDRLEN;
1220 if (new_style_driver) {
1221 *buf++ = PPP_ALLSTATIONS;
1227 nr = read(ppp_fd, buf, len);
1228 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1229 && errno != EIO && errno != EINTR)
1231 if (nr < 0 && errno == ENXIO)
1234 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1235 /* N.B. we read ppp_fd first since LCP packets come in there. */
1236 nr = read(ppp_dev_fd, buf, len);
1237 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1238 && errno != EIO && errno != EINTR)
1239 error("read /dev/ppp: %m");
1240 if (nr < 0 && errno == ENXIO)
1242 if (nr == 0 && doing_multilink) {
1243 remove_fd(ppp_dev_fd);
1247 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1249 return (new_style_driver && nr > 0)? nr+2: nr;
1252 /********************************************************************
1254 * get_loop_output - get outgoing packets from the ppp device,
1255 * and detect when we want to bring the real link up.
1256 * Return value is 1 if we need to bring up the link, 0 otherwise.
1259 get_loop_output(void)
1264 if (new_style_driver) {
1265 while ((n = read_packet(inpacket_buf)) > 0)
1266 if (loop_frame(inpacket_buf, n))
1271 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1272 if (loop_chars(inbuf, n))
1276 fatal("eof on loopback");
1278 if (errno != EWOULDBLOCK && errno != EAGAIN)
1279 fatal("read from loopback: %m(%d)", errno);
1285 * netif_set_mtu - set the MTU on the PPP network interface.
1288 netif_set_mtu(int unit, int mtu)
1292 memset (&ifr, '\0', sizeof (ifr));
1293 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1296 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1297 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1301 * netif_get_mtu - get the MTU on the PPP network interface.
1304 netif_get_mtu(int unit)
1308 memset (&ifr, '\0', sizeof (ifr));
1309 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1311 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1312 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1318 /********************************************************************
1320 * tty_send_config - configure the transmit characteristics of
1321 * the ppp interface.
1324 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1331 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1332 if (errno != EIO && errno != ENOTTY)
1333 error("Couldn't set transmit async character map: %m");
1338 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1339 | (sync_serial? SC_SYNC: 0);
1340 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1343 /********************************************************************
1345 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1348 void tty_set_xaccm (ext_accm accm)
1352 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1353 if ( ! ok_error (errno))
1354 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1358 /********************************************************************
1360 * tty_recv_config - configure the receive-side characteristics of
1361 * the ppp interface.
1364 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1367 * If we were called because the link has gone down then there is nothing
1368 * which may be done. Just return without incident.
1373 * Set the receiver parameters
1375 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1376 if (errno != EIO && errno != ENOTTY)
1377 error("Couldn't set channel receive MRU: %m");
1379 if (new_style_driver && ppp_dev_fd >= 0
1380 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1381 error("Couldn't set MRU in generic PPP layer: %m");
1383 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1384 if (errno != EIO && errno != ENOTTY)
1385 error("Couldn't set channel receive asyncmap: %m");
1389 /********************************************************************
1391 * ccp_test - ask kernel whether a given compression method
1392 * is acceptable for use.
1396 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1398 struct ppp_option_data data;
1400 memset (&data, '\0', sizeof (data));
1402 data.length = opt_len;
1403 data.transmit = for_transmit;
1405 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1408 return (errno == ENOBUFS)? 0: -1;
1411 /********************************************************************
1413 * ccp_flags_set - inform kernel about the current state of CCP.
1416 void ccp_flags_set (int unit, int isopen, int isup)
1420 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1421 if (still_ppp() && ppp_dev_fd >= 0)
1422 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1427 * set_filters - set the active and pass filters in the kernel driver.
1429 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1431 struct sock_fprog fp;
1433 fp.len = pass->bf_len;
1434 fp.filter = (struct sock_filter *) pass->bf_insns;
1435 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1436 if (errno == ENOTTY)
1437 warn("kernel does not support PPP filtering");
1439 error("Couldn't set pass-filter in kernel: %m");
1442 fp.len = active->bf_len;
1443 fp.filter = (struct sock_filter *) active->bf_insns;
1444 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1445 error("Couldn't set active-filter in kernel: %m");
1450 #endif /* PPP_FILTER */
1452 /********************************************************************
1454 * get_idle_time - return how long the link has been idle.
1457 get_idle_time(int u, struct ppp_idle *ip)
1459 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1462 /********************************************************************
1464 * get_ppp_stats_iocl - return statistics for the link, using the ioctl() method,
1465 * this only supports 32-bit counters, so need to count the wraps.
1468 get_ppp_stats_ioctl(int u, struct pppd_stats *stats)
1470 static u_int32_t previbytes = 0;
1471 static u_int32_t prevobytes = 0;
1472 static u_int32_t iwraps = 0;
1473 static u_int32_t owraps = 0;
1475 struct ifpppstatsreq req;
1477 memset (&req, 0, sizeof (req));
1479 req.stats_ptr = (caddr_t) &req.stats;
1480 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1481 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1482 error("Couldn't get PPP statistics: %m");
1485 stats->bytes_in = req.stats.p.ppp_ibytes;
1486 stats->bytes_out = req.stats.p.ppp_obytes;
1487 stats->pkts_in = req.stats.p.ppp_ipackets;
1488 stats->pkts_out = req.stats.p.ppp_opackets;
1490 if (stats->bytes_in < previbytes)
1492 if (stats->bytes_out < prevobytes)
1495 previbytes = stats->bytes_in;
1496 prevobytes = stats->bytes_out;
1498 stats->bytes_in += (uint64_t)iwraps << 32;
1499 stats->bytes_out += (uint64_t)owraps << 32;
1504 /********************************************************************
1505 * get_ppp_stats_rtnetlink - return statistics for the link, using rtnetlink
1506 * This provides native 64-bit counters.
1509 get_ppp_stats_rtnetlink(int u, struct pppd_stats *stats)
1511 static int rtnl_fd = -1;
1513 struct sockaddr_nl nladdr;
1515 struct nlmsghdr nlh;
1516 struct if_stats_msg ifsm;
1519 struct nlmsghdr nlh;
1522 struct nlmsgerr nlerr;
1528 /* We only case about these first fields from rtnl_link_stats64 */
1529 uint64_t rx_packets;
1530 uint64_t tx_packets;
1534 char __end_stats[0];
1542 memset(&nladdr, 0, sizeof(nladdr));
1543 nladdr.nl_family = AF_NETLINK;
1546 rtnl_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1548 error("get_ppp_stats_rtnetlink: error creating NETLINK socket: %m (line %d)", __LINE__);
1552 if (bind(rtnl_fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
1553 error("get_ppp_stats_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
1558 memset(&nlreq, 0, sizeof(nlreq));
1559 nlreq.nlh.nlmsg_len = sizeof(nlreq);
1560 nlreq.nlh.nlmsg_type = RTM_GETSTATS;
1561 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST;
1563 nlreq.ifsm.ifindex = if_nametoindex(ifname);
1564 nlreq.ifsm.filter_mask = IFLA_STATS_LINK_64;
1566 memset(&iov, 0, sizeof(iov));
1567 iov.iov_base = &nlreq;
1568 iov.iov_len = sizeof(nlreq);
1570 memset(&msg, 0, sizeof(msg));
1571 msg.msg_name = &nladdr;
1572 msg.msg_namelen = sizeof(nladdr);
1576 if (sendmsg(rtnl_fd, &msg, 0) < 0) {
1577 error("get_ppp_stats_rtnetlink: sendmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1581 /* We just need to repoint to IOV ... everything else stays the same */
1582 iov.iov_base = &nlresp;
1583 iov.iov_len = sizeof(nlresp);
1585 nlresplen = recvmsg(rtnl_fd, &msg, 0);
1587 if (nlresplen < 0) {
1588 error("get_ppp_stats_rtnetlink: recvmsg(RTM_GETSTATS): %m (line %d)", __LINE__);
1592 if (nlresplen < sizeof(nlresp.nlh)) {
1593 error("get_ppp_stats_rtnetlink: Netlink response message was incomplete (line %d)", __LINE__);
1597 if (nlresp.nlh.nlmsg_type == NLMSG_ERROR) {
1598 if (nlresplen < offsetof(struct nlresp, __end_err)) {
1599 if (kernel_version >= KVERSION(4,7,0))
1600 error("get_ppp_stats_rtnetlink: Netlink responded with error: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
1602 error("get_ppp_stats_rtnetlink: Netlink responded with an error message, but the nlmsgerr structure is incomplete (line %d).",
1608 if (nlresp.nlh.nlmsg_type != RTM_NEWSTATS) {
1609 error("get_ppp_stats_rtnetlink: Expected RTM_NEWSTATS response, found something else (mlmsg_type %d, line %d)",
1610 nlresp.nlh.nlmsg_type, __LINE__);
1614 if (nlresplen < offsetof(struct nlresp, __end_stats)) {
1615 error("get_ppp_stats_rtnetlink: Obtained an insufficiently sized rtnl_link_stats64 struct from the kernel (line %d).", __LINE__);
1619 stats->bytes_in = nlresp.stats.rx_bytes;
1620 stats->bytes_out = nlresp.stats.tx_bytes;
1621 stats->pkts_in = nlresp.stats.rx_packets;
1622 stats->pkts_out = nlresp.stats.tx_packets;
1631 /********************************************************************
1632 * get_ppp_stats_sysfs - return statistics for the link, using the files in sysfs,
1633 * this provides native 64-bit counters.
1636 get_ppp_stats_sysfs(int u, struct pppd_stats *stats)
1638 char fname[PATH_MAX+1];
1639 char buf[21], *err; /* 2^64 < 10^20 */
1641 unsigned long long val;
1648 #define statfield(fn, field) { .fname = #fn, .ptr = &stats->field, .size = sizeof(stats->field) }
1649 statfield(rx_bytes, bytes_in),
1650 statfield(tx_bytes, bytes_out),
1651 statfield(rx_packets, pkts_in),
1652 statfield(tx_packets, pkts_out),
1656 blen = snprintf(fname, sizeof(fname), "/sys/class/net/%s/statistics/", ifname);
1657 if (blen >= sizeof(fname))
1658 return 0; /* ifname max 15, so this should be impossible */
1660 for (int i = 0; i < sizeof(slist) / sizeof(*slist); ++i) {
1661 if (snprintf(fname + blen, sizeof(fname) - blen, "%s", slist[i].fname) >= sizeof(fname) - blen) {
1663 error("sysfs stats: filename %s/%s overflowed PATH_MAX", fname, slist[i].fname);
1667 fd = open(fname, O_RDONLY);
1669 error("%s: %m", fname);
1673 rlen = read(fd, buf, sizeof(buf) - 1);
1676 error("%s: %m", fname);
1679 /* trim trailing \n if present */
1680 while (rlen > 0 && buf[rlen-1] == '\n')
1685 val = strtoull(buf, &err, 10);
1686 if (*buf < '0' || *buf > '9' || errno != 0 || *err) {
1687 error("string to number conversion error converting %s (from %s) for remaining string %s%s%s",
1688 buf, fname, err, errno ? ": " : "", errno ? strerror(errno) : "");
1691 switch (slist[i].size) {
1692 #define stattype(type) case sizeof(type): *(type*)slist[i].ptr = (type)val; break
1699 error("Don't know how to store stats for %s of size %u", slist[i].fname, slist[i].size);
1707 /********************************************************************
1708 * Periodic timer function to be used to keep stats up to date in case of ioctl
1711 * Given the 25s interval this should be fine up to data rates of 1.37Gbps.
1712 * If you do change the timer, remember to also bring the get_ppp_stats (which
1713 * sets up the initial trigger) as well.
1716 ppp_stats_poller(void* u)
1718 struct pppd_stats dummy;
1719 get_ppp_stats_ioctl((long)u, &dummy);
1720 TIMEOUT(ppp_stats_poller, u, 25);
1723 /********************************************************************
1724 * get_ppp_stats - return statistics for the link.
1726 int get_ppp_stats(int u, struct pppd_stats *stats)
1728 static int (*func)(int, struct pppd_stats*) = NULL;
1731 if (get_ppp_stats_rtnetlink(u, stats)) {
1732 func = get_ppp_stats_rtnetlink;
1735 if (get_ppp_stats_sysfs(u, stats)) {
1736 func = get_ppp_stats_sysfs;
1739 warn("statistics falling back to ioctl which only supports 32-bit counters");
1740 func = get_ppp_stats_ioctl;
1741 TIMEOUT(ppp_stats_poller, (void*)(long)u, 25);
1744 return func(u, stats);
1747 /********************************************************************
1749 * ccp_fatal_error - returns 1 if decompression was disabled as a
1750 * result of an error detected after decompression of a packet,
1751 * 0 otherwise. This is necessary because of patent nonsense.
1754 int ccp_fatal_error (int unit)
1758 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1759 error("Couldn't read compression error flags: %m");
1762 return flags & SC_DC_FERROR;
1765 /********************************************************************
1767 * path_to_procfs - find the path to the proc file system mount point
1769 static char proc_path[MAXPATHLEN];
1770 static int proc_path_len;
1772 static char *path_to_procfs(const char *tail)
1774 struct mntent *mntent;
1777 if (proc_path_len == 0) {
1778 /* Default the mount location of /proc */
1779 strlcpy (proc_path, "/proc", sizeof(proc_path));
1781 fp = fopen(MOUNTED, "r");
1783 while ((mntent = getmntent(fp)) != NULL) {
1784 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1786 if (strcmp(mntent->mnt_type, "proc") == 0) {
1787 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1788 proc_path_len = strlen(proc_path);
1796 strlcpy(proc_path + proc_path_len, tail,
1797 sizeof(proc_path) - proc_path_len);
1802 * /proc/net/route parsing stuff.
1804 #define ROUTE_MAX_COLS 12
1805 FILE *route_fd = (FILE *) 0;
1806 static char route_buffer[512];
1807 static int route_dev_col, route_dest_col, route_gw_col;
1808 static int route_flags_col, route_metric_col, route_mask_col;
1809 static int route_num_cols;
1811 static int open_route_table (void);
1812 static void close_route_table (void);
1813 static int read_route_table (struct rtentry *rt);
1815 /********************************************************************
1817 * close_route_table - close the interface to the route table
1820 static void close_route_table (void)
1822 if (route_fd != (FILE *) 0) {
1824 route_fd = (FILE *) 0;
1828 /********************************************************************
1830 * open_route_table - open the interface to the route table
1832 static char route_delims[] = " \t\n";
1834 static int open_route_table (void)
1838 close_route_table();
1840 path = path_to_procfs("/net/route");
1841 route_fd = fopen (path, "r");
1842 if (route_fd == NULL) {
1843 error("can't open routing table %s: %m", path);
1847 route_dev_col = 0; /* default to usual columns */
1850 route_flags_col = 3;
1851 route_metric_col = 6;
1855 /* parse header line */
1856 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1857 char *p = route_buffer, *q;
1859 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1861 if ((q = strtok(p, route_delims)) == 0)
1863 if (strcasecmp(q, "iface") == 0)
1864 route_dev_col = col;
1865 else if (strcasecmp(q, "destination") == 0)
1866 route_dest_col = col;
1867 else if (strcasecmp(q, "gateway") == 0)
1869 else if (strcasecmp(q, "flags") == 0)
1870 route_flags_col = col;
1871 else if (strcasecmp(q, "mask") == 0)
1872 route_mask_col = col;
1875 if (used && col >= route_num_cols)
1876 route_num_cols = col + 1;
1884 /********************************************************************
1886 * read_route_table - read the next entry from the route table
1889 static int read_route_table(struct rtentry *rt)
1891 char *cols[ROUTE_MAX_COLS], *p;
1894 memset (rt, '\0', sizeof (struct rtentry));
1896 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1900 for (col = 0; col < route_num_cols; ++col) {
1901 cols[col] = strtok(p, route_delims);
1902 if (cols[col] == NULL)
1903 return 0; /* didn't get enough columns */
1907 SET_SA_FAMILY (rt->rt_dst, AF_INET);
1908 SET_SA_FAMILY (rt->rt_gateway, AF_INET);
1910 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1911 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1912 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1914 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1915 rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
1916 rt->rt_dev = cols[route_dev_col];
1921 /********************************************************************
1923 * defaultroute_exists - determine if there is a default route
1924 * with the given metric (or negative for any)
1927 static int defaultroute_exists (struct rtentry *rt, int metric)
1931 if (!open_route_table())
1934 while (read_route_table(rt) != 0) {
1935 if ((rt->rt_flags & RTF_UP) == 0)
1938 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1940 if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
1941 || rt->rt_metric == metric)) {
1947 close_route_table();
1952 * have_route_to - determine if the system has any route to
1953 * a given IP address. `addr' is in network byte order.
1954 * Return value is 1 if yes, 0 if no, -1 if don't know.
1955 * For demand mode to work properly, we have to ignore routes
1956 * through our own interface.
1958 int have_route_to(u_int32_t addr)
1963 if (!open_route_table())
1964 return -1; /* don't know */
1966 while (read_route_table(&rt)) {
1967 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1969 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1975 close_route_table();
1979 /********************************************************************
1981 * sifdefaultroute - assign a default route through the address given.
1983 * If the global default_rt_repl_rest flag is set, then this function
1984 * already replaced the original system defaultroute with some other
1985 * route and it should just replace the current defaultroute with
1986 * another one, without saving the current route. Use: demand mode,
1987 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1988 * and then changes the temporary addresses to the addresses for the real
1989 * ppp connection when it has come up.
1992 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
1994 struct rtentry rt, tmp_rt;
1995 struct rtentry *del_rt = NULL;
1997 if (default_rt_repl_rest) {
1998 /* We have already replaced the original defaultroute, if we
1999 * are called again, we will delete the current default route
2000 * and set the new default route in this function.
2001 * - this is normally only the case the doing demand: */
2002 if (defaultroute_exists(&tmp_rt, -1))
2004 } else if (defaultroute_exists(&old_def_rt, -1 ) &&
2005 strcmp( old_def_rt.rt_dev, ifname) != 0) {
2007 * We did not yet replace an existing default route, let's
2008 * check if we should save and replace a default route:
2010 u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
2012 if (old_gateway != gateway) {
2014 error("not replacing default route to %s [%I]",
2015 old_def_rt.rt_dev, old_gateway);
2018 /* we need to copy rt_dev because we need it permanent too: */
2019 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
2020 strcpy(tmp_dev, old_def_rt.rt_dev);
2021 old_def_rt.rt_dev = tmp_dev;
2023 notice("replacing old default route to %s [%I]",
2024 old_def_rt.rt_dev, old_gateway);
2025 default_rt_repl_rest = 1;
2026 del_rt = &old_def_rt;
2031 memset (&rt, 0, sizeof (rt));
2032 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2035 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2037 if (kernel_version > KVERSION(2,1,0)) {
2038 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2039 SIN_ADDR(rt.rt_genmask) = 0L;
2042 rt.rt_flags = RTF_UP;
2043 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2044 if ( ! ok_error ( errno ))
2045 error("default route ioctl(SIOCADDRT): %m");
2048 if (default_rt_repl_rest && del_rt)
2049 if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
2050 if ( ! ok_error ( errno ))
2051 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
2055 have_default_route = 1;
2059 /********************************************************************
2061 * cifdefaultroute - delete a default route through the address given.
2064 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
2068 have_default_route = 0;
2070 memset (&rt, '\0', sizeof (rt));
2071 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2072 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2077 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2079 if (kernel_version > KVERSION(2,1,0)) {
2080 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2081 SIN_ADDR(rt.rt_genmask) = 0L;
2084 rt.rt_flags = RTF_UP;
2085 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2087 if ( ! ok_error ( errno ))
2088 error("default route ioctl(SIOCDELRT): %m");
2092 if (default_rt_repl_rest) {
2093 notice("restoring old default route to %s [%I]",
2094 old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
2095 if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
2096 if ( ! ok_error ( errno ))
2097 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
2100 default_rt_repl_rest = 0;
2108 * /proc/net/ipv6_route parsing stuff.
2110 static int route_dest_plen_col;
2111 static int open_route6_table (void);
2112 static int read_route6_table (struct in6_rtmsg *rt);
2114 /********************************************************************
2116 * open_route6_table - open the interface to the route table
2118 static int open_route6_table (void)
2122 close_route_table();
2124 path = path_to_procfs("/net/ipv6_route");
2125 route_fd = fopen (path, "r");
2126 if (route_fd == NULL) {
2127 error("can't open routing table %s: %m", path);
2131 /* default to usual columns */
2133 route_dest_plen_col = 1;
2135 route_metric_col = 5;
2136 route_flags_col = 8;
2138 route_num_cols = 10;
2143 /********************************************************************
2145 * read_route6_table - read the next entry from the route table
2148 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
2155 for (i = 0; i < 4; i++) {
2156 memcpy(hex8, s + 8*i, 8);
2157 v = strtoul(hex8, NULL, 16);
2158 addr->s6_addr32[i] = v;
2162 static int read_route6_table(struct in6_rtmsg *rt)
2164 char *cols[ROUTE_MAX_COLS], *p;
2167 memset (rt, '\0', sizeof (struct in6_rtmsg));
2169 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
2173 for (col = 0; col < route_num_cols; ++col) {
2174 cols[col] = strtok(p, route_delims);
2175 if (cols[col] == NULL)
2176 return 0; /* didn't get enough columns */
2180 hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
2181 rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
2182 hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
2184 rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
2185 rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
2186 rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
2191 /********************************************************************
2193 * defaultroute6_exists - determine if there is a default route
2196 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
2200 if (!open_route6_table())
2203 while (read_route6_table(rt) != 0) {
2204 if ((rt->rtmsg_flags & RTF_UP) == 0)
2207 if (rt->rtmsg_dst_len != 0)
2209 if (rt->rtmsg_dst.s6_addr32[0] == 0L
2210 && rt->rtmsg_dst.s6_addr32[1] == 0L
2211 && rt->rtmsg_dst.s6_addr32[2] == 0L
2212 && rt->rtmsg_dst.s6_addr32[3] == 0L
2213 && (metric < 0 || rt->rtmsg_metric == metric)) {
2219 close_route_table();
2223 /********************************************************************
2225 * sif6defaultroute - assign a default route through the address given.
2227 * If the global default_rt_repl_rest flag is set, then this function
2228 * already replaced the original system defaultroute with some other
2229 * route and it should just replace the current defaultroute with
2230 * another one, without saving the current route. Use: demand mode,
2231 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
2232 * and then changes the temporary addresses to the addresses for the real
2233 * ppp connection when it has come up.
2236 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2238 struct in6_rtmsg rt;
2239 char buf[IF_NAMESIZE];
2241 if (defaultroute6_exists(&rt, dfl_route_metric) &&
2242 rt.rtmsg_ifindex != if_nametoindex(ifname)) {
2243 if (rt.rtmsg_flags & RTF_GATEWAY)
2244 error("not replacing existing default route via gateway");
2246 error("not replacing existing default route through %s",
2247 if_indextoname(rt.rtmsg_ifindex, buf));
2251 memset (&rt, 0, sizeof (rt));
2253 rt.rtmsg_ifindex = if_nametoindex(ifname);
2254 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2255 rt.rtmsg_dst_len = 0;
2257 rt.rtmsg_flags = RTF_UP;
2258 if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
2259 if ( ! ok_error ( errno ))
2260 error("default route ioctl(SIOCADDRT): %m");
2264 have_default_route6 = 1;
2268 /********************************************************************
2270 * cif6defaultroute - delete a default route through the address given.
2273 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2275 struct in6_rtmsg rt;
2277 have_default_route6 = 0;
2279 memset (&rt, '\0', sizeof (rt));
2281 rt.rtmsg_ifindex = if_nametoindex(ifname);
2282 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2283 rt.rtmsg_dst_len = 0;
2285 rt.rtmsg_flags = RTF_UP;
2286 if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2288 if ( ! ok_error ( errno ))
2289 error("default route ioctl(SIOCDELRT): %m");
2298 /********************************************************************
2300 * sifproxyarp - Make a proxy ARP entry for the peer.
2303 int sifproxyarp (int unit, u_int32_t his_adr)
2305 struct arpreq arpreq;
2308 if (has_proxy_arp == 0) {
2309 memset (&arpreq, '\0', sizeof(arpreq));
2311 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2312 SIN_ADDR(arpreq.arp_pa) = his_adr;
2313 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2315 * Get the hardware address of an interface on the same subnet
2316 * as our local address.
2318 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2319 sizeof(proxy_arp_dev))) {
2320 error("Cannot determine ethernet address for proxy ARP");
2323 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2325 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2326 if ( ! ok_error ( errno ))
2327 error("ioctl(SIOCSARP): %m");
2330 proxy_arp_addr = his_adr;
2334 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2335 if (forw_path != 0) {
2336 int fd = open(forw_path, O_WRONLY);
2338 if (write(fd, "1", 1) != 1)
2339 error("Couldn't enable IP forwarding: %m");
2349 /********************************************************************
2351 * cifproxyarp - Delete the proxy ARP entry for the peer.
2354 int cifproxyarp (int unit, u_int32_t his_adr)
2356 struct arpreq arpreq;
2358 if (has_proxy_arp) {
2360 memset (&arpreq, '\0', sizeof(arpreq));
2361 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2362 SIN_ADDR(arpreq.arp_pa) = his_adr;
2363 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2364 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2366 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2367 if ( ! ok_error ( errno ))
2368 warn("ioctl(SIOCDARP): %m");
2375 /********************************************************************
2377 * get_ether_addr - get the hardware address of an interface on the
2378 * the same subnet as ipaddr.
2381 static int get_ether_addr (u_int32_t ipaddr,
2382 struct sockaddr *hwaddr,
2383 char *name, int namelen)
2385 struct ifreq *ifr, *ifend;
2386 u_int32_t ina, mask;
2388 struct ifreq ifreq, bestifreq;
2390 struct ifreq ifs[MAX_IFS];
2392 u_int32_t bestmask=0;
2393 int found_interface = 0;
2395 ifc.ifc_len = sizeof(ifs);
2397 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2398 if ( ! ok_error ( errno ))
2399 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2404 * Scan through looking for an interface with an Internet
2405 * address on the same subnet as `ipaddr'.
2407 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2408 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2409 if (ifr->ifr_addr.sa_family == AF_INET) {
2410 ina = SIN_ADDR(ifr->ifr_addr);
2411 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2413 * Check that the interface is up, and not point-to-point
2416 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2419 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2422 * Get its netmask and check that it's on the right subnet.
2424 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2427 mask = SIN_ADDR(ifreq.ifr_addr);
2429 if (((ipaddr ^ ina) & mask) != 0)
2430 continue; /* no match */
2432 if (mask >= bestmask) {
2433 /* Compare using >= instead of > -- it is possible for
2434 an interface to have a netmask of 0.0.0.0 */
2435 found_interface = 1;
2442 if (!found_interface) return 0;
2444 strlcpy(name, bestifreq.ifr_name, namelen);
2446 /* trim off the :1 in eth0:1 */
2447 aliasp = strchr(name, ':');
2451 info("found interface %s for proxy arp", name);
2453 * Now get the hardware address.
2455 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2456 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2457 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2462 &bestifreq.ifr_hwaddr,
2463 sizeof (struct sockaddr));
2469 * get_if_hwaddr - get the hardware address for the specified
2470 * network interface device.
2473 get_if_hwaddr(u_char *addr, char *name)
2478 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2481 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2482 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2483 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2486 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2491 * get_first_ether_hwaddr - get the hardware address for the first
2492 * ethernet-style interface on this system.
2495 get_first_ether_hwaddr(u_char *addr)
2497 struct if_nameindex *if_ni, *i;
2501 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2505 if_ni = if_nameindex();
2513 for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2514 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2515 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2516 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2517 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2518 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2524 if_freenameindex(if_ni);
2530 /********************************************************************
2532 * Return user specified netmask, modified by any mask we might determine
2533 * for address `addr' (in network byte order).
2534 * Here we scan through the system's list of interfaces, looking for
2535 * any non-point-to-point interfaces which might appear to be on the same
2536 * network as `addr'. If we find any, we OR in their netmask to the
2537 * user-specified netmask.
2540 u_int32_t GetMask (u_int32_t addr)
2542 u_int32_t mask, nmask, ina;
2543 struct ifreq *ifr, *ifend, ifreq;
2545 struct ifreq ifs[MAX_IFS];
2549 if (IN_CLASSA(addr)) /* determine network mask for address class */
2550 nmask = IN_CLASSA_NET;
2551 else if (IN_CLASSB(addr))
2552 nmask = IN_CLASSB_NET;
2554 nmask = IN_CLASSC_NET;
2556 /* class D nets are disallowed by bad_ip_adrs */
2557 mask = netmask | htonl(nmask);
2559 * Scan through the system's network interfaces.
2561 ifc.ifc_len = sizeof(ifs);
2563 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2564 if ( ! ok_error ( errno ))
2565 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2569 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2570 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2572 * Check the interface's internet address.
2574 if (ifr->ifr_addr.sa_family != AF_INET)
2576 ina = SIN_ADDR(ifr->ifr_addr);
2577 if (((ntohl(ina) ^ addr) & nmask) != 0)
2580 * Check that the interface is up, and not point-to-point nor loopback.
2582 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2583 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2586 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2589 * Get its netmask and OR it into our mask.
2591 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2593 mask |= SIN_ADDR(ifreq.ifr_addr);
2599 /********************************************************************
2601 * Internal routine to decode the version.modification.patch level
2604 static void decode_version (char *buf, int *version,
2605 int *modification, int *patch)
2609 *version = (int) strtoul (buf, &endp, 10);
2613 if (endp != buf && *endp == '.') {
2615 *modification = (int) strtoul (buf, &endp, 10);
2616 if (endp != buf && *endp == '.') {
2618 *patch = (int) strtoul (buf, &buf, 10);
2623 /********************************************************************
2625 * Procedure to determine if the PPP line discipline is registered.
2629 ppp_registered(void)
2637 * We used to open the serial device and set it to the ppp line
2638 * discipline here, in order to create a ppp unit. But that is
2639 * not a good idea - the user might have specified a device that
2640 * they can't open (permission, or maybe it doesn't really exist).
2641 * So we grab a pty master/slave pair and use that.
2643 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2644 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2649 * Try to put the device into the PPP discipline.
2651 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2652 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2661 /********************************************************************
2663 * ppp_available - check whether the system has any ppp interfaces
2664 * (in fact we check whether we can do an ioctl on ppp0).
2667 int ppp_available(void)
2672 int my_version, my_modification, my_patch;
2673 int osmaj, osmin, ospatch;
2675 /* get the kernel version now, since we are called before sys_init */
2677 osmaj = osmin = ospatch = 0;
2678 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2679 kernel_version = KVERSION(osmaj, osmin, ospatch);
2681 fd = open("/dev/ppp", O_RDWR);
2683 new_style_driver = 1;
2685 /* XXX should get from driver */
2687 driver_modification = 4;
2693 if (kernel_version >= KVERSION(2,3,13)) {
2694 error("Couldn't open the /dev/ppp device: %m");
2695 if (errno == ENOENT)
2697 "You need to create the /dev/ppp device node by\n"
2698 "executing the following command as root:\n"
2699 " mknod /dev/ppp c 108 0\n";
2700 else if (errno == ENODEV || errno == ENXIO)
2702 "Please load the ppp_generic kernel module.\n";
2706 /* we are running on a really really old kernel */
2708 "This system lacks kernel support for PPP. This could be because\n"
2709 "the PPP kernel module could not be loaded, or because PPP was not\n"
2710 "included in the kernel configuration. If PPP was included as a\n"
2711 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2712 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2713 "See README.linux file in the ppp distribution for more details.\n";
2716 * Open a socket for doing the ioctl operations.
2718 s = socket(AF_INET, SOCK_DGRAM, 0);
2722 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2723 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2725 * If the device did not exist then attempt to create one by putting the
2726 * current tty into the PPP discipline. If this works then obtain the
2727 * flags for the device again.
2730 if (ppp_registered()) {
2731 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2732 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2736 * Ensure that the hardware address is for PPP and not something else
2739 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2741 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2745 * This is the PPP device. Validate the version of the driver at this
2746 * point to ensure that this program will work with the driver.
2749 char abBuffer [1024];
2751 ifr.ifr_data = abBuffer;
2752 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2754 error("Couldn't read driver version: %m");
2756 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2759 decode_version(abBuffer,
2761 &driver_modification,
2764 * Validate the version of the driver against the version that we used.
2766 decode_version(VERSION,
2771 /* The version numbers must match */
2772 if (driver_version != my_version)
2775 /* The modification levels must be legal */
2776 if (driver_modification < 3) {
2777 if (driver_modification >= 2) {
2778 /* we can cope with 2.2.0 and above */
2786 slprintf(route_buffer, sizeof(route_buffer),
2787 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2788 driver_version, driver_modification, driver_patch);
2790 no_ppp_msg = route_buffer;
2798 #ifndef HAVE_LOGWTMP
2799 /********************************************************************
2801 * Update the wtmp file with the appropriate user name and tty device.
2804 void logwtmp (const char *line, const char *name, const char *host)
2806 struct utmp ut, *utp;
2807 pid_t mypid = getpid();
2813 * Update the signon database for users.
2814 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2816 utmpname(_PATH_UTMP);
2818 while ((utp = getutent()) && (utp->ut_pid != mypid))
2822 memcpy(&ut, utp, sizeof(ut));
2824 /* some gettys/telnetds don't initialize utmp... */
2825 memset(&ut, 0, sizeof(ut));
2827 if (ut.ut_id[0] == 0)
2828 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2830 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2831 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2835 ut.ut_type = USER_PROCESS;
2838 /* Insert the host name if one is supplied */
2840 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2842 /* Insert the IP address of the remote system if IP is enabled */
2843 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2844 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2845 sizeof(ut.ut_addr));
2847 /* CL: Makes sure that the logout works */
2848 if (*host == 0 && *name==0)
2854 * Update the wtmp file.
2857 updwtmp(_PATH_WTMP, &ut);
2859 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2861 flock(wtmp, LOCK_EX);
2863 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2864 warn("error writing %s: %m", _PATH_WTMP);
2866 flock(wtmp, LOCK_UN);
2872 #endif /* HAVE_LOGWTMP */
2874 /********************************************************************
2876 * sifvjcomp - config tcp header compression
2879 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2884 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2885 error("Couldn't set up TCP header compression: %m");
2890 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2891 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2896 /********************************************************************
2898 * sifup - Config the interface up and enable IP packets to pass.
2905 if ((ret = setifstate(u, 1)))
2911 /********************************************************************
2913 * sifdown - Disable the indicated protocol and config the interface
2914 * down if there are no remaining protocols.
2919 if (if_is_up && --if_is_up > 0)
2927 return setifstate(u, 0);
2931 /********************************************************************
2933 * sif6up - Config the interface up for IPv6
2940 if ((ret = setifstate(u, 1)))
2946 /********************************************************************
2948 * sif6down - Disable the IPv6CP protocol and config the interface
2949 * down if there are no remaining protocols.
2952 int sif6down (int u)
2959 return setifstate(u, 0);
2963 /********************************************************************
2965 * setifstate - Config the interface up or down
2968 static int setifstate (int u, int state)
2972 memset (&ifr, '\0', sizeof (ifr));
2973 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2974 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2975 if (! ok_error (errno))
2976 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2981 ifr.ifr_flags |= IFF_UP;
2983 ifr.ifr_flags &= ~IFF_UP;
2984 ifr.ifr_flags |= IFF_POINTOPOINT;
2985 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2986 if (! ok_error (errno))
2987 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2993 /********************************************************************
2995 * sifaddr - Config the interface IP addresses and netmask.
2998 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
3004 memset (&ifr, '\0', sizeof (ifr));
3005 memset (&rt, '\0', sizeof (rt));
3007 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
3008 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
3009 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
3011 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
3013 * Set our IP address
3015 SIN_ADDR(ifr.ifr_addr) = our_adr;
3016 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3017 if (errno != EEXIST) {
3018 if (! ok_error (errno))
3019 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3022 warn("ioctl(SIOCSIFADDR): Address already exists");
3027 * Set the gateway address
3030 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
3031 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
3032 if (! ok_error (errno))
3033 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
3039 * For recent kernels, force the netmask to 255.255.255.255.
3041 if (kernel_version >= KVERSION(2,1,16))
3043 if (net_mask != 0) {
3044 SIN_ADDR(ifr.ifr_netmask) = net_mask;
3045 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
3046 if (! ok_error (errno))
3047 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
3052 * Add the device route
3054 if (kernel_version < KVERSION(2,1,16)) {
3055 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3056 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3059 SIN_ADDR(rt.rt_gateway) = 0L;
3060 SIN_ADDR(rt.rt_dst) = his_adr;
3061 rt.rt_flags = RTF_UP | RTF_HOST;
3063 if (kernel_version > KVERSION(2,1,0)) {
3064 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3065 SIN_ADDR(rt.rt_genmask) = -1L;
3068 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
3069 if (! ok_error (errno))
3070 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
3075 /* set ip_dynaddr in demand mode if address changes */
3076 if (demand && tune_kernel && !dynaddr_set
3077 && our_old_addr && our_old_addr != our_adr) {
3078 /* set ip_dynaddr if possible */
3082 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
3083 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
3084 if (write(fd, "1", 1) != 1)
3085 error("Couldn't enable dynamic IP addressing: %m");
3088 dynaddr_set = 1; /* only 1 attempt */
3095 /********************************************************************
3097 * cifaddr - Clear the interface IP addresses, and delete routes
3098 * through the interface if possible.
3101 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
3105 if (kernel_version < KVERSION(2,1,16)) {
3107 * Delete the route through the device
3110 memset (&rt, '\0', sizeof (rt));
3112 SET_SA_FAMILY (rt.rt_dst, AF_INET);
3113 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
3116 SIN_ADDR(rt.rt_gateway) = 0;
3117 SIN_ADDR(rt.rt_dst) = his_adr;
3118 rt.rt_flags = RTF_UP | RTF_HOST;
3120 if (kernel_version > KVERSION(2,1,0)) {
3121 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
3122 SIN_ADDR(rt.rt_genmask) = -1L;
3125 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
3126 if (still_ppp() && ! ok_error (errno))
3127 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
3132 /* This way it is possible to have an IPv6-only interface */
3133 memset(&ifr, 0, sizeof(ifr));
3134 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
3135 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3137 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3138 if (! ok_error (errno)) {
3139 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3144 our_old_addr = our_adr;
3150 /********************************************************************
3152 * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
3154 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
3157 struct nlmsghdr nlh;
3158 struct ifaddrmsg ifa;
3161 struct in6_addr addr;
3165 struct nlmsghdr nlh;
3166 struct nlmsgerr nlerr;
3168 struct sockaddr_nl nladdr;
3175 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
3177 error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
3182 * Tell kernel to not send to us payload of acknowledgment error message.
3183 * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
3184 * older kernel versions always send full payload in acknowledgment netlink
3185 * message. We ignore payload of this message as we need only error code,
3186 * to check if our set remote peer address request succeeded or failed.
3187 * So ignore return value from the following setsockopt() call as setting
3188 * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
3191 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
3193 memset(&nladdr, 0, sizeof(nladdr));
3194 nladdr.nl_family = AF_NETLINK;
3196 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
3197 error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
3202 memset(&nlreq, 0, sizeof(nlreq));
3203 nlreq.nlh.nlmsg_len = sizeof(nlreq);
3204 nlreq.nlh.nlmsg_type = RTM_NEWADDR;
3205 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
3206 nlreq.ifa.ifa_family = AF_INET6;
3207 nlreq.ifa.ifa_prefixlen = 128;
3208 nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
3209 nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
3210 nlreq.ifa.ifa_index = iface;
3211 nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
3212 nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
3213 IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
3214 nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
3215 nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
3218 * To set only local address, older kernel expects that local address is
3219 * in IFA_ADDRESS field (not IFA_LOCAL). New kernels with support for peer
3220 * address, ignore IFA_ADDRESS if is same as IFA_LOCAL. So for backward
3221 * compatibility when setting only local address, set it via both IFA_LOCAL
3222 * and IFA_ADDRESS fields. Same logic is implemented in 'ip address' command
3223 * from iproute2 project.
3225 if (!eui64_iszero(his_eui64))
3226 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
3228 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, our_eui64);
3230 memset(&nladdr, 0, sizeof(nladdr));
3231 nladdr.nl_family = AF_NETLINK;
3233 memset(&iov, 0, sizeof(iov));
3234 iov.iov_base = &nlreq;
3235 iov.iov_len = sizeof(nlreq);
3237 memset(&msg, 0, sizeof(msg));
3238 msg.msg_name = &nladdr;
3239 msg.msg_namelen = sizeof(nladdr);
3243 if (sendmsg(fd, &msg, 0) < 0) {
3244 error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
3249 memset(&iov, 0, sizeof(iov));
3250 iov.iov_base = &nlresp;
3251 iov.iov_len = sizeof(nlresp);
3253 memset(&msg, 0, sizeof(msg));
3254 msg.msg_name = &nladdr;
3255 msg.msg_namelen = sizeof(nladdr);
3259 nlresplen = recvmsg(fd, &msg, 0);
3261 if (nlresplen < 0) {
3262 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
3269 if (nladdr.nl_family != AF_NETLINK) {
3270 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
3274 if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
3275 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
3279 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
3280 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
3281 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
3285 /* error == 0 indicates success, negative value is errno code */
3286 if (nlresp.nlerr.error != 0) {
3288 * Linux kernel versions prior 3.11 do not support setting IPv6 peer
3289 * addresses and error response is expected. On older kernel versions
3290 * do not show this error message. On error pppd tries to fallback to
3291 * the old IOCTL method.
3293 if (kernel_version >= KVERSION(3,11,0))
3294 error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
3301 /********************************************************************
3303 * sif6addr - Config the interface with an IPv6 link-local address
3305 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3307 struct in6_ifreq ifr6;
3309 struct in6_rtmsg rt6;
3314 error("IPv6 socket creation failed: %m");
3317 memset(&ifr, 0, sizeof (ifr));
3318 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3319 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3320 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3324 if (kernel_version >= KVERSION(2,1,16)) {
3325 /* Set both local address and remote peer address (with route for it) via rtnetlink */
3326 ret = sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
3332 * Linux kernel versions prior 3.11 do not support setting IPv6 peer address
3333 * via rtnetlink. So if sif6addr_rtnetlink() fails then try old IOCTL method.
3336 /* Local interface */
3337 memset(&ifr6, 0, sizeof(ifr6));
3338 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3339 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3340 ifr6.ifr6_prefixlen = 128;
3342 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3343 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3348 if (!ret && !eui64_iszero(his_eui64)) {
3350 * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3351 * setting remote peer host address, so set only route to remote host.
3354 /* Route to remote host */
3355 memset(&rt6, 0, sizeof(rt6));
3356 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3357 rt6.rtmsg_flags = RTF_UP;
3358 rt6.rtmsg_dst_len = 128;
3359 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3360 rt6.rtmsg_metric = 1;
3362 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3363 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3372 /********************************************************************
3374 * cif6addr - Remove IPv6 address from interface
3376 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3379 struct in6_ifreq ifr6;
3383 error("IPv6 socket creation failed: %m");
3386 memset(&ifr, 0, sizeof(ifr));
3387 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3388 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3389 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3393 memset(&ifr6, 0, sizeof(ifr6));
3394 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3395 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3396 ifr6.ifr6_prefixlen = 128;
3398 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3399 if (errno != EADDRNOTAVAIL) {
3400 if (! ok_error (errno))
3401 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3404 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3413 * get_pty - get a pty master/slave pair and chown the slave side
3414 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
3417 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3419 int i, mfd, ret, sfd = -1;
3421 struct termios tios;
3425 * Try the unix98 way first.
3427 mfd = open("/dev/ptmx", O_RDWR);
3430 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3431 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3432 chmod(pty_name, S_IRUSR | S_IWUSR);
3435 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3436 warn("Couldn't unlock pty slave %s: %m", pty_name);
3438 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3440 warn("Couldn't open pty slave %s: %m", pty_name);
3445 #endif /* TIOCGPTN */
3448 /* the old way - scan through the pty name space */
3449 for (i = 0; i < 64; ++i) {
3450 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3451 'p' + i / 16, i % 16);
3452 mfd = open(pty_name, O_RDWR, 0);
3455 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3457 ret = fchown(sfd, uid, -1);
3459 warn("Couldn't change ownership of %s, %m", pty_name);
3461 ret = fchmod(sfd, S_IRUSR | S_IWUSR);
3463 warn("Couldn't change permissions of %s, %m", pty_name);
3475 strlcpy(slave_name, pty_name, 16);
3478 if (tcgetattr(sfd, &tios) == 0) {
3479 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3480 tios.c_cflag |= CS8 | CREAD | CLOCAL;
3481 tios.c_iflag = IGNPAR;
3484 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3485 warn("couldn't set attributes on pty: %m");
3487 warn("couldn't get attributes on pty: %m");
3492 /********************************************************************
3494 * open_loopback - open the device we use for getting packets
3495 * in demand mode. Under Linux, we use a pty master/slave pair.
3498 open_ppp_loopback(void)
3503 if (new_style_driver) {
3504 /* allocate ourselves a ppp unit */
3505 if (make_ppp_unit() < 0)
3507 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3508 set_kdebugflag(kdebugflag);
3513 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3514 fatal("No free pty for loopback");
3516 set_ppp_fd(slave_fd);
3518 flags = fcntl(master_fd, F_GETFL);
3520 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3521 warn("couldn't set master loopback to nonblock: %m");
3523 flags = fcntl(ppp_fd, F_GETFL);
3525 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3526 warn("couldn't set slave loopback to nonblock: %m");
3528 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3529 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3531 * Find out which interface we were given.
3533 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3534 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3536 * Enable debug in the driver if requested.
3538 set_kdebugflag (kdebugflag);
3543 /********************************************************************
3545 * sifnpmode - Set the mode for handling packets for a given NP.
3549 sifnpmode(int u, int proto, enum NPmode mode)
3553 npi.protocol = proto;
3555 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3556 if (! ok_error (errno))
3557 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3564 * Use the hostname as part of the random number seed.
3573 for (p = hostname; *p != 0; ++p)
3578 /********************************************************************
3580 * sys_check_options - check the options that the user specified
3584 sys_check_options(void)
3586 if (demand && driver_is_old) {
3587 option_error("demand dialling is not supported by kernel driver "
3588 "version %d.%d.%d", driver_version, driver_modification,
3592 if (multilink && !new_style_driver) {
3593 warn("Warning: multilink is not supported by the kernel driver");
3599 /********************************************************************
3601 * get_time - Get current time, monotonic if possible.
3604 get_time(struct timeval *tv)
3606 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3607 * Runtime checking makes it safe. */
3608 #ifndef CLOCK_MONOTONIC
3609 #define CLOCK_MONOTONIC 1
3611 static int monotonic = -1;
3616 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3620 tv->tv_sec = ts.tv_sec;
3621 tv->tv_usec = ts.tv_nsec / 1000;
3624 } else if (monotonic > 0)
3628 warn("Couldn't use monotonic clock source: %m");
3631 return gettimeofday(tv, NULL);