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>
76 #include <sys/errno.h>
79 #include <sys/utsname.h>
80 #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
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>
130 #if __GLIBC__ >= 2 && \
131 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
132 #include <netipx/ipx.h>
134 #include <linux/ipx.h>
136 #endif /* IPX_CHANGE */
139 #include <pcap-bpf.h>
140 #include <linux/filter.h>
141 #endif /* PPP_FILTER */
144 #include <sys/locks.h>
150 * This is in linux/include/net/ipv6.h.
154 struct in6_addr ifr6_addr;
155 __u32 ifr6_prefixlen;
156 unsigned int ifr6_ifindex;
160 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
161 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
162 sin6.s6_addr16[0] = htons(0xfe80); \
163 eui64_copy(eui64, sin6.s6_addr32[2]); \
168 /* We can get an EIO error on an ioctl if the modem has hung up */
169 #define ok_error(num) ((num)==EIO)
171 static int tty_disc = N_TTY; /* The TTY discipline */
172 static int ppp_disc = N_PPP; /* The PPP discpline */
173 static int initfdflags = -1; /* Initial file descriptor flags for fd */
174 static int ppp_fd = -1; /* fd which is set to PPP discipline */
175 static int sock_fd = -1; /* socket for doing interface ioctls */
176 static int slave_fd = -1; /* pty for old-style demand mode, slave */
177 static int master_fd = -1; /* pty for old-style demand mode, master */
179 static int sock6_fd = -1;
183 * For the old-style kernel driver, this is the same as ppp_fd.
184 * For the new-style driver, it is the fd of an instance of /dev/ppp
185 * which is attached to the ppp unit and is used for controlling it.
187 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
189 static int chindex; /* channel index (new style driver) */
191 static fd_set in_fds; /* set of fds that wait_input waits for */
192 static int max_in_fd; /* highest fd set in in_fds */
194 static int has_proxy_arp = 0;
195 static int driver_version = 0;
196 static int driver_modification = 0;
197 static int driver_patch = 0;
198 static int driver_is_old = 0;
199 static int restore_term = 0; /* 1 => we've munged the terminal */
200 static struct termios inittermios; /* Initial TTY termios */
202 int new_style_driver = 0;
204 static char loop_name[20];
205 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
207 static int if_is_up; /* Interface has been marked up */
208 static int have_default_route; /* Gateway for default route added */
209 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
210 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
211 static u_int32_t our_old_addr; /* for detecting address changes */
212 static int dynaddr_set; /* 1 if ip_dynaddr set */
213 static int looped; /* 1 if using loop */
214 static int link_mtu; /* mtu for the link (not bundle) */
216 static struct utsname utsname; /* for the kernel version */
217 static int kernel_version;
218 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
222 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
223 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
224 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
226 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
228 /* Prototypes for procedures local to this file. */
229 static int modify_flags(int fd, int clear_bits, int set_bits);
230 static int translate_speed (int bps);
231 static int baud_rate_of (int speed);
232 static void close_route_table (void);
233 static int open_route_table (void);
234 static int read_route_table (struct rtentry *rt);
235 static int defaultroute_exists (struct rtentry *rt);
236 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
237 char *name, int namelen);
238 static void decode_version (char *buf, int *version, int *mod, int *patch);
239 static int set_kdebugflag(int level);
240 static int ppp_registered(void);
241 static int make_ppp_unit(void);
243 extern u_char inpacket_buf[]; /* borrowed from main.c */
246 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
250 #define SET_SA_FAMILY(addr, family) \
251 memset ((char *) &(addr), '\0', sizeof(addr)); \
252 addr.sa_family = (family);
255 * Determine if the PPP connection should still be present.
260 /* new_fd is the fd of a tty */
261 static void set_ppp_fd (int new_fd)
264 if (!new_style_driver)
268 static int still_ppp(void)
270 if (new_style_driver)
271 return !hungup && ppp_fd >= 0;
272 if (!hungup || ppp_fd == slave_fd)
275 set_ppp_fd(slave_fd);
282 * modify_flags - set and clear flag bits controlling the kernel
285 static int modify_flags(int fd, int clear_bits, int set_bits)
289 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
291 flags = (flags & ~clear_bits) | set_bits;
292 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
299 error("Failed to set PPP kernel option flags: %m");
303 /********************************************************************
305 * sys_init - System-dependent initialization.
310 /* Get an internet socket for doing socket ioctls. */
311 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
313 fatal("Couldn't create IP socket: %m(%d)", errno);
316 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
318 sock6_fd = -errno; /* save errno for later */
325 /********************************************************************
327 * sys_cleanup - restore any system state we modified before exiting:
328 * mark the interface down, delete default route and/or proxy arp entry.
329 * This shouldn't call die() because it's called from die().
332 void sys_cleanup(void)
335 * Take down the device
342 * Delete any routes through the device.
344 if (have_default_route)
345 cifdefaultroute(0, 0, 0);
348 cifproxyarp(0, proxy_arp_addr);
351 /********************************************************************
353 * sys_close - Clean up in a child process before execing.
358 if (new_style_driver && ppp_dev_fd >= 0)
372 /********************************************************************
374 * set_kdebugflag - Define the debugging level for the kernel
377 static int set_kdebugflag (int requested_level)
381 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
382 if ( ! ok_error (errno) )
383 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
389 /********************************************************************
391 * tty_establish_ppp - Turn the serial port into a ppp interface.
394 int tty_establish_ppp (int tty_fd)
399 * Ensure that the tty device is in exclusive mode.
401 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
402 if ( ! ok_error ( errno ))
403 warn("Couldn't make tty exclusive: %m");
406 * Demand mode - prime the old ppp device to relinquish the unit.
408 if (!new_style_driver && looped
409 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
410 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
414 * Set the current tty to the PPP discpline
418 #define N_SYNC_PPP 14
420 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
421 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
422 if ( ! ok_error (errno) ) {
423 error("Couldn't set tty to PPP discipline: %m");
428 ret_fd = generic_establish_ppp(tty_fd);
430 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
431 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
435 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
436 (kdebugflag * SC_DEBUG) & SC_LOGB);
438 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
439 warn("Couldn't reset tty to normal line discipline: %m");
445 /********************************************************************
447 * generic_establish_ppp - Turn the fd into a ppp interface.
449 int generic_establish_ppp (int fd)
453 if (new_style_driver) {
456 /* Open an instance of /dev/ppp and connect the channel to it */
457 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
458 error("Couldn't get channel number: %m");
461 dbglog("using channel %d", chindex);
462 fd = open("/dev/ppp", O_RDWR);
464 error("Couldn't reopen /dev/ppp: %m");
467 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
468 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
469 error("Couldn't attach to channel %d: %m", chindex);
472 flags = fcntl(fd, F_GETFL);
473 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
474 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
479 if (!looped && !multilink) {
481 * Create a new PPP unit.
483 if (make_ppp_unit() < 0)
488 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
492 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
493 error("Couldn't attach to PPP unit %d: %m", ifunit);
500 * Old-style driver: find out which interface we were given.
503 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
504 if (ok_error (errno))
506 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
508 /* Check that we got the same unit again. */
509 if (looped && x != ifunit)
510 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
514 * Fetch the initial file flags and reset blocking mode on the file.
516 initfdflags = fcntl(fd, F_GETFL);
517 if (initfdflags == -1 ||
518 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
519 if ( ! ok_error (errno))
520 warn("Couldn't set device to non-blocking mode: %m");
525 * Enable debug in the driver if requested.
528 set_kdebugflag (kdebugflag);
540 /********************************************************************
542 * tty_disestablish_ppp - Restore the serial port to normal operation.
543 * This shouldn't call die() because it's called from die().
546 void tty_disestablish_ppp(int tty_fd)
550 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
552 if (tcflush(tty_fd, TCIOFLUSH) < 0)
554 warn("tcflush failed: %m");
558 * Restore the previous line discipline
560 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
561 if ( ! ok_error (errno))
562 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
565 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
566 if ( ! ok_error (errno))
567 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
570 /* Reset non-blocking mode on fd. */
571 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
572 if ( ! ok_error (errno))
573 warn("Couldn't restore device fd flags: %m");
579 generic_disestablish_ppp(tty_fd);
582 /********************************************************************
584 * generic_disestablish_ppp - Restore device components to normal
585 * operation, and reconnect the ppp unit to the loopback if in demand
586 * mode. This shouldn't call die() because it's called from die().
588 void generic_disestablish_ppp(int dev_fd)
590 if (new_style_driver) {
594 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
596 } else if (!doing_multilink && ppp_dev_fd >= 0) {
598 remove_fd(ppp_dev_fd);
602 /* old-style driver */
604 set_ppp_fd(slave_fd);
611 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
612 * Assumes new_style_driver.
614 static int make_ppp_unit()
618 if (ppp_dev_fd >= 0) {
619 dbglog("in make_ppp_unit, already had /dev/ppp open?");
622 ppp_dev_fd = open("/dev/ppp", O_RDWR);
624 fatal("Couldn't open /dev/ppp: %m");
625 flags = fcntl(ppp_dev_fd, F_GETFL);
627 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
628 warn("Couldn't set /dev/ppp to nonblock: %m");
631 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
632 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
633 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
635 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
638 error("Couldn't create new ppp unit: %m");
643 * cfg_bundle - configure the existing bundle.
644 * Used in demand mode.
646 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
648 if (!new_style_driver)
651 /* set the mrru, mtu and flags */
652 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
653 error("Couldn't set MRRU: %m");
655 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
656 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
657 | (mrru? SC_MULTILINK: 0)));
659 /* connect up the channel */
660 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
661 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
666 * make_new_bundle - create a new PPP unit (i.e. a bundle)
667 * and connect our channel to it. This should only get called
668 * if `multilink' was set at the time establish_ppp was called.
669 * In demand mode this uses our existing bundle instead of making
672 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
674 if (!new_style_driver)
677 /* make us a ppp unit */
678 if (make_ppp_unit() < 0)
681 /* set the mrru and flags */
682 cfg_bundle(mrru, mtru, rssn, tssn);
686 * bundle_attach - attach our link to a given PPP unit.
687 * We assume the unit is controlled by another pppd.
689 int bundle_attach(int ifnum)
693 if (!new_style_driver)
696 master_fd = open("/dev/ppp", O_RDWR);
698 fatal("Couldn't open /dev/ppp: %m");
699 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
700 if (errno == ENXIO) {
702 return 0; /* doesn't still exist */
704 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
706 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
707 fatal("Couldn't connect to interface unit %d: %m", ifnum);
708 modify_flags(master_fd, 0, SC_MULTILINK);
716 * destroy_bundle - tell the driver to destroy our bundle.
718 void destroy_bundle(void)
720 if (ppp_dev_fd >= 0) {
722 remove_fd(ppp_dev_fd);
727 /********************************************************************
729 * clean_check - Fetch the flags for the device and generate
730 * appropriate error messages.
732 void clean_check(void)
738 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
740 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
742 s = "all had bit 7 set to 1";
746 s = "all had bit 7 set to 0";
750 s = "all had odd parity";
754 s = "all had even parity";
759 warn("Receive serial link is not 8-bit clean:");
760 warn("Problem: %s", s);
768 * List of valid speeds.
772 int speed_int, speed_val;
853 { 1000000, B1000000 },
856 { 1152000, B1152000 },
859 { 1500000, B1500000 },
862 { 2000000, B2000000 },
865 { 2500000, B2500000 },
868 { 3000000, B3000000 },
871 { 3500000, B3500000 },
874 { 4000000, B4000000 },
879 /********************************************************************
881 * Translate from bits/second to a speed_t.
884 static int translate_speed (int bps)
886 struct speed *speedp;
889 for (speedp = speeds; speedp->speed_int; speedp++) {
890 if (bps == speedp->speed_int)
891 return speedp->speed_val;
893 warn("speed %d not supported", bps);
898 /********************************************************************
900 * Translate from a speed_t to bits/second.
903 static int baud_rate_of (int speed)
905 struct speed *speedp;
908 for (speedp = speeds; speedp->speed_int; speedp++) {
909 if (speed == speedp->speed_val)
910 return speedp->speed_int;
916 /********************************************************************
918 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
919 * at the requested speed, etc. If `local' is true, set CLOCAL
920 * regardless of whether the modem option was specified.
923 void set_up_tty(int tty_fd, int local)
929 if (tcgetattr(tty_fd, &tios) < 0) {
930 if (!ok_error(errno))
931 fatal("tcgetattr: %m (line %d)", __LINE__);
938 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
939 tios.c_cflag |= CS8 | CREAD | HUPCL;
941 tios.c_iflag = IGNBRK | IGNPAR;
945 tios.c_cc[VTIME] = 0;
948 tios.c_cflag ^= (CLOCAL | HUPCL);
952 tios.c_cflag |= CRTSCTS;
956 tios.c_iflag |= IXON | IXOFF;
957 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
958 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
962 tios.c_cflag &= ~CRTSCTS;
969 speed = translate_speed(inspeed);
971 cfsetospeed (&tios, speed);
972 cfsetispeed (&tios, speed);
975 * We can't proceed if the serial port speed is B0,
976 * since that implies that the serial port is disabled.
979 speed = cfgetospeed(&tios);
981 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
984 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
986 fatal("tcsetattr: %m (line %d)", __LINE__);
988 baud_rate = baud_rate_of(speed);
992 /********************************************************************
994 * setdtr - control the DTR line on the serial port.
995 * This is called from die(), so it shouldn't call die().
998 void setdtr (int tty_fd, int on)
1000 int modembits = TIOCM_DTR;
1002 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1005 /********************************************************************
1007 * restore_tty - restore the terminal to the saved settings.
1010 void restore_tty (int tty_fd)
1015 * Turn off echoing, because otherwise we can get into
1016 * a loop with the tty and the modem echoing to each other.
1017 * We presume we are the sole user of this tty device, so
1018 * when we close it, it will revert to its defaults anyway.
1020 if (!default_device)
1021 inittermios.c_lflag &= ~(ECHO | ECHONL);
1023 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1024 if (! ok_error (errno))
1025 warn("tcsetattr: %m (line %d)", __LINE__);
1030 /********************************************************************
1032 * output - Output PPP packet.
1035 void output (int unit, unsigned char *p, int len)
1040 dump_packet("sent", p, len);
1041 if (snoop_send_hook) snoop_send_hook(p, len);
1043 if (len < PPP_HDRLEN)
1045 if (new_style_driver) {
1048 proto = (p[0] << 8) + p[1];
1049 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1052 if (write(fd, p, len) < 0) {
1053 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1054 || errno == ENXIO || errno == EIO || errno == EINTR)
1055 warn("write: warning: %m (%d)", errno);
1057 error("write: %m (%d)", errno);
1061 /********************************************************************
1063 * wait_input - wait until there is data available,
1064 * for the length of time specified by *timo (indefinite
1068 void wait_input(struct timeval *timo)
1075 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1076 if (n < 0 && errno != EINTR)
1077 fatal("select: %m");
1081 * add_fd - add an fd to the set that wait_input waits for.
1085 if (fd >= FD_SETSIZE)
1086 fatal("internal error: file descriptor too large (%d)", fd);
1087 FD_SET(fd, &in_fds);
1093 * remove_fd - remove an fd from the set that wait_input waits for.
1095 void remove_fd(int fd)
1097 FD_CLR(fd, &in_fds);
1101 /********************************************************************
1103 * read_packet - get a PPP packet from the serial device.
1106 int read_packet (unsigned char *buf)
1110 len = PPP_MRU + PPP_HDRLEN;
1111 if (new_style_driver) {
1112 *buf++ = PPP_ALLSTATIONS;
1118 nr = read(ppp_fd, buf, len);
1119 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1120 && errno != EIO && errno != EINTR)
1122 if (nr < 0 && errno == ENXIO)
1125 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1126 /* N.B. we read ppp_fd first since LCP packets come in there. */
1127 nr = read(ppp_dev_fd, buf, len);
1128 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1129 && errno != EIO && errno != EINTR)
1130 error("read /dev/ppp: %m");
1131 if (nr < 0 && errno == ENXIO)
1133 if (nr == 0 && doing_multilink) {
1134 remove_fd(ppp_dev_fd);
1138 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1140 return (new_style_driver && nr > 0)? nr+2: nr;
1143 /********************************************************************
1145 * get_loop_output - get outgoing packets from the ppp device,
1146 * and detect when we want to bring the real link up.
1147 * Return value is 1 if we need to bring up the link, 0 otherwise.
1150 get_loop_output(void)
1155 if (new_style_driver) {
1156 while ((n = read_packet(inpacket_buf)) > 0)
1157 if (loop_frame(inpacket_buf, n))
1162 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1163 if (loop_chars(inbuf, n))
1167 fatal("eof on loopback");
1169 if (errno != EWOULDBLOCK && errno != EAGAIN)
1170 fatal("read from loopback: %m(%d)", errno);
1176 * netif_set_mtu - set the MTU on the PPP network interface.
1179 netif_set_mtu(int unit, int mtu)
1183 memset (&ifr, '\0', sizeof (ifr));
1184 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1187 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1188 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1192 * netif_get_mtu - get the MTU on the PPP network interface.
1195 netif_get_mtu(int unit)
1199 memset (&ifr, '\0', sizeof (ifr));
1200 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1202 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1203 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1209 /********************************************************************
1211 * tty_send_config - configure the transmit characteristics of
1212 * the ppp interface.
1215 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1222 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1223 if (errno != EIO && errno != ENOTTY)
1224 error("Couldn't set transmit async character map: %m");
1229 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1230 | (sync_serial? SC_SYNC: 0);
1231 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1234 /********************************************************************
1236 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1239 void tty_set_xaccm (ext_accm accm)
1243 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1244 if ( ! ok_error (errno))
1245 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1249 /********************************************************************
1251 * tty_recv_config - configure the receive-side characteristics of
1252 * the ppp interface.
1255 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1258 * If we were called because the link has gone down then there is nothing
1259 * which may be done. Just return without incident.
1264 * Set the receiver parameters
1266 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1267 if (errno != EIO && errno != ENOTTY)
1268 error("Couldn't set channel receive MRU: %m");
1270 if (new_style_driver && ppp_dev_fd >= 0
1271 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1272 error("Couldn't set MRU in generic PPP layer: %m");
1274 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1275 if (errno != EIO && errno != ENOTTY)
1276 error("Couldn't set channel receive asyncmap: %m");
1280 /********************************************************************
1282 * ccp_test - ask kernel whether a given compression method
1283 * is acceptable for use.
1287 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1289 struct ppp_option_data data;
1291 memset (&data, '\0', sizeof (data));
1293 data.length = opt_len;
1294 data.transmit = for_transmit;
1296 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1299 return (errno == ENOBUFS)? 0: -1;
1302 /********************************************************************
1304 * ccp_flags_set - inform kernel about the current state of CCP.
1307 void ccp_flags_set (int unit, int isopen, int isup)
1311 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1312 if (still_ppp() && ppp_dev_fd >= 0)
1313 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1318 * set_filters - set the active and pass filters in the kernel driver.
1320 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1322 struct sock_fprog fp;
1324 fp.len = pass->bf_len;
1325 fp.filter = (struct sock_filter *) pass->bf_insns;
1326 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1327 if (errno == ENOTTY)
1328 warn("kernel does not support PPP filtering");
1330 error("Couldn't set pass-filter in kernel: %m");
1333 fp.len = active->bf_len;
1334 fp.filter = (struct sock_filter *) active->bf_insns;
1335 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1336 error("Couldn't set active-filter in kernel: %m");
1341 #endif /* PPP_FILTER */
1343 /********************************************************************
1345 * get_idle_time - return how long the link has been idle.
1348 get_idle_time(u, ip)
1350 struct ppp_idle *ip;
1352 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1355 /********************************************************************
1357 * get_ppp_stats - return statistics for the link.
1360 get_ppp_stats(u, stats)
1362 struct pppd_stats *stats;
1364 struct ifpppstatsreq req;
1366 memset (&req, 0, sizeof (req));
1368 req.stats_ptr = (caddr_t) &req.stats;
1369 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1370 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1371 error("Couldn't get PPP statistics: %m");
1374 stats->bytes_in = req.stats.p.ppp_ibytes;
1375 stats->bytes_out = req.stats.p.ppp_obytes;
1376 stats->pkts_in = req.stats.p.ppp_ipackets;
1377 stats->pkts_out = req.stats.p.ppp_opackets;
1381 /********************************************************************
1383 * ccp_fatal_error - returns 1 if decompression was disabled as a
1384 * result of an error detected after decompression of a packet,
1385 * 0 otherwise. This is necessary because of patent nonsense.
1388 int ccp_fatal_error (int unit)
1392 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1393 error("Couldn't read compression error flags: %m");
1396 return flags & SC_DC_FERROR;
1399 /********************************************************************
1401 * path_to_procfs - find the path to the proc file system mount point
1403 static char proc_path[MAXPATHLEN];
1404 static int proc_path_len;
1406 static char *path_to_procfs(const char *tail)
1408 struct mntent *mntent;
1411 if (proc_path_len == 0) {
1412 /* Default the mount location of /proc */
1413 strlcpy (proc_path, "/proc", sizeof(proc_path));
1415 fp = fopen(MOUNTED, "r");
1417 while ((mntent = getmntent(fp)) != NULL) {
1418 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1420 if (strcmp(mntent->mnt_type, "proc") == 0) {
1421 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1422 proc_path_len = strlen(proc_path);
1430 strlcpy(proc_path + proc_path_len, tail,
1431 sizeof(proc_path) - proc_path_len);
1436 * /proc/net/route parsing stuff.
1438 #define ROUTE_MAX_COLS 12
1439 FILE *route_fd = (FILE *) 0;
1440 static char route_buffer[512];
1441 static int route_dev_col, route_dest_col, route_gw_col;
1442 static int route_flags_col, route_mask_col;
1443 static int route_num_cols;
1445 static int open_route_table (void);
1446 static void close_route_table (void);
1447 static int read_route_table (struct rtentry *rt);
1449 /********************************************************************
1451 * close_route_table - close the interface to the route table
1454 static void close_route_table (void)
1456 if (route_fd != (FILE *) 0) {
1458 route_fd = (FILE *) 0;
1462 /********************************************************************
1464 * open_route_table - open the interface to the route table
1466 static char route_delims[] = " \t\n";
1468 static int open_route_table (void)
1472 close_route_table();
1474 path = path_to_procfs("/net/route");
1475 route_fd = fopen (path, "r");
1476 if (route_fd == NULL) {
1477 error("can't open routing table %s: %m", path);
1481 route_dev_col = 0; /* default to usual columns */
1484 route_flags_col = 3;
1488 /* parse header line */
1489 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1490 char *p = route_buffer, *q;
1492 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1494 if ((q = strtok(p, route_delims)) == 0)
1496 if (strcasecmp(q, "iface") == 0)
1497 route_dev_col = col;
1498 else if (strcasecmp(q, "destination") == 0)
1499 route_dest_col = col;
1500 else if (strcasecmp(q, "gateway") == 0)
1502 else if (strcasecmp(q, "flags") == 0)
1503 route_flags_col = col;
1504 else if (strcasecmp(q, "mask") == 0)
1505 route_mask_col = col;
1508 if (used && col >= route_num_cols)
1509 route_num_cols = col + 1;
1517 /********************************************************************
1519 * read_route_table - read the next entry from the route table
1522 static int read_route_table(struct rtentry *rt)
1524 char *cols[ROUTE_MAX_COLS], *p;
1527 memset (rt, '\0', sizeof (struct rtentry));
1529 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1533 for (col = 0; col < route_num_cols; ++col) {
1534 cols[col] = strtok(p, route_delims);
1535 if (cols[col] == NULL)
1536 return 0; /* didn't get enough columns */
1540 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1541 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1542 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1544 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1545 rt->rt_dev = cols[route_dev_col];
1550 /********************************************************************
1552 * defaultroute_exists - determine if there is a default route
1555 static int defaultroute_exists (struct rtentry *rt)
1559 if (!open_route_table())
1562 while (read_route_table(rt) != 0) {
1563 if ((rt->rt_flags & RTF_UP) == 0)
1566 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1568 if (SIN_ADDR(rt->rt_dst) == 0L) {
1574 close_route_table();
1579 * have_route_to - determine if the system has any route to
1580 * a given IP address. `addr' is in network byte order.
1581 * Return value is 1 if yes, 0 if no, -1 if don't know.
1582 * For demand mode to work properly, we have to ignore routes
1583 * through our own interface.
1585 int have_route_to(u_int32_t addr)
1590 if (!open_route_table())
1591 return -1; /* don't know */
1593 while (read_route_table(&rt)) {
1594 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1596 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1602 close_route_table();
1606 /********************************************************************
1608 * sifdefaultroute - assign a default route through the address given.
1611 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1615 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1616 if (rt.rt_flags & RTF_GATEWAY)
1617 error("not replacing existing default route via %I",
1618 SIN_ADDR(rt.rt_gateway));
1620 error("not replacing existing default route through %s",
1625 memset (&rt, 0, sizeof (rt));
1626 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1630 if (kernel_version > KVERSION(2,1,0)) {
1631 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1632 SIN_ADDR(rt.rt_genmask) = 0L;
1635 rt.rt_flags = RTF_UP;
1636 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1637 if ( ! ok_error ( errno ))
1638 error("default route ioctl(SIOCADDRT): %m");
1642 have_default_route = 1;
1646 /********************************************************************
1648 * cifdefaultroute - delete a default route through the address given.
1651 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1655 have_default_route = 0;
1657 memset (&rt, '\0', sizeof (rt));
1658 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1659 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1661 if (kernel_version > KVERSION(2,1,0)) {
1662 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1663 SIN_ADDR(rt.rt_genmask) = 0L;
1666 rt.rt_flags = RTF_UP;
1667 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1669 if ( ! ok_error ( errno ))
1670 error("default route ioctl(SIOCDELRT): %m");
1678 /********************************************************************
1680 * sifproxyarp - Make a proxy ARP entry for the peer.
1683 int sifproxyarp (int unit, u_int32_t his_adr)
1685 struct arpreq arpreq;
1688 if (has_proxy_arp == 0) {
1689 memset (&arpreq, '\0', sizeof(arpreq));
1691 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1692 SIN_ADDR(arpreq.arp_pa) = his_adr;
1693 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1695 * Get the hardware address of an interface on the same subnet
1696 * as our local address.
1698 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1699 sizeof(proxy_arp_dev))) {
1700 error("Cannot determine ethernet address for proxy ARP");
1703 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1705 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1706 if ( ! ok_error ( errno ))
1707 error("ioctl(SIOCSARP): %m");
1710 proxy_arp_addr = his_adr;
1714 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1715 if (forw_path != 0) {
1716 int fd = open(forw_path, O_WRONLY);
1718 if (write(fd, "1", 1) != 1)
1719 error("Couldn't enable IP forwarding: %m");
1729 /********************************************************************
1731 * cifproxyarp - Delete the proxy ARP entry for the peer.
1734 int cifproxyarp (int unit, u_int32_t his_adr)
1736 struct arpreq arpreq;
1738 if (has_proxy_arp) {
1740 memset (&arpreq, '\0', sizeof(arpreq));
1741 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1742 SIN_ADDR(arpreq.arp_pa) = his_adr;
1743 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1744 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1746 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1747 if ( ! ok_error ( errno ))
1748 warn("ioctl(SIOCDARP): %m");
1755 /********************************************************************
1757 * get_ether_addr - get the hardware address of an interface on the
1758 * the same subnet as ipaddr.
1761 static int get_ether_addr (u_int32_t ipaddr,
1762 struct sockaddr *hwaddr,
1763 char *name, int namelen)
1765 struct ifreq *ifr, *ifend;
1766 u_int32_t ina, mask;
1768 struct ifreq ifreq, bestifreq;
1770 struct ifreq ifs[MAX_IFS];
1772 u_int32_t bestmask=0;
1773 int found_interface = 0;
1775 ifc.ifc_len = sizeof(ifs);
1777 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1778 if ( ! ok_error ( errno ))
1779 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1784 * Scan through looking for an interface with an Internet
1785 * address on the same subnet as `ipaddr'.
1787 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1788 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1789 if (ifr->ifr_addr.sa_family == AF_INET) {
1790 ina = SIN_ADDR(ifr->ifr_addr);
1791 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1793 * Check that the interface is up, and not point-to-point
1796 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1799 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1802 * Get its netmask and check that it's on the right subnet.
1804 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1807 mask = SIN_ADDR(ifreq.ifr_addr);
1809 if (((ipaddr ^ ina) & mask) != 0)
1810 continue; /* no match */
1812 if (mask >= bestmask) {
1813 /* Compare using >= instead of > -- it is possible for
1814 an interface to have a netmask of 0.0.0.0 */
1815 found_interface = 1;
1822 if (!found_interface) return 0;
1824 strlcpy(name, bestifreq.ifr_name, namelen);
1826 /* trim off the :1 in eth0:1 */
1827 aliasp = strchr(name, ':');
1831 info("found interface %s for proxy arp", name);
1833 * Now get the hardware address.
1835 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1836 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1837 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1842 &bestifreq.ifr_hwaddr,
1843 sizeof (struct sockaddr));
1849 * get_if_hwaddr - get the hardware address for the specified
1850 * network interface device.
1853 get_if_hwaddr(u_char *addr, char *name)
1858 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1861 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1862 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1863 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1866 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1871 * get_first_ethernet - return the name of the first ethernet-style
1872 * interface on this system.
1875 get_first_ethernet()
1880 /********************************************************************
1882 * Return user specified netmask, modified by any mask we might determine
1883 * for address `addr' (in network byte order).
1884 * Here we scan through the system's list of interfaces, looking for
1885 * any non-point-to-point interfaces which might appear to be on the same
1886 * network as `addr'. If we find any, we OR in their netmask to the
1887 * user-specified netmask.
1890 u_int32_t GetMask (u_int32_t addr)
1892 u_int32_t mask, nmask, ina;
1893 struct ifreq *ifr, *ifend, ifreq;
1895 struct ifreq ifs[MAX_IFS];
1899 if (IN_CLASSA(addr)) /* determine network mask for address class */
1900 nmask = IN_CLASSA_NET;
1901 else if (IN_CLASSB(addr))
1902 nmask = IN_CLASSB_NET;
1904 nmask = IN_CLASSC_NET;
1906 /* class D nets are disallowed by bad_ip_adrs */
1907 mask = netmask | htonl(nmask);
1909 * Scan through the system's network interfaces.
1911 ifc.ifc_len = sizeof(ifs);
1913 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1914 if ( ! ok_error ( errno ))
1915 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1919 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1920 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1922 * Check the interface's internet address.
1924 if (ifr->ifr_addr.sa_family != AF_INET)
1926 ina = SIN_ADDR(ifr->ifr_addr);
1927 if (((ntohl(ina) ^ addr) & nmask) != 0)
1930 * Check that the interface is up, and not point-to-point nor loopback.
1932 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1933 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1936 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1939 * Get its netmask and OR it into our mask.
1941 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1943 mask |= SIN_ADDR(ifreq.ifr_addr);
1949 /********************************************************************
1951 * Internal routine to decode the version.modification.patch level
1954 static void decode_version (char *buf, int *version,
1955 int *modification, int *patch)
1959 *version = (int) strtoul (buf, &endp, 10);
1963 if (endp != buf && *endp == '.') {
1965 *modification = (int) strtoul (buf, &endp, 10);
1966 if (endp != buf && *endp == '.') {
1968 *patch = (int) strtoul (buf, &buf, 10);
1973 /********************************************************************
1975 * Procedure to determine if the PPP line discipline is registered.
1979 ppp_registered(void)
1987 * We used to open the serial device and set it to the ppp line
1988 * discipline here, in order to create a ppp unit. But that is
1989 * not a good idea - the user might have specified a device that
1990 * they can't open (permission, or maybe it doesn't really exist).
1991 * So we grab a pty master/slave pair and use that.
1993 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1994 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1999 * Try to put the device into the PPP discipline.
2001 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2002 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2011 /********************************************************************
2013 * ppp_available - check whether the system has any ppp interfaces
2014 * (in fact we check whether we can do an ioctl on ppp0).
2017 int ppp_available(void)
2022 int my_version, my_modification, my_patch;
2023 int osmaj, osmin, ospatch;
2026 "This system lacks kernel support for PPP. This could be because\n"
2027 "the PPP kernel module could not be loaded, or because PPP was not\n"
2028 "included in the kernel configuration. If PPP was included as a\n"
2029 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2030 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2031 "See README.linux file in the ppp distribution for more details.\n";
2033 /* get the kernel version now, since we are called before sys_init */
2035 osmaj = osmin = ospatch = 0;
2036 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2037 kernel_version = KVERSION(osmaj, osmin, ospatch);
2039 fd = open("/dev/ppp", O_RDWR);
2041 if (fd < 0 && errno == ENOENT) {
2042 /* try making it and see if that helps. */
2043 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
2044 makedev(108, 0)) >= 0) {
2045 fd = open("/dev/ppp", O_RDWR);
2047 info("Created /dev/ppp device node");
2049 unlink("/dev/ppp"); /* didn't work, undo the mknod */
2050 } else if (errno == EEXIST) {
2051 fd = open("/dev/ppp", O_RDWR);
2056 new_style_driver = 1;
2058 /* XXX should get from driver */
2060 driver_modification = 4;
2065 if (kernel_version >= KVERSION(2,3,13)) {
2066 if (errno == ENOENT)
2068 "pppd is unable to open the /dev/ppp device.\n"
2069 "You need to create the /dev/ppp device node by\n"
2070 "executing the following command as root:\n"
2071 " mknod /dev/ppp c 108 0\n";
2076 * Open a socket for doing the ioctl operations.
2078 s = socket(AF_INET, SOCK_DGRAM, 0);
2082 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2083 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2085 * If the device did not exist then attempt to create one by putting the
2086 * current tty into the PPP discipline. If this works then obtain the
2087 * flags for the device again.
2090 if (ppp_registered()) {
2091 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2092 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2096 * Ensure that the hardware address is for PPP and not something else
2099 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2101 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2105 * This is the PPP device. Validate the version of the driver at this
2106 * point to ensure that this program will work with the driver.
2109 char abBuffer [1024];
2111 ifr.ifr_data = abBuffer;
2112 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2114 error("Couldn't read driver version: %m");
2116 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2119 decode_version(abBuffer,
2121 &driver_modification,
2124 * Validate the version of the driver against the version that we used.
2126 decode_version(VERSION,
2131 /* The version numbers must match */
2132 if (driver_version != my_version)
2135 /* The modification levels must be legal */
2136 if (driver_modification < 3) {
2137 if (driver_modification >= 2) {
2138 /* we can cope with 2.2.0 and above */
2147 slprintf(route_buffer, sizeof(route_buffer),
2148 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2149 driver_version, driver_modification, driver_patch);
2151 no_ppp_msg = route_buffer;
2158 /********************************************************************
2160 * Update the wtmp file with the appropriate user name and tty device.
2163 void logwtmp (const char *line, const char *name, const char *host)
2165 struct utmp ut, *utp;
2166 pid_t mypid = getpid();
2172 * Update the signon database for users.
2173 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2175 utmpname(_PATH_UTMP);
2177 while ((utp = getutent()) && (utp->ut_pid != mypid))
2181 memcpy(&ut, utp, sizeof(ut));
2183 /* some gettys/telnetds don't initialize utmp... */
2184 memset(&ut, 0, sizeof(ut));
2186 if (ut.ut_id[0] == 0)
2187 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2189 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2190 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2194 ut.ut_type = USER_PROCESS;
2197 /* Insert the host name if one is supplied */
2199 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2201 /* Insert the IP address of the remote system if IP is enabled */
2202 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2203 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2204 sizeof(ut.ut_addr));
2206 /* CL: Makes sure that the logout works */
2207 if (*host == 0 && *name==0)
2213 * Update the wtmp file.
2216 updwtmp(_PATH_WTMP, &ut);
2218 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2220 flock(wtmp, LOCK_EX);
2222 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2223 warn("error writing %s: %m", _PATH_WTMP);
2225 flock(wtmp, LOCK_UN);
2233 /********************************************************************
2235 * sifvjcomp - config tcp header compression
2238 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2243 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2244 error("Couldn't set up TCP header compression: %m");
2248 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2249 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2254 /********************************************************************
2256 * sifup - Config the interface up and enable IP packets to pass.
2263 memset (&ifr, '\0', sizeof (ifr));
2264 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2265 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2266 if (! ok_error (errno))
2267 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2271 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2272 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2273 if (! ok_error (errno))
2274 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2282 /********************************************************************
2284 * sifdown - Disable the indicated protocol and config the interface
2285 * down if there are no remaining protocols.
2292 if (if_is_up && --if_is_up > 0)
2295 memset (&ifr, '\0', sizeof (ifr));
2296 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2297 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2298 if (! ok_error (errno))
2299 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2303 ifr.ifr_flags &= ~IFF_UP;
2304 ifr.ifr_flags |= IFF_POINTOPOINT;
2305 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2306 if (! ok_error (errno))
2307 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2313 /********************************************************************
2315 * sifaddr - Config the interface IP addresses and netmask.
2318 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2324 memset (&ifr, '\0', sizeof (ifr));
2325 memset (&rt, '\0', sizeof (rt));
2327 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2328 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2329 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2331 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2333 * Set our IP address
2335 SIN_ADDR(ifr.ifr_addr) = our_adr;
2336 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2337 if (errno != EEXIST) {
2338 if (! ok_error (errno))
2339 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2342 warn("ioctl(SIOCSIFADDR): Address already exists");
2347 * Set the gateway address
2350 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2351 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2352 if (! ok_error (errno))
2353 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2359 * For recent kernels, force the netmask to 255.255.255.255.
2361 if (kernel_version >= KVERSION(2,1,16))
2363 if (net_mask != 0) {
2364 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2365 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2366 if (! ok_error (errno))
2367 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2372 * Add the device route
2374 if (kernel_version < KVERSION(2,1,16)) {
2375 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2376 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2379 SIN_ADDR(rt.rt_gateway) = 0L;
2380 SIN_ADDR(rt.rt_dst) = his_adr;
2381 rt.rt_flags = RTF_UP | RTF_HOST;
2383 if (kernel_version > KVERSION(2,1,0)) {
2384 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2385 SIN_ADDR(rt.rt_genmask) = -1L;
2388 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2389 if (! ok_error (errno))
2390 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2395 /* set ip_dynaddr in demand mode if address changes */
2396 if (demand && tune_kernel && !dynaddr_set
2397 && our_old_addr && our_old_addr != our_adr) {
2398 /* set ip_dynaddr if possible */
2402 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2403 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2404 if (write(fd, "1", 1) != 1)
2405 error("Couldn't enable dynamic IP addressing: %m");
2408 dynaddr_set = 1; /* only 1 attempt */
2415 /********************************************************************
2417 * cifaddr - Clear the interface IP addresses, and delete routes
2418 * through the interface if possible.
2421 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2425 if (kernel_version < KVERSION(2,1,16)) {
2427 * Delete the route through the device
2430 memset (&rt, '\0', sizeof (rt));
2432 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2433 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2436 SIN_ADDR(rt.rt_gateway) = 0;
2437 SIN_ADDR(rt.rt_dst) = his_adr;
2438 rt.rt_flags = RTF_UP | RTF_HOST;
2440 if (kernel_version > KVERSION(2,1,0)) {
2441 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2442 SIN_ADDR(rt.rt_genmask) = -1L;
2445 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2446 if (still_ppp() && ! ok_error (errno))
2447 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2452 /* This way it is possible to have an IPX-only or IPv6-only interface */
2453 memset(&ifr, 0, sizeof(ifr));
2454 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2455 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2457 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2458 if (! ok_error (errno)) {
2459 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2464 our_old_addr = our_adr;
2470 /********************************************************************
2472 * sif6addr - Config the interface with an IPv6 link-local address
2474 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2476 struct in6_ifreq ifr6;
2478 struct in6_rtmsg rt6;
2482 error("IPv6 socket creation failed: %m");
2485 memset(&ifr, 0, sizeof (ifr));
2486 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2487 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2488 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2492 /* Local interface */
2493 memset(&ifr6, 0, sizeof(ifr6));
2494 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2495 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2496 ifr6.ifr6_prefixlen = 10;
2498 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2499 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2503 /* Route to remote host */
2504 memset(&rt6, 0, sizeof(rt6));
2505 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2506 rt6.rtmsg_flags = RTF_UP;
2507 rt6.rtmsg_dst_len = 10;
2508 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2509 rt6.rtmsg_metric = 1;
2511 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2512 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2520 /********************************************************************
2522 * cif6addr - Remove IPv6 address from interface
2524 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2527 struct in6_ifreq ifr6;
2531 error("IPv6 socket creation failed: %m");
2534 memset(&ifr, 0, sizeof(ifr));
2535 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2536 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2537 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2541 memset(&ifr6, 0, sizeof(ifr6));
2542 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2543 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2544 ifr6.ifr6_prefixlen = 10;
2546 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2547 if (errno != EADDRNOTAVAIL) {
2548 if (! ok_error (errno))
2549 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2552 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2561 * get_pty - get a pty master/slave pair and chown the slave side
2562 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2565 get_pty(master_fdp, slave_fdp, slave_name, uid)
2571 int i, mfd, sfd = -1;
2573 struct termios tios;
2577 * Try the unix98 way first.
2579 mfd = open("/dev/ptmx", O_RDWR);
2582 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2583 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2584 chmod(pty_name, S_IRUSR | S_IWUSR);
2587 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2588 warn("Couldn't unlock pty slave %s: %m", pty_name);
2590 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2591 warn("Couldn't open pty slave %s: %m", pty_name);
2594 #endif /* TIOCGPTN */
2597 /* the old way - scan through the pty name space */
2598 for (i = 0; i < 64; ++i) {
2599 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2600 'p' + i / 16, i % 16);
2601 mfd = open(pty_name, O_RDWR, 0);
2604 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2606 fchown(sfd, uid, -1);
2607 fchmod(sfd, S_IRUSR | S_IWUSR);
2618 strlcpy(slave_name, pty_name, 16);
2621 if (tcgetattr(sfd, &tios) == 0) {
2622 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2623 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2624 tios.c_iflag = IGNPAR;
2627 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2628 warn("couldn't set attributes on pty: %m");
2630 warn("couldn't get attributes on pty: %m");
2635 /********************************************************************
2637 * open_loopback - open the device we use for getting packets
2638 * in demand mode. Under Linux, we use a pty master/slave pair.
2641 open_ppp_loopback(void)
2646 if (new_style_driver) {
2647 /* allocate ourselves a ppp unit */
2648 if (make_ppp_unit() < 0)
2650 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2651 set_kdebugflag(kdebugflag);
2656 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2657 fatal("No free pty for loopback");
2659 set_ppp_fd(slave_fd);
2661 flags = fcntl(master_fd, F_GETFL);
2663 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2664 warn("couldn't set master loopback to nonblock: %m");
2666 flags = fcntl(ppp_fd, F_GETFL);
2668 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2669 warn("couldn't set slave loopback to nonblock: %m");
2671 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2672 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2674 * Find out which interface we were given.
2676 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2677 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2679 * Enable debug in the driver if requested.
2681 set_kdebugflag (kdebugflag);
2686 /********************************************************************
2688 * sifnpmode - Set the mode for handling packets for a given NP.
2692 sifnpmode(u, proto, mode)
2699 npi.protocol = proto;
2701 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2702 if (! ok_error (errno))
2703 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2710 /********************************************************************
2712 * sipxfaddr - Config the interface IPX networknumber
2715 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2722 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2724 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2726 if (! ok_error (errno))
2727 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2731 memset (&ifr, '\0', sizeof (ifr));
2732 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2734 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2735 sipx->sipx_family = AF_IPX;
2736 sipx->sipx_port = 0;
2737 sipx->sipx_network = htonl (network);
2738 sipx->sipx_type = IPX_FRAME_ETHERII;
2739 sipx->sipx_action = IPX_CRTITF;
2741 * Set the IPX device
2743 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2745 if (errno != EEXIST) {
2746 if (! ok_error (errno))
2747 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2750 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2759 /********************************************************************
2761 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2762 * are removed and the device is no longer able to pass IPX
2766 int cipxfaddr (int unit)
2773 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2775 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2777 if (! ok_error (errno))
2778 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2782 memset (&ifr, '\0', sizeof (ifr));
2783 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2785 sipx->sipx_type = IPX_FRAME_ETHERII;
2786 sipx->sipx_action = IPX_DLTITF;
2787 sipx->sipx_family = AF_IPX;
2789 * Set the IPX device
2791 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2792 if (! ok_error (errno))
2793 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2803 * Use the hostname as part of the random number seed.
2812 for (p = hostname; *p != 0; ++p)
2817 /********************************************************************
2819 * sys_check_options - check the options that the user specified
2823 sys_check_options(void)
2827 * Disable the IPX protocol if the support is not present in the kernel.
2831 if (ipxcp_protent.enabled_flag) {
2832 struct stat stat_buf;
2833 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
2834 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
2835 || lstat(path, &stat_buf) < 0) {
2836 error("IPX support is not present in the kernel\n");
2837 ipxcp_protent.enabled_flag = 0;
2841 if (demand && driver_is_old) {
2842 option_error("demand dialling is not supported by kernel driver "
2843 "version %d.%d.%d", driver_version, driver_modification,
2847 if (multilink && !new_style_driver) {
2848 warn("Warning: multilink is not supported by the kernel driver");
2856 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2858 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2859 * that the system has a properly configured Ethernet interface for this
2860 * function to return non-zero.
2863 ether_to_eui64(eui64_t *p_eui64)
2867 const unsigned char *ptr;
2869 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2872 warn("could not open IPv6 socket");
2876 strcpy(ifr.ifr_name, "eth0");
2877 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2880 warn("could not obtain hardware address for eth0");
2886 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2888 ptr = ifr.ifr_hwaddr.sa_data;
2889 p_eui64->e8[0] = ptr[0] | 0x02;
2890 p_eui64->e8[1] = ptr[1];
2891 p_eui64->e8[2] = ptr[2];
2892 p_eui64->e8[3] = 0xFF;
2893 p_eui64->e8[4] = 0xFE;
2894 p_eui64->e8[5] = ptr[3];
2895 p_eui64->e8[6] = ptr[4];
2896 p_eui64->e8[7] = ptr[5];