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;
2025 /* get the kernel version now, since we are called before sys_init */
2027 osmaj = osmin = ospatch = 0;
2028 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2029 kernel_version = KVERSION(osmaj, osmin, ospatch);
2031 fd = open("/dev/ppp", O_RDWR);
2033 new_style_driver = 1;
2035 /* XXX should get from driver */
2037 driver_modification = 4;
2044 if (kernel_version >= KVERSION(2,3,13)) {
2045 error("Couldn't open the /dev/ppp device: %m");
2046 if (errno == ENOENT)
2048 "You need to create the /dev/ppp device node by\n"
2049 "executing the following command as root:\n"
2050 " mknod /dev/ppp c 108 0\n";
2051 else if (errno == ENODEV || errno == ENXIO)
2053 "Please load the ppp_generic kernel module.\n";
2057 /* we are running on a really really old kernel */
2059 "This system lacks kernel support for PPP. This could be because\n"
2060 "the PPP kernel module could not be loaded, or because PPP was not\n"
2061 "included in the kernel configuration. If PPP was included as a\n"
2062 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2063 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2064 "See README.linux file in the ppp distribution for more details.\n";
2067 * Open a socket for doing the ioctl operations.
2069 s = socket(AF_INET, SOCK_DGRAM, 0);
2073 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2074 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2076 * If the device did not exist then attempt to create one by putting the
2077 * current tty into the PPP discipline. If this works then obtain the
2078 * flags for the device again.
2081 if (ppp_registered()) {
2082 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2083 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2087 * Ensure that the hardware address is for PPP and not something else
2090 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2092 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2096 * This is the PPP device. Validate the version of the driver at this
2097 * point to ensure that this program will work with the driver.
2100 char abBuffer [1024];
2102 ifr.ifr_data = abBuffer;
2103 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2105 error("Couldn't read driver version: %m");
2107 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2110 decode_version(abBuffer,
2112 &driver_modification,
2115 * Validate the version of the driver against the version that we used.
2117 decode_version(VERSION,
2122 /* The version numbers must match */
2123 if (driver_version != my_version)
2126 /* The modification levels must be legal */
2127 if (driver_modification < 3) {
2128 if (driver_modification >= 2) {
2129 /* we can cope with 2.2.0 and above */
2138 slprintf(route_buffer, sizeof(route_buffer),
2139 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2140 driver_version, driver_modification, driver_patch);
2142 no_ppp_msg = route_buffer;
2149 /********************************************************************
2151 * Update the wtmp file with the appropriate user name and tty device.
2154 void logwtmp (const char *line, const char *name, const char *host)
2156 struct utmp ut, *utp;
2157 pid_t mypid = getpid();
2163 * Update the signon database for users.
2164 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2166 utmpname(_PATH_UTMP);
2168 while ((utp = getutent()) && (utp->ut_pid != mypid))
2172 memcpy(&ut, utp, sizeof(ut));
2174 /* some gettys/telnetds don't initialize utmp... */
2175 memset(&ut, 0, sizeof(ut));
2177 if (ut.ut_id[0] == 0)
2178 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2180 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2181 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2185 ut.ut_type = USER_PROCESS;
2188 /* Insert the host name if one is supplied */
2190 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2192 /* Insert the IP address of the remote system if IP is enabled */
2193 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2194 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2195 sizeof(ut.ut_addr));
2197 /* CL: Makes sure that the logout works */
2198 if (*host == 0 && *name==0)
2204 * Update the wtmp file.
2207 updwtmp(_PATH_WTMP, &ut);
2209 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2211 flock(wtmp, LOCK_EX);
2213 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2214 warn("error writing %s: %m", _PATH_WTMP);
2216 flock(wtmp, LOCK_UN);
2224 /********************************************************************
2226 * sifvjcomp - config tcp header compression
2229 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2234 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2235 error("Couldn't set up TCP header compression: %m");
2239 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2240 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2245 /********************************************************************
2247 * sifup - Config the interface up and enable IP packets to pass.
2254 memset (&ifr, '\0', sizeof (ifr));
2255 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2256 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2257 if (! ok_error (errno))
2258 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2262 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2263 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2264 if (! ok_error (errno))
2265 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2273 /********************************************************************
2275 * sifdown - Disable the indicated protocol and config the interface
2276 * down if there are no remaining protocols.
2283 if (if_is_up && --if_is_up > 0)
2286 memset (&ifr, '\0', sizeof (ifr));
2287 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2288 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2289 if (! ok_error (errno))
2290 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2294 ifr.ifr_flags &= ~IFF_UP;
2295 ifr.ifr_flags |= IFF_POINTOPOINT;
2296 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2297 if (! ok_error (errno))
2298 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2304 /********************************************************************
2306 * sifaddr - Config the interface IP addresses and netmask.
2309 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2315 memset (&ifr, '\0', sizeof (ifr));
2316 memset (&rt, '\0', sizeof (rt));
2318 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2319 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2320 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2322 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2324 * Set our IP address
2326 SIN_ADDR(ifr.ifr_addr) = our_adr;
2327 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2328 if (errno != EEXIST) {
2329 if (! ok_error (errno))
2330 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2333 warn("ioctl(SIOCSIFADDR): Address already exists");
2338 * Set the gateway address
2341 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2342 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2343 if (! ok_error (errno))
2344 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2350 * For recent kernels, force the netmask to 255.255.255.255.
2352 if (kernel_version >= KVERSION(2,1,16))
2354 if (net_mask != 0) {
2355 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2356 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2357 if (! ok_error (errno))
2358 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2363 * Add the device route
2365 if (kernel_version < KVERSION(2,1,16)) {
2366 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2367 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2370 SIN_ADDR(rt.rt_gateway) = 0L;
2371 SIN_ADDR(rt.rt_dst) = his_adr;
2372 rt.rt_flags = RTF_UP | RTF_HOST;
2374 if (kernel_version > KVERSION(2,1,0)) {
2375 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2376 SIN_ADDR(rt.rt_genmask) = -1L;
2379 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2380 if (! ok_error (errno))
2381 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2386 /* set ip_dynaddr in demand mode if address changes */
2387 if (demand && tune_kernel && !dynaddr_set
2388 && our_old_addr && our_old_addr != our_adr) {
2389 /* set ip_dynaddr if possible */
2393 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2394 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2395 if (write(fd, "1", 1) != 1)
2396 error("Couldn't enable dynamic IP addressing: %m");
2399 dynaddr_set = 1; /* only 1 attempt */
2406 /********************************************************************
2408 * cifaddr - Clear the interface IP addresses, and delete routes
2409 * through the interface if possible.
2412 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2416 if (kernel_version < KVERSION(2,1,16)) {
2418 * Delete the route through the device
2421 memset (&rt, '\0', sizeof (rt));
2423 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2424 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2427 SIN_ADDR(rt.rt_gateway) = 0;
2428 SIN_ADDR(rt.rt_dst) = his_adr;
2429 rt.rt_flags = RTF_UP | RTF_HOST;
2431 if (kernel_version > KVERSION(2,1,0)) {
2432 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2433 SIN_ADDR(rt.rt_genmask) = -1L;
2436 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2437 if (still_ppp() && ! ok_error (errno))
2438 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2443 /* This way it is possible to have an IPX-only or IPv6-only interface */
2444 memset(&ifr, 0, sizeof(ifr));
2445 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2446 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2448 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2449 if (! ok_error (errno)) {
2450 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2455 our_old_addr = our_adr;
2461 /********************************************************************
2463 * sif6addr - Config the interface with an IPv6 link-local address
2465 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2467 struct in6_ifreq ifr6;
2469 struct in6_rtmsg rt6;
2473 error("IPv6 socket creation failed: %m");
2476 memset(&ifr, 0, sizeof (ifr));
2477 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2478 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2479 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2483 /* Local interface */
2484 memset(&ifr6, 0, sizeof(ifr6));
2485 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2486 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2487 ifr6.ifr6_prefixlen = 10;
2489 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2490 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2494 /* Route to remote host */
2495 memset(&rt6, 0, sizeof(rt6));
2496 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2497 rt6.rtmsg_flags = RTF_UP;
2498 rt6.rtmsg_dst_len = 10;
2499 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2500 rt6.rtmsg_metric = 1;
2502 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2503 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2511 /********************************************************************
2513 * cif6addr - Remove IPv6 address from interface
2515 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2518 struct in6_ifreq ifr6;
2522 error("IPv6 socket creation failed: %m");
2525 memset(&ifr, 0, sizeof(ifr));
2526 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2527 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2528 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2532 memset(&ifr6, 0, sizeof(ifr6));
2533 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2534 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2535 ifr6.ifr6_prefixlen = 10;
2537 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2538 if (errno != EADDRNOTAVAIL) {
2539 if (! ok_error (errno))
2540 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2543 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2552 * get_pty - get a pty master/slave pair and chown the slave side
2553 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2556 get_pty(master_fdp, slave_fdp, slave_name, uid)
2562 int i, mfd, sfd = -1;
2564 struct termios tios;
2568 * Try the unix98 way first.
2570 mfd = open("/dev/ptmx", O_RDWR);
2573 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2574 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2575 chmod(pty_name, S_IRUSR | S_IWUSR);
2578 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2579 warn("Couldn't unlock pty slave %s: %m", pty_name);
2581 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2582 warn("Couldn't open pty slave %s: %m", pty_name);
2585 #endif /* TIOCGPTN */
2588 /* the old way - scan through the pty name space */
2589 for (i = 0; i < 64; ++i) {
2590 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2591 'p' + i / 16, i % 16);
2592 mfd = open(pty_name, O_RDWR, 0);
2595 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2597 fchown(sfd, uid, -1);
2598 fchmod(sfd, S_IRUSR | S_IWUSR);
2609 strlcpy(slave_name, pty_name, 16);
2612 if (tcgetattr(sfd, &tios) == 0) {
2613 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2614 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2615 tios.c_iflag = IGNPAR;
2618 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2619 warn("couldn't set attributes on pty: %m");
2621 warn("couldn't get attributes on pty: %m");
2626 /********************************************************************
2628 * open_loopback - open the device we use for getting packets
2629 * in demand mode. Under Linux, we use a pty master/slave pair.
2632 open_ppp_loopback(void)
2637 if (new_style_driver) {
2638 /* allocate ourselves a ppp unit */
2639 if (make_ppp_unit() < 0)
2641 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2642 set_kdebugflag(kdebugflag);
2647 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2648 fatal("No free pty for loopback");
2650 set_ppp_fd(slave_fd);
2652 flags = fcntl(master_fd, F_GETFL);
2654 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2655 warn("couldn't set master loopback to nonblock: %m");
2657 flags = fcntl(ppp_fd, F_GETFL);
2659 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2660 warn("couldn't set slave loopback to nonblock: %m");
2662 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2663 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2665 * Find out which interface we were given.
2667 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2668 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2670 * Enable debug in the driver if requested.
2672 set_kdebugflag (kdebugflag);
2677 /********************************************************************
2679 * sifnpmode - Set the mode for handling packets for a given NP.
2683 sifnpmode(u, proto, mode)
2690 npi.protocol = proto;
2692 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2693 if (! ok_error (errno))
2694 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2701 /********************************************************************
2703 * sipxfaddr - Config the interface IPX networknumber
2706 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2713 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2715 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2717 if (! ok_error (errno))
2718 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2722 memset (&ifr, '\0', sizeof (ifr));
2723 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2725 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2726 sipx->sipx_family = AF_IPX;
2727 sipx->sipx_port = 0;
2728 sipx->sipx_network = htonl (network);
2729 sipx->sipx_type = IPX_FRAME_ETHERII;
2730 sipx->sipx_action = IPX_CRTITF;
2732 * Set the IPX device
2734 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2736 if (errno != EEXIST) {
2737 if (! ok_error (errno))
2738 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2741 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2750 /********************************************************************
2752 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2753 * are removed and the device is no longer able to pass IPX
2757 int cipxfaddr (int unit)
2764 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2766 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2768 if (! ok_error (errno))
2769 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2773 memset (&ifr, '\0', sizeof (ifr));
2774 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2776 sipx->sipx_type = IPX_FRAME_ETHERII;
2777 sipx->sipx_action = IPX_DLTITF;
2778 sipx->sipx_family = AF_IPX;
2780 * Set the IPX device
2782 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2783 if (! ok_error (errno))
2784 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2794 * Use the hostname as part of the random number seed.
2803 for (p = hostname; *p != 0; ++p)
2808 /********************************************************************
2810 * sys_check_options - check the options that the user specified
2814 sys_check_options(void)
2818 * Disable the IPX protocol if the support is not present in the kernel.
2822 if (ipxcp_protent.enabled_flag) {
2823 struct stat stat_buf;
2824 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
2825 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
2826 || lstat(path, &stat_buf) < 0) {
2827 error("IPX support is not present in the kernel\n");
2828 ipxcp_protent.enabled_flag = 0;
2832 if (demand && driver_is_old) {
2833 option_error("demand dialling is not supported by kernel driver "
2834 "version %d.%d.%d", driver_version, driver_modification,
2838 if (multilink && !new_style_driver) {
2839 warn("Warning: multilink is not supported by the kernel driver");
2847 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2849 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2850 * that the system has a properly configured Ethernet interface for this
2851 * function to return non-zero.
2854 ether_to_eui64(eui64_t *p_eui64)
2858 const unsigned char *ptr;
2860 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2863 warn("could not open IPv6 socket");
2867 strcpy(ifr.ifr_name, "eth0");
2868 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2871 warn("could not obtain hardware address for eth0");
2877 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2879 ptr = ifr.ifr_hwaddr.sa_data;
2880 p_eui64->e8[0] = ptr[0] | 0x02;
2881 p_eui64->e8[1] = ptr[1];
2882 p_eui64->e8[2] = ptr[2];
2883 p_eui64->e8[3] = 0xFF;
2884 p_eui64->e8[4] = 0xFE;
2885 p_eui64->e8[5] = ptr[3];
2886 p_eui64->e8[6] = ptr[4];
2887 p_eui64->e8[7] = ptr[5];