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.
72 #include <sys/ioctl.h>
73 #include <sys/types.h>
74 #include <sys/socket.h>
78 #include <sys/utsname.h>
79 #include <sys/sysmacros.h>
96 /* This is in netdevice.h. However, this compile will fail miserably if
97 you attempt to include netdevice.h because it has so many references
98 to __memcpy functions which it should not attempt to do. So, since I
99 really don't use it, but it must be defined, define it now. */
102 #define MAX_ADDR_LEN 7
105 #if !defined(__GLIBC__) || __GLIBC__ >= 2
106 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
108 #include <net/if_arp.h>
109 #include <net/route.h>
110 #include <netinet/if_ether.h>
112 #include <linux/types.h>
113 #include <linux/if.h>
114 #include <linux/if_arp.h>
115 #include <linux/route.h>
116 #include <linux/if_ether.h>
118 #include <netinet/in.h>
119 #include <arpa/inet.h>
121 #include <linux/ppp_defs.h>
122 #include <linux/if_ppp.h>
125 #include <linux/netlink.h>
126 #include <linux/rtnetlink.h>
127 #include <linux/if_addr.h>
128 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
130 #define SOL_NETLINK 270
132 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
133 #ifndef NETLINK_CAP_ACK
134 #define NETLINK_CAP_ACK 10
144 #if __GLIBC__ >= 2 && \
145 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
146 #include <netipx/ipx.h>
148 #include <linux/ipx.h>
150 #endif /* IPX_CHANGE */
153 #include <pcap-bpf.h>
154 #include <linux/filter.h>
155 #endif /* PPP_FILTER */
158 #include <sys/locks.h>
164 * This is in linux/include/net/ipv6.h.
168 struct in6_addr ifr6_addr;
169 __u32 ifr6_prefixlen;
170 unsigned int ifr6_ifindex;
174 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
175 memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr)); \
176 (sin6).s6_addr16[0] = htons(0xfe80); \
177 eui64_copy(eui64, (sin6).s6_addr32[2]); \
180 static const eui64_t nulleui64;
183 /* We can get an EIO error on an ioctl if the modem has hung up */
184 #define ok_error(num) ((num)==EIO)
186 static int tty_disc = N_TTY; /* The TTY discipline */
187 static int ppp_disc = N_PPP; /* The PPP discpline */
188 static int initfdflags = -1; /* Initial file descriptor flags for fd */
189 static int ppp_fd = -1; /* fd which is set to PPP discipline */
190 static int sock_fd = -1; /* socket for doing interface ioctls */
191 static int slave_fd = -1; /* pty for old-style demand mode, slave */
192 static int master_fd = -1; /* pty for old-style demand mode, master */
194 static int sock6_fd = -1;
198 * For the old-style kernel driver, this is the same as ppp_fd.
199 * For the new-style driver, it is the fd of an instance of /dev/ppp
200 * which is attached to the ppp unit and is used for controlling it.
202 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
204 static int chindex; /* channel index (new style driver) */
206 static fd_set in_fds; /* set of fds that wait_input waits for */
207 static int max_in_fd; /* highest fd set in in_fds */
209 static int has_proxy_arp = 0;
210 static int driver_version = 0;
211 static int driver_modification = 0;
212 static int driver_patch = 0;
213 static int driver_is_old = 0;
214 static int restore_term = 0; /* 1 => we've munged the terminal */
215 static struct termios inittermios; /* Initial TTY termios */
217 int new_style_driver = 0;
219 static char loop_name[20];
220 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
222 static int if_is_up; /* Interface has been marked up */
223 static int if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
224 static int have_default_route; /* Gateway for default route added */
225 static int have_default_route6; /* Gateway for default IPv6 route added */
226 static struct rtentry old_def_rt; /* Old default route */
227 static int default_rt_repl_rest; /* replace and restore old default rt */
228 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
229 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
230 static u_int32_t our_old_addr; /* for detecting address changes */
231 static int dynaddr_set; /* 1 if ip_dynaddr set */
232 static int looped; /* 1 if using loop */
233 static int link_mtu; /* mtu for the link (not bundle) */
235 static struct utsname utsname; /* for the kernel version */
236 static int kernel_version;
237 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
241 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
242 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
243 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
245 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
247 /* Prototypes for procedures local to this file. */
248 static int modify_flags(int fd, int clear_bits, int set_bits);
249 static int translate_speed (int bps);
250 static int baud_rate_of (int speed);
251 static void close_route_table (void);
252 static int open_route_table (void);
253 static int read_route_table (struct rtentry *rt);
254 static int defaultroute_exists (struct rtentry *rt, int metric);
255 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
256 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
257 char *name, int namelen);
258 static void decode_version (char *buf, int *version, int *mod, int *patch);
259 static int set_kdebugflag(int level);
260 static int ppp_registered(void);
261 static int make_ppp_unit(void);
262 static int setifstate (int u, int state);
264 extern u_char inpacket_buf[]; /* borrowed from main.c */
266 extern int dfl_route_metric;
269 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
273 #define SET_SA_FAMILY(addr, family) \
274 memset ((char *) &(addr), '\0', sizeof(addr)); \
275 addr.sa_family = (family);
278 * Determine if the PPP connection should still be present.
283 /* new_fd is the fd of a tty */
284 static void set_ppp_fd (int new_fd)
287 if (!new_style_driver)
291 static int still_ppp(void)
293 if (new_style_driver)
294 return !hungup && ppp_fd >= 0;
295 if (!hungup || ppp_fd == slave_fd)
298 set_ppp_fd(slave_fd);
305 * modify_flags - set and clear flag bits controlling the kernel
308 static int modify_flags(int fd, int clear_bits, int set_bits)
312 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
314 flags = (flags & ~clear_bits) | set_bits;
315 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
322 error("Failed to set PPP kernel option flags: %m");
326 /********************************************************************
328 * sys_init - System-dependent initialization.
333 /* Get an internet socket for doing socket ioctls. */
334 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
336 fatal("Couldn't create IP socket: %m(%d)", errno);
339 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
341 sock6_fd = -errno; /* save errno for later */
348 /********************************************************************
350 * sys_cleanup - restore any system state we modified before exiting:
351 * mark the interface down, delete default route and/or proxy arp entry.
352 * This shouldn't call die() because it's called from die().
355 void sys_cleanup(void)
358 * Take down the device
368 * Delete any routes through the device.
370 if (have_default_route)
371 cifdefaultroute(0, 0, 0);
373 if (have_default_route6)
374 cif6defaultroute(0, nulleui64, nulleui64);
378 cifproxyarp(0, proxy_arp_addr);
381 /********************************************************************
383 * sys_close - Clean up in a child process before execing.
388 if (new_style_driver && ppp_dev_fd >= 0)
402 /********************************************************************
404 * set_kdebugflag - Define the debugging level for the kernel
407 static int set_kdebugflag (int requested_level)
411 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
412 if ( ! ok_error (errno) )
413 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
419 /********************************************************************
421 * tty_establish_ppp - Turn the serial port into a ppp interface.
424 int tty_establish_ppp (int tty_fd)
429 * Ensure that the tty device is in exclusive mode.
431 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
432 if ( ! ok_error ( errno ))
433 warn("Couldn't make tty exclusive: %m");
436 * Demand mode - prime the old ppp device to relinquish the unit.
438 if (!new_style_driver && looped
439 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
440 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
444 * Set the current tty to the PPP discpline
448 #define N_SYNC_PPP 14
450 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
451 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
452 if ( ! ok_error (errno) ) {
453 error("Couldn't set tty to PPP discipline: %m");
458 ret_fd = generic_establish_ppp(tty_fd);
460 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
461 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
465 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
466 (kdebugflag * SC_DEBUG) & SC_LOGB);
468 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
469 warn("Couldn't reset tty to normal line discipline: %m");
475 /********************************************************************
477 * generic_establish_ppp - Turn the fd into a ppp interface.
479 int generic_establish_ppp (int fd)
483 if (new_style_driver) {
486 /* If a ppp_fd is already open, close it first */
493 /* Open an instance of /dev/ppp and connect the channel to it */
494 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
495 error("Couldn't get channel number: %m");
498 dbglog("using channel %d", chindex);
499 fd = open("/dev/ppp", O_RDWR);
501 error("Couldn't reopen /dev/ppp: %m");
504 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
505 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
506 error("Couldn't attach to channel %d: %m", chindex);
509 flags = fcntl(fd, F_GETFL);
510 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
511 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
516 if (!looped && !multilink) {
518 * Create a new PPP unit.
520 if (make_ppp_unit() < 0)
525 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
529 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
530 error("Couldn't attach to PPP unit %d: %m", ifunit);
537 * Old-style driver: find out which interface we were given.
540 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
541 if (ok_error (errno))
543 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
545 /* Check that we got the same unit again. */
546 if (looped && x != ifunit)
547 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
551 * Fetch the initial file flags and reset blocking mode on the file.
553 initfdflags = fcntl(fd, F_GETFL);
554 if (initfdflags == -1 ||
555 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
556 if ( ! ok_error (errno))
557 warn("Couldn't set device to non-blocking mode: %m");
562 * Enable debug in the driver if requested.
565 set_kdebugflag (kdebugflag);
577 /********************************************************************
579 * tty_disestablish_ppp - Restore the serial port to normal operation.
580 * This shouldn't call die() because it's called from die().
583 void tty_disestablish_ppp(int tty_fd)
587 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
589 if (tcflush(tty_fd, TCIOFLUSH) < 0)
591 warn("tcflush failed: %m");
595 * Restore the previous line discipline
597 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
598 if ( ! ok_error (errno))
599 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
602 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
603 if ( ! ok_error (errno))
604 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
607 /* Reset non-blocking mode on fd. */
608 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
609 if ( ! ok_error (errno))
610 warn("Couldn't restore device fd flags: %m");
616 generic_disestablish_ppp(tty_fd);
619 /********************************************************************
621 * generic_disestablish_ppp - Restore device components to normal
622 * operation, and reconnect the ppp unit to the loopback if in demand
623 * mode. This shouldn't call die() because it's called from die().
625 void generic_disestablish_ppp(int dev_fd)
627 if (new_style_driver) {
631 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
633 } else if (!doing_multilink && ppp_dev_fd >= 0) {
635 remove_fd(ppp_dev_fd);
639 /* old-style driver */
641 set_ppp_fd(slave_fd);
648 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
649 * Assumes new_style_driver.
651 static int make_ppp_unit(void)
655 if (ppp_dev_fd >= 0) {
656 dbglog("in make_ppp_unit, already had /dev/ppp open?");
659 ppp_dev_fd = open("/dev/ppp", O_RDWR);
661 fatal("Couldn't open /dev/ppp: %m");
662 flags = fcntl(ppp_dev_fd, F_GETFL);
664 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
665 warn("Couldn't set /dev/ppp to nonblock: %m");
668 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
669 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
670 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
672 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
675 error("Couldn't create new ppp unit: %m");
677 if (x == 0 && req_ifname[0] != '\0') {
679 char t[MAXIFNAMELEN];
680 memset(&ifr, 0, sizeof(struct ifreq));
681 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
682 strlcpy(ifr.ifr_name, t, IF_NAMESIZE);
683 strlcpy(ifr.ifr_newname, req_ifname, IF_NAMESIZE);
684 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
686 error("Couldn't rename interface %s to %s: %m", t, req_ifname);
688 info("Renamed interface %s to %s", t, req_ifname);
695 * cfg_bundle - configure the existing bundle.
696 * Used in demand mode.
698 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
700 if (!new_style_driver)
703 /* set the mrru, mtu and flags */
704 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
705 error("Couldn't set MRRU: %m");
707 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
708 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
709 | (mrru? SC_MULTILINK: 0)));
711 /* connect up the channel */
712 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
713 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
718 * make_new_bundle - create a new PPP unit (i.e. a bundle)
719 * and connect our channel to it. This should only get called
720 * if `multilink' was set at the time establish_ppp was called.
721 * In demand mode this uses our existing bundle instead of making
724 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
726 if (!new_style_driver)
729 /* make us a ppp unit */
730 if (make_ppp_unit() < 0)
733 /* set the mrru and flags */
734 cfg_bundle(mrru, mtru, rssn, tssn);
738 * bundle_attach - attach our link to a given PPP unit.
739 * We assume the unit is controlled by another pppd.
741 int bundle_attach(int ifnum)
745 if (!new_style_driver)
748 master_fd = open("/dev/ppp", O_RDWR);
750 fatal("Couldn't open /dev/ppp: %m");
751 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
752 if (errno == ENXIO) {
754 return 0; /* doesn't still exist */
756 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
758 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
759 fatal("Couldn't connect to interface unit %d: %m", ifnum);
760 modify_flags(master_fd, 0, SC_MULTILINK);
768 * destroy_bundle - tell the driver to destroy our bundle.
770 void destroy_bundle(void)
772 if (ppp_dev_fd >= 0) {
774 remove_fd(ppp_dev_fd);
779 /********************************************************************
781 * clean_check - Fetch the flags for the device and generate
782 * appropriate error messages.
784 void clean_check(void)
790 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
792 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
794 s = "all had bit 7 set to 1";
798 s = "all had bit 7 set to 0";
802 s = "all had odd parity";
806 s = "all had even parity";
811 warn("Receive serial link is not 8-bit clean:");
812 warn("Problem: %s", s);
820 * List of valid speeds.
824 int speed_int, speed_val;
905 { 1000000, B1000000 },
908 { 1152000, B1152000 },
911 { 1500000, B1500000 },
914 { 2000000, B2000000 },
917 { 2500000, B2500000 },
920 { 3000000, B3000000 },
923 { 3500000, B3500000 },
926 { 4000000, B4000000 },
931 /********************************************************************
933 * Translate from bits/second to a speed_t.
936 static int translate_speed (int bps)
938 struct speed *speedp;
941 for (speedp = speeds; speedp->speed_int; speedp++) {
942 if (bps == speedp->speed_int)
943 return speedp->speed_val;
945 warn("speed %d not supported", bps);
950 /********************************************************************
952 * Translate from a speed_t to bits/second.
955 static int baud_rate_of (int speed)
957 struct speed *speedp;
960 for (speedp = speeds; speedp->speed_int; speedp++) {
961 if (speed == speedp->speed_val)
962 return speedp->speed_int;
968 /********************************************************************
970 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
971 * at the requested speed, etc. If `local' is true, set CLOCAL
972 * regardless of whether the modem option was specified.
975 void set_up_tty(int tty_fd, int local)
981 if (tcgetattr(tty_fd, &tios) < 0) {
982 if (!ok_error(errno))
983 fatal("tcgetattr: %m (line %d)", __LINE__);
990 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
991 tios.c_cflag |= CS8 | CREAD | HUPCL;
993 tios.c_iflag = IGNBRK | IGNPAR;
997 tios.c_cc[VTIME] = 0;
1000 tios.c_cflag ^= (CLOCAL | HUPCL);
1004 tios.c_cflag |= CRTSCTS;
1008 tios.c_iflag |= IXON | IXOFF;
1009 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
1010 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
1014 tios.c_cflag &= ~CRTSCTS;
1022 tios.c_cflag |= CSTOPB;
1024 speed = translate_speed(inspeed);
1026 cfsetospeed (&tios, speed);
1027 cfsetispeed (&tios, speed);
1030 * We can't proceed if the serial port speed is B0,
1031 * since that implies that the serial port is disabled.
1034 speed = cfgetospeed(&tios);
1036 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1039 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1041 fatal("tcsetattr: %m (line %d)", __LINE__);
1043 baud_rate = baud_rate_of(speed);
1047 /********************************************************************
1049 * setdtr - control the DTR line on the serial port.
1050 * This is called from die(), so it shouldn't call die().
1053 void setdtr (int tty_fd, int on)
1055 int modembits = TIOCM_DTR;
1057 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1060 /********************************************************************
1062 * restore_tty - restore the terminal to the saved settings.
1065 void restore_tty (int tty_fd)
1070 * Turn off echoing, because otherwise we can get into
1071 * a loop with the tty and the modem echoing to each other.
1072 * We presume we are the sole user of this tty device, so
1073 * when we close it, it will revert to its defaults anyway.
1075 if (!default_device)
1076 inittermios.c_lflag &= ~(ECHO | ECHONL);
1078 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1079 if (! ok_error (errno))
1080 warn("tcsetattr: %m (line %d)", __LINE__);
1085 /********************************************************************
1087 * output - Output PPP packet.
1090 void output (int unit, unsigned char *p, int len)
1095 dump_packet("sent", p, len);
1096 if (snoop_send_hook) snoop_send_hook(p, len);
1098 if (len < PPP_HDRLEN)
1100 if (new_style_driver) {
1103 proto = (p[0] << 8) + p[1];
1104 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1107 if (write(fd, p, len) < 0) {
1108 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1109 || errno == ENXIO || errno == EIO || errno == EINTR)
1110 warn("write: warning: %m (%d)", errno);
1112 error("write: %m (%d)", errno);
1116 /********************************************************************
1118 * wait_input - wait until there is data available,
1119 * for the length of time specified by *timo (indefinite
1123 void wait_input(struct timeval *timo)
1130 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1131 if (n < 0 && errno != EINTR)
1132 fatal("select: %m");
1136 * add_fd - add an fd to the set that wait_input waits for.
1140 if (fd >= FD_SETSIZE)
1141 fatal("internal error: file descriptor too large (%d)", fd);
1142 FD_SET(fd, &in_fds);
1148 * remove_fd - remove an fd from the set that wait_input waits for.
1150 void remove_fd(int fd)
1152 FD_CLR(fd, &in_fds);
1156 /********************************************************************
1158 * read_packet - get a PPP packet from the serial device.
1161 int read_packet (unsigned char *buf)
1165 len = PPP_MRU + PPP_HDRLEN;
1166 if (new_style_driver) {
1167 *buf++ = PPP_ALLSTATIONS;
1173 nr = read(ppp_fd, buf, len);
1174 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1175 && errno != EIO && errno != EINTR)
1177 if (nr < 0 && errno == ENXIO)
1180 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1181 /* N.B. we read ppp_fd first since LCP packets come in there. */
1182 nr = read(ppp_dev_fd, buf, len);
1183 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1184 && errno != EIO && errno != EINTR)
1185 error("read /dev/ppp: %m");
1186 if (nr < 0 && errno == ENXIO)
1188 if (nr == 0 && doing_multilink) {
1189 remove_fd(ppp_dev_fd);
1193 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1195 return (new_style_driver && nr > 0)? nr+2: nr;
1198 /********************************************************************
1200 * get_loop_output - get outgoing packets from the ppp device,
1201 * and detect when we want to bring the real link up.
1202 * Return value is 1 if we need to bring up the link, 0 otherwise.
1205 get_loop_output(void)
1210 if (new_style_driver) {
1211 while ((n = read_packet(inpacket_buf)) > 0)
1212 if (loop_frame(inpacket_buf, n))
1217 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1218 if (loop_chars(inbuf, n))
1222 fatal("eof on loopback");
1224 if (errno != EWOULDBLOCK && errno != EAGAIN)
1225 fatal("read from loopback: %m(%d)", errno);
1231 * netif_set_mtu - set the MTU on the PPP network interface.
1234 netif_set_mtu(int unit, int mtu)
1238 memset (&ifr, '\0', sizeof (ifr));
1239 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1242 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1243 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1247 * netif_get_mtu - get the MTU on the PPP network interface.
1250 netif_get_mtu(int unit)
1254 memset (&ifr, '\0', sizeof (ifr));
1255 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1257 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1258 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1264 /********************************************************************
1266 * tty_send_config - configure the transmit characteristics of
1267 * the ppp interface.
1270 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1277 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1278 if (errno != EIO && errno != ENOTTY)
1279 error("Couldn't set transmit async character map: %m");
1284 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1285 | (sync_serial? SC_SYNC: 0);
1286 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1289 /********************************************************************
1291 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1294 void tty_set_xaccm (ext_accm accm)
1298 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1299 if ( ! ok_error (errno))
1300 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1304 /********************************************************************
1306 * tty_recv_config - configure the receive-side characteristics of
1307 * the ppp interface.
1310 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1313 * If we were called because the link has gone down then there is nothing
1314 * which may be done. Just return without incident.
1319 * Set the receiver parameters
1321 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1322 if (errno != EIO && errno != ENOTTY)
1323 error("Couldn't set channel receive MRU: %m");
1325 if (new_style_driver && ppp_dev_fd >= 0
1326 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1327 error("Couldn't set MRU in generic PPP layer: %m");
1329 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1330 if (errno != EIO && errno != ENOTTY)
1331 error("Couldn't set channel receive asyncmap: %m");
1335 /********************************************************************
1337 * ccp_test - ask kernel whether a given compression method
1338 * is acceptable for use.
1342 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1344 struct ppp_option_data data;
1346 memset (&data, '\0', sizeof (data));
1348 data.length = opt_len;
1349 data.transmit = for_transmit;
1351 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1354 return (errno == ENOBUFS)? 0: -1;
1357 /********************************************************************
1359 * ccp_flags_set - inform kernel about the current state of CCP.
1362 void ccp_flags_set (int unit, int isopen, int isup)
1366 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1367 if (still_ppp() && ppp_dev_fd >= 0)
1368 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1373 * set_filters - set the active and pass filters in the kernel driver.
1375 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1377 struct sock_fprog fp;
1379 fp.len = pass->bf_len;
1380 fp.filter = (struct sock_filter *) pass->bf_insns;
1381 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1382 if (errno == ENOTTY)
1383 warn("kernel does not support PPP filtering");
1385 error("Couldn't set pass-filter in kernel: %m");
1388 fp.len = active->bf_len;
1389 fp.filter = (struct sock_filter *) active->bf_insns;
1390 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1391 error("Couldn't set active-filter in kernel: %m");
1396 #endif /* PPP_FILTER */
1398 /********************************************************************
1400 * get_idle_time - return how long the link has been idle.
1403 get_idle_time(int u, struct ppp_idle *ip)
1405 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1408 /********************************************************************
1410 * get_ppp_stats - return statistics for the link.
1413 get_ppp_stats(int u, struct pppd_stats *stats)
1415 struct ifpppstatsreq req;
1417 memset (&req, 0, sizeof (req));
1419 req.stats_ptr = (caddr_t) &req.stats;
1420 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1421 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1422 error("Couldn't get PPP statistics: %m");
1425 stats->bytes_in = req.stats.p.ppp_ibytes;
1426 stats->bytes_out = req.stats.p.ppp_obytes;
1427 stats->pkts_in = req.stats.p.ppp_ipackets;
1428 stats->pkts_out = req.stats.p.ppp_opackets;
1432 /********************************************************************
1434 * ccp_fatal_error - returns 1 if decompression was disabled as a
1435 * result of an error detected after decompression of a packet,
1436 * 0 otherwise. This is necessary because of patent nonsense.
1439 int ccp_fatal_error (int unit)
1443 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1444 error("Couldn't read compression error flags: %m");
1447 return flags & SC_DC_FERROR;
1450 /********************************************************************
1452 * path_to_procfs - find the path to the proc file system mount point
1454 static char proc_path[MAXPATHLEN];
1455 static int proc_path_len;
1457 static char *path_to_procfs(const char *tail)
1459 struct mntent *mntent;
1462 if (proc_path_len == 0) {
1463 /* Default the mount location of /proc */
1464 strlcpy (proc_path, "/proc", sizeof(proc_path));
1466 fp = fopen(MOUNTED, "r");
1468 while ((mntent = getmntent(fp)) != NULL) {
1469 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1471 if (strcmp(mntent->mnt_type, "proc") == 0) {
1472 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1473 proc_path_len = strlen(proc_path);
1481 strlcpy(proc_path + proc_path_len, tail,
1482 sizeof(proc_path) - proc_path_len);
1487 * /proc/net/route parsing stuff.
1489 #define ROUTE_MAX_COLS 12
1490 FILE *route_fd = (FILE *) 0;
1491 static char route_buffer[512];
1492 static int route_dev_col, route_dest_col, route_gw_col;
1493 static int route_flags_col, route_metric_col, route_mask_col;
1494 static int route_num_cols;
1496 static int open_route_table (void);
1497 static void close_route_table (void);
1498 static int read_route_table (struct rtentry *rt);
1500 /********************************************************************
1502 * close_route_table - close the interface to the route table
1505 static void close_route_table (void)
1507 if (route_fd != (FILE *) 0) {
1509 route_fd = (FILE *) 0;
1513 /********************************************************************
1515 * open_route_table - open the interface to the route table
1517 static char route_delims[] = " \t\n";
1519 static int open_route_table (void)
1523 close_route_table();
1525 path = path_to_procfs("/net/route");
1526 route_fd = fopen (path, "r");
1527 if (route_fd == NULL) {
1528 error("can't open routing table %s: %m", path);
1532 route_dev_col = 0; /* default to usual columns */
1535 route_flags_col = 3;
1536 route_metric_col = 6;
1540 /* parse header line */
1541 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1542 char *p = route_buffer, *q;
1544 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1546 if ((q = strtok(p, route_delims)) == 0)
1548 if (strcasecmp(q, "iface") == 0)
1549 route_dev_col = col;
1550 else if (strcasecmp(q, "destination") == 0)
1551 route_dest_col = col;
1552 else if (strcasecmp(q, "gateway") == 0)
1554 else if (strcasecmp(q, "flags") == 0)
1555 route_flags_col = col;
1556 else if (strcasecmp(q, "mask") == 0)
1557 route_mask_col = col;
1560 if (used && col >= route_num_cols)
1561 route_num_cols = col + 1;
1569 /********************************************************************
1571 * read_route_table - read the next entry from the route table
1574 static int read_route_table(struct rtentry *rt)
1576 char *cols[ROUTE_MAX_COLS], *p;
1579 memset (rt, '\0', sizeof (struct rtentry));
1581 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1585 for (col = 0; col < route_num_cols; ++col) {
1586 cols[col] = strtok(p, route_delims);
1587 if (cols[col] == NULL)
1588 return 0; /* didn't get enough columns */
1592 SET_SA_FAMILY (rt->rt_dst, AF_INET);
1593 SET_SA_FAMILY (rt->rt_gateway, AF_INET);
1595 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1596 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1597 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1599 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1600 rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
1601 rt->rt_dev = cols[route_dev_col];
1606 /********************************************************************
1608 * defaultroute_exists - determine if there is a default route
1609 * with the given metric (or negative for any)
1612 static int defaultroute_exists (struct rtentry *rt, int metric)
1616 if (!open_route_table())
1619 while (read_route_table(rt) != 0) {
1620 if ((rt->rt_flags & RTF_UP) == 0)
1623 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1625 if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
1626 || rt->rt_metric == metric)) {
1632 close_route_table();
1637 * have_route_to - determine if the system has any route to
1638 * a given IP address. `addr' is in network byte order.
1639 * Return value is 1 if yes, 0 if no, -1 if don't know.
1640 * For demand mode to work properly, we have to ignore routes
1641 * through our own interface.
1643 int have_route_to(u_int32_t addr)
1648 if (!open_route_table())
1649 return -1; /* don't know */
1651 while (read_route_table(&rt)) {
1652 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1654 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1660 close_route_table();
1664 /********************************************************************
1666 * sifdefaultroute - assign a default route through the address given.
1668 * If the global default_rt_repl_rest flag is set, then this function
1669 * already replaced the original system defaultroute with some other
1670 * route and it should just replace the current defaultroute with
1671 * another one, without saving the current route. Use: demand mode,
1672 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1673 * and then changes the temporary addresses to the addresses for the real
1674 * ppp connection when it has come up.
1677 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
1679 struct rtentry rt, tmp_rt;
1680 struct rtentry *del_rt = NULL;
1682 if (default_rt_repl_rest) {
1683 /* We have already replaced the original defaultroute, if we
1684 * are called again, we will delete the current default route
1685 * and set the new default route in this function.
1686 * - this is normally only the case the doing demand: */
1687 if (defaultroute_exists(&tmp_rt, -1))
1689 } else if (defaultroute_exists(&old_def_rt, -1 ) &&
1690 strcmp( old_def_rt.rt_dev, ifname) != 0) {
1692 * We did not yet replace an existing default route, let's
1693 * check if we should save and replace a default route:
1695 u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
1697 if (old_gateway != gateway) {
1699 error("not replacing default route to %s [%I]",
1700 old_def_rt.rt_dev, old_gateway);
1703 /* we need to copy rt_dev because we need it permanent too: */
1704 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
1705 strcpy(tmp_dev, old_def_rt.rt_dev);
1706 old_def_rt.rt_dev = tmp_dev;
1708 notice("replacing old default route to %s [%I]",
1709 old_def_rt.rt_dev, old_gateway);
1710 default_rt_repl_rest = 1;
1711 del_rt = &old_def_rt;
1716 memset (&rt, 0, sizeof (rt));
1717 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1720 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1722 if (kernel_version > KVERSION(2,1,0)) {
1723 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1724 SIN_ADDR(rt.rt_genmask) = 0L;
1727 rt.rt_flags = RTF_UP;
1728 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1729 if ( ! ok_error ( errno ))
1730 error("default route ioctl(SIOCADDRT): %m");
1733 if (default_rt_repl_rest && del_rt)
1734 if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
1735 if ( ! ok_error ( errno ))
1736 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
1740 have_default_route = 1;
1744 /********************************************************************
1746 * cifdefaultroute - delete a default route through the address given.
1749 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1753 have_default_route = 0;
1755 memset (&rt, '\0', sizeof (rt));
1756 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1757 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1762 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1764 if (kernel_version > KVERSION(2,1,0)) {
1765 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1766 SIN_ADDR(rt.rt_genmask) = 0L;
1769 rt.rt_flags = RTF_UP;
1770 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1772 if ( ! ok_error ( errno ))
1773 error("default route ioctl(SIOCDELRT): %m");
1777 if (default_rt_repl_rest) {
1778 notice("restoring old default route to %s [%I]",
1779 old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
1780 if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
1781 if ( ! ok_error ( errno ))
1782 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
1785 default_rt_repl_rest = 0;
1793 * /proc/net/ipv6_route parsing stuff.
1795 static int route_dest_plen_col;
1796 static int open_route6_table (void);
1797 static int read_route6_table (struct in6_rtmsg *rt);
1799 /********************************************************************
1801 * open_route6_table - open the interface to the route table
1803 static int open_route6_table (void)
1807 close_route_table();
1809 path = path_to_procfs("/net/ipv6_route");
1810 route_fd = fopen (path, "r");
1811 if (route_fd == NULL) {
1812 error("can't open routing table %s: %m", path);
1816 /* default to usual columns */
1818 route_dest_plen_col = 1;
1820 route_metric_col = 5;
1821 route_flags_col = 8;
1823 route_num_cols = 10;
1828 /********************************************************************
1830 * read_route6_table - read the next entry from the route table
1833 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
1840 for (i = 0; i < 4; i++) {
1841 memcpy(hex8, s + 8*i, 8);
1842 v = strtoul(hex8, NULL, 16);
1843 addr->s6_addr32[i] = v;
1847 static int read_route6_table(struct in6_rtmsg *rt)
1849 char *cols[ROUTE_MAX_COLS], *p;
1852 memset (rt, '\0', sizeof (struct in6_rtmsg));
1854 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1858 for (col = 0; col < route_num_cols; ++col) {
1859 cols[col] = strtok(p, route_delims);
1860 if (cols[col] == NULL)
1861 return 0; /* didn't get enough columns */
1865 hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
1866 rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
1867 hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
1869 rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
1870 rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
1871 rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
1876 /********************************************************************
1878 * defaultroute6_exists - determine if there is a default route
1881 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
1885 if (!open_route6_table())
1888 while (read_route6_table(rt) != 0) {
1889 if ((rt->rtmsg_flags & RTF_UP) == 0)
1892 if (rt->rtmsg_dst_len != 0)
1894 if (rt->rtmsg_dst.s6_addr32[0] == 0L
1895 && rt->rtmsg_dst.s6_addr32[1] == 0L
1896 && rt->rtmsg_dst.s6_addr32[2] == 0L
1897 && rt->rtmsg_dst.s6_addr32[3] == 0L
1898 && (metric < 0 || rt->rtmsg_metric == metric)) {
1904 close_route_table();
1908 /********************************************************************
1910 * sif6defaultroute - assign a default route through the address given.
1912 * If the global default_rt_repl_rest flag is set, then this function
1913 * already replaced the original system defaultroute with some other
1914 * route and it should just replace the current defaultroute with
1915 * another one, without saving the current route. Use: demand mode,
1916 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1917 * and then changes the temporary addresses to the addresses for the real
1918 * ppp connection when it has come up.
1921 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
1923 struct in6_rtmsg rt;
1924 char buf[IF_NAMESIZE];
1926 if (defaultroute6_exists(&rt, dfl_route_metric) &&
1927 rt.rtmsg_ifindex != if_nametoindex(ifname)) {
1928 if (rt.rtmsg_flags & RTF_GATEWAY)
1929 error("not replacing existing default route via gateway");
1931 error("not replacing existing default route through %s",
1932 if_indextoname(rt.rtmsg_ifindex, buf));
1936 memset (&rt, 0, sizeof (rt));
1938 rt.rtmsg_ifindex = if_nametoindex(ifname);
1939 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1940 rt.rtmsg_dst_len = 0;
1942 rt.rtmsg_flags = RTF_UP;
1943 if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
1944 if ( ! ok_error ( errno ))
1945 error("default route ioctl(SIOCADDRT): %m");
1949 have_default_route6 = 1;
1953 /********************************************************************
1955 * cif6defaultroute - delete a default route through the address given.
1958 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
1960 struct in6_rtmsg rt;
1962 have_default_route6 = 0;
1964 memset (&rt, '\0', sizeof (rt));
1966 rt.rtmsg_ifindex = if_nametoindex(ifname);
1967 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1968 rt.rtmsg_dst_len = 0;
1970 rt.rtmsg_flags = RTF_UP;
1971 if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1973 if ( ! ok_error ( errno ))
1974 error("default route ioctl(SIOCDELRT): %m");
1983 /********************************************************************
1985 * sifproxyarp - Make a proxy ARP entry for the peer.
1988 int sifproxyarp (int unit, u_int32_t his_adr)
1990 struct arpreq arpreq;
1993 if (has_proxy_arp == 0) {
1994 memset (&arpreq, '\0', sizeof(arpreq));
1996 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1997 SIN_ADDR(arpreq.arp_pa) = his_adr;
1998 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2000 * Get the hardware address of an interface on the same subnet
2001 * as our local address.
2003 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2004 sizeof(proxy_arp_dev))) {
2005 error("Cannot determine ethernet address for proxy ARP");
2008 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2010 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2011 if ( ! ok_error ( errno ))
2012 error("ioctl(SIOCSARP): %m");
2015 proxy_arp_addr = his_adr;
2019 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2020 if (forw_path != 0) {
2021 int fd = open(forw_path, O_WRONLY);
2023 if (write(fd, "1", 1) != 1)
2024 error("Couldn't enable IP forwarding: %m");
2034 /********************************************************************
2036 * cifproxyarp - Delete the proxy ARP entry for the peer.
2039 int cifproxyarp (int unit, u_int32_t his_adr)
2041 struct arpreq arpreq;
2043 if (has_proxy_arp) {
2045 memset (&arpreq, '\0', sizeof(arpreq));
2046 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2047 SIN_ADDR(arpreq.arp_pa) = his_adr;
2048 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2049 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2051 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2052 if ( ! ok_error ( errno ))
2053 warn("ioctl(SIOCDARP): %m");
2060 /********************************************************************
2062 * get_ether_addr - get the hardware address of an interface on the
2063 * the same subnet as ipaddr.
2066 static int get_ether_addr (u_int32_t ipaddr,
2067 struct sockaddr *hwaddr,
2068 char *name, int namelen)
2070 struct ifreq *ifr, *ifend;
2071 u_int32_t ina, mask;
2073 struct ifreq ifreq, bestifreq;
2075 struct ifreq ifs[MAX_IFS];
2077 u_int32_t bestmask=0;
2078 int found_interface = 0;
2080 ifc.ifc_len = sizeof(ifs);
2082 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2083 if ( ! ok_error ( errno ))
2084 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2089 * Scan through looking for an interface with an Internet
2090 * address on the same subnet as `ipaddr'.
2092 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2093 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2094 if (ifr->ifr_addr.sa_family == AF_INET) {
2095 ina = SIN_ADDR(ifr->ifr_addr);
2096 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2098 * Check that the interface is up, and not point-to-point
2101 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2104 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2107 * Get its netmask and check that it's on the right subnet.
2109 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2112 mask = SIN_ADDR(ifreq.ifr_addr);
2114 if (((ipaddr ^ ina) & mask) != 0)
2115 continue; /* no match */
2117 if (mask >= bestmask) {
2118 /* Compare using >= instead of > -- it is possible for
2119 an interface to have a netmask of 0.0.0.0 */
2120 found_interface = 1;
2127 if (!found_interface) return 0;
2129 strlcpy(name, bestifreq.ifr_name, namelen);
2131 /* trim off the :1 in eth0:1 */
2132 aliasp = strchr(name, ':');
2136 info("found interface %s for proxy arp", name);
2138 * Now get the hardware address.
2140 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2141 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2142 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2147 &bestifreq.ifr_hwaddr,
2148 sizeof (struct sockaddr));
2154 * get_if_hwaddr - get the hardware address for the specified
2155 * network interface device.
2158 get_if_hwaddr(u_char *addr, char *name)
2163 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2166 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2167 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2168 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2171 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2176 * get_first_ether_hwaddr - get the hardware address for the first
2177 * ethernet-style interface on this system.
2180 get_first_ether_hwaddr(u_char *addr)
2182 struct if_nameindex *if_ni, *i;
2186 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2190 if_ni = if_nameindex();
2198 for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2199 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2200 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2201 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2202 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2203 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2209 if_freenameindex(if_ni);
2215 /********************************************************************
2217 * Return user specified netmask, modified by any mask we might determine
2218 * for address `addr' (in network byte order).
2219 * Here we scan through the system's list of interfaces, looking for
2220 * any non-point-to-point interfaces which might appear to be on the same
2221 * network as `addr'. If we find any, we OR in their netmask to the
2222 * user-specified netmask.
2225 u_int32_t GetMask (u_int32_t addr)
2227 u_int32_t mask, nmask, ina;
2228 struct ifreq *ifr, *ifend, ifreq;
2230 struct ifreq ifs[MAX_IFS];
2234 if (IN_CLASSA(addr)) /* determine network mask for address class */
2235 nmask = IN_CLASSA_NET;
2236 else if (IN_CLASSB(addr))
2237 nmask = IN_CLASSB_NET;
2239 nmask = IN_CLASSC_NET;
2241 /* class D nets are disallowed by bad_ip_adrs */
2242 mask = netmask | htonl(nmask);
2244 * Scan through the system's network interfaces.
2246 ifc.ifc_len = sizeof(ifs);
2248 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2249 if ( ! ok_error ( errno ))
2250 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2254 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2255 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2257 * Check the interface's internet address.
2259 if (ifr->ifr_addr.sa_family != AF_INET)
2261 ina = SIN_ADDR(ifr->ifr_addr);
2262 if (((ntohl(ina) ^ addr) & nmask) != 0)
2265 * Check that the interface is up, and not point-to-point nor loopback.
2267 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2268 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2271 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2274 * Get its netmask and OR it into our mask.
2276 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2278 mask |= SIN_ADDR(ifreq.ifr_addr);
2284 /********************************************************************
2286 * Internal routine to decode the version.modification.patch level
2289 static void decode_version (char *buf, int *version,
2290 int *modification, int *patch)
2294 *version = (int) strtoul (buf, &endp, 10);
2298 if (endp != buf && *endp == '.') {
2300 *modification = (int) strtoul (buf, &endp, 10);
2301 if (endp != buf && *endp == '.') {
2303 *patch = (int) strtoul (buf, &buf, 10);
2308 /********************************************************************
2310 * Procedure to determine if the PPP line discipline is registered.
2314 ppp_registered(void)
2322 * We used to open the serial device and set it to the ppp line
2323 * discipline here, in order to create a ppp unit. But that is
2324 * not a good idea - the user might have specified a device that
2325 * they can't open (permission, or maybe it doesn't really exist).
2326 * So we grab a pty master/slave pair and use that.
2328 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2329 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2334 * Try to put the device into the PPP discipline.
2336 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2337 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2346 /********************************************************************
2348 * ppp_available - check whether the system has any ppp interfaces
2349 * (in fact we check whether we can do an ioctl on ppp0).
2352 int ppp_available(void)
2357 int my_version, my_modification, my_patch;
2358 int osmaj, osmin, ospatch;
2360 /* get the kernel version now, since we are called before sys_init */
2362 osmaj = osmin = ospatch = 0;
2363 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2364 kernel_version = KVERSION(osmaj, osmin, ospatch);
2366 fd = open("/dev/ppp", O_RDWR);
2368 new_style_driver = 1;
2370 /* XXX should get from driver */
2372 driver_modification = 4;
2378 if (kernel_version >= KVERSION(2,3,13)) {
2379 error("Couldn't open the /dev/ppp device: %m");
2380 if (errno == ENOENT)
2382 "You need to create the /dev/ppp device node by\n"
2383 "executing the following command as root:\n"
2384 " mknod /dev/ppp c 108 0\n";
2385 else if (errno == ENODEV || errno == ENXIO)
2387 "Please load the ppp_generic kernel module.\n";
2391 /* we are running on a really really old kernel */
2393 "This system lacks kernel support for PPP. This could be because\n"
2394 "the PPP kernel module could not be loaded, or because PPP was not\n"
2395 "included in the kernel configuration. If PPP was included as a\n"
2396 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2397 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2398 "See README.linux file in the ppp distribution for more details.\n";
2401 * Open a socket for doing the ioctl operations.
2403 s = socket(AF_INET, SOCK_DGRAM, 0);
2407 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2408 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2410 * If the device did not exist then attempt to create one by putting the
2411 * current tty into the PPP discipline. If this works then obtain the
2412 * flags for the device again.
2415 if (ppp_registered()) {
2416 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2417 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2421 * Ensure that the hardware address is for PPP and not something else
2424 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2426 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2430 * This is the PPP device. Validate the version of the driver at this
2431 * point to ensure that this program will work with the driver.
2434 char abBuffer [1024];
2436 ifr.ifr_data = abBuffer;
2437 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2439 error("Couldn't read driver version: %m");
2441 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2444 decode_version(abBuffer,
2446 &driver_modification,
2449 * Validate the version of the driver against the version that we used.
2451 decode_version(VERSION,
2456 /* The version numbers must match */
2457 if (driver_version != my_version)
2460 /* The modification levels must be legal */
2461 if (driver_modification < 3) {
2462 if (driver_modification >= 2) {
2463 /* we can cope with 2.2.0 and above */
2471 slprintf(route_buffer, sizeof(route_buffer),
2472 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2473 driver_version, driver_modification, driver_patch);
2475 no_ppp_msg = route_buffer;
2483 #ifndef HAVE_LOGWTMP
2484 /********************************************************************
2486 * Update the wtmp file with the appropriate user name and tty device.
2489 void logwtmp (const char *line, const char *name, const char *host)
2491 struct utmp ut, *utp;
2492 pid_t mypid = getpid();
2498 * Update the signon database for users.
2499 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2501 utmpname(_PATH_UTMP);
2503 while ((utp = getutent()) && (utp->ut_pid != mypid))
2507 memcpy(&ut, utp, sizeof(ut));
2509 /* some gettys/telnetds don't initialize utmp... */
2510 memset(&ut, 0, sizeof(ut));
2512 if (ut.ut_id[0] == 0)
2513 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2515 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2516 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2520 ut.ut_type = USER_PROCESS;
2523 /* Insert the host name if one is supplied */
2525 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2527 /* Insert the IP address of the remote system if IP is enabled */
2528 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2529 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2530 sizeof(ut.ut_addr));
2532 /* CL: Makes sure that the logout works */
2533 if (*host == 0 && *name==0)
2539 * Update the wtmp file.
2542 updwtmp(_PATH_WTMP, &ut);
2544 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2546 flock(wtmp, LOCK_EX);
2548 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2549 warn("error writing %s: %m", _PATH_WTMP);
2551 flock(wtmp, LOCK_UN);
2557 #endif /* HAVE_LOGWTMP */
2559 /********************************************************************
2561 * sifvjcomp - config tcp header compression
2564 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2569 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2570 error("Couldn't set up TCP header compression: %m");
2575 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2576 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2581 /********************************************************************
2583 * sifup - Config the interface up and enable IP packets to pass.
2590 if ((ret = setifstate(u, 1)))
2596 /********************************************************************
2598 * sifdown - Disable the indicated protocol and config the interface
2599 * down if there are no remaining protocols.
2604 if (if_is_up && --if_is_up > 0)
2612 return setifstate(u, 0);
2616 /********************************************************************
2618 * sif6up - Config the interface up for IPv6
2625 if ((ret = setifstate(u, 1)))
2631 /********************************************************************
2633 * sif6down - Disable the IPv6CP protocol and config the interface
2634 * down if there are no remaining protocols.
2637 int sif6down (int u)
2644 return setifstate(u, 0);
2648 /********************************************************************
2650 * setifstate - Config the interface up or down
2653 static int setifstate (int u, int state)
2657 memset (&ifr, '\0', sizeof (ifr));
2658 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2659 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2660 if (! ok_error (errno))
2661 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2666 ifr.ifr_flags |= IFF_UP;
2668 ifr.ifr_flags &= ~IFF_UP;
2669 ifr.ifr_flags |= IFF_POINTOPOINT;
2670 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2671 if (! ok_error (errno))
2672 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2678 /********************************************************************
2680 * sifaddr - Config the interface IP addresses and netmask.
2683 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2689 memset (&ifr, '\0', sizeof (ifr));
2690 memset (&rt, '\0', sizeof (rt));
2692 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2693 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2694 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2696 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2698 * Set our IP address
2700 SIN_ADDR(ifr.ifr_addr) = our_adr;
2701 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2702 if (errno != EEXIST) {
2703 if (! ok_error (errno))
2704 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2707 warn("ioctl(SIOCSIFADDR): Address already exists");
2712 * Set the gateway address
2715 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2716 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2717 if (! ok_error (errno))
2718 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2724 * For recent kernels, force the netmask to 255.255.255.255.
2726 if (kernel_version >= KVERSION(2,1,16))
2728 if (net_mask != 0) {
2729 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2730 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2731 if (! ok_error (errno))
2732 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2737 * Add the device route
2739 if (kernel_version < KVERSION(2,1,16)) {
2740 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2741 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2744 SIN_ADDR(rt.rt_gateway) = 0L;
2745 SIN_ADDR(rt.rt_dst) = his_adr;
2746 rt.rt_flags = RTF_UP | RTF_HOST;
2748 if (kernel_version > KVERSION(2,1,0)) {
2749 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2750 SIN_ADDR(rt.rt_genmask) = -1L;
2753 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2754 if (! ok_error (errno))
2755 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2760 /* set ip_dynaddr in demand mode if address changes */
2761 if (demand && tune_kernel && !dynaddr_set
2762 && our_old_addr && our_old_addr != our_adr) {
2763 /* set ip_dynaddr if possible */
2767 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2768 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2769 if (write(fd, "1", 1) != 1)
2770 error("Couldn't enable dynamic IP addressing: %m");
2773 dynaddr_set = 1; /* only 1 attempt */
2780 /********************************************************************
2782 * cifaddr - Clear the interface IP addresses, and delete routes
2783 * through the interface if possible.
2786 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2790 if (kernel_version < KVERSION(2,1,16)) {
2792 * Delete the route through the device
2795 memset (&rt, '\0', sizeof (rt));
2797 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2798 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2801 SIN_ADDR(rt.rt_gateway) = 0;
2802 SIN_ADDR(rt.rt_dst) = his_adr;
2803 rt.rt_flags = RTF_UP | RTF_HOST;
2805 if (kernel_version > KVERSION(2,1,0)) {
2806 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2807 SIN_ADDR(rt.rt_genmask) = -1L;
2810 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2811 if (still_ppp() && ! ok_error (errno))
2812 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2817 /* This way it is possible to have an IPX-only or IPv6-only interface */
2818 memset(&ifr, 0, sizeof(ifr));
2819 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2820 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2822 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2823 if (! ok_error (errno)) {
2824 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2829 our_old_addr = our_adr;
2835 /********************************************************************
2837 * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
2839 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
2842 struct nlmsghdr nlh;
2843 struct ifaddrmsg ifa;
2846 struct in6_addr addr;
2850 struct nlmsghdr nlh;
2851 struct nlmsgerr nlerr;
2853 struct sockaddr_nl nladdr;
2860 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
2862 error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
2867 * Tell kernel to not send to us payload of acknowledgment error message.
2868 * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
2869 * older kernel versions always send full payload in acknowledgment netlink
2870 * message. We ignore payload of this message as we need only error code,
2871 * to check if our set remote peer address request succeeded or failed.
2872 * So ignore return value from the following setsockopt() call as setting
2873 * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
2876 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
2878 memset(&nladdr, 0, sizeof(nladdr));
2879 nladdr.nl_family = AF_NETLINK;
2881 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
2882 error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
2887 memset(&nlreq, 0, sizeof(nlreq));
2888 nlreq.nlh.nlmsg_len = sizeof(nlreq);
2889 nlreq.nlh.nlmsg_type = RTM_NEWADDR;
2890 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
2891 nlreq.ifa.ifa_family = AF_INET6;
2892 nlreq.ifa.ifa_prefixlen = 128;
2893 nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
2894 nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
2895 nlreq.ifa.ifa_index = iface;
2896 nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
2897 nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
2898 IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
2899 nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
2900 nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
2901 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
2903 memset(&nladdr, 0, sizeof(nladdr));
2904 nladdr.nl_family = AF_NETLINK;
2906 memset(&iov, 0, sizeof(iov));
2907 iov.iov_base = &nlreq;
2908 iov.iov_len = sizeof(nlreq);
2910 memset(&msg, 0, sizeof(msg));
2911 msg.msg_name = &nladdr;
2912 msg.msg_namelen = sizeof(nladdr);
2916 if (sendmsg(fd, &msg, 0) < 0) {
2917 error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
2922 memset(&iov, 0, sizeof(iov));
2923 iov.iov_base = &nlresp;
2924 iov.iov_len = sizeof(nlresp);
2926 memset(&msg, 0, sizeof(msg));
2927 msg.msg_name = &nladdr;
2928 msg.msg_namelen = sizeof(nladdr);
2932 nlresplen = recvmsg(fd, &msg, 0);
2934 if (nlresplen < 0) {
2935 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
2942 if (nladdr.nl_family != AF_NETLINK) {
2943 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
2947 if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
2948 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
2952 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
2953 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
2954 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
2958 /* error == 0 indicates success, negative value is errno code */
2959 if (nlresp.nlerr.error != 0) {
2960 error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
2967 /********************************************************************
2969 * sif6addr - Config the interface with an IPv6 link-local address
2971 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2973 struct in6_ifreq ifr6;
2975 struct in6_rtmsg rt6;
2979 error("IPv6 socket creation failed: %m");
2982 memset(&ifr, 0, sizeof (ifr));
2983 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2984 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2985 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2989 if (kernel_version >= KVERSION(2,1,16)) {
2990 /* Set both local address and remote peer address (with route for it) via rtnetlink */
2991 return sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
2993 /* Local interface */
2994 memset(&ifr6, 0, sizeof(ifr6));
2995 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2996 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2997 ifr6.ifr6_prefixlen = 128;
2999 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3000 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3005 * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3006 * setting remote peer host address, so set only route to remote host.
3009 /* Route to remote host */
3010 memset(&rt6, 0, sizeof(rt6));
3011 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3012 rt6.rtmsg_flags = RTF_UP;
3013 rt6.rtmsg_dst_len = 128;
3014 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3015 rt6.rtmsg_metric = 1;
3017 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3018 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3027 /********************************************************************
3029 * cif6addr - Remove IPv6 address from interface
3031 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3034 struct in6_ifreq ifr6;
3038 error("IPv6 socket creation failed: %m");
3041 memset(&ifr, 0, sizeof(ifr));
3042 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3043 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3044 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3048 memset(&ifr6, 0, sizeof(ifr6));
3049 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3050 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3051 ifr6.ifr6_prefixlen = 128;
3053 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3054 if (errno != EADDRNOTAVAIL) {
3055 if (! ok_error (errno))
3056 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3059 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3068 * get_pty - get a pty master/slave pair and chown the slave side
3069 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
3072 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3074 int i, mfd, sfd = -1;
3076 struct termios tios;
3080 * Try the unix98 way first.
3082 mfd = open("/dev/ptmx", O_RDWR);
3085 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3086 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3087 chmod(pty_name, S_IRUSR | S_IWUSR);
3090 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3091 warn("Couldn't unlock pty slave %s: %m", pty_name);
3093 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3095 warn("Couldn't open pty slave %s: %m", pty_name);
3100 #endif /* TIOCGPTN */
3103 /* the old way - scan through the pty name space */
3104 for (i = 0; i < 64; ++i) {
3105 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3106 'p' + i / 16, i % 16);
3107 mfd = open(pty_name, O_RDWR, 0);
3110 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3112 fchown(sfd, uid, -1);
3113 fchmod(sfd, S_IRUSR | S_IWUSR);
3124 strlcpy(slave_name, pty_name, 16);
3127 if (tcgetattr(sfd, &tios) == 0) {
3128 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3129 tios.c_cflag |= CS8 | CREAD | CLOCAL;
3130 tios.c_iflag = IGNPAR;
3133 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3134 warn("couldn't set attributes on pty: %m");
3136 warn("couldn't get attributes on pty: %m");
3141 /********************************************************************
3143 * open_loopback - open the device we use for getting packets
3144 * in demand mode. Under Linux, we use a pty master/slave pair.
3147 open_ppp_loopback(void)
3152 if (new_style_driver) {
3153 /* allocate ourselves a ppp unit */
3154 if (make_ppp_unit() < 0)
3156 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3157 set_kdebugflag(kdebugflag);
3162 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3163 fatal("No free pty for loopback");
3165 set_ppp_fd(slave_fd);
3167 flags = fcntl(master_fd, F_GETFL);
3169 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3170 warn("couldn't set master loopback to nonblock: %m");
3172 flags = fcntl(ppp_fd, F_GETFL);
3174 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3175 warn("couldn't set slave loopback to nonblock: %m");
3177 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3178 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3180 * Find out which interface we were given.
3182 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3183 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3185 * Enable debug in the driver if requested.
3187 set_kdebugflag (kdebugflag);
3192 /********************************************************************
3194 * sifnpmode - Set the mode for handling packets for a given NP.
3198 sifnpmode(int u, int proto, enum NPmode mode)
3202 npi.protocol = proto;
3204 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3205 if (! ok_error (errno))
3206 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3213 /********************************************************************
3215 * sipxfaddr - Config the interface IPX networknumber
3218 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
3225 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3227 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3229 if (! ok_error (errno))
3230 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3234 memset (&ifr, '\0', sizeof (ifr));
3235 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3237 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
3238 sipx->sipx_family = AF_IPX;
3239 sipx->sipx_port = 0;
3240 sipx->sipx_network = htonl (network);
3241 sipx->sipx_type = IPX_FRAME_ETHERII;
3242 sipx->sipx_action = IPX_CRTITF;
3244 * Set the IPX device
3246 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3248 if (errno != EEXIST) {
3249 if (! ok_error (errno))
3250 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
3253 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
3262 /********************************************************************
3264 * cipxfaddr - Clear the information for the IPX network. The IPX routes
3265 * are removed and the device is no longer able to pass IPX
3269 int cipxfaddr (int unit)
3276 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3278 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3280 if (! ok_error (errno))
3281 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3285 memset (&ifr, '\0', sizeof (ifr));
3286 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3288 sipx->sipx_type = IPX_FRAME_ETHERII;
3289 sipx->sipx_action = IPX_DLTITF;
3290 sipx->sipx_family = AF_IPX;
3292 * Set the IPX device
3294 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3295 if (! ok_error (errno))
3296 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
3306 * Use the hostname as part of the random number seed.
3315 for (p = hostname; *p != 0; ++p)
3320 /********************************************************************
3322 * sys_check_options - check the options that the user specified
3326 sys_check_options(void)
3330 * Disable the IPX protocol if the support is not present in the kernel.
3334 if (ipxcp_protent.enabled_flag) {
3335 struct stat stat_buf;
3336 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
3337 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
3338 || lstat(path, &stat_buf) < 0) {
3339 error("IPX support is not present in the kernel\n");
3340 ipxcp_protent.enabled_flag = 0;
3344 if (demand && driver_is_old) {
3345 option_error("demand dialling is not supported by kernel driver "
3346 "version %d.%d.%d", driver_version, driver_modification,
3350 if (multilink && !new_style_driver) {
3351 warn("Warning: multilink is not supported by the kernel driver");
3357 /********************************************************************
3359 * get_time - Get current time, monotonic if possible.
3362 get_time(struct timeval *tv)
3364 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3365 * Runtime checking makes it safe. */
3366 #ifndef CLOCK_MONOTONIC
3367 #define CLOCK_MONOTONIC 1
3369 static int monotonic = -1;
3374 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3378 tv->tv_sec = ts.tv_sec;
3379 tv->tv_usec = ts.tv_nsec / 1000;
3382 } else if (monotonic > 0)
3386 warn("Couldn't use monotonic clock source: %m");
3389 return gettimeofday(tv, NULL);