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 if6_is_up; /* Interface has been marked up for IPv6, to help differentiate */
209 static int have_default_route; /* Gateway for default route added */
210 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
211 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
212 static u_int32_t our_old_addr; /* for detecting address changes */
213 static int dynaddr_set; /* 1 if ip_dynaddr set */
214 static int looped; /* 1 if using loop */
215 static int link_mtu; /* mtu for the link (not bundle) */
217 static struct utsname utsname; /* for the kernel version */
218 static int kernel_version;
219 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
223 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
224 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
225 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
227 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
229 /* Prototypes for procedures local to this file. */
230 static int modify_flags(int fd, int clear_bits, int set_bits);
231 static int translate_speed (int bps);
232 static int baud_rate_of (int speed);
233 static void close_route_table (void);
234 static int open_route_table (void);
235 static int read_route_table (struct rtentry *rt);
236 static int defaultroute_exists (struct rtentry *rt);
237 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
238 char *name, int namelen);
239 static void decode_version (char *buf, int *version, int *mod, int *patch);
240 static int set_kdebugflag(int level);
241 static int ppp_registered(void);
242 static int make_ppp_unit(void);
243 static int setifstate (int u, int state);
245 extern u_char inpacket_buf[]; /* borrowed from main.c */
248 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
252 #define SET_SA_FAMILY(addr, family) \
253 memset ((char *) &(addr), '\0', sizeof(addr)); \
254 addr.sa_family = (family);
257 * Determine if the PPP connection should still be present.
262 /* new_fd is the fd of a tty */
263 static void set_ppp_fd (int new_fd)
266 if (!new_style_driver)
270 static int still_ppp(void)
272 if (new_style_driver)
273 return !hungup && ppp_fd >= 0;
274 if (!hungup || ppp_fd == slave_fd)
277 set_ppp_fd(slave_fd);
284 * modify_flags - set and clear flag bits controlling the kernel
287 static int modify_flags(int fd, int clear_bits, int set_bits)
291 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
293 flags = (flags & ~clear_bits) | set_bits;
294 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
301 error("Failed to set PPP kernel option flags: %m");
305 /********************************************************************
307 * sys_init - System-dependent initialization.
312 /* Get an internet socket for doing socket ioctls. */
313 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
315 fatal("Couldn't create IP socket: %m(%d)", errno);
318 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
320 sock6_fd = -errno; /* save errno for later */
327 /********************************************************************
329 * sys_cleanup - restore any system state we modified before exiting:
330 * mark the interface down, delete default route and/or proxy arp entry.
331 * This shouldn't call die() because it's called from die().
334 void sys_cleanup(void)
337 * Take down the device
347 * Delete any routes through the device.
349 if (have_default_route)
350 cifdefaultroute(0, 0, 0);
353 cifproxyarp(0, proxy_arp_addr);
356 /********************************************************************
358 * sys_close - Clean up in a child process before execing.
363 if (new_style_driver && ppp_dev_fd >= 0)
377 /********************************************************************
379 * set_kdebugflag - Define the debugging level for the kernel
382 static int set_kdebugflag (int requested_level)
386 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
387 if ( ! ok_error (errno) )
388 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
394 /********************************************************************
396 * tty_establish_ppp - Turn the serial port into a ppp interface.
399 int tty_establish_ppp (int tty_fd)
404 * Ensure that the tty device is in exclusive mode.
406 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
407 if ( ! ok_error ( errno ))
408 warn("Couldn't make tty exclusive: %m");
411 * Demand mode - prime the old ppp device to relinquish the unit.
413 if (!new_style_driver && looped
414 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
415 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
419 * Set the current tty to the PPP discpline
423 #define N_SYNC_PPP 14
425 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
426 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
427 if ( ! ok_error (errno) ) {
428 error("Couldn't set tty to PPP discipline: %m");
433 ret_fd = generic_establish_ppp(tty_fd);
435 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
436 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
440 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
441 (kdebugflag * SC_DEBUG) & SC_LOGB);
443 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
444 warn("Couldn't reset tty to normal line discipline: %m");
450 /********************************************************************
452 * generic_establish_ppp - Turn the fd into a ppp interface.
454 int generic_establish_ppp (int fd)
458 if (new_style_driver) {
461 /* Open an instance of /dev/ppp and connect the channel to it */
462 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
463 error("Couldn't get channel number: %m");
466 dbglog("using channel %d", chindex);
467 fd = open("/dev/ppp", O_RDWR);
469 error("Couldn't reopen /dev/ppp: %m");
472 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
473 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
474 error("Couldn't attach to channel %d: %m", chindex);
477 flags = fcntl(fd, F_GETFL);
478 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
479 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
484 if (!looped && !multilink) {
486 * Create a new PPP unit.
488 if (make_ppp_unit() < 0)
493 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
497 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
498 error("Couldn't attach to PPP unit %d: %m", ifunit);
505 * Old-style driver: find out which interface we were given.
508 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
509 if (ok_error (errno))
511 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
513 /* Check that we got the same unit again. */
514 if (looped && x != ifunit)
515 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
519 * Fetch the initial file flags and reset blocking mode on the file.
521 initfdflags = fcntl(fd, F_GETFL);
522 if (initfdflags == -1 ||
523 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
524 if ( ! ok_error (errno))
525 warn("Couldn't set device to non-blocking mode: %m");
530 * Enable debug in the driver if requested.
533 set_kdebugflag (kdebugflag);
545 /********************************************************************
547 * tty_disestablish_ppp - Restore the serial port to normal operation.
548 * This shouldn't call die() because it's called from die().
551 void tty_disestablish_ppp(int tty_fd)
555 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
557 if (tcflush(tty_fd, TCIOFLUSH) < 0)
559 warn("tcflush failed: %m");
563 * Restore the previous line discipline
565 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
566 if ( ! ok_error (errno))
567 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
570 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
571 if ( ! ok_error (errno))
572 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
575 /* Reset non-blocking mode on fd. */
576 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
577 if ( ! ok_error (errno))
578 warn("Couldn't restore device fd flags: %m");
584 generic_disestablish_ppp(tty_fd);
587 /********************************************************************
589 * generic_disestablish_ppp - Restore device components to normal
590 * operation, and reconnect the ppp unit to the loopback if in demand
591 * mode. This shouldn't call die() because it's called from die().
593 void generic_disestablish_ppp(int dev_fd)
595 if (new_style_driver) {
599 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
601 } else if (!doing_multilink && ppp_dev_fd >= 0) {
603 remove_fd(ppp_dev_fd);
607 /* old-style driver */
609 set_ppp_fd(slave_fd);
616 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
617 * Assumes new_style_driver.
619 static int make_ppp_unit()
623 if (ppp_dev_fd >= 0) {
624 dbglog("in make_ppp_unit, already had /dev/ppp open?");
627 ppp_dev_fd = open("/dev/ppp", O_RDWR);
629 fatal("Couldn't open /dev/ppp: %m");
630 flags = fcntl(ppp_dev_fd, F_GETFL);
632 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
633 warn("Couldn't set /dev/ppp to nonblock: %m");
636 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
637 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
638 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
640 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
643 error("Couldn't create new ppp unit: %m");
648 * cfg_bundle - configure the existing bundle.
649 * Used in demand mode.
651 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
653 if (!new_style_driver)
656 /* set the mrru, mtu and flags */
657 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
658 error("Couldn't set MRRU: %m");
660 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
661 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
662 | (mrru? SC_MULTILINK: 0)));
664 /* connect up the channel */
665 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
666 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
671 * make_new_bundle - create a new PPP unit (i.e. a bundle)
672 * and connect our channel to it. This should only get called
673 * if `multilink' was set at the time establish_ppp was called.
674 * In demand mode this uses our existing bundle instead of making
677 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
679 if (!new_style_driver)
682 /* make us a ppp unit */
683 if (make_ppp_unit() < 0)
686 /* set the mrru and flags */
687 cfg_bundle(mrru, mtru, rssn, tssn);
691 * bundle_attach - attach our link to a given PPP unit.
692 * We assume the unit is controlled by another pppd.
694 int bundle_attach(int ifnum)
698 if (!new_style_driver)
701 master_fd = open("/dev/ppp", O_RDWR);
703 fatal("Couldn't open /dev/ppp: %m");
704 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
705 if (errno == ENXIO) {
707 return 0; /* doesn't still exist */
709 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
711 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
712 fatal("Couldn't connect to interface unit %d: %m", ifnum);
713 modify_flags(master_fd, 0, SC_MULTILINK);
721 * destroy_bundle - tell the driver to destroy our bundle.
723 void destroy_bundle(void)
725 if (ppp_dev_fd >= 0) {
727 remove_fd(ppp_dev_fd);
732 /********************************************************************
734 * clean_check - Fetch the flags for the device and generate
735 * appropriate error messages.
737 void clean_check(void)
743 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
745 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
747 s = "all had bit 7 set to 1";
751 s = "all had bit 7 set to 0";
755 s = "all had odd parity";
759 s = "all had even parity";
764 warn("Receive serial link is not 8-bit clean:");
765 warn("Problem: %s", s);
773 * List of valid speeds.
777 int speed_int, speed_val;
858 { 1000000, B1000000 },
861 { 1152000, B1152000 },
864 { 1500000, B1500000 },
867 { 2000000, B2000000 },
870 { 2500000, B2500000 },
873 { 3000000, B3000000 },
876 { 3500000, B3500000 },
879 { 4000000, B4000000 },
884 /********************************************************************
886 * Translate from bits/second to a speed_t.
889 static int translate_speed (int bps)
891 struct speed *speedp;
894 for (speedp = speeds; speedp->speed_int; speedp++) {
895 if (bps == speedp->speed_int)
896 return speedp->speed_val;
898 warn("speed %d not supported", bps);
903 /********************************************************************
905 * Translate from a speed_t to bits/second.
908 static int baud_rate_of (int speed)
910 struct speed *speedp;
913 for (speedp = speeds; speedp->speed_int; speedp++) {
914 if (speed == speedp->speed_val)
915 return speedp->speed_int;
921 /********************************************************************
923 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
924 * at the requested speed, etc. If `local' is true, set CLOCAL
925 * regardless of whether the modem option was specified.
928 void set_up_tty(int tty_fd, int local)
934 if (tcgetattr(tty_fd, &tios) < 0) {
935 if (!ok_error(errno))
936 fatal("tcgetattr: %m (line %d)", __LINE__);
943 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
944 tios.c_cflag |= CS8 | CREAD | HUPCL;
946 tios.c_iflag = IGNBRK | IGNPAR;
950 tios.c_cc[VTIME] = 0;
953 tios.c_cflag ^= (CLOCAL | HUPCL);
957 tios.c_cflag |= CRTSCTS;
961 tios.c_iflag |= IXON | IXOFF;
962 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
963 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
967 tios.c_cflag &= ~CRTSCTS;
975 tios.c_cflag |= CSTOPB;
977 speed = translate_speed(inspeed);
979 cfsetospeed (&tios, speed);
980 cfsetispeed (&tios, speed);
983 * We can't proceed if the serial port speed is B0,
984 * since that implies that the serial port is disabled.
987 speed = cfgetospeed(&tios);
989 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
992 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
994 fatal("tcsetattr: %m (line %d)", __LINE__);
996 baud_rate = baud_rate_of(speed);
1000 /********************************************************************
1002 * setdtr - control the DTR line on the serial port.
1003 * This is called from die(), so it shouldn't call die().
1006 void setdtr (int tty_fd, int on)
1008 int modembits = TIOCM_DTR;
1010 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1013 /********************************************************************
1015 * restore_tty - restore the terminal to the saved settings.
1018 void restore_tty (int tty_fd)
1023 * Turn off echoing, because otherwise we can get into
1024 * a loop with the tty and the modem echoing to each other.
1025 * We presume we are the sole user of this tty device, so
1026 * when we close it, it will revert to its defaults anyway.
1028 if (!default_device)
1029 inittermios.c_lflag &= ~(ECHO | ECHONL);
1031 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1032 if (! ok_error (errno))
1033 warn("tcsetattr: %m (line %d)", __LINE__);
1038 /********************************************************************
1040 * output - Output PPP packet.
1043 void output (int unit, unsigned char *p, int len)
1048 dump_packet("sent", p, len);
1049 if (snoop_send_hook) snoop_send_hook(p, len);
1051 if (len < PPP_HDRLEN)
1053 if (new_style_driver) {
1056 proto = (p[0] << 8) + p[1];
1057 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1060 if (write(fd, p, len) < 0) {
1061 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1062 || errno == ENXIO || errno == EIO || errno == EINTR)
1063 warn("write: warning: %m (%d)", errno);
1065 error("write: %m (%d)", errno);
1069 /********************************************************************
1071 * wait_input - wait until there is data available,
1072 * for the length of time specified by *timo (indefinite
1076 void wait_input(struct timeval *timo)
1083 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1084 if (n < 0 && errno != EINTR)
1085 fatal("select: %m");
1089 * add_fd - add an fd to the set that wait_input waits for.
1093 if (fd >= FD_SETSIZE)
1094 fatal("internal error: file descriptor too large (%d)", fd);
1095 FD_SET(fd, &in_fds);
1101 * remove_fd - remove an fd from the set that wait_input waits for.
1103 void remove_fd(int fd)
1105 FD_CLR(fd, &in_fds);
1109 /********************************************************************
1111 * read_packet - get a PPP packet from the serial device.
1114 int read_packet (unsigned char *buf)
1118 len = PPP_MRU + PPP_HDRLEN;
1119 if (new_style_driver) {
1120 *buf++ = PPP_ALLSTATIONS;
1126 nr = read(ppp_fd, buf, len);
1127 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1128 && errno != EIO && errno != EINTR)
1130 if (nr < 0 && errno == ENXIO)
1133 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1134 /* N.B. we read ppp_fd first since LCP packets come in there. */
1135 nr = read(ppp_dev_fd, buf, len);
1136 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1137 && errno != EIO && errno != EINTR)
1138 error("read /dev/ppp: %m");
1139 if (nr < 0 && errno == ENXIO)
1141 if (nr == 0 && doing_multilink) {
1142 remove_fd(ppp_dev_fd);
1146 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1148 return (new_style_driver && nr > 0)? nr+2: nr;
1151 /********************************************************************
1153 * get_loop_output - get outgoing packets from the ppp device,
1154 * and detect when we want to bring the real link up.
1155 * Return value is 1 if we need to bring up the link, 0 otherwise.
1158 get_loop_output(void)
1163 if (new_style_driver) {
1164 while ((n = read_packet(inpacket_buf)) > 0)
1165 if (loop_frame(inpacket_buf, n))
1170 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1171 if (loop_chars(inbuf, n))
1175 fatal("eof on loopback");
1177 if (errno != EWOULDBLOCK && errno != EAGAIN)
1178 fatal("read from loopback: %m(%d)", errno);
1184 * netif_set_mtu - set the MTU on the PPP network interface.
1187 netif_set_mtu(int unit, int mtu)
1191 memset (&ifr, '\0', sizeof (ifr));
1192 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1195 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1196 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1200 * netif_get_mtu - get the MTU on the PPP network interface.
1203 netif_get_mtu(int unit)
1207 memset (&ifr, '\0', sizeof (ifr));
1208 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1210 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1211 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1217 /********************************************************************
1219 * tty_send_config - configure the transmit characteristics of
1220 * the ppp interface.
1223 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1230 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1231 if (errno != EIO && errno != ENOTTY)
1232 error("Couldn't set transmit async character map: %m");
1237 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1238 | (sync_serial? SC_SYNC: 0);
1239 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1242 /********************************************************************
1244 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1247 void tty_set_xaccm (ext_accm accm)
1251 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1252 if ( ! ok_error (errno))
1253 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1257 /********************************************************************
1259 * tty_recv_config - configure the receive-side characteristics of
1260 * the ppp interface.
1263 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1266 * If we were called because the link has gone down then there is nothing
1267 * which may be done. Just return without incident.
1272 * Set the receiver parameters
1274 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1275 if (errno != EIO && errno != ENOTTY)
1276 error("Couldn't set channel receive MRU: %m");
1278 if (new_style_driver && ppp_dev_fd >= 0
1279 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1280 error("Couldn't set MRU in generic PPP layer: %m");
1282 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1283 if (errno != EIO && errno != ENOTTY)
1284 error("Couldn't set channel receive asyncmap: %m");
1288 /********************************************************************
1290 * ccp_test - ask kernel whether a given compression method
1291 * is acceptable for use.
1295 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1297 struct ppp_option_data data;
1299 memset (&data, '\0', sizeof (data));
1301 data.length = opt_len;
1302 data.transmit = for_transmit;
1304 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1307 return (errno == ENOBUFS)? 0: -1;
1310 /********************************************************************
1312 * ccp_flags_set - inform kernel about the current state of CCP.
1315 void ccp_flags_set (int unit, int isopen, int isup)
1319 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1320 if (still_ppp() && ppp_dev_fd >= 0)
1321 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1326 * set_filters - set the active and pass filters in the kernel driver.
1328 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1330 struct sock_fprog fp;
1332 fp.len = pass->bf_len;
1333 fp.filter = (struct sock_filter *) pass->bf_insns;
1334 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1335 if (errno == ENOTTY)
1336 warn("kernel does not support PPP filtering");
1338 error("Couldn't set pass-filter in kernel: %m");
1341 fp.len = active->bf_len;
1342 fp.filter = (struct sock_filter *) active->bf_insns;
1343 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1344 error("Couldn't set active-filter in kernel: %m");
1349 #endif /* PPP_FILTER */
1351 /********************************************************************
1353 * get_idle_time - return how long the link has been idle.
1356 get_idle_time(u, ip)
1358 struct ppp_idle *ip;
1360 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1363 /********************************************************************
1365 * get_ppp_stats - return statistics for the link.
1368 get_ppp_stats(u, stats)
1370 struct pppd_stats *stats;
1372 struct ifpppstatsreq req;
1374 memset (&req, 0, sizeof (req));
1376 req.stats_ptr = (caddr_t) &req.stats;
1377 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1378 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1379 error("Couldn't get PPP statistics: %m");
1382 stats->bytes_in = req.stats.p.ppp_ibytes;
1383 stats->bytes_out = req.stats.p.ppp_obytes;
1384 stats->pkts_in = req.stats.p.ppp_ipackets;
1385 stats->pkts_out = req.stats.p.ppp_opackets;
1389 /********************************************************************
1391 * ccp_fatal_error - returns 1 if decompression was disabled as a
1392 * result of an error detected after decompression of a packet,
1393 * 0 otherwise. This is necessary because of patent nonsense.
1396 int ccp_fatal_error (int unit)
1400 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1401 error("Couldn't read compression error flags: %m");
1404 return flags & SC_DC_FERROR;
1407 /********************************************************************
1409 * path_to_procfs - find the path to the proc file system mount point
1411 static char proc_path[MAXPATHLEN];
1412 static int proc_path_len;
1414 static char *path_to_procfs(const char *tail)
1416 struct mntent *mntent;
1419 if (proc_path_len == 0) {
1420 /* Default the mount location of /proc */
1421 strlcpy (proc_path, "/proc", sizeof(proc_path));
1423 fp = fopen(MOUNTED, "r");
1425 while ((mntent = getmntent(fp)) != NULL) {
1426 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1428 if (strcmp(mntent->mnt_type, "proc") == 0) {
1429 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1430 proc_path_len = strlen(proc_path);
1438 strlcpy(proc_path + proc_path_len, tail,
1439 sizeof(proc_path) - proc_path_len);
1444 * /proc/net/route parsing stuff.
1446 #define ROUTE_MAX_COLS 12
1447 FILE *route_fd = (FILE *) 0;
1448 static char route_buffer[512];
1449 static int route_dev_col, route_dest_col, route_gw_col;
1450 static int route_flags_col, route_mask_col;
1451 static int route_num_cols;
1453 static int open_route_table (void);
1454 static void close_route_table (void);
1455 static int read_route_table (struct rtentry *rt);
1457 /********************************************************************
1459 * close_route_table - close the interface to the route table
1462 static void close_route_table (void)
1464 if (route_fd != (FILE *) 0) {
1466 route_fd = (FILE *) 0;
1470 /********************************************************************
1472 * open_route_table - open the interface to the route table
1474 static char route_delims[] = " \t\n";
1476 static int open_route_table (void)
1480 close_route_table();
1482 path = path_to_procfs("/net/route");
1483 route_fd = fopen (path, "r");
1484 if (route_fd == NULL) {
1485 error("can't open routing table %s: %m", path);
1489 route_dev_col = 0; /* default to usual columns */
1492 route_flags_col = 3;
1496 /* parse header line */
1497 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1498 char *p = route_buffer, *q;
1500 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1502 if ((q = strtok(p, route_delims)) == 0)
1504 if (strcasecmp(q, "iface") == 0)
1505 route_dev_col = col;
1506 else if (strcasecmp(q, "destination") == 0)
1507 route_dest_col = col;
1508 else if (strcasecmp(q, "gateway") == 0)
1510 else if (strcasecmp(q, "flags") == 0)
1511 route_flags_col = col;
1512 else if (strcasecmp(q, "mask") == 0)
1513 route_mask_col = col;
1516 if (used && col >= route_num_cols)
1517 route_num_cols = col + 1;
1525 /********************************************************************
1527 * read_route_table - read the next entry from the route table
1530 static int read_route_table(struct rtentry *rt)
1532 char *cols[ROUTE_MAX_COLS], *p;
1535 memset (rt, '\0', sizeof (struct rtentry));
1537 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1541 for (col = 0; col < route_num_cols; ++col) {
1542 cols[col] = strtok(p, route_delims);
1543 if (cols[col] == NULL)
1544 return 0; /* didn't get enough columns */
1548 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1549 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1550 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1552 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1553 rt->rt_dev = cols[route_dev_col];
1558 /********************************************************************
1560 * defaultroute_exists - determine if there is a default route
1563 static int defaultroute_exists (struct rtentry *rt)
1567 if (!open_route_table())
1570 while (read_route_table(rt) != 0) {
1571 if ((rt->rt_flags & RTF_UP) == 0)
1574 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1576 if (SIN_ADDR(rt->rt_dst) == 0L) {
1582 close_route_table();
1587 * have_route_to - determine if the system has any route to
1588 * a given IP address. `addr' is in network byte order.
1589 * Return value is 1 if yes, 0 if no, -1 if don't know.
1590 * For demand mode to work properly, we have to ignore routes
1591 * through our own interface.
1593 int have_route_to(u_int32_t addr)
1598 if (!open_route_table())
1599 return -1; /* don't know */
1601 while (read_route_table(&rt)) {
1602 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1604 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1610 close_route_table();
1614 /********************************************************************
1616 * sifdefaultroute - assign a default route through the address given.
1619 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1623 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1624 if (rt.rt_flags & RTF_GATEWAY)
1625 error("not replacing existing default route via %I",
1626 SIN_ADDR(rt.rt_gateway));
1628 error("not replacing existing default route through %s",
1633 memset (&rt, 0, sizeof (rt));
1634 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1638 if (kernel_version > KVERSION(2,1,0)) {
1639 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1640 SIN_ADDR(rt.rt_genmask) = 0L;
1643 rt.rt_flags = RTF_UP;
1644 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1645 if ( ! ok_error ( errno ))
1646 error("default route ioctl(SIOCADDRT): %m");
1650 have_default_route = 1;
1654 /********************************************************************
1656 * cifdefaultroute - delete a default route through the address given.
1659 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1663 have_default_route = 0;
1665 memset (&rt, '\0', sizeof (rt));
1666 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1667 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1671 if (kernel_version > KVERSION(2,1,0)) {
1672 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1673 SIN_ADDR(rt.rt_genmask) = 0L;
1676 rt.rt_flags = RTF_UP;
1677 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1679 if ( ! ok_error ( errno ))
1680 error("default route ioctl(SIOCDELRT): %m");
1688 /********************************************************************
1690 * sifproxyarp - Make a proxy ARP entry for the peer.
1693 int sifproxyarp (int unit, u_int32_t his_adr)
1695 struct arpreq arpreq;
1698 if (has_proxy_arp == 0) {
1699 memset (&arpreq, '\0', sizeof(arpreq));
1701 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1702 SIN_ADDR(arpreq.arp_pa) = his_adr;
1703 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1705 * Get the hardware address of an interface on the same subnet
1706 * as our local address.
1708 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1709 sizeof(proxy_arp_dev))) {
1710 error("Cannot determine ethernet address for proxy ARP");
1713 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1715 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1716 if ( ! ok_error ( errno ))
1717 error("ioctl(SIOCSARP): %m");
1720 proxy_arp_addr = his_adr;
1724 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1725 if (forw_path != 0) {
1726 int fd = open(forw_path, O_WRONLY);
1728 if (write(fd, "1", 1) != 1)
1729 error("Couldn't enable IP forwarding: %m");
1739 /********************************************************************
1741 * cifproxyarp - Delete the proxy ARP entry for the peer.
1744 int cifproxyarp (int unit, u_int32_t his_adr)
1746 struct arpreq arpreq;
1748 if (has_proxy_arp) {
1750 memset (&arpreq, '\0', sizeof(arpreq));
1751 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1752 SIN_ADDR(arpreq.arp_pa) = his_adr;
1753 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1754 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1756 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1757 if ( ! ok_error ( errno ))
1758 warn("ioctl(SIOCDARP): %m");
1765 /********************************************************************
1767 * get_ether_addr - get the hardware address of an interface on the
1768 * the same subnet as ipaddr.
1771 static int get_ether_addr (u_int32_t ipaddr,
1772 struct sockaddr *hwaddr,
1773 char *name, int namelen)
1775 struct ifreq *ifr, *ifend;
1776 u_int32_t ina, mask;
1778 struct ifreq ifreq, bestifreq;
1780 struct ifreq ifs[MAX_IFS];
1782 u_int32_t bestmask=0;
1783 int found_interface = 0;
1785 ifc.ifc_len = sizeof(ifs);
1787 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1788 if ( ! ok_error ( errno ))
1789 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1794 * Scan through looking for an interface with an Internet
1795 * address on the same subnet as `ipaddr'.
1797 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1798 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1799 if (ifr->ifr_addr.sa_family == AF_INET) {
1800 ina = SIN_ADDR(ifr->ifr_addr);
1801 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1803 * Check that the interface is up, and not point-to-point
1806 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1809 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1812 * Get its netmask and check that it's on the right subnet.
1814 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1817 mask = SIN_ADDR(ifreq.ifr_addr);
1819 if (((ipaddr ^ ina) & mask) != 0)
1820 continue; /* no match */
1822 if (mask >= bestmask) {
1823 /* Compare using >= instead of > -- it is possible for
1824 an interface to have a netmask of 0.0.0.0 */
1825 found_interface = 1;
1832 if (!found_interface) return 0;
1834 strlcpy(name, bestifreq.ifr_name, namelen);
1836 /* trim off the :1 in eth0:1 */
1837 aliasp = strchr(name, ':');
1841 info("found interface %s for proxy arp", name);
1843 * Now get the hardware address.
1845 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1846 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1847 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1852 &bestifreq.ifr_hwaddr,
1853 sizeof (struct sockaddr));
1859 * get_if_hwaddr - get the hardware address for the specified
1860 * network interface device.
1863 get_if_hwaddr(u_char *addr, char *name)
1868 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1871 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1872 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1873 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1876 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1881 * get_first_ethernet - return the name of the first ethernet-style
1882 * interface on this system.
1885 get_first_ethernet()
1890 /********************************************************************
1892 * Return user specified netmask, modified by any mask we might determine
1893 * for address `addr' (in network byte order).
1894 * Here we scan through the system's list of interfaces, looking for
1895 * any non-point-to-point interfaces which might appear to be on the same
1896 * network as `addr'. If we find any, we OR in their netmask to the
1897 * user-specified netmask.
1900 u_int32_t GetMask (u_int32_t addr)
1902 u_int32_t mask, nmask, ina;
1903 struct ifreq *ifr, *ifend, ifreq;
1905 struct ifreq ifs[MAX_IFS];
1909 if (IN_CLASSA(addr)) /* determine network mask for address class */
1910 nmask = IN_CLASSA_NET;
1911 else if (IN_CLASSB(addr))
1912 nmask = IN_CLASSB_NET;
1914 nmask = IN_CLASSC_NET;
1916 /* class D nets are disallowed by bad_ip_adrs */
1917 mask = netmask | htonl(nmask);
1919 * Scan through the system's network interfaces.
1921 ifc.ifc_len = sizeof(ifs);
1923 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1924 if ( ! ok_error ( errno ))
1925 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1929 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1930 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1932 * Check the interface's internet address.
1934 if (ifr->ifr_addr.sa_family != AF_INET)
1936 ina = SIN_ADDR(ifr->ifr_addr);
1937 if (((ntohl(ina) ^ addr) & nmask) != 0)
1940 * Check that the interface is up, and not point-to-point nor loopback.
1942 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1943 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1946 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1949 * Get its netmask and OR it into our mask.
1951 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1953 mask |= SIN_ADDR(ifreq.ifr_addr);
1959 /********************************************************************
1961 * Internal routine to decode the version.modification.patch level
1964 static void decode_version (char *buf, int *version,
1965 int *modification, int *patch)
1969 *version = (int) strtoul (buf, &endp, 10);
1973 if (endp != buf && *endp == '.') {
1975 *modification = (int) strtoul (buf, &endp, 10);
1976 if (endp != buf && *endp == '.') {
1978 *patch = (int) strtoul (buf, &buf, 10);
1983 /********************************************************************
1985 * Procedure to determine if the PPP line discipline is registered.
1989 ppp_registered(void)
1997 * We used to open the serial device and set it to the ppp line
1998 * discipline here, in order to create a ppp unit. But that is
1999 * not a good idea - the user might have specified a device that
2000 * they can't open (permission, or maybe it doesn't really exist).
2001 * So we grab a pty master/slave pair and use that.
2003 if (!get_pty(&mfd, &local_fd, slave, 0)) {
2004 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2009 * Try to put the device into the PPP discipline.
2011 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2012 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2021 /********************************************************************
2023 * ppp_available - check whether the system has any ppp interfaces
2024 * (in fact we check whether we can do an ioctl on ppp0).
2027 int ppp_available(void)
2032 int my_version, my_modification, my_patch;
2033 int osmaj, osmin, ospatch;
2035 /* get the kernel version now, since we are called before sys_init */
2037 osmaj = osmin = ospatch = 0;
2038 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2039 kernel_version = KVERSION(osmaj, osmin, ospatch);
2041 fd = open("/dev/ppp", O_RDWR);
2043 new_style_driver = 1;
2045 /* XXX should get from driver */
2047 driver_modification = 4;
2053 if (kernel_version >= KVERSION(2,3,13)) {
2054 error("Couldn't open the /dev/ppp device: %m");
2055 if (errno == ENOENT)
2057 "You need to create the /dev/ppp device node by\n"
2058 "executing the following command as root:\n"
2059 " mknod /dev/ppp c 108 0\n";
2060 else if (errno == ENODEV || errno == ENXIO)
2062 "Please load the ppp_generic kernel module.\n";
2066 /* we are running on a really really old kernel */
2068 "This system lacks kernel support for PPP. This could be because\n"
2069 "the PPP kernel module could not be loaded, or because PPP was not\n"
2070 "included in the kernel configuration. If PPP was included as a\n"
2071 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2072 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2073 "See README.linux file in the ppp distribution for more details.\n";
2076 * Open a socket for doing the ioctl operations.
2078 s = socket(AF_INET, SOCK_DGRAM, 0);
2082 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2083 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2085 * If the device did not exist then attempt to create one by putting the
2086 * current tty into the PPP discipline. If this works then obtain the
2087 * flags for the device again.
2090 if (ppp_registered()) {
2091 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2092 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2096 * Ensure that the hardware address is for PPP and not something else
2099 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2101 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2105 * This is the PPP device. Validate the version of the driver at this
2106 * point to ensure that this program will work with the driver.
2109 char abBuffer [1024];
2111 ifr.ifr_data = abBuffer;
2112 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2114 error("Couldn't read driver version: %m");
2116 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2119 decode_version(abBuffer,
2121 &driver_modification,
2124 * Validate the version of the driver against the version that we used.
2126 decode_version(VERSION,
2131 /* The version numbers must match */
2132 if (driver_version != my_version)
2135 /* The modification levels must be legal */
2136 if (driver_modification < 3) {
2137 if (driver_modification >= 2) {
2138 /* we can cope with 2.2.0 and above */
2147 slprintf(route_buffer, sizeof(route_buffer),
2148 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2149 driver_version, driver_modification, driver_patch);
2151 no_ppp_msg = route_buffer;
2158 #ifndef HAVE_LOGWTMP
2159 /********************************************************************
2161 * Update the wtmp file with the appropriate user name and tty device.
2164 void logwtmp (const char *line, const char *name, const char *host)
2166 struct utmp ut, *utp;
2167 pid_t mypid = getpid();
2173 * Update the signon database for users.
2174 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2176 utmpname(_PATH_UTMP);
2178 while ((utp = getutent()) && (utp->ut_pid != mypid))
2182 memcpy(&ut, utp, sizeof(ut));
2184 /* some gettys/telnetds don't initialize utmp... */
2185 memset(&ut, 0, sizeof(ut));
2187 if (ut.ut_id[0] == 0)
2188 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2190 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2191 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2195 ut.ut_type = USER_PROCESS;
2198 /* Insert the host name if one is supplied */
2200 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2202 /* Insert the IP address of the remote system if IP is enabled */
2203 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2204 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2205 sizeof(ut.ut_addr));
2207 /* CL: Makes sure that the logout works */
2208 if (*host == 0 && *name==0)
2214 * Update the wtmp file.
2217 updwtmp(_PATH_WTMP, &ut);
2219 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2221 flock(wtmp, LOCK_EX);
2223 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2224 warn("error writing %s: %m", _PATH_WTMP);
2226 flock(wtmp, LOCK_UN);
2232 #endif /* HAVE_LOGWTMP */
2234 /********************************************************************
2236 * sifvjcomp - config tcp header compression
2239 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2244 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2245 error("Couldn't set up TCP header compression: %m");
2250 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2251 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2256 /********************************************************************
2258 * sifup - Config the interface up and enable IP packets to pass.
2265 if ((ret = setifstate(u, 1)))
2271 /********************************************************************
2273 * sifdown - Disable the indicated protocol and config the interface
2274 * down if there are no remaining protocols.
2279 if (if_is_up && --if_is_up > 0)
2287 return setifstate(u, 0);
2291 /********************************************************************
2293 * sif6up - Config the interface up for IPv6
2300 if ((ret = setifstate(u, 1)))
2306 /********************************************************************
2308 * sif6down - Disable the IPv6CP protocol and config the interface
2309 * down if there are no remaining protocols.
2312 int sif6down (int u)
2319 return setifstate(u, 0);
2323 /********************************************************************
2325 * setifstate - Config the interface up or down
2328 static int setifstate (int u, int state)
2332 memset (&ifr, '\0', sizeof (ifr));
2333 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2334 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2335 if (! ok_error (errno))
2336 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2341 ifr.ifr_flags |= IFF_UP;
2343 ifr.ifr_flags &= ~IFF_UP;
2344 ifr.ifr_flags |= IFF_POINTOPOINT;
2345 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2346 if (! ok_error (errno))
2347 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2353 /********************************************************************
2355 * sifaddr - Config the interface IP addresses and netmask.
2358 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2364 memset (&ifr, '\0', sizeof (ifr));
2365 memset (&rt, '\0', sizeof (rt));
2367 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2368 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2369 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2371 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2373 * Set our IP address
2375 SIN_ADDR(ifr.ifr_addr) = our_adr;
2376 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2377 if (errno != EEXIST) {
2378 if (! ok_error (errno))
2379 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2382 warn("ioctl(SIOCSIFADDR): Address already exists");
2387 * Set the gateway address
2390 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2391 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2392 if (! ok_error (errno))
2393 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2399 * For recent kernels, force the netmask to 255.255.255.255.
2401 if (kernel_version >= KVERSION(2,1,16))
2403 if (net_mask != 0) {
2404 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2405 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2406 if (! ok_error (errno))
2407 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2412 * Add the device route
2414 if (kernel_version < KVERSION(2,1,16)) {
2415 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2416 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2419 SIN_ADDR(rt.rt_gateway) = 0L;
2420 SIN_ADDR(rt.rt_dst) = his_adr;
2421 rt.rt_flags = RTF_UP | RTF_HOST;
2423 if (kernel_version > KVERSION(2,1,0)) {
2424 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2425 SIN_ADDR(rt.rt_genmask) = -1L;
2428 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2429 if (! ok_error (errno))
2430 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2435 /* set ip_dynaddr in demand mode if address changes */
2436 if (demand && tune_kernel && !dynaddr_set
2437 && our_old_addr && our_old_addr != our_adr) {
2438 /* set ip_dynaddr if possible */
2442 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2443 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2444 if (write(fd, "1", 1) != 1)
2445 error("Couldn't enable dynamic IP addressing: %m");
2448 dynaddr_set = 1; /* only 1 attempt */
2455 /********************************************************************
2457 * cifaddr - Clear the interface IP addresses, and delete routes
2458 * through the interface if possible.
2461 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2465 if (kernel_version < KVERSION(2,1,16)) {
2467 * Delete the route through the device
2470 memset (&rt, '\0', sizeof (rt));
2472 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2473 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2476 SIN_ADDR(rt.rt_gateway) = 0;
2477 SIN_ADDR(rt.rt_dst) = his_adr;
2478 rt.rt_flags = RTF_UP | RTF_HOST;
2480 if (kernel_version > KVERSION(2,1,0)) {
2481 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2482 SIN_ADDR(rt.rt_genmask) = -1L;
2485 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2486 if (still_ppp() && ! ok_error (errno))
2487 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2492 /* This way it is possible to have an IPX-only or IPv6-only interface */
2493 memset(&ifr, 0, sizeof(ifr));
2494 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2495 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2497 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2498 if (! ok_error (errno)) {
2499 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2504 our_old_addr = our_adr;
2510 /********************************************************************
2512 * sif6addr - Config the interface with an IPv6 link-local address
2514 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2516 struct in6_ifreq ifr6;
2518 struct in6_rtmsg rt6;
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("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2532 /* Local interface */
2533 memset(&ifr6, 0, sizeof(ifr6));
2534 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2535 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2536 ifr6.ifr6_prefixlen = 10;
2538 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2539 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2543 /* Route to remote host */
2544 memset(&rt6, 0, sizeof(rt6));
2545 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2546 rt6.rtmsg_flags = RTF_UP;
2547 rt6.rtmsg_dst_len = 10;
2548 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2549 rt6.rtmsg_metric = 1;
2551 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2552 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2560 /********************************************************************
2562 * cif6addr - Remove IPv6 address from interface
2564 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2567 struct in6_ifreq ifr6;
2571 error("IPv6 socket creation failed: %m");
2574 memset(&ifr, 0, sizeof(ifr));
2575 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2576 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2577 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2581 memset(&ifr6, 0, sizeof(ifr6));
2582 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2583 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2584 ifr6.ifr6_prefixlen = 10;
2586 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2587 if (errno != EADDRNOTAVAIL) {
2588 if (! ok_error (errno))
2589 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2592 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2601 * get_pty - get a pty master/slave pair and chown the slave side
2602 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2605 get_pty(master_fdp, slave_fdp, slave_name, uid)
2611 int i, mfd, sfd = -1;
2613 struct termios tios;
2617 * Try the unix98 way first.
2619 mfd = open("/dev/ptmx", O_RDWR);
2622 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2623 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2624 chmod(pty_name, S_IRUSR | S_IWUSR);
2627 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2628 warn("Couldn't unlock pty slave %s: %m", pty_name);
2630 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2631 warn("Couldn't open pty slave %s: %m", pty_name);
2634 #endif /* TIOCGPTN */
2637 /* the old way - scan through the pty name space */
2638 for (i = 0; i < 64; ++i) {
2639 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2640 'p' + i / 16, i % 16);
2641 mfd = open(pty_name, O_RDWR, 0);
2644 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2646 fchown(sfd, uid, -1);
2647 fchmod(sfd, S_IRUSR | S_IWUSR);
2658 strlcpy(slave_name, pty_name, 16);
2661 if (tcgetattr(sfd, &tios) == 0) {
2662 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2663 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2664 tios.c_iflag = IGNPAR;
2667 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2668 warn("couldn't set attributes on pty: %m");
2670 warn("couldn't get attributes on pty: %m");
2675 /********************************************************************
2677 * open_loopback - open the device we use for getting packets
2678 * in demand mode. Under Linux, we use a pty master/slave pair.
2681 open_ppp_loopback(void)
2686 if (new_style_driver) {
2687 /* allocate ourselves a ppp unit */
2688 if (make_ppp_unit() < 0)
2690 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2691 set_kdebugflag(kdebugflag);
2696 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2697 fatal("No free pty for loopback");
2699 set_ppp_fd(slave_fd);
2701 flags = fcntl(master_fd, F_GETFL);
2703 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2704 warn("couldn't set master loopback to nonblock: %m");
2706 flags = fcntl(ppp_fd, F_GETFL);
2708 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2709 warn("couldn't set slave loopback to nonblock: %m");
2711 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2712 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2714 * Find out which interface we were given.
2716 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2717 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2719 * Enable debug in the driver if requested.
2721 set_kdebugflag (kdebugflag);
2726 /********************************************************************
2728 * sifnpmode - Set the mode for handling packets for a given NP.
2732 sifnpmode(u, proto, mode)
2739 npi.protocol = proto;
2741 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2742 if (! ok_error (errno))
2743 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2750 /********************************************************************
2752 * sipxfaddr - Config the interface IPX networknumber
2755 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2762 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2764 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2766 if (! ok_error (errno))
2767 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2771 memset (&ifr, '\0', sizeof (ifr));
2772 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2774 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2775 sipx->sipx_family = AF_IPX;
2776 sipx->sipx_port = 0;
2777 sipx->sipx_network = htonl (network);
2778 sipx->sipx_type = IPX_FRAME_ETHERII;
2779 sipx->sipx_action = IPX_CRTITF;
2781 * Set the IPX device
2783 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2785 if (errno != EEXIST) {
2786 if (! ok_error (errno))
2787 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2790 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2799 /********************************************************************
2801 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2802 * are removed and the device is no longer able to pass IPX
2806 int cipxfaddr (int unit)
2813 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2815 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2817 if (! ok_error (errno))
2818 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2822 memset (&ifr, '\0', sizeof (ifr));
2823 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2825 sipx->sipx_type = IPX_FRAME_ETHERII;
2826 sipx->sipx_action = IPX_DLTITF;
2827 sipx->sipx_family = AF_IPX;
2829 * Set the IPX device
2831 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2832 if (! ok_error (errno))
2833 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2843 * Use the hostname as part of the random number seed.
2852 for (p = hostname; *p != 0; ++p)
2857 /********************************************************************
2859 * sys_check_options - check the options that the user specified
2863 sys_check_options(void)
2867 * Disable the IPX protocol if the support is not present in the kernel.
2871 if (ipxcp_protent.enabled_flag) {
2872 struct stat stat_buf;
2873 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
2874 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
2875 || lstat(path, &stat_buf) < 0) {
2876 error("IPX support is not present in the kernel\n");
2877 ipxcp_protent.enabled_flag = 0;
2881 if (demand && driver_is_old) {
2882 option_error("demand dialling is not supported by kernel driver "
2883 "version %d.%d.%d", driver_version, driver_modification,
2887 if (multilink && !new_style_driver) {
2888 warn("Warning: multilink is not supported by the kernel driver");
2896 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2898 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2899 * that the system has a properly configured Ethernet interface for this
2900 * function to return non-zero.
2903 ether_to_eui64(eui64_t *p_eui64)
2907 const unsigned char *ptr;
2909 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2912 warn("could not open IPv6 socket");
2916 strcpy(ifr.ifr_name, "eth0");
2917 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2920 warn("could not obtain hardware address for eth0");
2926 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2928 ptr = (unsigned char *) ifr.ifr_hwaddr.sa_data;
2929 p_eui64->e8[0] = ptr[0] | 0x02;
2930 p_eui64->e8[1] = ptr[1];
2931 p_eui64->e8[2] = ptr[2];
2932 p_eui64->e8[3] = 0xFF;
2933 p_eui64->e8[4] = 0xFE;
2934 p_eui64->e8[5] = ptr[3];
2935 p_eui64->e8[6] = ptr[4];
2936 p_eui64->e8[7] = ptr[5];