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>
101 /* This is in netdevice.h. However, this compile will fail miserably if
102 you attempt to include netdevice.h because it has so many references
103 to __memcpy functions which it should not attempt to do. So, since I
104 really don't use it, but it must be defined, define it now. */
107 #define MAX_ADDR_LEN 7
110 #if !defined(__GLIBC__) || __GLIBC__ >= 2
111 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
113 #include <net/if_arp.h>
114 #include <net/route.h>
115 #include <netinet/if_ether.h>
117 #include <linux/types.h>
118 #include <linux/if.h>
119 #include <linux/if_arp.h>
120 #include <linux/route.h>
121 #include <linux/if_ether.h>
123 #include <netinet/in.h>
124 #include <arpa/inet.h>
126 #include <linux/ppp_defs.h>
127 #include <linux/if_ppp.h>
130 #include <linux/netlink.h>
131 #include <linux/rtnetlink.h>
132 #include <linux/if_addr.h>
133 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
135 #define SOL_NETLINK 270
137 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
138 #ifndef NETLINK_CAP_ACK
139 #define NETLINK_CAP_ACK 10
149 #if __GLIBC__ >= 2 && \
150 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
151 #include <netipx/ipx.h>
153 #include <linux/ipx.h>
155 #endif /* IPX_CHANGE */
158 #include <pcap-bpf.h>
159 #include <linux/filter.h>
160 #endif /* PPP_FILTER */
163 #include <sys/locks.h>
167 * Instead of system header file <termios.h> use local "termios_linux.h" header
168 * file as it provides additional support for arbitrary baud rates via BOTHER.
170 #include "termios_linux.h"
175 * This is in linux/include/net/ipv6.h.
179 struct in6_addr ifr6_addr;
180 __u32 ifr6_prefixlen;
181 unsigned int ifr6_ifindex;
185 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
186 memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr)); \
187 (sin6).s6_addr16[0] = htons(0xfe80); \
188 eui64_copy(eui64, (sin6).s6_addr32[2]); \
191 static const eui64_t nulleui64;
194 /* We can get an EIO error on an ioctl if the modem has hung up */
195 #define ok_error(num) ((num)==EIO)
197 static int tty_disc = N_TTY; /* The TTY discipline */
198 static int ppp_disc = N_PPP; /* The PPP discpline */
199 static int initfdflags = -1; /* Initial file descriptor flags for fd */
200 static int ppp_fd = -1; /* fd which is set to PPP discipline */
201 static int sock_fd = -1; /* socket for doing interface ioctls */
202 static int slave_fd = -1; /* pty for old-style demand mode, slave */
203 static int master_fd = -1; /* pty for old-style demand mode, master */
205 static int sock6_fd = -1;
209 * For the old-style kernel driver, this is the same as ppp_fd.
210 * For the new-style driver, it is the fd of an instance of /dev/ppp
211 * which is attached to the ppp unit and is used for controlling it.
213 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
215 static int chindex; /* channel index (new style driver) */
217 static fd_set in_fds; /* set of fds that wait_input waits for */
218 static int max_in_fd; /* highest fd set in in_fds */
220 static int has_proxy_arp = 0;
221 static int driver_version = 0;
222 static int driver_modification = 0;
223 static int driver_patch = 0;
224 static int driver_is_old = 0;
225 static int restore_term = 0; /* 1 => we've munged the terminal */
226 static struct termios inittermios; /* Initial TTY termios */
228 int new_style_driver = 0;
230 static char loop_name[20];
231 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
233 static int if_is_up; /* Interface has been marked up */
234 static int if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
235 static int have_default_route; /* Gateway for default route added */
236 static int have_default_route6; /* Gateway for default IPv6 route added */
237 static struct rtentry old_def_rt; /* Old default route */
238 static int default_rt_repl_rest; /* replace and restore old default rt */
239 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
240 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
241 static u_int32_t our_old_addr; /* for detecting address changes */
242 static int dynaddr_set; /* 1 if ip_dynaddr set */
243 static int looped; /* 1 if using loop */
244 static int link_mtu; /* mtu for the link (not bundle) */
246 static struct utsname utsname; /* for the kernel version */
247 static int kernel_version;
248 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
252 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
253 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
254 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
256 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
258 /* Prototypes for procedures local to this file. */
259 static int modify_flags(int fd, int clear_bits, int set_bits);
260 static int translate_speed (int bps);
261 static int baud_rate_of (int speed);
262 static void close_route_table (void);
263 static int open_route_table (void);
264 static int read_route_table (struct rtentry *rt);
265 static int defaultroute_exists (struct rtentry *rt, int metric);
266 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
267 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
268 char *name, int namelen);
269 static void decode_version (char *buf, int *version, int *mod, int *patch);
270 static int set_kdebugflag(int level);
271 static int ppp_registered(void);
272 static int make_ppp_unit(void);
273 static int setifstate (int u, int state);
275 extern u_char inpacket_buf[]; /* borrowed from main.c */
277 extern int dfl_route_metric;
280 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
284 #define SET_SA_FAMILY(addr, family) \
285 memset ((char *) &(addr), '\0', sizeof(addr)); \
286 addr.sa_family = (family);
289 * Determine if the PPP connection should still be present.
294 /* new_fd is the fd of a tty */
295 static void set_ppp_fd (int new_fd)
298 if (!new_style_driver)
302 static int still_ppp(void)
304 if (new_style_driver)
305 return !hungup && ppp_fd >= 0;
306 if (!hungup || ppp_fd == slave_fd)
309 set_ppp_fd(slave_fd);
316 * modify_flags - set and clear flag bits controlling the kernel
319 static int modify_flags(int fd, int clear_bits, int set_bits)
323 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
325 flags = (flags & ~clear_bits) | set_bits;
326 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
333 error("Failed to set PPP kernel option flags: %m");
337 /********************************************************************
339 * sys_init - System-dependent initialization.
344 /* Get an internet socket for doing socket ioctls. */
345 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
347 fatal("Couldn't create IP socket: %m(%d)", errno);
350 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
352 sock6_fd = -errno; /* save errno for later */
359 /********************************************************************
361 * sys_cleanup - restore any system state we modified before exiting:
362 * mark the interface down, delete default route and/or proxy arp entry.
363 * This shouldn't call die() because it's called from die().
366 void sys_cleanup(void)
369 * Take down the device
379 * Delete any routes through the device.
381 if (have_default_route)
382 cifdefaultroute(0, 0, 0);
384 if (have_default_route6)
385 cif6defaultroute(0, nulleui64, nulleui64);
389 cifproxyarp(0, proxy_arp_addr);
392 /********************************************************************
394 * sys_close - Clean up in a child process before execing.
399 if (new_style_driver && ppp_dev_fd >= 0)
413 /********************************************************************
415 * set_kdebugflag - Define the debugging level for the kernel
418 static int set_kdebugflag (int requested_level)
422 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
423 if ( ! ok_error (errno) )
424 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
430 /********************************************************************
432 * tty_establish_ppp - Turn the serial port into a ppp interface.
435 int tty_establish_ppp (int tty_fd)
440 * Ensure that the tty device is in exclusive mode.
442 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
443 if ( ! ok_error ( errno ))
444 warn("Couldn't make tty exclusive: %m");
447 * Demand mode - prime the old ppp device to relinquish the unit.
449 if (!new_style_driver && looped
450 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
451 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
455 * Set the current tty to the PPP discpline
459 #define N_SYNC_PPP 14
461 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
462 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
463 if ( ! ok_error (errno) ) {
464 error("Couldn't set tty to PPP discipline: %m");
469 ret_fd = generic_establish_ppp(tty_fd);
471 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
472 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
476 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
477 (kdebugflag * SC_DEBUG) & SC_LOGB);
479 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
480 warn("Couldn't reset tty to normal line discipline: %m");
486 /********************************************************************
488 * generic_establish_ppp - Turn the fd into a ppp interface.
490 int generic_establish_ppp (int fd)
494 if (new_style_driver) {
497 /* If a ppp_fd is already open, close it first */
504 /* Open an instance of /dev/ppp and connect the channel to it */
505 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
506 error("Couldn't get channel number: %m");
509 dbglog("using channel %d", chindex);
510 fd = open("/dev/ppp", O_RDWR);
512 error("Couldn't reopen /dev/ppp: %m");
515 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
516 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
517 error("Couldn't attach to channel %d: %m", chindex);
520 flags = fcntl(fd, F_GETFL);
521 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
522 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
527 if (!looped && !multilink) {
529 * Create a new PPP unit.
531 if (make_ppp_unit() < 0)
536 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
540 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
541 error("Couldn't attach to PPP unit %d: %m", ifunit);
548 * Old-style driver: find out which interface we were given.
551 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
552 if (ok_error (errno))
554 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
556 /* Check that we got the same unit again. */
557 if (looped && x != ifunit)
558 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
562 * Fetch the initial file flags and reset blocking mode on the file.
564 initfdflags = fcntl(fd, F_GETFL);
565 if (initfdflags == -1 ||
566 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
567 if ( ! ok_error (errno))
568 warn("Couldn't set device to non-blocking mode: %m");
573 * Enable debug in the driver if requested.
576 set_kdebugflag (kdebugflag);
588 /********************************************************************
590 * tty_disestablish_ppp - Restore the serial port to normal operation.
591 * This shouldn't call die() because it's called from die().
594 void tty_disestablish_ppp(int tty_fd)
598 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
600 if (tcflush(tty_fd, TCIOFLUSH) < 0)
602 warn("tcflush failed: %m");
606 * Restore the previous line discipline
608 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
609 if ( ! ok_error (errno))
610 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
613 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
614 if ( ! ok_error (errno))
615 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
618 /* Reset non-blocking mode on fd. */
619 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
620 if ( ! ok_error (errno))
621 warn("Couldn't restore device fd flags: %m");
627 generic_disestablish_ppp(tty_fd);
630 /********************************************************************
632 * generic_disestablish_ppp - Restore device components to normal
633 * operation, and reconnect the ppp unit to the loopback if in demand
634 * mode. This shouldn't call die() because it's called from die().
636 void generic_disestablish_ppp(int dev_fd)
638 if (new_style_driver) {
642 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
644 } else if (!doing_multilink && ppp_dev_fd >= 0) {
646 remove_fd(ppp_dev_fd);
650 /* old-style driver */
652 set_ppp_fd(slave_fd);
659 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
660 * Assumes new_style_driver.
662 static int make_ppp_unit(void)
666 if (ppp_dev_fd >= 0) {
667 dbglog("in make_ppp_unit, already had /dev/ppp open?");
670 ppp_dev_fd = open("/dev/ppp", O_RDWR);
672 fatal("Couldn't open /dev/ppp: %m");
673 flags = fcntl(ppp_dev_fd, F_GETFL);
675 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
676 warn("Couldn't set /dev/ppp to nonblock: %m");
679 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
680 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
681 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
683 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
686 error("Couldn't create new ppp unit: %m");
688 if (x == 0 && req_ifname[0] != '\0') {
691 memset(&ifr, 0, sizeof(struct ifreq));
692 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
693 strlcpy(ifr.ifr_name, t, IFNAMSIZ);
694 strlcpy(ifr.ifr_newname, req_ifname, IFNAMSIZ);
695 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
697 error("Couldn't rename interface %s to %s: %m", t, req_ifname);
699 info("Renamed interface %s to %s", t, req_ifname);
706 * cfg_bundle - configure the existing bundle.
707 * Used in demand mode.
709 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
711 if (!new_style_driver)
714 /* set the mrru, mtu and flags */
715 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
716 error("Couldn't set MRRU: %m");
718 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
719 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
720 | (mrru? SC_MULTILINK: 0)));
722 /* connect up the channel */
723 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
724 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
729 * make_new_bundle - create a new PPP unit (i.e. a bundle)
730 * and connect our channel to it. This should only get called
731 * if `multilink' was set at the time establish_ppp was called.
732 * In demand mode this uses our existing bundle instead of making
735 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
737 if (!new_style_driver)
740 /* make us a ppp unit */
741 if (make_ppp_unit() < 0)
744 /* set the mrru and flags */
745 cfg_bundle(mrru, mtru, rssn, tssn);
749 * bundle_attach - attach our link to a given PPP unit.
750 * We assume the unit is controlled by another pppd.
752 int bundle_attach(int ifnum)
756 if (!new_style_driver)
759 master_fd = open("/dev/ppp", O_RDWR);
761 fatal("Couldn't open /dev/ppp: %m");
762 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
763 if (errno == ENXIO) {
765 return 0; /* doesn't still exist */
767 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
769 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
770 fatal("Couldn't connect to interface unit %d: %m", ifnum);
771 modify_flags(master_fd, 0, SC_MULTILINK);
779 * destroy_bundle - tell the driver to destroy our bundle.
781 void destroy_bundle(void)
783 if (ppp_dev_fd >= 0) {
785 remove_fd(ppp_dev_fd);
790 /********************************************************************
792 * clean_check - Fetch the flags for the device and generate
793 * appropriate error messages.
795 void clean_check(void)
801 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
803 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
805 s = "all had bit 7 set to 1";
809 s = "all had bit 7 set to 0";
813 s = "all had odd parity";
817 s = "all had even parity";
822 warn("Receive serial link is not 8-bit clean:");
823 warn("Problem: %s", s);
831 * List of valid speeds.
835 int speed_int, speed_val;
922 { 1000000, B1000000 },
925 { 1152000, B1152000 },
928 { 1500000, B1500000 },
931 { 2000000, B2000000 },
934 { 2500000, B2500000 },
937 { 3000000, B3000000 },
940 { 3500000, B3500000 },
943 { 4000000, B4000000 },
948 /********************************************************************
950 * Translate from bits/second to a speed_t.
953 static int translate_speed (int bps)
955 struct speed *speedp;
958 for (speedp = speeds; speedp->speed_int; speedp++) {
959 if (bps == speedp->speed_int)
960 return speedp->speed_val;
966 /********************************************************************
968 * Translate from a speed_t to bits/second.
971 static int baud_rate_of (int speed)
973 struct speed *speedp;
976 for (speedp = speeds; speedp->speed_int; speedp++) {
977 if (speed == speedp->speed_val)
978 return speedp->speed_int;
984 /********************************************************************
986 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
987 * at the requested speed, etc. If `local' is true, set CLOCAL
988 * regardless of whether the modem option was specified.
991 void set_up_tty(int tty_fd, int local)
997 if (tcgetattr(tty_fd, &tios) < 0) {
998 if (!ok_error(errno))
999 fatal("tcgetattr: %m (line %d)", __LINE__);
1006 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1007 tios.c_cflag |= CS8 | CREAD | HUPCL;
1009 tios.c_iflag = IGNBRK | IGNPAR;
1012 tios.c_cc[VMIN] = 1;
1013 tios.c_cc[VTIME] = 0;
1015 if (local || !modem)
1016 tios.c_cflag ^= (CLOCAL | HUPCL);
1020 tios.c_cflag |= CRTSCTS;
1024 tios.c_iflag |= IXON | IXOFF;
1025 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
1026 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
1030 tios.c_cflag &= ~CRTSCTS;
1038 tios.c_cflag |= CSTOPB;
1041 speed = translate_speed(inspeed);
1043 cfsetospeed (&tios, speed);
1044 cfsetispeed (&tios, speed);
1045 speed = cfgetospeed(&tios);
1046 baud_rate = baud_rate_of(speed);
1049 tios.c_cflag &= ~CBAUD;
1050 tios.c_cflag |= BOTHER;
1051 tios.c_ospeed = inspeed;
1053 /* B0 sets input baudrate to the output baudrate */
1054 tios.c_cflag &= ~(CBAUD << IBSHIFT);
1055 tios.c_cflag |= B0 << IBSHIFT;
1056 tios.c_ispeed = inspeed;
1058 baud_rate = inspeed;
1065 speed = cfgetospeed(&tios);
1066 baud_rate = baud_rate_of(speed);
1069 baud_rate = tios.c_ospeed;
1074 * We can't proceed if the serial port baud rate is unknown,
1075 * since that implies that the serial port is disabled.
1079 fatal("speed %d not supported", inspeed);
1081 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1084 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1086 fatal("tcsetattr: %m (line %d)", __LINE__);
1090 /********************************************************************
1092 * setdtr - control the DTR line on the serial port.
1093 * This is called from die(), so it shouldn't call die().
1096 void setdtr (int tty_fd, int on)
1098 int modembits = TIOCM_DTR;
1100 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1103 /********************************************************************
1105 * restore_tty - restore the terminal to the saved settings.
1108 void restore_tty (int tty_fd)
1113 * Turn off echoing, because otherwise we can get into
1114 * a loop with the tty and the modem echoing to each other.
1115 * We presume we are the sole user of this tty device, so
1116 * when we close it, it will revert to its defaults anyway.
1118 if (!default_device)
1119 inittermios.c_lflag &= ~(ECHO | ECHONL);
1121 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1122 if (! ok_error (errno))
1123 warn("tcsetattr: %m (line %d)", __LINE__);
1128 /********************************************************************
1130 * output - Output PPP packet.
1133 void output (int unit, unsigned char *p, int len)
1138 dump_packet("sent", p, len);
1139 if (snoop_send_hook) snoop_send_hook(p, len);
1141 if (len < PPP_HDRLEN)
1143 if (new_style_driver) {
1146 proto = (p[0] << 8) + p[1];
1147 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1150 if (write(fd, p, len) < 0) {
1151 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1152 || errno == ENXIO || errno == EIO || errno == EINTR)
1153 warn("write: warning: %m (%d)", errno);
1155 error("write: %m (%d)", errno);
1159 /********************************************************************
1161 * wait_input - wait until there is data available,
1162 * for the length of time specified by *timo (indefinite
1166 void wait_input(struct timeval *timo)
1173 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1174 if (n < 0 && errno != EINTR)
1175 fatal("select: %m");
1179 * add_fd - add an fd to the set that wait_input waits for.
1183 if (fd >= FD_SETSIZE)
1184 fatal("internal error: file descriptor too large (%d)", fd);
1185 FD_SET(fd, &in_fds);
1191 * remove_fd - remove an fd from the set that wait_input waits for.
1193 void remove_fd(int fd)
1195 FD_CLR(fd, &in_fds);
1199 /********************************************************************
1201 * read_packet - get a PPP packet from the serial device.
1204 int read_packet (unsigned char *buf)
1208 len = PPP_MRU + PPP_HDRLEN;
1209 if (new_style_driver) {
1210 *buf++ = PPP_ALLSTATIONS;
1216 nr = read(ppp_fd, buf, len);
1217 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1218 && errno != EIO && errno != EINTR)
1220 if (nr < 0 && errno == ENXIO)
1223 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1224 /* N.B. we read ppp_fd first since LCP packets come in there. */
1225 nr = read(ppp_dev_fd, buf, len);
1226 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1227 && errno != EIO && errno != EINTR)
1228 error("read /dev/ppp: %m");
1229 if (nr < 0 && errno == ENXIO)
1231 if (nr == 0 && doing_multilink) {
1232 remove_fd(ppp_dev_fd);
1236 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1238 return (new_style_driver && nr > 0)? nr+2: nr;
1241 /********************************************************************
1243 * get_loop_output - get outgoing packets from the ppp device,
1244 * and detect when we want to bring the real link up.
1245 * Return value is 1 if we need to bring up the link, 0 otherwise.
1248 get_loop_output(void)
1253 if (new_style_driver) {
1254 while ((n = read_packet(inpacket_buf)) > 0)
1255 if (loop_frame(inpacket_buf, n))
1260 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1261 if (loop_chars(inbuf, n))
1265 fatal("eof on loopback");
1267 if (errno != EWOULDBLOCK && errno != EAGAIN)
1268 fatal("read from loopback: %m(%d)", errno);
1274 * netif_set_mtu - set the MTU on the PPP network interface.
1277 netif_set_mtu(int unit, int mtu)
1281 memset (&ifr, '\0', sizeof (ifr));
1282 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1285 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1286 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1290 * netif_get_mtu - get the MTU on the PPP network interface.
1293 netif_get_mtu(int unit)
1297 memset (&ifr, '\0', sizeof (ifr));
1298 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1300 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1301 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1307 /********************************************************************
1309 * tty_send_config - configure the transmit characteristics of
1310 * the ppp interface.
1313 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1320 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1321 if (errno != EIO && errno != ENOTTY)
1322 error("Couldn't set transmit async character map: %m");
1327 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1328 | (sync_serial? SC_SYNC: 0);
1329 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1332 /********************************************************************
1334 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1337 void tty_set_xaccm (ext_accm accm)
1341 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1342 if ( ! ok_error (errno))
1343 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1347 /********************************************************************
1349 * tty_recv_config - configure the receive-side characteristics of
1350 * the ppp interface.
1353 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1356 * If we were called because the link has gone down then there is nothing
1357 * which may be done. Just return without incident.
1362 * Set the receiver parameters
1364 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1365 if (errno != EIO && errno != ENOTTY)
1366 error("Couldn't set channel receive MRU: %m");
1368 if (new_style_driver && ppp_dev_fd >= 0
1369 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1370 error("Couldn't set MRU in generic PPP layer: %m");
1372 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1373 if (errno != EIO && errno != ENOTTY)
1374 error("Couldn't set channel receive asyncmap: %m");
1378 /********************************************************************
1380 * ccp_test - ask kernel whether a given compression method
1381 * is acceptable for use.
1385 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1387 struct ppp_option_data data;
1389 memset (&data, '\0', sizeof (data));
1391 data.length = opt_len;
1392 data.transmit = for_transmit;
1394 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1397 return (errno == ENOBUFS)? 0: -1;
1400 /********************************************************************
1402 * ccp_flags_set - inform kernel about the current state of CCP.
1405 void ccp_flags_set (int unit, int isopen, int isup)
1409 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1410 if (still_ppp() && ppp_dev_fd >= 0)
1411 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1416 * set_filters - set the active and pass filters in the kernel driver.
1418 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1420 struct sock_fprog fp;
1422 fp.len = pass->bf_len;
1423 fp.filter = (struct sock_filter *) pass->bf_insns;
1424 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1425 if (errno == ENOTTY)
1426 warn("kernel does not support PPP filtering");
1428 error("Couldn't set pass-filter in kernel: %m");
1431 fp.len = active->bf_len;
1432 fp.filter = (struct sock_filter *) active->bf_insns;
1433 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1434 error("Couldn't set active-filter in kernel: %m");
1439 #endif /* PPP_FILTER */
1441 /********************************************************************
1443 * get_idle_time - return how long the link has been idle.
1446 get_idle_time(int u, struct ppp_idle *ip)
1448 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1451 /********************************************************************
1453 * get_ppp_stats - return statistics for the link.
1456 get_ppp_stats(int u, struct pppd_stats *stats)
1458 struct ifpppstatsreq req;
1460 memset (&req, 0, sizeof (req));
1462 req.stats_ptr = (caddr_t) &req.stats;
1463 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1464 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1465 error("Couldn't get PPP statistics: %m");
1468 stats->bytes_in = req.stats.p.ppp_ibytes;
1469 stats->bytes_out = req.stats.p.ppp_obytes;
1470 stats->pkts_in = req.stats.p.ppp_ipackets;
1471 stats->pkts_out = req.stats.p.ppp_opackets;
1475 /********************************************************************
1477 * ccp_fatal_error - returns 1 if decompression was disabled as a
1478 * result of an error detected after decompression of a packet,
1479 * 0 otherwise. This is necessary because of patent nonsense.
1482 int ccp_fatal_error (int unit)
1486 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1487 error("Couldn't read compression error flags: %m");
1490 return flags & SC_DC_FERROR;
1493 /********************************************************************
1495 * path_to_procfs - find the path to the proc file system mount point
1497 static char proc_path[MAXPATHLEN];
1498 static int proc_path_len;
1500 static char *path_to_procfs(const char *tail)
1502 struct mntent *mntent;
1505 if (proc_path_len == 0) {
1506 /* Default the mount location of /proc */
1507 strlcpy (proc_path, "/proc", sizeof(proc_path));
1509 fp = fopen(MOUNTED, "r");
1511 while ((mntent = getmntent(fp)) != NULL) {
1512 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1514 if (strcmp(mntent->mnt_type, "proc") == 0) {
1515 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1516 proc_path_len = strlen(proc_path);
1524 strlcpy(proc_path + proc_path_len, tail,
1525 sizeof(proc_path) - proc_path_len);
1530 * /proc/net/route parsing stuff.
1532 #define ROUTE_MAX_COLS 12
1533 FILE *route_fd = (FILE *) 0;
1534 static char route_buffer[512];
1535 static int route_dev_col, route_dest_col, route_gw_col;
1536 static int route_flags_col, route_metric_col, route_mask_col;
1537 static int route_num_cols;
1539 static int open_route_table (void);
1540 static void close_route_table (void);
1541 static int read_route_table (struct rtentry *rt);
1543 /********************************************************************
1545 * close_route_table - close the interface to the route table
1548 static void close_route_table (void)
1550 if (route_fd != (FILE *) 0) {
1552 route_fd = (FILE *) 0;
1556 /********************************************************************
1558 * open_route_table - open the interface to the route table
1560 static char route_delims[] = " \t\n";
1562 static int open_route_table (void)
1566 close_route_table();
1568 path = path_to_procfs("/net/route");
1569 route_fd = fopen (path, "r");
1570 if (route_fd == NULL) {
1571 error("can't open routing table %s: %m", path);
1575 route_dev_col = 0; /* default to usual columns */
1578 route_flags_col = 3;
1579 route_metric_col = 6;
1583 /* parse header line */
1584 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1585 char *p = route_buffer, *q;
1587 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1589 if ((q = strtok(p, route_delims)) == 0)
1591 if (strcasecmp(q, "iface") == 0)
1592 route_dev_col = col;
1593 else if (strcasecmp(q, "destination") == 0)
1594 route_dest_col = col;
1595 else if (strcasecmp(q, "gateway") == 0)
1597 else if (strcasecmp(q, "flags") == 0)
1598 route_flags_col = col;
1599 else if (strcasecmp(q, "mask") == 0)
1600 route_mask_col = col;
1603 if (used && col >= route_num_cols)
1604 route_num_cols = col + 1;
1612 /********************************************************************
1614 * read_route_table - read the next entry from the route table
1617 static int read_route_table(struct rtentry *rt)
1619 char *cols[ROUTE_MAX_COLS], *p;
1622 memset (rt, '\0', sizeof (struct rtentry));
1624 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1628 for (col = 0; col < route_num_cols; ++col) {
1629 cols[col] = strtok(p, route_delims);
1630 if (cols[col] == NULL)
1631 return 0; /* didn't get enough columns */
1635 SET_SA_FAMILY (rt->rt_dst, AF_INET);
1636 SET_SA_FAMILY (rt->rt_gateway, AF_INET);
1638 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1639 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1640 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1642 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1643 rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
1644 rt->rt_dev = cols[route_dev_col];
1649 /********************************************************************
1651 * defaultroute_exists - determine if there is a default route
1652 * with the given metric (or negative for any)
1655 static int defaultroute_exists (struct rtentry *rt, int metric)
1659 if (!open_route_table())
1662 while (read_route_table(rt) != 0) {
1663 if ((rt->rt_flags & RTF_UP) == 0)
1666 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1668 if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
1669 || rt->rt_metric == metric)) {
1675 close_route_table();
1680 * have_route_to - determine if the system has any route to
1681 * a given IP address. `addr' is in network byte order.
1682 * Return value is 1 if yes, 0 if no, -1 if don't know.
1683 * For demand mode to work properly, we have to ignore routes
1684 * through our own interface.
1686 int have_route_to(u_int32_t addr)
1691 if (!open_route_table())
1692 return -1; /* don't know */
1694 while (read_route_table(&rt)) {
1695 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1697 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1703 close_route_table();
1707 /********************************************************************
1709 * sifdefaultroute - assign a default route through the address given.
1711 * If the global default_rt_repl_rest flag is set, then this function
1712 * already replaced the original system defaultroute with some other
1713 * route and it should just replace the current defaultroute with
1714 * another one, without saving the current route. Use: demand mode,
1715 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1716 * and then changes the temporary addresses to the addresses for the real
1717 * ppp connection when it has come up.
1720 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
1722 struct rtentry rt, tmp_rt;
1723 struct rtentry *del_rt = NULL;
1725 if (default_rt_repl_rest) {
1726 /* We have already replaced the original defaultroute, if we
1727 * are called again, we will delete the current default route
1728 * and set the new default route in this function.
1729 * - this is normally only the case the doing demand: */
1730 if (defaultroute_exists(&tmp_rt, -1))
1732 } else if (defaultroute_exists(&old_def_rt, -1 ) &&
1733 strcmp( old_def_rt.rt_dev, ifname) != 0) {
1735 * We did not yet replace an existing default route, let's
1736 * check if we should save and replace a default route:
1738 u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
1740 if (old_gateway != gateway) {
1742 error("not replacing default route to %s [%I]",
1743 old_def_rt.rt_dev, old_gateway);
1746 /* we need to copy rt_dev because we need it permanent too: */
1747 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
1748 strcpy(tmp_dev, old_def_rt.rt_dev);
1749 old_def_rt.rt_dev = tmp_dev;
1751 notice("replacing old default route to %s [%I]",
1752 old_def_rt.rt_dev, old_gateway);
1753 default_rt_repl_rest = 1;
1754 del_rt = &old_def_rt;
1759 memset (&rt, 0, sizeof (rt));
1760 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1763 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1765 if (kernel_version > KVERSION(2,1,0)) {
1766 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1767 SIN_ADDR(rt.rt_genmask) = 0L;
1770 rt.rt_flags = RTF_UP;
1771 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1772 if ( ! ok_error ( errno ))
1773 error("default route ioctl(SIOCADDRT): %m");
1776 if (default_rt_repl_rest && del_rt)
1777 if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
1778 if ( ! ok_error ( errno ))
1779 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
1783 have_default_route = 1;
1787 /********************************************************************
1789 * cifdefaultroute - delete a default route through the address given.
1792 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1796 have_default_route = 0;
1798 memset (&rt, '\0', sizeof (rt));
1799 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1800 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1805 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1807 if (kernel_version > KVERSION(2,1,0)) {
1808 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1809 SIN_ADDR(rt.rt_genmask) = 0L;
1812 rt.rt_flags = RTF_UP;
1813 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1815 if ( ! ok_error ( errno ))
1816 error("default route ioctl(SIOCDELRT): %m");
1820 if (default_rt_repl_rest) {
1821 notice("restoring old default route to %s [%I]",
1822 old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
1823 if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
1824 if ( ! ok_error ( errno ))
1825 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
1828 default_rt_repl_rest = 0;
1836 * /proc/net/ipv6_route parsing stuff.
1838 static int route_dest_plen_col;
1839 static int open_route6_table (void);
1840 static int read_route6_table (struct in6_rtmsg *rt);
1842 /********************************************************************
1844 * open_route6_table - open the interface to the route table
1846 static int open_route6_table (void)
1850 close_route_table();
1852 path = path_to_procfs("/net/ipv6_route");
1853 route_fd = fopen (path, "r");
1854 if (route_fd == NULL) {
1855 error("can't open routing table %s: %m", path);
1859 /* default to usual columns */
1861 route_dest_plen_col = 1;
1863 route_metric_col = 5;
1864 route_flags_col = 8;
1866 route_num_cols = 10;
1871 /********************************************************************
1873 * read_route6_table - read the next entry from the route table
1876 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
1883 for (i = 0; i < 4; i++) {
1884 memcpy(hex8, s + 8*i, 8);
1885 v = strtoul(hex8, NULL, 16);
1886 addr->s6_addr32[i] = v;
1890 static int read_route6_table(struct in6_rtmsg *rt)
1892 char *cols[ROUTE_MAX_COLS], *p;
1895 memset (rt, '\0', sizeof (struct in6_rtmsg));
1897 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1901 for (col = 0; col < route_num_cols; ++col) {
1902 cols[col] = strtok(p, route_delims);
1903 if (cols[col] == NULL)
1904 return 0; /* didn't get enough columns */
1908 hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
1909 rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
1910 hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
1912 rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
1913 rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
1914 rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
1919 /********************************************************************
1921 * defaultroute6_exists - determine if there is a default route
1924 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
1928 if (!open_route6_table())
1931 while (read_route6_table(rt) != 0) {
1932 if ((rt->rtmsg_flags & RTF_UP) == 0)
1935 if (rt->rtmsg_dst_len != 0)
1937 if (rt->rtmsg_dst.s6_addr32[0] == 0L
1938 && rt->rtmsg_dst.s6_addr32[1] == 0L
1939 && rt->rtmsg_dst.s6_addr32[2] == 0L
1940 && rt->rtmsg_dst.s6_addr32[3] == 0L
1941 && (metric < 0 || rt->rtmsg_metric == metric)) {
1947 close_route_table();
1951 /********************************************************************
1953 * sif6defaultroute - assign a default route through the address given.
1955 * If the global default_rt_repl_rest flag is set, then this function
1956 * already replaced the original system defaultroute with some other
1957 * route and it should just replace the current defaultroute with
1958 * another one, without saving the current route. Use: demand mode,
1959 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1960 * and then changes the temporary addresses to the addresses for the real
1961 * ppp connection when it has come up.
1964 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
1966 struct in6_rtmsg rt;
1967 char buf[IF_NAMESIZE];
1969 if (defaultroute6_exists(&rt, dfl_route_metric) &&
1970 rt.rtmsg_ifindex != if_nametoindex(ifname)) {
1971 if (rt.rtmsg_flags & RTF_GATEWAY)
1972 error("not replacing existing default route via gateway");
1974 error("not replacing existing default route through %s",
1975 if_indextoname(rt.rtmsg_ifindex, buf));
1979 memset (&rt, 0, sizeof (rt));
1981 rt.rtmsg_ifindex = if_nametoindex(ifname);
1982 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1983 rt.rtmsg_dst_len = 0;
1985 rt.rtmsg_flags = RTF_UP;
1986 if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
1987 if ( ! ok_error ( errno ))
1988 error("default route ioctl(SIOCADDRT): %m");
1992 have_default_route6 = 1;
1996 /********************************************************************
1998 * cif6defaultroute - delete a default route through the address given.
2001 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2003 struct in6_rtmsg rt;
2005 have_default_route6 = 0;
2007 memset (&rt, '\0', sizeof (rt));
2009 rt.rtmsg_ifindex = if_nametoindex(ifname);
2010 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2011 rt.rtmsg_dst_len = 0;
2013 rt.rtmsg_flags = RTF_UP;
2014 if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2016 if ( ! ok_error ( errno ))
2017 error("default route ioctl(SIOCDELRT): %m");
2026 /********************************************************************
2028 * sifproxyarp - Make a proxy ARP entry for the peer.
2031 int sifproxyarp (int unit, u_int32_t his_adr)
2033 struct arpreq arpreq;
2036 if (has_proxy_arp == 0) {
2037 memset (&arpreq, '\0', sizeof(arpreq));
2039 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2040 SIN_ADDR(arpreq.arp_pa) = his_adr;
2041 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2043 * Get the hardware address of an interface on the same subnet
2044 * as our local address.
2046 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2047 sizeof(proxy_arp_dev))) {
2048 error("Cannot determine ethernet address for proxy ARP");
2051 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2053 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2054 if ( ! ok_error ( errno ))
2055 error("ioctl(SIOCSARP): %m");
2058 proxy_arp_addr = his_adr;
2062 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2063 if (forw_path != 0) {
2064 int fd = open(forw_path, O_WRONLY);
2066 if (write(fd, "1", 1) != 1)
2067 error("Couldn't enable IP forwarding: %m");
2077 /********************************************************************
2079 * cifproxyarp - Delete the proxy ARP entry for the peer.
2082 int cifproxyarp (int unit, u_int32_t his_adr)
2084 struct arpreq arpreq;
2086 if (has_proxy_arp) {
2088 memset (&arpreq, '\0', sizeof(arpreq));
2089 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2090 SIN_ADDR(arpreq.arp_pa) = his_adr;
2091 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2092 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2094 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2095 if ( ! ok_error ( errno ))
2096 warn("ioctl(SIOCDARP): %m");
2103 /********************************************************************
2105 * get_ether_addr - get the hardware address of an interface on the
2106 * the same subnet as ipaddr.
2109 static int get_ether_addr (u_int32_t ipaddr,
2110 struct sockaddr *hwaddr,
2111 char *name, int namelen)
2113 struct ifreq *ifr, *ifend;
2114 u_int32_t ina, mask;
2116 struct ifreq ifreq, bestifreq;
2118 struct ifreq ifs[MAX_IFS];
2120 u_int32_t bestmask=0;
2121 int found_interface = 0;
2123 ifc.ifc_len = sizeof(ifs);
2125 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2126 if ( ! ok_error ( errno ))
2127 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2132 * Scan through looking for an interface with an Internet
2133 * address on the same subnet as `ipaddr'.
2135 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2136 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2137 if (ifr->ifr_addr.sa_family == AF_INET) {
2138 ina = SIN_ADDR(ifr->ifr_addr);
2139 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2141 * Check that the interface is up, and not point-to-point
2144 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2147 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2150 * Get its netmask and check that it's on the right subnet.
2152 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2155 mask = SIN_ADDR(ifreq.ifr_addr);
2157 if (((ipaddr ^ ina) & mask) != 0)
2158 continue; /* no match */
2160 if (mask >= bestmask) {
2161 /* Compare using >= instead of > -- it is possible for
2162 an interface to have a netmask of 0.0.0.0 */
2163 found_interface = 1;
2170 if (!found_interface) return 0;
2172 strlcpy(name, bestifreq.ifr_name, namelen);
2174 /* trim off the :1 in eth0:1 */
2175 aliasp = strchr(name, ':');
2179 info("found interface %s for proxy arp", name);
2181 * Now get the hardware address.
2183 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2184 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2185 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2190 &bestifreq.ifr_hwaddr,
2191 sizeof (struct sockaddr));
2197 * get_if_hwaddr - get the hardware address for the specified
2198 * network interface device.
2201 get_if_hwaddr(u_char *addr, char *name)
2206 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2209 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2210 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2211 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2214 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2219 * get_first_ether_hwaddr - get the hardware address for the first
2220 * ethernet-style interface on this system.
2223 get_first_ether_hwaddr(u_char *addr)
2225 struct if_nameindex *if_ni, *i;
2229 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2233 if_ni = if_nameindex();
2241 for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2242 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2243 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2244 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2245 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2246 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2252 if_freenameindex(if_ni);
2258 /********************************************************************
2260 * Return user specified netmask, modified by any mask we might determine
2261 * for address `addr' (in network byte order).
2262 * Here we scan through the system's list of interfaces, looking for
2263 * any non-point-to-point interfaces which might appear to be on the same
2264 * network as `addr'. If we find any, we OR in their netmask to the
2265 * user-specified netmask.
2268 u_int32_t GetMask (u_int32_t addr)
2270 u_int32_t mask, nmask, ina;
2271 struct ifreq *ifr, *ifend, ifreq;
2273 struct ifreq ifs[MAX_IFS];
2277 if (IN_CLASSA(addr)) /* determine network mask for address class */
2278 nmask = IN_CLASSA_NET;
2279 else if (IN_CLASSB(addr))
2280 nmask = IN_CLASSB_NET;
2282 nmask = IN_CLASSC_NET;
2284 /* class D nets are disallowed by bad_ip_adrs */
2285 mask = netmask | htonl(nmask);
2287 * Scan through the system's network interfaces.
2289 ifc.ifc_len = sizeof(ifs);
2291 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2292 if ( ! ok_error ( errno ))
2293 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2297 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2298 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2300 * Check the interface's internet address.
2302 if (ifr->ifr_addr.sa_family != AF_INET)
2304 ina = SIN_ADDR(ifr->ifr_addr);
2305 if (((ntohl(ina) ^ addr) & nmask) != 0)
2308 * Check that the interface is up, and not point-to-point nor loopback.
2310 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2311 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2314 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2317 * Get its netmask and OR it into our mask.
2319 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2321 mask |= SIN_ADDR(ifreq.ifr_addr);
2327 /********************************************************************
2329 * Internal routine to decode the version.modification.patch level
2332 static void decode_version (char *buf, int *version,
2333 int *modification, int *patch)
2337 *version = (int) strtoul (buf, &endp, 10);
2341 if (endp != buf && *endp == '.') {
2343 *modification = (int) strtoul (buf, &endp, 10);
2344 if (endp != buf && *endp == '.') {
2346 *patch = (int) strtoul (buf, &buf, 10);
2351 /********************************************************************
2353 * Procedure to determine if the PPP line discipline is registered.
2357 ppp_registered(void)
2365 * We used to open the serial device and set it to the ppp line
2366 * discipline here, in order to create a ppp unit. But that is
2367 * not a good idea - the user might have specified a device that
2368 * they can't open (permission, or maybe it doesn't really exist).
2369 * So we grab a pty master/slave pair and use that.
2371 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2372 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2377 * Try to put the device into the PPP discipline.
2379 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2380 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2389 /********************************************************************
2391 * ppp_available - check whether the system has any ppp interfaces
2392 * (in fact we check whether we can do an ioctl on ppp0).
2395 int ppp_available(void)
2400 int my_version, my_modification, my_patch;
2401 int osmaj, osmin, ospatch;
2403 /* get the kernel version now, since we are called before sys_init */
2405 osmaj = osmin = ospatch = 0;
2406 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2407 kernel_version = KVERSION(osmaj, osmin, ospatch);
2409 fd = open("/dev/ppp", O_RDWR);
2411 new_style_driver = 1;
2413 /* XXX should get from driver */
2415 driver_modification = 4;
2421 if (kernel_version >= KVERSION(2,3,13)) {
2422 error("Couldn't open the /dev/ppp device: %m");
2423 if (errno == ENOENT)
2425 "You need to create the /dev/ppp device node by\n"
2426 "executing the following command as root:\n"
2427 " mknod /dev/ppp c 108 0\n";
2428 else if (errno == ENODEV || errno == ENXIO)
2430 "Please load the ppp_generic kernel module.\n";
2434 /* we are running on a really really old kernel */
2436 "This system lacks kernel support for PPP. This could be because\n"
2437 "the PPP kernel module could not be loaded, or because PPP was not\n"
2438 "included in the kernel configuration. If PPP was included as a\n"
2439 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2440 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2441 "See README.linux file in the ppp distribution for more details.\n";
2444 * Open a socket for doing the ioctl operations.
2446 s = socket(AF_INET, SOCK_DGRAM, 0);
2450 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2451 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2453 * If the device did not exist then attempt to create one by putting the
2454 * current tty into the PPP discipline. If this works then obtain the
2455 * flags for the device again.
2458 if (ppp_registered()) {
2459 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2460 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2464 * Ensure that the hardware address is for PPP and not something else
2467 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2469 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2473 * This is the PPP device. Validate the version of the driver at this
2474 * point to ensure that this program will work with the driver.
2477 char abBuffer [1024];
2479 ifr.ifr_data = abBuffer;
2480 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2482 error("Couldn't read driver version: %m");
2484 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2487 decode_version(abBuffer,
2489 &driver_modification,
2492 * Validate the version of the driver against the version that we used.
2494 decode_version(VERSION,
2499 /* The version numbers must match */
2500 if (driver_version != my_version)
2503 /* The modification levels must be legal */
2504 if (driver_modification < 3) {
2505 if (driver_modification >= 2) {
2506 /* we can cope with 2.2.0 and above */
2514 slprintf(route_buffer, sizeof(route_buffer),
2515 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2516 driver_version, driver_modification, driver_patch);
2518 no_ppp_msg = route_buffer;
2526 #ifndef HAVE_LOGWTMP
2527 /********************************************************************
2529 * Update the wtmp file with the appropriate user name and tty device.
2532 void logwtmp (const char *line, const char *name, const char *host)
2534 struct utmp ut, *utp;
2535 pid_t mypid = getpid();
2541 * Update the signon database for users.
2542 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2544 utmpname(_PATH_UTMP);
2546 while ((utp = getutent()) && (utp->ut_pid != mypid))
2550 memcpy(&ut, utp, sizeof(ut));
2552 /* some gettys/telnetds don't initialize utmp... */
2553 memset(&ut, 0, sizeof(ut));
2555 if (ut.ut_id[0] == 0)
2556 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2558 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2559 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2563 ut.ut_type = USER_PROCESS;
2566 /* Insert the host name if one is supplied */
2568 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2570 /* Insert the IP address of the remote system if IP is enabled */
2571 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2572 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2573 sizeof(ut.ut_addr));
2575 /* CL: Makes sure that the logout works */
2576 if (*host == 0 && *name==0)
2582 * Update the wtmp file.
2585 updwtmp(_PATH_WTMP, &ut);
2587 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2589 flock(wtmp, LOCK_EX);
2591 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2592 warn("error writing %s: %m", _PATH_WTMP);
2594 flock(wtmp, LOCK_UN);
2600 #endif /* HAVE_LOGWTMP */
2602 /********************************************************************
2604 * sifvjcomp - config tcp header compression
2607 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2612 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2613 error("Couldn't set up TCP header compression: %m");
2618 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2619 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2624 /********************************************************************
2626 * sifup - Config the interface up and enable IP packets to pass.
2633 if ((ret = setifstate(u, 1)))
2639 /********************************************************************
2641 * sifdown - Disable the indicated protocol and config the interface
2642 * down if there are no remaining protocols.
2647 if (if_is_up && --if_is_up > 0)
2655 return setifstate(u, 0);
2659 /********************************************************************
2661 * sif6up - Config the interface up for IPv6
2668 if ((ret = setifstate(u, 1)))
2674 /********************************************************************
2676 * sif6down - Disable the IPv6CP protocol and config the interface
2677 * down if there are no remaining protocols.
2680 int sif6down (int u)
2687 return setifstate(u, 0);
2691 /********************************************************************
2693 * setifstate - Config the interface up or down
2696 static int setifstate (int u, int state)
2700 memset (&ifr, '\0', sizeof (ifr));
2701 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2702 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2703 if (! ok_error (errno))
2704 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2709 ifr.ifr_flags |= IFF_UP;
2711 ifr.ifr_flags &= ~IFF_UP;
2712 ifr.ifr_flags |= IFF_POINTOPOINT;
2713 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2714 if (! ok_error (errno))
2715 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2721 /********************************************************************
2723 * sifaddr - Config the interface IP addresses and netmask.
2726 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2732 memset (&ifr, '\0', sizeof (ifr));
2733 memset (&rt, '\0', sizeof (rt));
2735 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2736 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2737 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2739 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2741 * Set our IP address
2743 SIN_ADDR(ifr.ifr_addr) = our_adr;
2744 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2745 if (errno != EEXIST) {
2746 if (! ok_error (errno))
2747 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2750 warn("ioctl(SIOCSIFADDR): Address already exists");
2755 * Set the gateway address
2758 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2759 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2760 if (! ok_error (errno))
2761 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2767 * For recent kernels, force the netmask to 255.255.255.255.
2769 if (kernel_version >= KVERSION(2,1,16))
2771 if (net_mask != 0) {
2772 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2773 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2774 if (! ok_error (errno))
2775 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2780 * Add the device route
2782 if (kernel_version < KVERSION(2,1,16)) {
2783 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2784 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2787 SIN_ADDR(rt.rt_gateway) = 0L;
2788 SIN_ADDR(rt.rt_dst) = his_adr;
2789 rt.rt_flags = RTF_UP | RTF_HOST;
2791 if (kernel_version > KVERSION(2,1,0)) {
2792 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2793 SIN_ADDR(rt.rt_genmask) = -1L;
2796 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2797 if (! ok_error (errno))
2798 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2803 /* set ip_dynaddr in demand mode if address changes */
2804 if (demand && tune_kernel && !dynaddr_set
2805 && our_old_addr && our_old_addr != our_adr) {
2806 /* set ip_dynaddr if possible */
2810 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2811 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2812 if (write(fd, "1", 1) != 1)
2813 error("Couldn't enable dynamic IP addressing: %m");
2816 dynaddr_set = 1; /* only 1 attempt */
2823 /********************************************************************
2825 * cifaddr - Clear the interface IP addresses, and delete routes
2826 * through the interface if possible.
2829 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2833 if (kernel_version < KVERSION(2,1,16)) {
2835 * Delete the route through the device
2838 memset (&rt, '\0', sizeof (rt));
2840 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2841 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2844 SIN_ADDR(rt.rt_gateway) = 0;
2845 SIN_ADDR(rt.rt_dst) = his_adr;
2846 rt.rt_flags = RTF_UP | RTF_HOST;
2848 if (kernel_version > KVERSION(2,1,0)) {
2849 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2850 SIN_ADDR(rt.rt_genmask) = -1L;
2853 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2854 if (still_ppp() && ! ok_error (errno))
2855 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2860 /* This way it is possible to have an IPX-only or IPv6-only interface */
2861 memset(&ifr, 0, sizeof(ifr));
2862 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2863 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2865 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2866 if (! ok_error (errno)) {
2867 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2872 our_old_addr = our_adr;
2878 /********************************************************************
2880 * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
2882 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
2885 struct nlmsghdr nlh;
2886 struct ifaddrmsg ifa;
2889 struct in6_addr addr;
2893 struct nlmsghdr nlh;
2894 struct nlmsgerr nlerr;
2896 struct sockaddr_nl nladdr;
2903 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
2905 error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
2910 * Tell kernel to not send to us payload of acknowledgment error message.
2911 * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
2912 * older kernel versions always send full payload in acknowledgment netlink
2913 * message. We ignore payload of this message as we need only error code,
2914 * to check if our set remote peer address request succeeded or failed.
2915 * So ignore return value from the following setsockopt() call as setting
2916 * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
2919 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
2921 memset(&nladdr, 0, sizeof(nladdr));
2922 nladdr.nl_family = AF_NETLINK;
2924 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
2925 error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
2930 memset(&nlreq, 0, sizeof(nlreq));
2931 nlreq.nlh.nlmsg_len = sizeof(nlreq);
2932 nlreq.nlh.nlmsg_type = RTM_NEWADDR;
2933 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
2934 nlreq.ifa.ifa_family = AF_INET6;
2935 nlreq.ifa.ifa_prefixlen = 128;
2936 nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
2937 nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
2938 nlreq.ifa.ifa_index = iface;
2939 nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
2940 nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
2941 IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
2942 nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
2943 nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
2946 * To set only local address, older kernel expects that local address is
2947 * in IFA_ADDRESS field (not IFA_LOCAL). New kernels with support for peer
2948 * address, ignore IFA_ADDRESS if is same as IFA_LOCAL. So for backward
2949 * compatibility when setting only local address, set it via both IFA_LOCAL
2950 * and IFA_ADDRESS fields. Same logic is implemented in 'ip address' command
2951 * from iproute2 project.
2953 if (!eui64_iszero(his_eui64))
2954 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
2956 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, our_eui64);
2958 memset(&nladdr, 0, sizeof(nladdr));
2959 nladdr.nl_family = AF_NETLINK;
2961 memset(&iov, 0, sizeof(iov));
2962 iov.iov_base = &nlreq;
2963 iov.iov_len = sizeof(nlreq);
2965 memset(&msg, 0, sizeof(msg));
2966 msg.msg_name = &nladdr;
2967 msg.msg_namelen = sizeof(nladdr);
2971 if (sendmsg(fd, &msg, 0) < 0) {
2972 error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
2977 memset(&iov, 0, sizeof(iov));
2978 iov.iov_base = &nlresp;
2979 iov.iov_len = sizeof(nlresp);
2981 memset(&msg, 0, sizeof(msg));
2982 msg.msg_name = &nladdr;
2983 msg.msg_namelen = sizeof(nladdr);
2987 nlresplen = recvmsg(fd, &msg, 0);
2989 if (nlresplen < 0) {
2990 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
2997 if (nladdr.nl_family != AF_NETLINK) {
2998 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
3002 if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
3003 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
3007 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
3008 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
3009 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
3013 /* error == 0 indicates success, negative value is errno code */
3014 if (nlresp.nlerr.error != 0) {
3016 * Linux kernel versions prior 3.11 do not support setting IPv6 peer
3017 * addresses and error response is expected. On older kernel versions
3018 * do not show this error message. On error pppd tries to fallback to
3019 * the old IOCTL method.
3021 if (kernel_version >= KVERSION(3,11,0))
3022 error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
3029 /********************************************************************
3031 * sif6addr - Config the interface with an IPv6 link-local address
3033 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3035 struct in6_ifreq ifr6;
3037 struct in6_rtmsg rt6;
3042 error("IPv6 socket creation failed: %m");
3045 memset(&ifr, 0, sizeof (ifr));
3046 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3047 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3048 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3052 if (kernel_version >= KVERSION(2,1,16)) {
3053 /* Set both local address and remote peer address (with route for it) via rtnetlink */
3054 ret = sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
3060 * Linux kernel versions prior 3.11 do not support setting IPv6 peer address
3061 * via rtnetlink. So if sif6addr_rtnetlink() fails then try old IOCTL method.
3064 /* Local interface */
3065 memset(&ifr6, 0, sizeof(ifr6));
3066 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3067 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3068 ifr6.ifr6_prefixlen = 128;
3070 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3071 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3076 if (!ret && !eui64_iszero(his_eui64)) {
3078 * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3079 * setting remote peer host address, so set only route to remote host.
3082 /* Route to remote host */
3083 memset(&rt6, 0, sizeof(rt6));
3084 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3085 rt6.rtmsg_flags = RTF_UP;
3086 rt6.rtmsg_dst_len = 128;
3087 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3088 rt6.rtmsg_metric = 1;
3090 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3091 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3100 /********************************************************************
3102 * cif6addr - Remove IPv6 address from interface
3104 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3107 struct in6_ifreq ifr6;
3111 error("IPv6 socket creation failed: %m");
3114 memset(&ifr, 0, sizeof(ifr));
3115 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3116 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3117 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3121 memset(&ifr6, 0, sizeof(ifr6));
3122 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3123 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3124 ifr6.ifr6_prefixlen = 128;
3126 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3127 if (errno != EADDRNOTAVAIL) {
3128 if (! ok_error (errno))
3129 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3132 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3141 * get_pty - get a pty master/slave pair and chown the slave side
3142 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
3145 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3147 int i, mfd, ret, sfd = -1;
3149 struct termios tios;
3153 * Try the unix98 way first.
3155 mfd = open("/dev/ptmx", O_RDWR);
3158 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3159 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3160 chmod(pty_name, S_IRUSR | S_IWUSR);
3163 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3164 warn("Couldn't unlock pty slave %s: %m", pty_name);
3166 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3168 warn("Couldn't open pty slave %s: %m", pty_name);
3173 #endif /* TIOCGPTN */
3176 /* the old way - scan through the pty name space */
3177 for (i = 0; i < 64; ++i) {
3178 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3179 'p' + i / 16, i % 16);
3180 mfd = open(pty_name, O_RDWR, 0);
3183 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3185 ret = fchown(sfd, uid, -1);
3187 warn("Couldn't change ownership of %s, %m", pty_name);
3189 ret = fchmod(sfd, S_IRUSR | S_IWUSR);
3191 warn("Couldn't change permissions of %s, %m", pty_name);
3203 strlcpy(slave_name, pty_name, 16);
3206 if (tcgetattr(sfd, &tios) == 0) {
3207 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3208 tios.c_cflag |= CS8 | CREAD | CLOCAL;
3209 tios.c_iflag = IGNPAR;
3212 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3213 warn("couldn't set attributes on pty: %m");
3215 warn("couldn't get attributes on pty: %m");
3220 /********************************************************************
3222 * open_loopback - open the device we use for getting packets
3223 * in demand mode. Under Linux, we use a pty master/slave pair.
3226 open_ppp_loopback(void)
3231 if (new_style_driver) {
3232 /* allocate ourselves a ppp unit */
3233 if (make_ppp_unit() < 0)
3235 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3236 set_kdebugflag(kdebugflag);
3241 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3242 fatal("No free pty for loopback");
3244 set_ppp_fd(slave_fd);
3246 flags = fcntl(master_fd, F_GETFL);
3248 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3249 warn("couldn't set master loopback to nonblock: %m");
3251 flags = fcntl(ppp_fd, F_GETFL);
3253 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3254 warn("couldn't set slave loopback to nonblock: %m");
3256 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3257 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3259 * Find out which interface we were given.
3261 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3262 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3264 * Enable debug in the driver if requested.
3266 set_kdebugflag (kdebugflag);
3271 /********************************************************************
3273 * sifnpmode - Set the mode for handling packets for a given NP.
3277 sifnpmode(int u, int proto, enum NPmode mode)
3281 npi.protocol = proto;
3283 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3284 if (! ok_error (errno))
3285 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3292 /********************************************************************
3294 * sipxfaddr - Config the interface IPX networknumber
3297 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
3304 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3306 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3308 if (! ok_error (errno))
3309 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3313 memset (&ifr, '\0', sizeof (ifr));
3314 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3316 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
3317 sipx->sipx_family = AF_IPX;
3318 sipx->sipx_port = 0;
3319 sipx->sipx_network = htonl (network);
3320 sipx->sipx_type = IPX_FRAME_ETHERII;
3321 sipx->sipx_action = IPX_CRTITF;
3323 * Set the IPX device
3325 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3327 if (errno != EEXIST) {
3328 if (! ok_error (errno))
3329 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
3332 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
3341 /********************************************************************
3343 * cipxfaddr - Clear the information for the IPX network. The IPX routes
3344 * are removed and the device is no longer able to pass IPX
3348 int cipxfaddr (int unit)
3355 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3357 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3359 if (! ok_error (errno))
3360 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3364 memset (&ifr, '\0', sizeof (ifr));
3365 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3367 sipx->sipx_type = IPX_FRAME_ETHERII;
3368 sipx->sipx_action = IPX_DLTITF;
3369 sipx->sipx_family = AF_IPX;
3371 * Set the IPX device
3373 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3374 if (! ok_error (errno))
3375 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
3385 * Use the hostname as part of the random number seed.
3394 for (p = hostname; *p != 0; ++p)
3399 /********************************************************************
3401 * sys_check_options - check the options that the user specified
3405 sys_check_options(void)
3409 * Disable the IPX protocol if the support is not present in the kernel.
3413 if (ipxcp_protent.enabled_flag) {
3414 struct stat stat_buf;
3415 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
3416 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
3417 || lstat(path, &stat_buf) < 0) {
3418 error("IPX support is not present in the kernel\n");
3419 ipxcp_protent.enabled_flag = 0;
3423 if (demand && driver_is_old) {
3424 option_error("demand dialling is not supported by kernel driver "
3425 "version %d.%d.%d", driver_version, driver_modification,
3429 if (multilink && !new_style_driver) {
3430 warn("Warning: multilink is not supported by the kernel driver");
3436 /********************************************************************
3438 * get_time - Get current time, monotonic if possible.
3441 get_time(struct timeval *tv)
3443 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3444 * Runtime checking makes it safe. */
3445 #ifndef CLOCK_MONOTONIC
3446 #define CLOCK_MONOTONIC 1
3448 static int monotonic = -1;
3453 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3457 tv->tv_sec = ts.tv_sec;
3458 tv->tv_usec = ts.tv_nsec / 1000;
3461 } else if (monotonic > 0)
3465 warn("Couldn't use monotonic clock source: %m");
3468 return gettimeofday(tv, NULL);