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>
102 /* This is in netdevice.h. However, this compile will fail miserably if
103 you attempt to include netdevice.h because it has so many references
104 to __memcpy functions which it should not attempt to do. So, since I
105 really don't use it, but it must be defined, define it now. */
108 #define MAX_ADDR_LEN 7
111 #if !defined(__GLIBC__) || __GLIBC__ >= 2
112 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
113 #include <asm/ioctls.h>
115 #include <net/if_arp.h>
116 #include <net/route.h>
117 #include <netinet/if_ether.h>
119 #include <linux/types.h>
120 #include <linux/if.h>
121 #include <linux/if_arp.h>
122 #include <linux/route.h>
123 #include <linux/if_ether.h>
125 #include <netinet/in.h>
126 #include <arpa/inet.h>
128 #include <linux/ppp_defs.h>
129 #include <linux/if_ppp.h>
132 #include <linux/netlink.h>
133 #include <linux/rtnetlink.h>
134 #include <linux/if_addr.h>
135 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
137 #define SOL_NETLINK 270
139 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
140 #ifndef NETLINK_CAP_ACK
141 #define NETLINK_CAP_ACK 10
151 #if __GLIBC__ >= 2 && \
152 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
153 #include <netipx/ipx.h>
155 #include <linux/ipx.h>
157 #endif /* IPX_CHANGE */
160 #include <pcap-bpf.h>
161 #include <linux/filter.h>
162 #endif /* PPP_FILTER */
165 #include <sys/locks.h>
169 #define BOTHER 0010000
172 unsigned int c_iflag;
173 unsigned int c_oflag;
174 unsigned int c_cflag;
175 unsigned int c_lflag;
176 unsigned char c_line;
177 unsigned char c_cc[19];
178 unsigned int c_ispeed;
179 unsigned int c_ospeed;
185 * This is in linux/include/net/ipv6.h.
189 struct in6_addr ifr6_addr;
190 __u32 ifr6_prefixlen;
191 unsigned int ifr6_ifindex;
195 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
196 memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr)); \
197 (sin6).s6_addr16[0] = htons(0xfe80); \
198 eui64_copy(eui64, (sin6).s6_addr32[2]); \
201 static const eui64_t nulleui64;
204 /* We can get an EIO error on an ioctl if the modem has hung up */
205 #define ok_error(num) ((num)==EIO)
207 static int tty_disc = N_TTY; /* The TTY discipline */
208 static int ppp_disc = N_PPP; /* The PPP discpline */
209 static int initfdflags = -1; /* Initial file descriptor flags for fd */
210 static int ppp_fd = -1; /* fd which is set to PPP discipline */
211 static int sock_fd = -1; /* socket for doing interface ioctls */
212 static int slave_fd = -1; /* pty for old-style demand mode, slave */
213 static int master_fd = -1; /* pty for old-style demand mode, master */
215 static int sock6_fd = -1;
219 * For the old-style kernel driver, this is the same as ppp_fd.
220 * For the new-style driver, it is the fd of an instance of /dev/ppp
221 * which is attached to the ppp unit and is used for controlling it.
223 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
225 static int chindex; /* channel index (new style driver) */
227 static fd_set in_fds; /* set of fds that wait_input waits for */
228 static int max_in_fd; /* highest fd set in in_fds */
230 static int has_proxy_arp = 0;
231 static int driver_version = 0;
232 static int driver_modification = 0;
233 static int driver_patch = 0;
234 static int driver_is_old = 0;
235 static int restore_term = 0; /* 1 => we've munged the terminal */
236 static struct termios inittermios; /* Initial TTY termios */
238 int new_style_driver = 0;
240 static char loop_name[20];
241 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
243 static int if_is_up; /* Interface has been marked up */
244 static int if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
245 static int have_default_route; /* Gateway for default route added */
246 static int have_default_route6; /* Gateway for default IPv6 route added */
247 static struct rtentry old_def_rt; /* Old default route */
248 static int default_rt_repl_rest; /* replace and restore old default rt */
249 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
250 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
251 static u_int32_t our_old_addr; /* for detecting address changes */
252 static int dynaddr_set; /* 1 if ip_dynaddr set */
253 static int looped; /* 1 if using loop */
254 static int link_mtu; /* mtu for the link (not bundle) */
256 static struct utsname utsname; /* for the kernel version */
257 static int kernel_version;
258 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
262 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
263 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
264 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
266 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
268 /* Prototypes for procedures local to this file. */
269 static int modify_flags(int fd, int clear_bits, int set_bits);
270 static int translate_speed (int bps);
271 static int baud_rate_of (int speed);
272 static void close_route_table (void);
273 static int open_route_table (void);
274 static int read_route_table (struct rtentry *rt);
275 static int defaultroute_exists (struct rtentry *rt, int metric);
276 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
277 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
278 char *name, int namelen);
279 static void decode_version (char *buf, int *version, int *mod, int *patch);
280 static int set_kdebugflag(int level);
281 static int ppp_registered(void);
282 static int make_ppp_unit(void);
283 static int setifstate (int u, int state);
285 extern u_char inpacket_buf[]; /* borrowed from main.c */
287 extern int dfl_route_metric;
290 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
294 #define SET_SA_FAMILY(addr, family) \
295 memset ((char *) &(addr), '\0', sizeof(addr)); \
296 addr.sa_family = (family);
299 * Determine if the PPP connection should still be present.
304 /* new_fd is the fd of a tty */
305 static void set_ppp_fd (int new_fd)
308 if (!new_style_driver)
312 static int still_ppp(void)
314 if (new_style_driver)
315 return !hungup && ppp_fd >= 0;
316 if (!hungup || ppp_fd == slave_fd)
319 set_ppp_fd(slave_fd);
326 * modify_flags - set and clear flag bits controlling the kernel
329 static int modify_flags(int fd, int clear_bits, int set_bits)
333 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
335 flags = (flags & ~clear_bits) | set_bits;
336 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
343 error("Failed to set PPP kernel option flags: %m");
347 /********************************************************************
349 * sys_init - System-dependent initialization.
354 /* Get an internet socket for doing socket ioctls. */
355 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
357 fatal("Couldn't create IP socket: %m(%d)", errno);
360 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
362 sock6_fd = -errno; /* save errno for later */
369 /********************************************************************
371 * sys_cleanup - restore any system state we modified before exiting:
372 * mark the interface down, delete default route and/or proxy arp entry.
373 * This shouldn't call die() because it's called from die().
376 void sys_cleanup(void)
379 * Take down the device
389 * Delete any routes through the device.
391 if (have_default_route)
392 cifdefaultroute(0, 0, 0);
394 if (have_default_route6)
395 cif6defaultroute(0, nulleui64, nulleui64);
399 cifproxyarp(0, proxy_arp_addr);
402 /********************************************************************
404 * sys_close - Clean up in a child process before execing.
409 if (new_style_driver && ppp_dev_fd >= 0)
423 /********************************************************************
425 * set_kdebugflag - Define the debugging level for the kernel
428 static int set_kdebugflag (int requested_level)
432 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
433 if ( ! ok_error (errno) )
434 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
440 /********************************************************************
442 * tty_establish_ppp - Turn the serial port into a ppp interface.
445 int tty_establish_ppp (int tty_fd)
450 * Ensure that the tty device is in exclusive mode.
452 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
453 if ( ! ok_error ( errno ))
454 warn("Couldn't make tty exclusive: %m");
457 * Demand mode - prime the old ppp device to relinquish the unit.
459 if (!new_style_driver && looped
460 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
461 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
465 * Set the current tty to the PPP discpline
469 #define N_SYNC_PPP 14
471 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
472 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
473 if ( ! ok_error (errno) ) {
474 error("Couldn't set tty to PPP discipline: %m");
479 ret_fd = generic_establish_ppp(tty_fd);
481 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
482 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
486 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
487 (kdebugflag * SC_DEBUG) & SC_LOGB);
489 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
490 warn("Couldn't reset tty to normal line discipline: %m");
496 /********************************************************************
498 * generic_establish_ppp - Turn the fd into a ppp interface.
500 int generic_establish_ppp (int fd)
504 if (new_style_driver) {
507 /* If a ppp_fd is already open, close it first */
514 /* Open an instance of /dev/ppp and connect the channel to it */
515 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
516 error("Couldn't get channel number: %m");
519 dbglog("using channel %d", chindex);
520 fd = open("/dev/ppp", O_RDWR);
522 error("Couldn't reopen /dev/ppp: %m");
525 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
526 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
527 error("Couldn't attach to channel %d: %m", chindex);
530 flags = fcntl(fd, F_GETFL);
531 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
532 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
537 if (!looped && !multilink) {
539 * Create a new PPP unit.
541 if (make_ppp_unit() < 0)
546 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
550 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
551 error("Couldn't attach to PPP unit %d: %m", ifunit);
558 * Old-style driver: find out which interface we were given.
561 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
562 if (ok_error (errno))
564 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
566 /* Check that we got the same unit again. */
567 if (looped && x != ifunit)
568 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
572 * Fetch the initial file flags and reset blocking mode on the file.
574 initfdflags = fcntl(fd, F_GETFL);
575 if (initfdflags == -1 ||
576 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
577 if ( ! ok_error (errno))
578 warn("Couldn't set device to non-blocking mode: %m");
583 * Enable debug in the driver if requested.
586 set_kdebugflag (kdebugflag);
598 /********************************************************************
600 * tty_disestablish_ppp - Restore the serial port to normal operation.
601 * This shouldn't call die() because it's called from die().
604 void tty_disestablish_ppp(int tty_fd)
608 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
610 if (tcflush(tty_fd, TCIOFLUSH) < 0)
612 warn("tcflush failed: %m");
616 * Restore the previous line discipline
618 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
619 if ( ! ok_error (errno))
620 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
623 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
624 if ( ! ok_error (errno))
625 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
628 /* Reset non-blocking mode on fd. */
629 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
630 if ( ! ok_error (errno))
631 warn("Couldn't restore device fd flags: %m");
637 generic_disestablish_ppp(tty_fd);
640 /********************************************************************
642 * generic_disestablish_ppp - Restore device components to normal
643 * operation, and reconnect the ppp unit to the loopback if in demand
644 * mode. This shouldn't call die() because it's called from die().
646 void generic_disestablish_ppp(int dev_fd)
648 if (new_style_driver) {
652 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
654 } else if (!doing_multilink && ppp_dev_fd >= 0) {
656 remove_fd(ppp_dev_fd);
660 /* old-style driver */
662 set_ppp_fd(slave_fd);
669 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
670 * Assumes new_style_driver.
672 static int make_ppp_unit(void)
676 if (ppp_dev_fd >= 0) {
677 dbglog("in make_ppp_unit, already had /dev/ppp open?");
680 ppp_dev_fd = open("/dev/ppp", O_RDWR);
682 fatal("Couldn't open /dev/ppp: %m");
683 flags = fcntl(ppp_dev_fd, F_GETFL);
685 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
686 warn("Couldn't set /dev/ppp to nonblock: %m");
689 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
690 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
691 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
693 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
696 error("Couldn't create new ppp unit: %m");
698 if (x == 0 && req_ifname[0] != '\0') {
700 char t[MAXIFNAMELEN];
701 memset(&ifr, 0, sizeof(struct ifreq));
702 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
703 strlcpy(ifr.ifr_name, t, IF_NAMESIZE);
704 strlcpy(ifr.ifr_newname, req_ifname, IF_NAMESIZE);
705 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
707 error("Couldn't rename interface %s to %s: %m", t, req_ifname);
709 info("Renamed interface %s to %s", t, req_ifname);
716 * cfg_bundle - configure the existing bundle.
717 * Used in demand mode.
719 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
721 if (!new_style_driver)
724 /* set the mrru, mtu and flags */
725 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
726 error("Couldn't set MRRU: %m");
728 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
729 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
730 | (mrru? SC_MULTILINK: 0)));
732 /* connect up the channel */
733 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
734 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
739 * make_new_bundle - create a new PPP unit (i.e. a bundle)
740 * and connect our channel to it. This should only get called
741 * if `multilink' was set at the time establish_ppp was called.
742 * In demand mode this uses our existing bundle instead of making
745 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
747 if (!new_style_driver)
750 /* make us a ppp unit */
751 if (make_ppp_unit() < 0)
754 /* set the mrru and flags */
755 cfg_bundle(mrru, mtru, rssn, tssn);
759 * bundle_attach - attach our link to a given PPP unit.
760 * We assume the unit is controlled by another pppd.
762 int bundle_attach(int ifnum)
766 if (!new_style_driver)
769 master_fd = open("/dev/ppp", O_RDWR);
771 fatal("Couldn't open /dev/ppp: %m");
772 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
773 if (errno == ENXIO) {
775 return 0; /* doesn't still exist */
777 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
779 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
780 fatal("Couldn't connect to interface unit %d: %m", ifnum);
781 modify_flags(master_fd, 0, SC_MULTILINK);
789 * destroy_bundle - tell the driver to destroy our bundle.
791 void destroy_bundle(void)
793 if (ppp_dev_fd >= 0) {
795 remove_fd(ppp_dev_fd);
800 /********************************************************************
802 * clean_check - Fetch the flags for the device and generate
803 * appropriate error messages.
805 void clean_check(void)
811 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
813 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
815 s = "all had bit 7 set to 1";
819 s = "all had bit 7 set to 0";
823 s = "all had odd parity";
827 s = "all had even parity";
832 warn("Receive serial link is not 8-bit clean:");
833 warn("Problem: %s", s);
841 * List of valid speeds.
845 int speed_int, speed_val;
932 { 1000000, B1000000 },
935 { 1152000, B1152000 },
938 { 1500000, B1500000 },
941 { 2000000, B2000000 },
944 { 2500000, B2500000 },
947 { 3000000, B3000000 },
950 { 3500000, B3500000 },
953 { 4000000, B4000000 },
958 /********************************************************************
960 * Translate from bits/second to a speed_t.
963 static int translate_speed (int bps)
965 struct speed *speedp;
968 for (speedp = speeds; speedp->speed_int; speedp++) {
969 if (bps == speedp->speed_int)
970 return speedp->speed_val;
976 /********************************************************************
978 * Translate from a speed_t to bits/second.
981 static int baud_rate_of (int speed)
983 struct speed *speedp;
986 for (speedp = speeds; speedp->speed_int; speedp++) {
987 if (speed == speedp->speed_val)
988 return speedp->speed_int;
994 /********************************************************************
996 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
997 * at the requested speed, etc. If `local' is true, set CLOCAL
998 * regardless of whether the modem option was specified.
1001 void set_up_tty(int tty_fd, int local)
1004 struct termios tios;
1007 if (tcgetattr(tty_fd, &tios) < 0) {
1008 if (!ok_error(errno))
1009 fatal("tcgetattr: %m (line %d)", __LINE__);
1016 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1017 tios.c_cflag |= CS8 | CREAD | HUPCL;
1019 tios.c_iflag = IGNBRK | IGNPAR;
1022 tios.c_cc[VMIN] = 1;
1023 tios.c_cc[VTIME] = 0;
1025 if (local || !modem)
1026 tios.c_cflag ^= (CLOCAL | HUPCL);
1030 tios.c_cflag |= CRTSCTS;
1034 tios.c_iflag |= IXON | IXOFF;
1035 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
1036 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
1040 tios.c_cflag &= ~CRTSCTS;
1048 tios.c_cflag |= CSTOPB;
1051 speed = translate_speed(inspeed);
1053 cfsetospeed (&tios, speed);
1054 cfsetispeed (&tios, speed);
1055 speed = cfgetospeed(&tios);
1057 baud_rate = baud_rate_of(speed);
1060 speed = cfgetospeed(&tios);
1061 baud_rate = baud_rate_of(speed);
1064 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1066 fatal("tcsetattr: %m (line %d)", __LINE__);
1069 /* Most Linux architectures and drivers support arbitrary baud rate values via BOTHER */
1072 struct termios2 tios2;
1073 if (ioctl(tty_fd, TCGETS2, &tios2) == 0) {
1075 tios2.c_cflag &= ~CBAUD;
1076 tios2.c_cflag |= BOTHER;
1077 tios2.c_ispeed = inspeed;
1078 tios2.c_ospeed = inspeed;
1080 if (ioctl(tty_fd, TCSETS2, &tios2) == 0)
1081 baud_rate = inspeed;
1084 if ((tios2.c_cflag & CBAUD) == BOTHER && tios2.c_ospeed)
1085 baud_rate = tios2.c_ospeed;
1092 * We can't proceed if the serial port baud rate is unknown,
1093 * since that implies that the serial port is disabled.
1097 fatal("speed %d not supported", inspeed);
1099 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1103 /********************************************************************
1105 * setdtr - control the DTR line on the serial port.
1106 * This is called from die(), so it shouldn't call die().
1109 void setdtr (int tty_fd, int on)
1111 int modembits = TIOCM_DTR;
1113 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1116 /********************************************************************
1118 * restore_tty - restore the terminal to the saved settings.
1121 void restore_tty (int tty_fd)
1126 * Turn off echoing, because otherwise we can get into
1127 * a loop with the tty and the modem echoing to each other.
1128 * We presume we are the sole user of this tty device, so
1129 * when we close it, it will revert to its defaults anyway.
1131 if (!default_device)
1132 inittermios.c_lflag &= ~(ECHO | ECHONL);
1134 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1135 if (! ok_error (errno))
1136 warn("tcsetattr: %m (line %d)", __LINE__);
1141 /********************************************************************
1143 * output - Output PPP packet.
1146 void output (int unit, unsigned char *p, int len)
1151 dump_packet("sent", p, len);
1152 if (snoop_send_hook) snoop_send_hook(p, len);
1154 if (len < PPP_HDRLEN)
1156 if (new_style_driver) {
1159 proto = (p[0] << 8) + p[1];
1160 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1163 if (write(fd, p, len) < 0) {
1164 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1165 || errno == ENXIO || errno == EIO || errno == EINTR)
1166 warn("write: warning: %m (%d)", errno);
1168 error("write: %m (%d)", errno);
1172 /********************************************************************
1174 * wait_input - wait until there is data available,
1175 * for the length of time specified by *timo (indefinite
1179 void wait_input(struct timeval *timo)
1186 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1187 if (n < 0 && errno != EINTR)
1188 fatal("select: %m");
1192 * add_fd - add an fd to the set that wait_input waits for.
1196 if (fd >= FD_SETSIZE)
1197 fatal("internal error: file descriptor too large (%d)", fd);
1198 FD_SET(fd, &in_fds);
1204 * remove_fd - remove an fd from the set that wait_input waits for.
1206 void remove_fd(int fd)
1208 FD_CLR(fd, &in_fds);
1212 /********************************************************************
1214 * read_packet - get a PPP packet from the serial device.
1217 int read_packet (unsigned char *buf)
1221 len = PPP_MRU + PPP_HDRLEN;
1222 if (new_style_driver) {
1223 *buf++ = PPP_ALLSTATIONS;
1229 nr = read(ppp_fd, buf, len);
1230 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1231 && errno != EIO && errno != EINTR)
1233 if (nr < 0 && errno == ENXIO)
1236 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1237 /* N.B. we read ppp_fd first since LCP packets come in there. */
1238 nr = read(ppp_dev_fd, buf, len);
1239 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1240 && errno != EIO && errno != EINTR)
1241 error("read /dev/ppp: %m");
1242 if (nr < 0 && errno == ENXIO)
1244 if (nr == 0 && doing_multilink) {
1245 remove_fd(ppp_dev_fd);
1249 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1251 return (new_style_driver && nr > 0)? nr+2: nr;
1254 /********************************************************************
1256 * get_loop_output - get outgoing packets from the ppp device,
1257 * and detect when we want to bring the real link up.
1258 * Return value is 1 if we need to bring up the link, 0 otherwise.
1261 get_loop_output(void)
1266 if (new_style_driver) {
1267 while ((n = read_packet(inpacket_buf)) > 0)
1268 if (loop_frame(inpacket_buf, n))
1273 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1274 if (loop_chars(inbuf, n))
1278 fatal("eof on loopback");
1280 if (errno != EWOULDBLOCK && errno != EAGAIN)
1281 fatal("read from loopback: %m(%d)", errno);
1287 * netif_set_mtu - set the MTU on the PPP network interface.
1290 netif_set_mtu(int unit, int mtu)
1294 memset (&ifr, '\0', sizeof (ifr));
1295 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1298 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1299 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1303 * netif_get_mtu - get the MTU on the PPP network interface.
1306 netif_get_mtu(int unit)
1310 memset (&ifr, '\0', sizeof (ifr));
1311 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1313 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1314 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1320 /********************************************************************
1322 * tty_send_config - configure the transmit characteristics of
1323 * the ppp interface.
1326 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1333 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1334 if (errno != EIO && errno != ENOTTY)
1335 error("Couldn't set transmit async character map: %m");
1340 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1341 | (sync_serial? SC_SYNC: 0);
1342 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1345 /********************************************************************
1347 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1350 void tty_set_xaccm (ext_accm accm)
1354 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1355 if ( ! ok_error (errno))
1356 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1360 /********************************************************************
1362 * tty_recv_config - configure the receive-side characteristics of
1363 * the ppp interface.
1366 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1369 * If we were called because the link has gone down then there is nothing
1370 * which may be done. Just return without incident.
1375 * Set the receiver parameters
1377 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1378 if (errno != EIO && errno != ENOTTY)
1379 error("Couldn't set channel receive MRU: %m");
1381 if (new_style_driver && ppp_dev_fd >= 0
1382 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1383 error("Couldn't set MRU in generic PPP layer: %m");
1385 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1386 if (errno != EIO && errno != ENOTTY)
1387 error("Couldn't set channel receive asyncmap: %m");
1391 /********************************************************************
1393 * ccp_test - ask kernel whether a given compression method
1394 * is acceptable for use.
1398 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1400 struct ppp_option_data data;
1402 memset (&data, '\0', sizeof (data));
1404 data.length = opt_len;
1405 data.transmit = for_transmit;
1407 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1410 return (errno == ENOBUFS)? 0: -1;
1413 /********************************************************************
1415 * ccp_flags_set - inform kernel about the current state of CCP.
1418 void ccp_flags_set (int unit, int isopen, int isup)
1422 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1423 if (still_ppp() && ppp_dev_fd >= 0)
1424 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1429 * set_filters - set the active and pass filters in the kernel driver.
1431 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1433 struct sock_fprog fp;
1435 fp.len = pass->bf_len;
1436 fp.filter = (struct sock_filter *) pass->bf_insns;
1437 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1438 if (errno == ENOTTY)
1439 warn("kernel does not support PPP filtering");
1441 error("Couldn't set pass-filter in kernel: %m");
1444 fp.len = active->bf_len;
1445 fp.filter = (struct sock_filter *) active->bf_insns;
1446 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1447 error("Couldn't set active-filter in kernel: %m");
1452 #endif /* PPP_FILTER */
1454 /********************************************************************
1456 * get_idle_time - return how long the link has been idle.
1459 get_idle_time(int u, struct ppp_idle *ip)
1461 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1464 /********************************************************************
1466 * get_ppp_stats - return statistics for the link.
1469 get_ppp_stats(int u, struct pppd_stats *stats)
1471 struct ifpppstatsreq req;
1473 memset (&req, 0, sizeof (req));
1475 req.stats_ptr = (caddr_t) &req.stats;
1476 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1477 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1478 error("Couldn't get PPP statistics: %m");
1481 stats->bytes_in = req.stats.p.ppp_ibytes;
1482 stats->bytes_out = req.stats.p.ppp_obytes;
1483 stats->pkts_in = req.stats.p.ppp_ipackets;
1484 stats->pkts_out = req.stats.p.ppp_opackets;
1488 /********************************************************************
1490 * ccp_fatal_error - returns 1 if decompression was disabled as a
1491 * result of an error detected after decompression of a packet,
1492 * 0 otherwise. This is necessary because of patent nonsense.
1495 int ccp_fatal_error (int unit)
1499 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1500 error("Couldn't read compression error flags: %m");
1503 return flags & SC_DC_FERROR;
1506 /********************************************************************
1508 * path_to_procfs - find the path to the proc file system mount point
1510 static char proc_path[MAXPATHLEN];
1511 static int proc_path_len;
1513 static char *path_to_procfs(const char *tail)
1515 struct mntent *mntent;
1518 if (proc_path_len == 0) {
1519 /* Default the mount location of /proc */
1520 strlcpy (proc_path, "/proc", sizeof(proc_path));
1522 fp = fopen(MOUNTED, "r");
1524 while ((mntent = getmntent(fp)) != NULL) {
1525 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1527 if (strcmp(mntent->mnt_type, "proc") == 0) {
1528 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1529 proc_path_len = strlen(proc_path);
1537 strlcpy(proc_path + proc_path_len, tail,
1538 sizeof(proc_path) - proc_path_len);
1543 * /proc/net/route parsing stuff.
1545 #define ROUTE_MAX_COLS 12
1546 FILE *route_fd = (FILE *) 0;
1547 static char route_buffer[512];
1548 static int route_dev_col, route_dest_col, route_gw_col;
1549 static int route_flags_col, route_metric_col, route_mask_col;
1550 static int route_num_cols;
1552 static int open_route_table (void);
1553 static void close_route_table (void);
1554 static int read_route_table (struct rtentry *rt);
1556 /********************************************************************
1558 * close_route_table - close the interface to the route table
1561 static void close_route_table (void)
1563 if (route_fd != (FILE *) 0) {
1565 route_fd = (FILE *) 0;
1569 /********************************************************************
1571 * open_route_table - open the interface to the route table
1573 static char route_delims[] = " \t\n";
1575 static int open_route_table (void)
1579 close_route_table();
1581 path = path_to_procfs("/net/route");
1582 route_fd = fopen (path, "r");
1583 if (route_fd == NULL) {
1584 error("can't open routing table %s: %m", path);
1588 route_dev_col = 0; /* default to usual columns */
1591 route_flags_col = 3;
1592 route_metric_col = 6;
1596 /* parse header line */
1597 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1598 char *p = route_buffer, *q;
1600 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1602 if ((q = strtok(p, route_delims)) == 0)
1604 if (strcasecmp(q, "iface") == 0)
1605 route_dev_col = col;
1606 else if (strcasecmp(q, "destination") == 0)
1607 route_dest_col = col;
1608 else if (strcasecmp(q, "gateway") == 0)
1610 else if (strcasecmp(q, "flags") == 0)
1611 route_flags_col = col;
1612 else if (strcasecmp(q, "mask") == 0)
1613 route_mask_col = col;
1616 if (used && col >= route_num_cols)
1617 route_num_cols = col + 1;
1625 /********************************************************************
1627 * read_route_table - read the next entry from the route table
1630 static int read_route_table(struct rtentry *rt)
1632 char *cols[ROUTE_MAX_COLS], *p;
1635 memset (rt, '\0', sizeof (struct rtentry));
1637 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1641 for (col = 0; col < route_num_cols; ++col) {
1642 cols[col] = strtok(p, route_delims);
1643 if (cols[col] == NULL)
1644 return 0; /* didn't get enough columns */
1648 SET_SA_FAMILY (rt->rt_dst, AF_INET);
1649 SET_SA_FAMILY (rt->rt_gateway, AF_INET);
1651 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1652 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1653 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1655 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1656 rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
1657 rt->rt_dev = cols[route_dev_col];
1662 /********************************************************************
1664 * defaultroute_exists - determine if there is a default route
1665 * with the given metric (or negative for any)
1668 static int defaultroute_exists (struct rtentry *rt, int metric)
1672 if (!open_route_table())
1675 while (read_route_table(rt) != 0) {
1676 if ((rt->rt_flags & RTF_UP) == 0)
1679 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1681 if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
1682 || rt->rt_metric == metric)) {
1688 close_route_table();
1693 * have_route_to - determine if the system has any route to
1694 * a given IP address. `addr' is in network byte order.
1695 * Return value is 1 if yes, 0 if no, -1 if don't know.
1696 * For demand mode to work properly, we have to ignore routes
1697 * through our own interface.
1699 int have_route_to(u_int32_t addr)
1704 if (!open_route_table())
1705 return -1; /* don't know */
1707 while (read_route_table(&rt)) {
1708 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1710 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1716 close_route_table();
1720 /********************************************************************
1722 * sifdefaultroute - assign a default route through the address given.
1724 * If the global default_rt_repl_rest flag is set, then this function
1725 * already replaced the original system defaultroute with some other
1726 * route and it should just replace the current defaultroute with
1727 * another one, without saving the current route. Use: demand mode,
1728 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1729 * and then changes the temporary addresses to the addresses for the real
1730 * ppp connection when it has come up.
1733 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
1735 struct rtentry rt, tmp_rt;
1736 struct rtentry *del_rt = NULL;
1738 if (default_rt_repl_rest) {
1739 /* We have already replaced the original defaultroute, if we
1740 * are called again, we will delete the current default route
1741 * and set the new default route in this function.
1742 * - this is normally only the case the doing demand: */
1743 if (defaultroute_exists(&tmp_rt, -1))
1745 } else if (defaultroute_exists(&old_def_rt, -1 ) &&
1746 strcmp( old_def_rt.rt_dev, ifname) != 0) {
1748 * We did not yet replace an existing default route, let's
1749 * check if we should save and replace a default route:
1751 u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
1753 if (old_gateway != gateway) {
1755 error("not replacing default route to %s [%I]",
1756 old_def_rt.rt_dev, old_gateway);
1759 /* we need to copy rt_dev because we need it permanent too: */
1760 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
1761 strcpy(tmp_dev, old_def_rt.rt_dev);
1762 old_def_rt.rt_dev = tmp_dev;
1764 notice("replacing old default route to %s [%I]",
1765 old_def_rt.rt_dev, old_gateway);
1766 default_rt_repl_rest = 1;
1767 del_rt = &old_def_rt;
1772 memset (&rt, 0, sizeof (rt));
1773 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1776 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1778 if (kernel_version > KVERSION(2,1,0)) {
1779 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1780 SIN_ADDR(rt.rt_genmask) = 0L;
1783 rt.rt_flags = RTF_UP;
1784 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1785 if ( ! ok_error ( errno ))
1786 error("default route ioctl(SIOCADDRT): %m");
1789 if (default_rt_repl_rest && del_rt)
1790 if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
1791 if ( ! ok_error ( errno ))
1792 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
1796 have_default_route = 1;
1800 /********************************************************************
1802 * cifdefaultroute - delete a default route through the address given.
1805 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1809 have_default_route = 0;
1811 memset (&rt, '\0', sizeof (rt));
1812 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1813 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1818 rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1820 if (kernel_version > KVERSION(2,1,0)) {
1821 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1822 SIN_ADDR(rt.rt_genmask) = 0L;
1825 rt.rt_flags = RTF_UP;
1826 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1828 if ( ! ok_error ( errno ))
1829 error("default route ioctl(SIOCDELRT): %m");
1833 if (default_rt_repl_rest) {
1834 notice("restoring old default route to %s [%I]",
1835 old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
1836 if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
1837 if ( ! ok_error ( errno ))
1838 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
1841 default_rt_repl_rest = 0;
1849 * /proc/net/ipv6_route parsing stuff.
1851 static int route_dest_plen_col;
1852 static int open_route6_table (void);
1853 static int read_route6_table (struct in6_rtmsg *rt);
1855 /********************************************************************
1857 * open_route6_table - open the interface to the route table
1859 static int open_route6_table (void)
1863 close_route_table();
1865 path = path_to_procfs("/net/ipv6_route");
1866 route_fd = fopen (path, "r");
1867 if (route_fd == NULL) {
1868 error("can't open routing table %s: %m", path);
1872 /* default to usual columns */
1874 route_dest_plen_col = 1;
1876 route_metric_col = 5;
1877 route_flags_col = 8;
1879 route_num_cols = 10;
1884 /********************************************************************
1886 * read_route6_table - read the next entry from the route table
1889 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
1896 for (i = 0; i < 4; i++) {
1897 memcpy(hex8, s + 8*i, 8);
1898 v = strtoul(hex8, NULL, 16);
1899 addr->s6_addr32[i] = v;
1903 static int read_route6_table(struct in6_rtmsg *rt)
1905 char *cols[ROUTE_MAX_COLS], *p;
1908 memset (rt, '\0', sizeof (struct in6_rtmsg));
1910 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1914 for (col = 0; col < route_num_cols; ++col) {
1915 cols[col] = strtok(p, route_delims);
1916 if (cols[col] == NULL)
1917 return 0; /* didn't get enough columns */
1921 hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
1922 rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
1923 hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
1925 rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
1926 rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
1927 rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
1932 /********************************************************************
1934 * defaultroute6_exists - determine if there is a default route
1937 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
1941 if (!open_route6_table())
1944 while (read_route6_table(rt) != 0) {
1945 if ((rt->rtmsg_flags & RTF_UP) == 0)
1948 if (rt->rtmsg_dst_len != 0)
1950 if (rt->rtmsg_dst.s6_addr32[0] == 0L
1951 && rt->rtmsg_dst.s6_addr32[1] == 0L
1952 && rt->rtmsg_dst.s6_addr32[2] == 0L
1953 && rt->rtmsg_dst.s6_addr32[3] == 0L
1954 && (metric < 0 || rt->rtmsg_metric == metric)) {
1960 close_route_table();
1964 /********************************************************************
1966 * sif6defaultroute - assign a default route through the address given.
1968 * If the global default_rt_repl_rest flag is set, then this function
1969 * already replaced the original system defaultroute with some other
1970 * route and it should just replace the current defaultroute with
1971 * another one, without saving the current route. Use: demand mode,
1972 * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1973 * and then changes the temporary addresses to the addresses for the real
1974 * ppp connection when it has come up.
1977 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
1979 struct in6_rtmsg rt;
1980 char buf[IF_NAMESIZE];
1982 if (defaultroute6_exists(&rt, dfl_route_metric) &&
1983 rt.rtmsg_ifindex != if_nametoindex(ifname)) {
1984 if (rt.rtmsg_flags & RTF_GATEWAY)
1985 error("not replacing existing default route via gateway");
1987 error("not replacing existing default route through %s",
1988 if_indextoname(rt.rtmsg_ifindex, buf));
1992 memset (&rt, 0, sizeof (rt));
1994 rt.rtmsg_ifindex = if_nametoindex(ifname);
1995 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1996 rt.rtmsg_dst_len = 0;
1998 rt.rtmsg_flags = RTF_UP;
1999 if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
2000 if ( ! ok_error ( errno ))
2001 error("default route ioctl(SIOCADDRT): %m");
2005 have_default_route6 = 1;
2009 /********************************************************************
2011 * cif6defaultroute - delete a default route through the address given.
2014 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2016 struct in6_rtmsg rt;
2018 have_default_route6 = 0;
2020 memset (&rt, '\0', sizeof (rt));
2022 rt.rtmsg_ifindex = if_nametoindex(ifname);
2023 rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2024 rt.rtmsg_dst_len = 0;
2026 rt.rtmsg_flags = RTF_UP;
2027 if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2029 if ( ! ok_error ( errno ))
2030 error("default route ioctl(SIOCDELRT): %m");
2039 /********************************************************************
2041 * sifproxyarp - Make a proxy ARP entry for the peer.
2044 int sifproxyarp (int unit, u_int32_t his_adr)
2046 struct arpreq arpreq;
2049 if (has_proxy_arp == 0) {
2050 memset (&arpreq, '\0', sizeof(arpreq));
2052 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2053 SIN_ADDR(arpreq.arp_pa) = his_adr;
2054 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2056 * Get the hardware address of an interface on the same subnet
2057 * as our local address.
2059 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2060 sizeof(proxy_arp_dev))) {
2061 error("Cannot determine ethernet address for proxy ARP");
2064 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2066 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2067 if ( ! ok_error ( errno ))
2068 error("ioctl(SIOCSARP): %m");
2071 proxy_arp_addr = his_adr;
2075 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2076 if (forw_path != 0) {
2077 int fd = open(forw_path, O_WRONLY);
2079 if (write(fd, "1", 1) != 1)
2080 error("Couldn't enable IP forwarding: %m");
2090 /********************************************************************
2092 * cifproxyarp - Delete the proxy ARP entry for the peer.
2095 int cifproxyarp (int unit, u_int32_t his_adr)
2097 struct arpreq arpreq;
2099 if (has_proxy_arp) {
2101 memset (&arpreq, '\0', sizeof(arpreq));
2102 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2103 SIN_ADDR(arpreq.arp_pa) = his_adr;
2104 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2105 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2107 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2108 if ( ! ok_error ( errno ))
2109 warn("ioctl(SIOCDARP): %m");
2116 /********************************************************************
2118 * get_ether_addr - get the hardware address of an interface on the
2119 * the same subnet as ipaddr.
2122 static int get_ether_addr (u_int32_t ipaddr,
2123 struct sockaddr *hwaddr,
2124 char *name, int namelen)
2126 struct ifreq *ifr, *ifend;
2127 u_int32_t ina, mask;
2129 struct ifreq ifreq, bestifreq;
2131 struct ifreq ifs[MAX_IFS];
2133 u_int32_t bestmask=0;
2134 int found_interface = 0;
2136 ifc.ifc_len = sizeof(ifs);
2138 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2139 if ( ! ok_error ( errno ))
2140 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2145 * Scan through looking for an interface with an Internet
2146 * address on the same subnet as `ipaddr'.
2148 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2149 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2150 if (ifr->ifr_addr.sa_family == AF_INET) {
2151 ina = SIN_ADDR(ifr->ifr_addr);
2152 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2154 * Check that the interface is up, and not point-to-point
2157 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2160 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2163 * Get its netmask and check that it's on the right subnet.
2165 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2168 mask = SIN_ADDR(ifreq.ifr_addr);
2170 if (((ipaddr ^ ina) & mask) != 0)
2171 continue; /* no match */
2173 if (mask >= bestmask) {
2174 /* Compare using >= instead of > -- it is possible for
2175 an interface to have a netmask of 0.0.0.0 */
2176 found_interface = 1;
2183 if (!found_interface) return 0;
2185 strlcpy(name, bestifreq.ifr_name, namelen);
2187 /* trim off the :1 in eth0:1 */
2188 aliasp = strchr(name, ':');
2192 info("found interface %s for proxy arp", name);
2194 * Now get the hardware address.
2196 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2197 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2198 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2203 &bestifreq.ifr_hwaddr,
2204 sizeof (struct sockaddr));
2210 * get_if_hwaddr - get the hardware address for the specified
2211 * network interface device.
2214 get_if_hwaddr(u_char *addr, char *name)
2219 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2222 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2223 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2224 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2227 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2232 * get_first_ether_hwaddr - get the hardware address for the first
2233 * ethernet-style interface on this system.
2236 get_first_ether_hwaddr(u_char *addr)
2238 struct if_nameindex *if_ni, *i;
2242 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2246 if_ni = if_nameindex();
2254 for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2255 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2256 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2257 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2258 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2259 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2265 if_freenameindex(if_ni);
2271 /********************************************************************
2273 * Return user specified netmask, modified by any mask we might determine
2274 * for address `addr' (in network byte order).
2275 * Here we scan through the system's list of interfaces, looking for
2276 * any non-point-to-point interfaces which might appear to be on the same
2277 * network as `addr'. If we find any, we OR in their netmask to the
2278 * user-specified netmask.
2281 u_int32_t GetMask (u_int32_t addr)
2283 u_int32_t mask, nmask, ina;
2284 struct ifreq *ifr, *ifend, ifreq;
2286 struct ifreq ifs[MAX_IFS];
2290 if (IN_CLASSA(addr)) /* determine network mask for address class */
2291 nmask = IN_CLASSA_NET;
2292 else if (IN_CLASSB(addr))
2293 nmask = IN_CLASSB_NET;
2295 nmask = IN_CLASSC_NET;
2297 /* class D nets are disallowed by bad_ip_adrs */
2298 mask = netmask | htonl(nmask);
2300 * Scan through the system's network interfaces.
2302 ifc.ifc_len = sizeof(ifs);
2304 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2305 if ( ! ok_error ( errno ))
2306 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2310 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2311 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2313 * Check the interface's internet address.
2315 if (ifr->ifr_addr.sa_family != AF_INET)
2317 ina = SIN_ADDR(ifr->ifr_addr);
2318 if (((ntohl(ina) ^ addr) & nmask) != 0)
2321 * Check that the interface is up, and not point-to-point nor loopback.
2323 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2324 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2327 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2330 * Get its netmask and OR it into our mask.
2332 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2334 mask |= SIN_ADDR(ifreq.ifr_addr);
2340 /********************************************************************
2342 * Internal routine to decode the version.modification.patch level
2345 static void decode_version (char *buf, int *version,
2346 int *modification, int *patch)
2350 *version = (int) strtoul (buf, &endp, 10);
2354 if (endp != buf && *endp == '.') {
2356 *modification = (int) strtoul (buf, &endp, 10);
2357 if (endp != buf && *endp == '.') {
2359 *patch = (int) strtoul (buf, &buf, 10);
2364 /********************************************************************
2366 * Procedure to determine if the PPP line discipline is registered.
2370 ppp_registered(void)
2378 * We used to open the serial device and set it to the ppp line
2379 * discipline here, in order to create a ppp unit. But that is
2380 * not a good idea - the user might have specified a device that
2381 * they can't open (permission, or maybe it doesn't really exist).
2382 * So we grab a pty master/slave pair and use that.
2384 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2385 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2390 * Try to put the device into the PPP discipline.
2392 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2393 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2402 /********************************************************************
2404 * ppp_available - check whether the system has any ppp interfaces
2405 * (in fact we check whether we can do an ioctl on ppp0).
2408 int ppp_available(void)
2413 int my_version, my_modification, my_patch;
2414 int osmaj, osmin, ospatch;
2416 /* get the kernel version now, since we are called before sys_init */
2418 osmaj = osmin = ospatch = 0;
2419 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2420 kernel_version = KVERSION(osmaj, osmin, ospatch);
2422 fd = open("/dev/ppp", O_RDWR);
2424 new_style_driver = 1;
2426 /* XXX should get from driver */
2428 driver_modification = 4;
2434 if (kernel_version >= KVERSION(2,3,13)) {
2435 error("Couldn't open the /dev/ppp device: %m");
2436 if (errno == ENOENT)
2438 "You need to create the /dev/ppp device node by\n"
2439 "executing the following command as root:\n"
2440 " mknod /dev/ppp c 108 0\n";
2441 else if (errno == ENODEV || errno == ENXIO)
2443 "Please load the ppp_generic kernel module.\n";
2447 /* we are running on a really really old kernel */
2449 "This system lacks kernel support for PPP. This could be because\n"
2450 "the PPP kernel module could not be loaded, or because PPP was not\n"
2451 "included in the kernel configuration. If PPP was included as a\n"
2452 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2453 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2454 "See README.linux file in the ppp distribution for more details.\n";
2457 * Open a socket for doing the ioctl operations.
2459 s = socket(AF_INET, SOCK_DGRAM, 0);
2463 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2464 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2466 * If the device did not exist then attempt to create one by putting the
2467 * current tty into the PPP discipline. If this works then obtain the
2468 * flags for the device again.
2471 if (ppp_registered()) {
2472 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2473 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2477 * Ensure that the hardware address is for PPP and not something else
2480 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2482 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2486 * This is the PPP device. Validate the version of the driver at this
2487 * point to ensure that this program will work with the driver.
2490 char abBuffer [1024];
2492 ifr.ifr_data = abBuffer;
2493 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2495 error("Couldn't read driver version: %m");
2497 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2500 decode_version(abBuffer,
2502 &driver_modification,
2505 * Validate the version of the driver against the version that we used.
2507 decode_version(VERSION,
2512 /* The version numbers must match */
2513 if (driver_version != my_version)
2516 /* The modification levels must be legal */
2517 if (driver_modification < 3) {
2518 if (driver_modification >= 2) {
2519 /* we can cope with 2.2.0 and above */
2527 slprintf(route_buffer, sizeof(route_buffer),
2528 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2529 driver_version, driver_modification, driver_patch);
2531 no_ppp_msg = route_buffer;
2539 #ifndef HAVE_LOGWTMP
2540 /********************************************************************
2542 * Update the wtmp file with the appropriate user name and tty device.
2545 void logwtmp (const char *line, const char *name, const char *host)
2547 struct utmp ut, *utp;
2548 pid_t mypid = getpid();
2554 * Update the signon database for users.
2555 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2557 utmpname(_PATH_UTMP);
2559 while ((utp = getutent()) && (utp->ut_pid != mypid))
2563 memcpy(&ut, utp, sizeof(ut));
2565 /* some gettys/telnetds don't initialize utmp... */
2566 memset(&ut, 0, sizeof(ut));
2568 if (ut.ut_id[0] == 0)
2569 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2571 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2572 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2576 ut.ut_type = USER_PROCESS;
2579 /* Insert the host name if one is supplied */
2581 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2583 /* Insert the IP address of the remote system if IP is enabled */
2584 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2585 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2586 sizeof(ut.ut_addr));
2588 /* CL: Makes sure that the logout works */
2589 if (*host == 0 && *name==0)
2595 * Update the wtmp file.
2598 updwtmp(_PATH_WTMP, &ut);
2600 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2602 flock(wtmp, LOCK_EX);
2604 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2605 warn("error writing %s: %m", _PATH_WTMP);
2607 flock(wtmp, LOCK_UN);
2613 #endif /* HAVE_LOGWTMP */
2615 /********************************************************************
2617 * sifvjcomp - config tcp header compression
2620 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2625 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2626 error("Couldn't set up TCP header compression: %m");
2631 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2632 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2637 /********************************************************************
2639 * sifup - Config the interface up and enable IP packets to pass.
2646 if ((ret = setifstate(u, 1)))
2652 /********************************************************************
2654 * sifdown - Disable the indicated protocol and config the interface
2655 * down if there are no remaining protocols.
2660 if (if_is_up && --if_is_up > 0)
2668 return setifstate(u, 0);
2672 /********************************************************************
2674 * sif6up - Config the interface up for IPv6
2681 if ((ret = setifstate(u, 1)))
2687 /********************************************************************
2689 * sif6down - Disable the IPv6CP protocol and config the interface
2690 * down if there are no remaining protocols.
2693 int sif6down (int u)
2700 return setifstate(u, 0);
2704 /********************************************************************
2706 * setifstate - Config the interface up or down
2709 static int setifstate (int u, int state)
2713 memset (&ifr, '\0', sizeof (ifr));
2714 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2715 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2716 if (! ok_error (errno))
2717 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2722 ifr.ifr_flags |= IFF_UP;
2724 ifr.ifr_flags &= ~IFF_UP;
2725 ifr.ifr_flags |= IFF_POINTOPOINT;
2726 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2727 if (! ok_error (errno))
2728 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2734 /********************************************************************
2736 * sifaddr - Config the interface IP addresses and netmask.
2739 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2745 memset (&ifr, '\0', sizeof (ifr));
2746 memset (&rt, '\0', sizeof (rt));
2748 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2749 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2750 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2752 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2754 * Set our IP address
2756 SIN_ADDR(ifr.ifr_addr) = our_adr;
2757 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2758 if (errno != EEXIST) {
2759 if (! ok_error (errno))
2760 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2763 warn("ioctl(SIOCSIFADDR): Address already exists");
2768 * Set the gateway address
2771 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2772 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2773 if (! ok_error (errno))
2774 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2780 * For recent kernels, force the netmask to 255.255.255.255.
2782 if (kernel_version >= KVERSION(2,1,16))
2784 if (net_mask != 0) {
2785 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2786 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2787 if (! ok_error (errno))
2788 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2793 * Add the device route
2795 if (kernel_version < KVERSION(2,1,16)) {
2796 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2797 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2800 SIN_ADDR(rt.rt_gateway) = 0L;
2801 SIN_ADDR(rt.rt_dst) = his_adr;
2802 rt.rt_flags = RTF_UP | RTF_HOST;
2804 if (kernel_version > KVERSION(2,1,0)) {
2805 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2806 SIN_ADDR(rt.rt_genmask) = -1L;
2809 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2810 if (! ok_error (errno))
2811 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2816 /* set ip_dynaddr in demand mode if address changes */
2817 if (demand && tune_kernel && !dynaddr_set
2818 && our_old_addr && our_old_addr != our_adr) {
2819 /* set ip_dynaddr if possible */
2823 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2824 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2825 if (write(fd, "1", 1) != 1)
2826 error("Couldn't enable dynamic IP addressing: %m");
2829 dynaddr_set = 1; /* only 1 attempt */
2836 /********************************************************************
2838 * cifaddr - Clear the interface IP addresses, and delete routes
2839 * through the interface if possible.
2842 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2846 if (kernel_version < KVERSION(2,1,16)) {
2848 * Delete the route through the device
2851 memset (&rt, '\0', sizeof (rt));
2853 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2854 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2857 SIN_ADDR(rt.rt_gateway) = 0;
2858 SIN_ADDR(rt.rt_dst) = his_adr;
2859 rt.rt_flags = RTF_UP | RTF_HOST;
2861 if (kernel_version > KVERSION(2,1,0)) {
2862 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2863 SIN_ADDR(rt.rt_genmask) = -1L;
2866 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2867 if (still_ppp() && ! ok_error (errno))
2868 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2873 /* This way it is possible to have an IPX-only or IPv6-only interface */
2874 memset(&ifr, 0, sizeof(ifr));
2875 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2876 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2878 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2879 if (! ok_error (errno)) {
2880 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2885 our_old_addr = our_adr;
2891 /********************************************************************
2893 * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
2895 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
2898 struct nlmsghdr nlh;
2899 struct ifaddrmsg ifa;
2902 struct in6_addr addr;
2906 struct nlmsghdr nlh;
2907 struct nlmsgerr nlerr;
2909 struct sockaddr_nl nladdr;
2916 fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
2918 error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
2923 * Tell kernel to not send to us payload of acknowledgment error message.
2924 * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
2925 * older kernel versions always send full payload in acknowledgment netlink
2926 * message. We ignore payload of this message as we need only error code,
2927 * to check if our set remote peer address request succeeded or failed.
2928 * So ignore return value from the following setsockopt() call as setting
2929 * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
2932 setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
2934 memset(&nladdr, 0, sizeof(nladdr));
2935 nladdr.nl_family = AF_NETLINK;
2937 if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
2938 error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
2943 memset(&nlreq, 0, sizeof(nlreq));
2944 nlreq.nlh.nlmsg_len = sizeof(nlreq);
2945 nlreq.nlh.nlmsg_type = RTM_NEWADDR;
2946 nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
2947 nlreq.ifa.ifa_family = AF_INET6;
2948 nlreq.ifa.ifa_prefixlen = 128;
2949 nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
2950 nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
2951 nlreq.ifa.ifa_index = iface;
2952 nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
2953 nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
2954 IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
2955 nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
2956 nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
2957 IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
2959 memset(&nladdr, 0, sizeof(nladdr));
2960 nladdr.nl_family = AF_NETLINK;
2962 memset(&iov, 0, sizeof(iov));
2963 iov.iov_base = &nlreq;
2964 iov.iov_len = sizeof(nlreq);
2966 memset(&msg, 0, sizeof(msg));
2967 msg.msg_name = &nladdr;
2968 msg.msg_namelen = sizeof(nladdr);
2972 if (sendmsg(fd, &msg, 0) < 0) {
2973 error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
2978 memset(&iov, 0, sizeof(iov));
2979 iov.iov_base = &nlresp;
2980 iov.iov_len = sizeof(nlresp);
2982 memset(&msg, 0, sizeof(msg));
2983 msg.msg_name = &nladdr;
2984 msg.msg_namelen = sizeof(nladdr);
2988 nlresplen = recvmsg(fd, &msg, 0);
2990 if (nlresplen < 0) {
2991 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
2998 if (nladdr.nl_family != AF_NETLINK) {
2999 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
3003 if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
3004 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
3008 /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
3009 if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
3010 error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
3014 /* error == 0 indicates success, negative value is errno code */
3015 if (nlresp.nlerr.error != 0) {
3016 error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
3023 /********************************************************************
3025 * sif6addr - Config the interface with an IPv6 link-local address
3027 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3029 struct in6_ifreq ifr6;
3031 struct in6_rtmsg rt6;
3035 error("IPv6 socket creation failed: %m");
3038 memset(&ifr, 0, sizeof (ifr));
3039 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3040 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3041 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3045 if (kernel_version >= KVERSION(2,1,16)) {
3046 /* Set both local address and remote peer address (with route for it) via rtnetlink */
3047 return sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
3049 /* Local interface */
3050 memset(&ifr6, 0, sizeof(ifr6));
3051 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3052 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3053 ifr6.ifr6_prefixlen = 128;
3055 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3056 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3061 * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3062 * setting remote peer host address, so set only route to remote host.
3065 /* Route to remote host */
3066 memset(&rt6, 0, sizeof(rt6));
3067 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3068 rt6.rtmsg_flags = RTF_UP;
3069 rt6.rtmsg_dst_len = 128;
3070 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3071 rt6.rtmsg_metric = 1;
3073 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3074 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3083 /********************************************************************
3085 * cif6addr - Remove IPv6 address from interface
3087 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3090 struct in6_ifreq ifr6;
3094 error("IPv6 socket creation failed: %m");
3097 memset(&ifr, 0, sizeof(ifr));
3098 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3099 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3100 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3104 memset(&ifr6, 0, sizeof(ifr6));
3105 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3106 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3107 ifr6.ifr6_prefixlen = 128;
3109 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3110 if (errno != EADDRNOTAVAIL) {
3111 if (! ok_error (errno))
3112 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3115 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3124 * get_pty - get a pty master/slave pair and chown the slave side
3125 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
3128 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3130 int i, mfd, sfd = -1;
3132 struct termios tios;
3136 * Try the unix98 way first.
3138 mfd = open("/dev/ptmx", O_RDWR);
3141 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3142 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3143 chmod(pty_name, S_IRUSR | S_IWUSR);
3146 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3147 warn("Couldn't unlock pty slave %s: %m", pty_name);
3149 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3151 warn("Couldn't open pty slave %s: %m", pty_name);
3156 #endif /* TIOCGPTN */
3159 /* the old way - scan through the pty name space */
3160 for (i = 0; i < 64; ++i) {
3161 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3162 'p' + i / 16, i % 16);
3163 mfd = open(pty_name, O_RDWR, 0);
3166 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3168 fchown(sfd, uid, -1);
3169 fchmod(sfd, S_IRUSR | S_IWUSR);
3180 strlcpy(slave_name, pty_name, 16);
3183 if (tcgetattr(sfd, &tios) == 0) {
3184 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3185 tios.c_cflag |= CS8 | CREAD | CLOCAL;
3186 tios.c_iflag = IGNPAR;
3189 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3190 warn("couldn't set attributes on pty: %m");
3192 warn("couldn't get attributes on pty: %m");
3197 /********************************************************************
3199 * open_loopback - open the device we use for getting packets
3200 * in demand mode. Under Linux, we use a pty master/slave pair.
3203 open_ppp_loopback(void)
3208 if (new_style_driver) {
3209 /* allocate ourselves a ppp unit */
3210 if (make_ppp_unit() < 0)
3212 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3213 set_kdebugflag(kdebugflag);
3218 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3219 fatal("No free pty for loopback");
3221 set_ppp_fd(slave_fd);
3223 flags = fcntl(master_fd, F_GETFL);
3225 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3226 warn("couldn't set master loopback to nonblock: %m");
3228 flags = fcntl(ppp_fd, F_GETFL);
3230 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3231 warn("couldn't set slave loopback to nonblock: %m");
3233 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3234 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3236 * Find out which interface we were given.
3238 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3239 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3241 * Enable debug in the driver if requested.
3243 set_kdebugflag (kdebugflag);
3248 /********************************************************************
3250 * sifnpmode - Set the mode for handling packets for a given NP.
3254 sifnpmode(int u, int proto, enum NPmode mode)
3258 npi.protocol = proto;
3260 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3261 if (! ok_error (errno))
3262 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3269 /********************************************************************
3271 * sipxfaddr - Config the interface IPX networknumber
3274 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
3281 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3283 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3285 if (! ok_error (errno))
3286 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3290 memset (&ifr, '\0', sizeof (ifr));
3291 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3293 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
3294 sipx->sipx_family = AF_IPX;
3295 sipx->sipx_port = 0;
3296 sipx->sipx_network = htonl (network);
3297 sipx->sipx_type = IPX_FRAME_ETHERII;
3298 sipx->sipx_action = IPX_CRTITF;
3300 * Set the IPX device
3302 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3304 if (errno != EEXIST) {
3305 if (! ok_error (errno))
3306 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
3309 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
3318 /********************************************************************
3320 * cipxfaddr - Clear the information for the IPX network. The IPX routes
3321 * are removed and the device is no longer able to pass IPX
3325 int cipxfaddr (int unit)
3332 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3334 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3336 if (! ok_error (errno))
3337 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3341 memset (&ifr, '\0', sizeof (ifr));
3342 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3344 sipx->sipx_type = IPX_FRAME_ETHERII;
3345 sipx->sipx_action = IPX_DLTITF;
3346 sipx->sipx_family = AF_IPX;
3348 * Set the IPX device
3350 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3351 if (! ok_error (errno))
3352 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
3362 * Use the hostname as part of the random number seed.
3371 for (p = hostname; *p != 0; ++p)
3376 /********************************************************************
3378 * sys_check_options - check the options that the user specified
3382 sys_check_options(void)
3386 * Disable the IPX protocol if the support is not present in the kernel.
3390 if (ipxcp_protent.enabled_flag) {
3391 struct stat stat_buf;
3392 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
3393 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
3394 || lstat(path, &stat_buf) < 0) {
3395 error("IPX support is not present in the kernel\n");
3396 ipxcp_protent.enabled_flag = 0;
3400 if (demand && driver_is_old) {
3401 option_error("demand dialling is not supported by kernel driver "
3402 "version %d.%d.%d", driver_version, driver_modification,
3406 if (multilink && !new_style_driver) {
3407 warn("Warning: multilink is not supported by the kernel driver");
3413 /********************************************************************
3415 * get_time - Get current time, monotonic if possible.
3418 get_time(struct timeval *tv)
3420 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3421 * Runtime checking makes it safe. */
3422 #ifndef CLOCK_MONOTONIC
3423 #define CLOCK_MONOTONIC 1
3425 static int monotonic = -1;
3430 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3434 tv->tv_sec = ts.tv_sec;
3435 tv->tv_usec = ts.tv_nsec / 1000;
3438 } else if (monotonic > 0)
3442 warn("Couldn't use monotonic clock source: %m");
3445 return gettimeofday(tv, NULL);