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);
1663 if (kernel_version > KVERSION(2,1,0)) {
1664 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1665 SIN_ADDR(rt.rt_genmask) = 0L;
1668 rt.rt_flags = RTF_UP;
1669 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1671 if ( ! ok_error ( errno ))
1672 error("default route ioctl(SIOCDELRT): %m");
1680 /********************************************************************
1682 * sifproxyarp - Make a proxy ARP entry for the peer.
1685 int sifproxyarp (int unit, u_int32_t his_adr)
1687 struct arpreq arpreq;
1690 if (has_proxy_arp == 0) {
1691 memset (&arpreq, '\0', sizeof(arpreq));
1693 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1694 SIN_ADDR(arpreq.arp_pa) = his_adr;
1695 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1697 * Get the hardware address of an interface on the same subnet
1698 * as our local address.
1700 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1701 sizeof(proxy_arp_dev))) {
1702 error("Cannot determine ethernet address for proxy ARP");
1705 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1707 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1708 if ( ! ok_error ( errno ))
1709 error("ioctl(SIOCSARP): %m");
1712 proxy_arp_addr = his_adr;
1716 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1717 if (forw_path != 0) {
1718 int fd = open(forw_path, O_WRONLY);
1720 if (write(fd, "1", 1) != 1)
1721 error("Couldn't enable IP forwarding: %m");
1731 /********************************************************************
1733 * cifproxyarp - Delete the proxy ARP entry for the peer.
1736 int cifproxyarp (int unit, u_int32_t his_adr)
1738 struct arpreq arpreq;
1740 if (has_proxy_arp) {
1742 memset (&arpreq, '\0', sizeof(arpreq));
1743 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1744 SIN_ADDR(arpreq.arp_pa) = his_adr;
1745 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1746 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1748 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1749 if ( ! ok_error ( errno ))
1750 warn("ioctl(SIOCDARP): %m");
1757 /********************************************************************
1759 * get_ether_addr - get the hardware address of an interface on the
1760 * the same subnet as ipaddr.
1763 static int get_ether_addr (u_int32_t ipaddr,
1764 struct sockaddr *hwaddr,
1765 char *name, int namelen)
1767 struct ifreq *ifr, *ifend;
1768 u_int32_t ina, mask;
1770 struct ifreq ifreq, bestifreq;
1772 struct ifreq ifs[MAX_IFS];
1774 u_int32_t bestmask=0;
1775 int found_interface = 0;
1777 ifc.ifc_len = sizeof(ifs);
1779 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1780 if ( ! ok_error ( errno ))
1781 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1786 * Scan through looking for an interface with an Internet
1787 * address on the same subnet as `ipaddr'.
1789 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1790 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1791 if (ifr->ifr_addr.sa_family == AF_INET) {
1792 ina = SIN_ADDR(ifr->ifr_addr);
1793 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1795 * Check that the interface is up, and not point-to-point
1798 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1801 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1804 * Get its netmask and check that it's on the right subnet.
1806 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1809 mask = SIN_ADDR(ifreq.ifr_addr);
1811 if (((ipaddr ^ ina) & mask) != 0)
1812 continue; /* no match */
1814 if (mask >= bestmask) {
1815 /* Compare using >= instead of > -- it is possible for
1816 an interface to have a netmask of 0.0.0.0 */
1817 found_interface = 1;
1824 if (!found_interface) return 0;
1826 strlcpy(name, bestifreq.ifr_name, namelen);
1828 /* trim off the :1 in eth0:1 */
1829 aliasp = strchr(name, ':');
1833 info("found interface %s for proxy arp", name);
1835 * Now get the hardware address.
1837 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1838 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1839 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1844 &bestifreq.ifr_hwaddr,
1845 sizeof (struct sockaddr));
1851 * get_if_hwaddr - get the hardware address for the specified
1852 * network interface device.
1855 get_if_hwaddr(u_char *addr, char *name)
1860 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1863 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1864 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1865 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1868 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1873 * get_first_ethernet - return the name of the first ethernet-style
1874 * interface on this system.
1877 get_first_ethernet()
1882 /********************************************************************
1884 * Return user specified netmask, modified by any mask we might determine
1885 * for address `addr' (in network byte order).
1886 * Here we scan through the system's list of interfaces, looking for
1887 * any non-point-to-point interfaces which might appear to be on the same
1888 * network as `addr'. If we find any, we OR in their netmask to the
1889 * user-specified netmask.
1892 u_int32_t GetMask (u_int32_t addr)
1894 u_int32_t mask, nmask, ina;
1895 struct ifreq *ifr, *ifend, ifreq;
1897 struct ifreq ifs[MAX_IFS];
1901 if (IN_CLASSA(addr)) /* determine network mask for address class */
1902 nmask = IN_CLASSA_NET;
1903 else if (IN_CLASSB(addr))
1904 nmask = IN_CLASSB_NET;
1906 nmask = IN_CLASSC_NET;
1908 /* class D nets are disallowed by bad_ip_adrs */
1909 mask = netmask | htonl(nmask);
1911 * Scan through the system's network interfaces.
1913 ifc.ifc_len = sizeof(ifs);
1915 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1916 if ( ! ok_error ( errno ))
1917 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1921 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1922 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1924 * Check the interface's internet address.
1926 if (ifr->ifr_addr.sa_family != AF_INET)
1928 ina = SIN_ADDR(ifr->ifr_addr);
1929 if (((ntohl(ina) ^ addr) & nmask) != 0)
1932 * Check that the interface is up, and not point-to-point nor loopback.
1934 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1935 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1938 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1941 * Get its netmask and OR it into our mask.
1943 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1945 mask |= SIN_ADDR(ifreq.ifr_addr);
1951 /********************************************************************
1953 * Internal routine to decode the version.modification.patch level
1956 static void decode_version (char *buf, int *version,
1957 int *modification, int *patch)
1961 *version = (int) strtoul (buf, &endp, 10);
1965 if (endp != buf && *endp == '.') {
1967 *modification = (int) strtoul (buf, &endp, 10);
1968 if (endp != buf && *endp == '.') {
1970 *patch = (int) strtoul (buf, &buf, 10);
1975 /********************************************************************
1977 * Procedure to determine if the PPP line discipline is registered.
1981 ppp_registered(void)
1989 * We used to open the serial device and set it to the ppp line
1990 * discipline here, in order to create a ppp unit. But that is
1991 * not a good idea - the user might have specified a device that
1992 * they can't open (permission, or maybe it doesn't really exist).
1993 * So we grab a pty master/slave pair and use that.
1995 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1996 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2001 * Try to put the device into the PPP discipline.
2003 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2004 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2013 /********************************************************************
2015 * ppp_available - check whether the system has any ppp interfaces
2016 * (in fact we check whether we can do an ioctl on ppp0).
2019 int ppp_available(void)
2024 int my_version, my_modification, my_patch;
2025 int osmaj, osmin, ospatch;
2027 /* get the kernel version now, since we are called before sys_init */
2029 osmaj = osmin = ospatch = 0;
2030 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2031 kernel_version = KVERSION(osmaj, osmin, ospatch);
2033 fd = open("/dev/ppp", O_RDWR);
2035 new_style_driver = 1;
2037 /* XXX should get from driver */
2039 driver_modification = 4;
2045 if (kernel_version >= KVERSION(2,3,13)) {
2046 error("Couldn't open the /dev/ppp device: %m");
2047 if (errno == ENOENT)
2049 "You need to create the /dev/ppp device node by\n"
2050 "executing the following command as root:\n"
2051 " mknod /dev/ppp c 108 0\n";
2052 else if (errno == ENODEV || errno == ENXIO)
2054 "Please load the ppp_generic kernel module.\n";
2058 /* we are running on a really really old kernel */
2060 "This system lacks kernel support for PPP. This could be because\n"
2061 "the PPP kernel module could not be loaded, or because PPP was not\n"
2062 "included in the kernel configuration. If PPP was included as a\n"
2063 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2064 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2065 "See README.linux file in the ppp distribution for more details.\n";
2068 * Open a socket for doing the ioctl operations.
2070 s = socket(AF_INET, SOCK_DGRAM, 0);
2074 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2075 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2077 * If the device did not exist then attempt to create one by putting the
2078 * current tty into the PPP discipline. If this works then obtain the
2079 * flags for the device again.
2082 if (ppp_registered()) {
2083 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2084 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2088 * Ensure that the hardware address is for PPP and not something else
2091 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2093 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2097 * This is the PPP device. Validate the version of the driver at this
2098 * point to ensure that this program will work with the driver.
2101 char abBuffer [1024];
2103 ifr.ifr_data = abBuffer;
2104 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2106 error("Couldn't read driver version: %m");
2108 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2111 decode_version(abBuffer,
2113 &driver_modification,
2116 * Validate the version of the driver against the version that we used.
2118 decode_version(VERSION,
2123 /* The version numbers must match */
2124 if (driver_version != my_version)
2127 /* The modification levels must be legal */
2128 if (driver_modification < 3) {
2129 if (driver_modification >= 2) {
2130 /* we can cope with 2.2.0 and above */
2139 slprintf(route_buffer, sizeof(route_buffer),
2140 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2141 driver_version, driver_modification, driver_patch);
2143 no_ppp_msg = route_buffer;
2150 #ifndef HAVE_LOGWTMP
2151 /********************************************************************
2153 * Update the wtmp file with the appropriate user name and tty device.
2156 void logwtmp (const char *line, const char *name, const char *host)
2158 struct utmp ut, *utp;
2159 pid_t mypid = getpid();
2165 * Update the signon database for users.
2166 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2168 utmpname(_PATH_UTMP);
2170 while ((utp = getutent()) && (utp->ut_pid != mypid))
2174 memcpy(&ut, utp, sizeof(ut));
2176 /* some gettys/telnetds don't initialize utmp... */
2177 memset(&ut, 0, sizeof(ut));
2179 if (ut.ut_id[0] == 0)
2180 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2182 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2183 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2187 ut.ut_type = USER_PROCESS;
2190 /* Insert the host name if one is supplied */
2192 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2194 /* Insert the IP address of the remote system if IP is enabled */
2195 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2196 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2197 sizeof(ut.ut_addr));
2199 /* CL: Makes sure that the logout works */
2200 if (*host == 0 && *name==0)
2206 * Update the wtmp file.
2209 updwtmp(_PATH_WTMP, &ut);
2211 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2213 flock(wtmp, LOCK_EX);
2215 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2216 warn("error writing %s: %m", _PATH_WTMP);
2218 flock(wtmp, LOCK_UN);
2224 #endif /* HAVE_LOGWTMP */
2226 /********************************************************************
2228 * sifvjcomp - config tcp header compression
2231 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2236 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2237 error("Couldn't set up TCP header compression: %m");
2242 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2243 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2248 /********************************************************************
2250 * sifup - Config the interface up and enable IP packets to pass.
2257 memset (&ifr, '\0', sizeof (ifr));
2258 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2259 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2260 if (! ok_error (errno))
2261 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2265 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2266 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2267 if (! ok_error (errno))
2268 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2276 /********************************************************************
2278 * sifdown - Disable the indicated protocol and config the interface
2279 * down if there are no remaining protocols.
2286 if (if_is_up && --if_is_up > 0)
2289 memset (&ifr, '\0', sizeof (ifr));
2290 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2291 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2292 if (! ok_error (errno))
2293 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2297 ifr.ifr_flags &= ~IFF_UP;
2298 ifr.ifr_flags |= IFF_POINTOPOINT;
2299 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2300 if (! ok_error (errno))
2301 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2307 /********************************************************************
2309 * sifaddr - Config the interface IP addresses and netmask.
2312 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2318 memset (&ifr, '\0', sizeof (ifr));
2319 memset (&rt, '\0', sizeof (rt));
2321 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2322 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2323 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2325 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2327 * Set our IP address
2329 SIN_ADDR(ifr.ifr_addr) = our_adr;
2330 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2331 if (errno != EEXIST) {
2332 if (! ok_error (errno))
2333 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2336 warn("ioctl(SIOCSIFADDR): Address already exists");
2341 * Set the gateway address
2344 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2345 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2346 if (! ok_error (errno))
2347 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2353 * For recent kernels, force the netmask to 255.255.255.255.
2355 if (kernel_version >= KVERSION(2,1,16))
2357 if (net_mask != 0) {
2358 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2359 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2360 if (! ok_error (errno))
2361 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2366 * Add the device route
2368 if (kernel_version < KVERSION(2,1,16)) {
2369 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2370 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2373 SIN_ADDR(rt.rt_gateway) = 0L;
2374 SIN_ADDR(rt.rt_dst) = his_adr;
2375 rt.rt_flags = RTF_UP | RTF_HOST;
2377 if (kernel_version > KVERSION(2,1,0)) {
2378 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2379 SIN_ADDR(rt.rt_genmask) = -1L;
2382 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2383 if (! ok_error (errno))
2384 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2389 /* set ip_dynaddr in demand mode if address changes */
2390 if (demand && tune_kernel && !dynaddr_set
2391 && our_old_addr && our_old_addr != our_adr) {
2392 /* set ip_dynaddr if possible */
2396 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2397 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2398 if (write(fd, "1", 1) != 1)
2399 error("Couldn't enable dynamic IP addressing: %m");
2402 dynaddr_set = 1; /* only 1 attempt */
2409 /********************************************************************
2411 * cifaddr - Clear the interface IP addresses, and delete routes
2412 * through the interface if possible.
2415 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2419 if (kernel_version < KVERSION(2,1,16)) {
2421 * Delete the route through the device
2424 memset (&rt, '\0', sizeof (rt));
2426 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2427 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2430 SIN_ADDR(rt.rt_gateway) = 0;
2431 SIN_ADDR(rt.rt_dst) = his_adr;
2432 rt.rt_flags = RTF_UP | RTF_HOST;
2434 if (kernel_version > KVERSION(2,1,0)) {
2435 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2436 SIN_ADDR(rt.rt_genmask) = -1L;
2439 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2440 if (still_ppp() && ! ok_error (errno))
2441 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2446 /* This way it is possible to have an IPX-only or IPv6-only interface */
2447 memset(&ifr, 0, sizeof(ifr));
2448 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2449 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2451 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2452 if (! ok_error (errno)) {
2453 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2458 our_old_addr = our_adr;
2464 /********************************************************************
2466 * sif6addr - Config the interface with an IPv6 link-local address
2468 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2470 struct in6_ifreq ifr6;
2472 struct in6_rtmsg rt6;
2476 error("IPv6 socket creation failed: %m");
2479 memset(&ifr, 0, sizeof (ifr));
2480 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2481 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2482 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2486 /* Local interface */
2487 memset(&ifr6, 0, sizeof(ifr6));
2488 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2489 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2490 ifr6.ifr6_prefixlen = 10;
2492 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2493 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2497 /* Route to remote host */
2498 memset(&rt6, 0, sizeof(rt6));
2499 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2500 rt6.rtmsg_flags = RTF_UP;
2501 rt6.rtmsg_dst_len = 10;
2502 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2503 rt6.rtmsg_metric = 1;
2505 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2506 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2514 /********************************************************************
2516 * cif6addr - Remove IPv6 address from interface
2518 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2521 struct in6_ifreq ifr6;
2525 error("IPv6 socket creation failed: %m");
2528 memset(&ifr, 0, sizeof(ifr));
2529 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2530 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2531 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2535 memset(&ifr6, 0, sizeof(ifr6));
2536 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2537 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2538 ifr6.ifr6_prefixlen = 10;
2540 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2541 if (errno != EADDRNOTAVAIL) {
2542 if (! ok_error (errno))
2543 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2546 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2555 * get_pty - get a pty master/slave pair and chown the slave side
2556 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2559 get_pty(master_fdp, slave_fdp, slave_name, uid)
2565 int i, mfd, sfd = -1;
2567 struct termios tios;
2571 * Try the unix98 way first.
2573 mfd = open("/dev/ptmx", O_RDWR);
2576 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2577 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2578 chmod(pty_name, S_IRUSR | S_IWUSR);
2581 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2582 warn("Couldn't unlock pty slave %s: %m", pty_name);
2584 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2585 warn("Couldn't open pty slave %s: %m", pty_name);
2588 #endif /* TIOCGPTN */
2591 /* the old way - scan through the pty name space */
2592 for (i = 0; i < 64; ++i) {
2593 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2594 'p' + i / 16, i % 16);
2595 mfd = open(pty_name, O_RDWR, 0);
2598 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2600 fchown(sfd, uid, -1);
2601 fchmod(sfd, S_IRUSR | S_IWUSR);
2612 strlcpy(slave_name, pty_name, 16);
2615 if (tcgetattr(sfd, &tios) == 0) {
2616 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2617 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2618 tios.c_iflag = IGNPAR;
2621 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2622 warn("couldn't set attributes on pty: %m");
2624 warn("couldn't get attributes on pty: %m");
2629 /********************************************************************
2631 * open_loopback - open the device we use for getting packets
2632 * in demand mode. Under Linux, we use a pty master/slave pair.
2635 open_ppp_loopback(void)
2640 if (new_style_driver) {
2641 /* allocate ourselves a ppp unit */
2642 if (make_ppp_unit() < 0)
2644 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2645 set_kdebugflag(kdebugflag);
2650 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2651 fatal("No free pty for loopback");
2653 set_ppp_fd(slave_fd);
2655 flags = fcntl(master_fd, F_GETFL);
2657 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2658 warn("couldn't set master loopback to nonblock: %m");
2660 flags = fcntl(ppp_fd, F_GETFL);
2662 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2663 warn("couldn't set slave loopback to nonblock: %m");
2665 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2666 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2668 * Find out which interface we were given.
2670 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2671 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2673 * Enable debug in the driver if requested.
2675 set_kdebugflag (kdebugflag);
2680 /********************************************************************
2682 * sifnpmode - Set the mode for handling packets for a given NP.
2686 sifnpmode(u, proto, mode)
2693 npi.protocol = proto;
2695 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2696 if (! ok_error (errno))
2697 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2704 /********************************************************************
2706 * sipxfaddr - Config the interface IPX networknumber
2709 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2716 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2718 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2720 if (! ok_error (errno))
2721 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2725 memset (&ifr, '\0', sizeof (ifr));
2726 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2728 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2729 sipx->sipx_family = AF_IPX;
2730 sipx->sipx_port = 0;
2731 sipx->sipx_network = htonl (network);
2732 sipx->sipx_type = IPX_FRAME_ETHERII;
2733 sipx->sipx_action = IPX_CRTITF;
2735 * Set the IPX device
2737 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2739 if (errno != EEXIST) {
2740 if (! ok_error (errno))
2741 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2744 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2753 /********************************************************************
2755 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2756 * are removed and the device is no longer able to pass IPX
2760 int cipxfaddr (int unit)
2767 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2769 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2771 if (! ok_error (errno))
2772 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2776 memset (&ifr, '\0', sizeof (ifr));
2777 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2779 sipx->sipx_type = IPX_FRAME_ETHERII;
2780 sipx->sipx_action = IPX_DLTITF;
2781 sipx->sipx_family = AF_IPX;
2783 * Set the IPX device
2785 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2786 if (! ok_error (errno))
2787 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2797 * Use the hostname as part of the random number seed.
2806 for (p = hostname; *p != 0; ++p)
2811 /********************************************************************
2813 * sys_check_options - check the options that the user specified
2817 sys_check_options(void)
2821 * Disable the IPX protocol if the support is not present in the kernel.
2825 if (ipxcp_protent.enabled_flag) {
2826 struct stat stat_buf;
2827 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
2828 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
2829 || lstat(path, &stat_buf) < 0) {
2830 error("IPX support is not present in the kernel\n");
2831 ipxcp_protent.enabled_flag = 0;
2835 if (demand && driver_is_old) {
2836 option_error("demand dialling is not supported by kernel driver "
2837 "version %d.%d.%d", driver_version, driver_modification,
2841 if (multilink && !new_style_driver) {
2842 warn("Warning: multilink is not supported by the kernel driver");
2850 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2852 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2853 * that the system has a properly configured Ethernet interface for this
2854 * function to return non-zero.
2857 ether_to_eui64(eui64_t *p_eui64)
2861 const unsigned char *ptr;
2863 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2866 warn("could not open IPv6 socket");
2870 strcpy(ifr.ifr_name, "eth0");
2871 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2874 warn("could not obtain hardware address for eth0");
2880 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2882 ptr = (unsigned char *) ifr.ifr_hwaddr.sa_data;
2883 p_eui64->e8[0] = ptr[0] | 0x02;
2884 p_eui64->e8[1] = ptr[1];
2885 p_eui64->e8[2] = ptr[2];
2886 p_eui64->e8[3] = 0xFF;
2887 p_eui64->e8[4] = 0xFE;
2888 p_eui64->e8[5] = ptr[3];
2889 p_eui64->e8[6] = ptr[4];
2890 p_eui64->e8[7] = ptr[5];