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;
970 tios.c_cflag |= CSTOPB;
972 speed = translate_speed(inspeed);
974 cfsetospeed (&tios, speed);
975 cfsetispeed (&tios, speed);
978 * We can't proceed if the serial port speed is B0,
979 * since that implies that the serial port is disabled.
982 speed = cfgetospeed(&tios);
984 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
987 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
989 fatal("tcsetattr: %m (line %d)", __LINE__);
991 baud_rate = baud_rate_of(speed);
995 /********************************************************************
997 * setdtr - control the DTR line on the serial port.
998 * This is called from die(), so it shouldn't call die().
1001 void setdtr (int tty_fd, int on)
1003 int modembits = TIOCM_DTR;
1005 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1008 /********************************************************************
1010 * restore_tty - restore the terminal to the saved settings.
1013 void restore_tty (int tty_fd)
1018 * Turn off echoing, because otherwise we can get into
1019 * a loop with the tty and the modem echoing to each other.
1020 * We presume we are the sole user of this tty device, so
1021 * when we close it, it will revert to its defaults anyway.
1023 if (!default_device)
1024 inittermios.c_lflag &= ~(ECHO | ECHONL);
1026 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1027 if (! ok_error (errno))
1028 warn("tcsetattr: %m (line %d)", __LINE__);
1033 /********************************************************************
1035 * output - Output PPP packet.
1038 void output (int unit, unsigned char *p, int len)
1043 dump_packet("sent", p, len);
1044 if (snoop_send_hook) snoop_send_hook(p, len);
1046 if (len < PPP_HDRLEN)
1048 if (new_style_driver) {
1051 proto = (p[0] << 8) + p[1];
1052 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1055 if (write(fd, p, len) < 0) {
1056 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1057 || errno == ENXIO || errno == EIO || errno == EINTR)
1058 warn("write: warning: %m (%d)", errno);
1060 error("write: %m (%d)", errno);
1064 /********************************************************************
1066 * wait_input - wait until there is data available,
1067 * for the length of time specified by *timo (indefinite
1071 void wait_input(struct timeval *timo)
1078 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1079 if (n < 0 && errno != EINTR)
1080 fatal("select: %m");
1084 * add_fd - add an fd to the set that wait_input waits for.
1088 if (fd >= FD_SETSIZE)
1089 fatal("internal error: file descriptor too large (%d)", fd);
1090 FD_SET(fd, &in_fds);
1096 * remove_fd - remove an fd from the set that wait_input waits for.
1098 void remove_fd(int fd)
1100 FD_CLR(fd, &in_fds);
1104 /********************************************************************
1106 * read_packet - get a PPP packet from the serial device.
1109 int read_packet (unsigned char *buf)
1113 len = PPP_MRU + PPP_HDRLEN;
1114 if (new_style_driver) {
1115 *buf++ = PPP_ALLSTATIONS;
1121 nr = read(ppp_fd, buf, len);
1122 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1123 && errno != EIO && errno != EINTR)
1125 if (nr < 0 && errno == ENXIO)
1128 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1129 /* N.B. we read ppp_fd first since LCP packets come in there. */
1130 nr = read(ppp_dev_fd, buf, len);
1131 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1132 && errno != EIO && errno != EINTR)
1133 error("read /dev/ppp: %m");
1134 if (nr < 0 && errno == ENXIO)
1136 if (nr == 0 && doing_multilink) {
1137 remove_fd(ppp_dev_fd);
1141 if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1143 return (new_style_driver && nr > 0)? nr+2: nr;
1146 /********************************************************************
1148 * get_loop_output - get outgoing packets from the ppp device,
1149 * and detect when we want to bring the real link up.
1150 * Return value is 1 if we need to bring up the link, 0 otherwise.
1153 get_loop_output(void)
1158 if (new_style_driver) {
1159 while ((n = read_packet(inpacket_buf)) > 0)
1160 if (loop_frame(inpacket_buf, n))
1165 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1166 if (loop_chars(inbuf, n))
1170 fatal("eof on loopback");
1172 if (errno != EWOULDBLOCK && errno != EAGAIN)
1173 fatal("read from loopback: %m(%d)", errno);
1179 * netif_set_mtu - set the MTU on the PPP network interface.
1182 netif_set_mtu(int unit, int mtu)
1186 memset (&ifr, '\0', sizeof (ifr));
1187 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1190 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1191 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1195 * netif_get_mtu - get the MTU on the PPP network interface.
1198 netif_get_mtu(int unit)
1202 memset (&ifr, '\0', sizeof (ifr));
1203 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1205 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1206 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1212 /********************************************************************
1214 * tty_send_config - configure the transmit characteristics of
1215 * the ppp interface.
1218 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1225 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1226 if (errno != EIO && errno != ENOTTY)
1227 error("Couldn't set transmit async character map: %m");
1232 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1233 | (sync_serial? SC_SYNC: 0);
1234 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1237 /********************************************************************
1239 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1242 void tty_set_xaccm (ext_accm accm)
1246 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1247 if ( ! ok_error (errno))
1248 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1252 /********************************************************************
1254 * tty_recv_config - configure the receive-side characteristics of
1255 * the ppp interface.
1258 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1261 * If we were called because the link has gone down then there is nothing
1262 * which may be done. Just return without incident.
1267 * Set the receiver parameters
1269 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1270 if (errno != EIO && errno != ENOTTY)
1271 error("Couldn't set channel receive MRU: %m");
1273 if (new_style_driver && ppp_dev_fd >= 0
1274 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1275 error("Couldn't set MRU in generic PPP layer: %m");
1277 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1278 if (errno != EIO && errno != ENOTTY)
1279 error("Couldn't set channel receive asyncmap: %m");
1283 /********************************************************************
1285 * ccp_test - ask kernel whether a given compression method
1286 * is acceptable for use.
1290 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1292 struct ppp_option_data data;
1294 memset (&data, '\0', sizeof (data));
1296 data.length = opt_len;
1297 data.transmit = for_transmit;
1299 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1302 return (errno == ENOBUFS)? 0: -1;
1305 /********************************************************************
1307 * ccp_flags_set - inform kernel about the current state of CCP.
1310 void ccp_flags_set (int unit, int isopen, int isup)
1314 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1315 if (still_ppp() && ppp_dev_fd >= 0)
1316 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1321 * set_filters - set the active and pass filters in the kernel driver.
1323 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1325 struct sock_fprog fp;
1327 fp.len = pass->bf_len;
1328 fp.filter = (struct sock_filter *) pass->bf_insns;
1329 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1330 if (errno == ENOTTY)
1331 warn("kernel does not support PPP filtering");
1333 error("Couldn't set pass-filter in kernel: %m");
1336 fp.len = active->bf_len;
1337 fp.filter = (struct sock_filter *) active->bf_insns;
1338 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1339 error("Couldn't set active-filter in kernel: %m");
1344 #endif /* PPP_FILTER */
1346 /********************************************************************
1348 * get_idle_time - return how long the link has been idle.
1351 get_idle_time(u, ip)
1353 struct ppp_idle *ip;
1355 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1358 /********************************************************************
1360 * get_ppp_stats - return statistics for the link.
1363 get_ppp_stats(u, stats)
1365 struct pppd_stats *stats;
1367 struct ifpppstatsreq req;
1369 memset (&req, 0, sizeof (req));
1371 req.stats_ptr = (caddr_t) &req.stats;
1372 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1373 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1374 error("Couldn't get PPP statistics: %m");
1377 stats->bytes_in = req.stats.p.ppp_ibytes;
1378 stats->bytes_out = req.stats.p.ppp_obytes;
1379 stats->pkts_in = req.stats.p.ppp_ipackets;
1380 stats->pkts_out = req.stats.p.ppp_opackets;
1384 /********************************************************************
1386 * ccp_fatal_error - returns 1 if decompression was disabled as a
1387 * result of an error detected after decompression of a packet,
1388 * 0 otherwise. This is necessary because of patent nonsense.
1391 int ccp_fatal_error (int unit)
1395 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1396 error("Couldn't read compression error flags: %m");
1399 return flags & SC_DC_FERROR;
1402 /********************************************************************
1404 * path_to_procfs - find the path to the proc file system mount point
1406 static char proc_path[MAXPATHLEN];
1407 static int proc_path_len;
1409 static char *path_to_procfs(const char *tail)
1411 struct mntent *mntent;
1414 if (proc_path_len == 0) {
1415 /* Default the mount location of /proc */
1416 strlcpy (proc_path, "/proc", sizeof(proc_path));
1418 fp = fopen(MOUNTED, "r");
1420 while ((mntent = getmntent(fp)) != NULL) {
1421 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1423 if (strcmp(mntent->mnt_type, "proc") == 0) {
1424 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1425 proc_path_len = strlen(proc_path);
1433 strlcpy(proc_path + proc_path_len, tail,
1434 sizeof(proc_path) - proc_path_len);
1439 * /proc/net/route parsing stuff.
1441 #define ROUTE_MAX_COLS 12
1442 FILE *route_fd = (FILE *) 0;
1443 static char route_buffer[512];
1444 static int route_dev_col, route_dest_col, route_gw_col;
1445 static int route_flags_col, route_mask_col;
1446 static int route_num_cols;
1448 static int open_route_table (void);
1449 static void close_route_table (void);
1450 static int read_route_table (struct rtentry *rt);
1452 /********************************************************************
1454 * close_route_table - close the interface to the route table
1457 static void close_route_table (void)
1459 if (route_fd != (FILE *) 0) {
1461 route_fd = (FILE *) 0;
1465 /********************************************************************
1467 * open_route_table - open the interface to the route table
1469 static char route_delims[] = " \t\n";
1471 static int open_route_table (void)
1475 close_route_table();
1477 path = path_to_procfs("/net/route");
1478 route_fd = fopen (path, "r");
1479 if (route_fd == NULL) {
1480 error("can't open routing table %s: %m", path);
1484 route_dev_col = 0; /* default to usual columns */
1487 route_flags_col = 3;
1491 /* parse header line */
1492 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1493 char *p = route_buffer, *q;
1495 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1497 if ((q = strtok(p, route_delims)) == 0)
1499 if (strcasecmp(q, "iface") == 0)
1500 route_dev_col = col;
1501 else if (strcasecmp(q, "destination") == 0)
1502 route_dest_col = col;
1503 else if (strcasecmp(q, "gateway") == 0)
1505 else if (strcasecmp(q, "flags") == 0)
1506 route_flags_col = col;
1507 else if (strcasecmp(q, "mask") == 0)
1508 route_mask_col = col;
1511 if (used && col >= route_num_cols)
1512 route_num_cols = col + 1;
1520 /********************************************************************
1522 * read_route_table - read the next entry from the route table
1525 static int read_route_table(struct rtentry *rt)
1527 char *cols[ROUTE_MAX_COLS], *p;
1530 memset (rt, '\0', sizeof (struct rtentry));
1532 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1536 for (col = 0; col < route_num_cols; ++col) {
1537 cols[col] = strtok(p, route_delims);
1538 if (cols[col] == NULL)
1539 return 0; /* didn't get enough columns */
1543 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1544 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1545 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1547 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1548 rt->rt_dev = cols[route_dev_col];
1553 /********************************************************************
1555 * defaultroute_exists - determine if there is a default route
1558 static int defaultroute_exists (struct rtentry *rt)
1562 if (!open_route_table())
1565 while (read_route_table(rt) != 0) {
1566 if ((rt->rt_flags & RTF_UP) == 0)
1569 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1571 if (SIN_ADDR(rt->rt_dst) == 0L) {
1577 close_route_table();
1582 * have_route_to - determine if the system has any route to
1583 * a given IP address. `addr' is in network byte order.
1584 * Return value is 1 if yes, 0 if no, -1 if don't know.
1585 * For demand mode to work properly, we have to ignore routes
1586 * through our own interface.
1588 int have_route_to(u_int32_t addr)
1593 if (!open_route_table())
1594 return -1; /* don't know */
1596 while (read_route_table(&rt)) {
1597 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1599 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1605 close_route_table();
1609 /********************************************************************
1611 * sifdefaultroute - assign a default route through the address given.
1614 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1618 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1619 if (rt.rt_flags & RTF_GATEWAY)
1620 error("not replacing existing default route via %I",
1621 SIN_ADDR(rt.rt_gateway));
1623 error("not replacing existing default route through %s",
1628 memset (&rt, 0, sizeof (rt));
1629 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1633 if (kernel_version > KVERSION(2,1,0)) {
1634 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1635 SIN_ADDR(rt.rt_genmask) = 0L;
1638 rt.rt_flags = RTF_UP;
1639 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1640 if ( ! ok_error ( errno ))
1641 error("default route ioctl(SIOCADDRT): %m");
1645 have_default_route = 1;
1649 /********************************************************************
1651 * cifdefaultroute - delete a default route through the address given.
1654 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1658 have_default_route = 0;
1660 memset (&rt, '\0', sizeof (rt));
1661 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1662 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1666 if (kernel_version > KVERSION(2,1,0)) {
1667 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1668 SIN_ADDR(rt.rt_genmask) = 0L;
1671 rt.rt_flags = RTF_UP;
1672 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1674 if ( ! ok_error ( errno ))
1675 error("default route ioctl(SIOCDELRT): %m");
1683 /********************************************************************
1685 * sifproxyarp - Make a proxy ARP entry for the peer.
1688 int sifproxyarp (int unit, u_int32_t his_adr)
1690 struct arpreq arpreq;
1693 if (has_proxy_arp == 0) {
1694 memset (&arpreq, '\0', sizeof(arpreq));
1696 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1697 SIN_ADDR(arpreq.arp_pa) = his_adr;
1698 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1700 * Get the hardware address of an interface on the same subnet
1701 * as our local address.
1703 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1704 sizeof(proxy_arp_dev))) {
1705 error("Cannot determine ethernet address for proxy ARP");
1708 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1710 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1711 if ( ! ok_error ( errno ))
1712 error("ioctl(SIOCSARP): %m");
1715 proxy_arp_addr = his_adr;
1719 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1720 if (forw_path != 0) {
1721 int fd = open(forw_path, O_WRONLY);
1723 if (write(fd, "1", 1) != 1)
1724 error("Couldn't enable IP forwarding: %m");
1734 /********************************************************************
1736 * cifproxyarp - Delete the proxy ARP entry for the peer.
1739 int cifproxyarp (int unit, u_int32_t his_adr)
1741 struct arpreq arpreq;
1743 if (has_proxy_arp) {
1745 memset (&arpreq, '\0', sizeof(arpreq));
1746 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1747 SIN_ADDR(arpreq.arp_pa) = his_adr;
1748 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1749 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1751 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1752 if ( ! ok_error ( errno ))
1753 warn("ioctl(SIOCDARP): %m");
1760 /********************************************************************
1762 * get_ether_addr - get the hardware address of an interface on the
1763 * the same subnet as ipaddr.
1766 static int get_ether_addr (u_int32_t ipaddr,
1767 struct sockaddr *hwaddr,
1768 char *name, int namelen)
1770 struct ifreq *ifr, *ifend;
1771 u_int32_t ina, mask;
1773 struct ifreq ifreq, bestifreq;
1775 struct ifreq ifs[MAX_IFS];
1777 u_int32_t bestmask=0;
1778 int found_interface = 0;
1780 ifc.ifc_len = sizeof(ifs);
1782 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1783 if ( ! ok_error ( errno ))
1784 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1789 * Scan through looking for an interface with an Internet
1790 * address on the same subnet as `ipaddr'.
1792 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1793 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1794 if (ifr->ifr_addr.sa_family == AF_INET) {
1795 ina = SIN_ADDR(ifr->ifr_addr);
1796 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1798 * Check that the interface is up, and not point-to-point
1801 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1804 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1807 * Get its netmask and check that it's on the right subnet.
1809 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1812 mask = SIN_ADDR(ifreq.ifr_addr);
1814 if (((ipaddr ^ ina) & mask) != 0)
1815 continue; /* no match */
1817 if (mask >= bestmask) {
1818 /* Compare using >= instead of > -- it is possible for
1819 an interface to have a netmask of 0.0.0.0 */
1820 found_interface = 1;
1827 if (!found_interface) return 0;
1829 strlcpy(name, bestifreq.ifr_name, namelen);
1831 /* trim off the :1 in eth0:1 */
1832 aliasp = strchr(name, ':');
1836 info("found interface %s for proxy arp", name);
1838 * Now get the hardware address.
1840 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1841 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1842 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1847 &bestifreq.ifr_hwaddr,
1848 sizeof (struct sockaddr));
1854 * get_if_hwaddr - get the hardware address for the specified
1855 * network interface device.
1858 get_if_hwaddr(u_char *addr, char *name)
1863 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1866 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1867 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1868 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1871 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1876 * get_first_ethernet - return the name of the first ethernet-style
1877 * interface on this system.
1880 get_first_ethernet()
1885 /********************************************************************
1887 * Return user specified netmask, modified by any mask we might determine
1888 * for address `addr' (in network byte order).
1889 * Here we scan through the system's list of interfaces, looking for
1890 * any non-point-to-point interfaces which might appear to be on the same
1891 * network as `addr'. If we find any, we OR in their netmask to the
1892 * user-specified netmask.
1895 u_int32_t GetMask (u_int32_t addr)
1897 u_int32_t mask, nmask, ina;
1898 struct ifreq *ifr, *ifend, ifreq;
1900 struct ifreq ifs[MAX_IFS];
1904 if (IN_CLASSA(addr)) /* determine network mask for address class */
1905 nmask = IN_CLASSA_NET;
1906 else if (IN_CLASSB(addr))
1907 nmask = IN_CLASSB_NET;
1909 nmask = IN_CLASSC_NET;
1911 /* class D nets are disallowed by bad_ip_adrs */
1912 mask = netmask | htonl(nmask);
1914 * Scan through the system's network interfaces.
1916 ifc.ifc_len = sizeof(ifs);
1918 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1919 if ( ! ok_error ( errno ))
1920 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1924 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1925 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1927 * Check the interface's internet address.
1929 if (ifr->ifr_addr.sa_family != AF_INET)
1931 ina = SIN_ADDR(ifr->ifr_addr);
1932 if (((ntohl(ina) ^ addr) & nmask) != 0)
1935 * Check that the interface is up, and not point-to-point nor loopback.
1937 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1938 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1941 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1944 * Get its netmask and OR it into our mask.
1946 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1948 mask |= SIN_ADDR(ifreq.ifr_addr);
1954 /********************************************************************
1956 * Internal routine to decode the version.modification.patch level
1959 static void decode_version (char *buf, int *version,
1960 int *modification, int *patch)
1964 *version = (int) strtoul (buf, &endp, 10);
1968 if (endp != buf && *endp == '.') {
1970 *modification = (int) strtoul (buf, &endp, 10);
1971 if (endp != buf && *endp == '.') {
1973 *patch = (int) strtoul (buf, &buf, 10);
1978 /********************************************************************
1980 * Procedure to determine if the PPP line discipline is registered.
1984 ppp_registered(void)
1992 * We used to open the serial device and set it to the ppp line
1993 * discipline here, in order to create a ppp unit. But that is
1994 * not a good idea - the user might have specified a device that
1995 * they can't open (permission, or maybe it doesn't really exist).
1996 * So we grab a pty master/slave pair and use that.
1998 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1999 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2004 * Try to put the device into the PPP discipline.
2006 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2007 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2016 /********************************************************************
2018 * ppp_available - check whether the system has any ppp interfaces
2019 * (in fact we check whether we can do an ioctl on ppp0).
2022 int ppp_available(void)
2027 int my_version, my_modification, my_patch;
2028 int osmaj, osmin, ospatch;
2030 /* get the kernel version now, since we are called before sys_init */
2032 osmaj = osmin = ospatch = 0;
2033 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2034 kernel_version = KVERSION(osmaj, osmin, ospatch);
2036 fd = open("/dev/ppp", O_RDWR);
2038 new_style_driver = 1;
2040 /* XXX should get from driver */
2042 driver_modification = 4;
2048 if (kernel_version >= KVERSION(2,3,13)) {
2049 error("Couldn't open the /dev/ppp device: %m");
2050 if (errno == ENOENT)
2052 "You need to create the /dev/ppp device node by\n"
2053 "executing the following command as root:\n"
2054 " mknod /dev/ppp c 108 0\n";
2055 else if (errno == ENODEV || errno == ENXIO)
2057 "Please load the ppp_generic kernel module.\n";
2061 /* we are running on a really really old kernel */
2063 "This system lacks kernel support for PPP. This could be because\n"
2064 "the PPP kernel module could not be loaded, or because PPP was not\n"
2065 "included in the kernel configuration. If PPP was included as a\n"
2066 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2067 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2068 "See README.linux file in the ppp distribution for more details.\n";
2071 * Open a socket for doing the ioctl operations.
2073 s = socket(AF_INET, SOCK_DGRAM, 0);
2077 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2078 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2080 * If the device did not exist then attempt to create one by putting the
2081 * current tty into the PPP discipline. If this works then obtain the
2082 * flags for the device again.
2085 if (ppp_registered()) {
2086 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2087 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2091 * Ensure that the hardware address is for PPP and not something else
2094 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2096 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2100 * This is the PPP device. Validate the version of the driver at this
2101 * point to ensure that this program will work with the driver.
2104 char abBuffer [1024];
2106 ifr.ifr_data = abBuffer;
2107 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2109 error("Couldn't read driver version: %m");
2111 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2114 decode_version(abBuffer,
2116 &driver_modification,
2119 * Validate the version of the driver against the version that we used.
2121 decode_version(VERSION,
2126 /* The version numbers must match */
2127 if (driver_version != my_version)
2130 /* The modification levels must be legal */
2131 if (driver_modification < 3) {
2132 if (driver_modification >= 2) {
2133 /* we can cope with 2.2.0 and above */
2142 slprintf(route_buffer, sizeof(route_buffer),
2143 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2144 driver_version, driver_modification, driver_patch);
2146 no_ppp_msg = route_buffer;
2153 #ifndef HAVE_LOGWTMP
2154 /********************************************************************
2156 * Update the wtmp file with the appropriate user name and tty device.
2159 void logwtmp (const char *line, const char *name, const char *host)
2161 struct utmp ut, *utp;
2162 pid_t mypid = getpid();
2168 * Update the signon database for users.
2169 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2171 utmpname(_PATH_UTMP);
2173 while ((utp = getutent()) && (utp->ut_pid != mypid))
2177 memcpy(&ut, utp, sizeof(ut));
2179 /* some gettys/telnetds don't initialize utmp... */
2180 memset(&ut, 0, sizeof(ut));
2182 if (ut.ut_id[0] == 0)
2183 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2185 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2186 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2190 ut.ut_type = USER_PROCESS;
2193 /* Insert the host name if one is supplied */
2195 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2197 /* Insert the IP address of the remote system if IP is enabled */
2198 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2199 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2200 sizeof(ut.ut_addr));
2202 /* CL: Makes sure that the logout works */
2203 if (*host == 0 && *name==0)
2209 * Update the wtmp file.
2212 updwtmp(_PATH_WTMP, &ut);
2214 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2216 flock(wtmp, LOCK_EX);
2218 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2219 warn("error writing %s: %m", _PATH_WTMP);
2221 flock(wtmp, LOCK_UN);
2227 #endif /* HAVE_LOGWTMP */
2229 /********************************************************************
2231 * sifvjcomp - config tcp header compression
2234 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2239 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2240 error("Couldn't set up TCP header compression: %m");
2245 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2246 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2251 /********************************************************************
2253 * sifup - Config the interface up and enable IP packets to pass.
2260 memset (&ifr, '\0', sizeof (ifr));
2261 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2262 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2263 if (! ok_error (errno))
2264 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2268 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2269 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2270 if (! ok_error (errno))
2271 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2279 /********************************************************************
2281 * sifdown - Disable the indicated protocol and config the interface
2282 * down if there are no remaining protocols.
2289 if (if_is_up && --if_is_up > 0)
2292 memset (&ifr, '\0', sizeof (ifr));
2293 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2294 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2295 if (! ok_error (errno))
2296 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2300 ifr.ifr_flags &= ~IFF_UP;
2301 ifr.ifr_flags |= IFF_POINTOPOINT;
2302 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2303 if (! ok_error (errno))
2304 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2310 /********************************************************************
2312 * sifaddr - Config the interface IP addresses and netmask.
2315 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2321 memset (&ifr, '\0', sizeof (ifr));
2322 memset (&rt, '\0', sizeof (rt));
2324 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2325 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2326 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2328 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2330 * Set our IP address
2332 SIN_ADDR(ifr.ifr_addr) = our_adr;
2333 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2334 if (errno != EEXIST) {
2335 if (! ok_error (errno))
2336 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2339 warn("ioctl(SIOCSIFADDR): Address already exists");
2344 * Set the gateway address
2347 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2348 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2349 if (! ok_error (errno))
2350 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2356 * For recent kernels, force the netmask to 255.255.255.255.
2358 if (kernel_version >= KVERSION(2,1,16))
2360 if (net_mask != 0) {
2361 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2362 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2363 if (! ok_error (errno))
2364 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2369 * Add the device route
2371 if (kernel_version < KVERSION(2,1,16)) {
2372 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2373 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2376 SIN_ADDR(rt.rt_gateway) = 0L;
2377 SIN_ADDR(rt.rt_dst) = his_adr;
2378 rt.rt_flags = RTF_UP | RTF_HOST;
2380 if (kernel_version > KVERSION(2,1,0)) {
2381 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2382 SIN_ADDR(rt.rt_genmask) = -1L;
2385 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2386 if (! ok_error (errno))
2387 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2392 /* set ip_dynaddr in demand mode if address changes */
2393 if (demand && tune_kernel && !dynaddr_set
2394 && our_old_addr && our_old_addr != our_adr) {
2395 /* set ip_dynaddr if possible */
2399 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2400 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2401 if (write(fd, "1", 1) != 1)
2402 error("Couldn't enable dynamic IP addressing: %m");
2405 dynaddr_set = 1; /* only 1 attempt */
2412 /********************************************************************
2414 * cifaddr - Clear the interface IP addresses, and delete routes
2415 * through the interface if possible.
2418 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2422 if (kernel_version < KVERSION(2,1,16)) {
2424 * Delete the route through the device
2427 memset (&rt, '\0', sizeof (rt));
2429 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2430 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2433 SIN_ADDR(rt.rt_gateway) = 0;
2434 SIN_ADDR(rt.rt_dst) = his_adr;
2435 rt.rt_flags = RTF_UP | RTF_HOST;
2437 if (kernel_version > KVERSION(2,1,0)) {
2438 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2439 SIN_ADDR(rt.rt_genmask) = -1L;
2442 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2443 if (still_ppp() && ! ok_error (errno))
2444 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2449 /* This way it is possible to have an IPX-only or IPv6-only interface */
2450 memset(&ifr, 0, sizeof(ifr));
2451 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2452 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2454 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2455 if (! ok_error (errno)) {
2456 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2461 our_old_addr = our_adr;
2467 /********************************************************************
2469 * sif6addr - Config the interface with an IPv6 link-local address
2471 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2473 struct in6_ifreq ifr6;
2475 struct in6_rtmsg rt6;
2479 error("IPv6 socket creation failed: %m");
2482 memset(&ifr, 0, sizeof (ifr));
2483 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2484 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2485 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2489 /* Local interface */
2490 memset(&ifr6, 0, sizeof(ifr6));
2491 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2492 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2493 ifr6.ifr6_prefixlen = 10;
2495 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2496 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2500 /* Route to remote host */
2501 memset(&rt6, 0, sizeof(rt6));
2502 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2503 rt6.rtmsg_flags = RTF_UP;
2504 rt6.rtmsg_dst_len = 10;
2505 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2506 rt6.rtmsg_metric = 1;
2508 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2509 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2517 /********************************************************************
2519 * cif6addr - Remove IPv6 address from interface
2521 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2524 struct in6_ifreq ifr6;
2528 error("IPv6 socket creation failed: %m");
2531 memset(&ifr, 0, sizeof(ifr));
2532 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2533 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2534 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2538 memset(&ifr6, 0, sizeof(ifr6));
2539 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2540 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2541 ifr6.ifr6_prefixlen = 10;
2543 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2544 if (errno != EADDRNOTAVAIL) {
2545 if (! ok_error (errno))
2546 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2549 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2558 * get_pty - get a pty master/slave pair and chown the slave side
2559 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2562 get_pty(master_fdp, slave_fdp, slave_name, uid)
2568 int i, mfd, sfd = -1;
2570 struct termios tios;
2574 * Try the unix98 way first.
2576 mfd = open("/dev/ptmx", O_RDWR);
2579 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2580 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2581 chmod(pty_name, S_IRUSR | S_IWUSR);
2584 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2585 warn("Couldn't unlock pty slave %s: %m", pty_name);
2587 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2588 warn("Couldn't open pty slave %s: %m", pty_name);
2591 #endif /* TIOCGPTN */
2594 /* the old way - scan through the pty name space */
2595 for (i = 0; i < 64; ++i) {
2596 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2597 'p' + i / 16, i % 16);
2598 mfd = open(pty_name, O_RDWR, 0);
2601 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2603 fchown(sfd, uid, -1);
2604 fchmod(sfd, S_IRUSR | S_IWUSR);
2615 strlcpy(slave_name, pty_name, 16);
2618 if (tcgetattr(sfd, &tios) == 0) {
2619 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2620 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2621 tios.c_iflag = IGNPAR;
2624 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2625 warn("couldn't set attributes on pty: %m");
2627 warn("couldn't get attributes on pty: %m");
2632 /********************************************************************
2634 * open_loopback - open the device we use for getting packets
2635 * in demand mode. Under Linux, we use a pty master/slave pair.
2638 open_ppp_loopback(void)
2643 if (new_style_driver) {
2644 /* allocate ourselves a ppp unit */
2645 if (make_ppp_unit() < 0)
2647 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2648 set_kdebugflag(kdebugflag);
2653 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2654 fatal("No free pty for loopback");
2656 set_ppp_fd(slave_fd);
2658 flags = fcntl(master_fd, F_GETFL);
2660 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2661 warn("couldn't set master loopback to nonblock: %m");
2663 flags = fcntl(ppp_fd, F_GETFL);
2665 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2666 warn("couldn't set slave loopback to nonblock: %m");
2668 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2669 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2671 * Find out which interface we were given.
2673 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2674 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2676 * Enable debug in the driver if requested.
2678 set_kdebugflag (kdebugflag);
2683 /********************************************************************
2685 * sifnpmode - Set the mode for handling packets for a given NP.
2689 sifnpmode(u, proto, mode)
2696 npi.protocol = proto;
2698 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2699 if (! ok_error (errno))
2700 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2707 /********************************************************************
2709 * sipxfaddr - Config the interface IPX networknumber
2712 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2719 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2721 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2723 if (! ok_error (errno))
2724 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2728 memset (&ifr, '\0', sizeof (ifr));
2729 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2731 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2732 sipx->sipx_family = AF_IPX;
2733 sipx->sipx_port = 0;
2734 sipx->sipx_network = htonl (network);
2735 sipx->sipx_type = IPX_FRAME_ETHERII;
2736 sipx->sipx_action = IPX_CRTITF;
2738 * Set the IPX device
2740 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2742 if (errno != EEXIST) {
2743 if (! ok_error (errno))
2744 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2747 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2756 /********************************************************************
2758 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2759 * are removed and the device is no longer able to pass IPX
2763 int cipxfaddr (int unit)
2770 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2772 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2774 if (! ok_error (errno))
2775 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2779 memset (&ifr, '\0', sizeof (ifr));
2780 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2782 sipx->sipx_type = IPX_FRAME_ETHERII;
2783 sipx->sipx_action = IPX_DLTITF;
2784 sipx->sipx_family = AF_IPX;
2786 * Set the IPX device
2788 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2789 if (! ok_error (errno))
2790 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2800 * Use the hostname as part of the random number seed.
2809 for (p = hostname; *p != 0; ++p)
2814 /********************************************************************
2816 * sys_check_options - check the options that the user specified
2820 sys_check_options(void)
2824 * Disable the IPX protocol if the support is not present in the kernel.
2828 if (ipxcp_protent.enabled_flag) {
2829 struct stat stat_buf;
2830 if ( ((path = path_to_procfs("/net/ipx/interface")) == NULL
2831 && (path = path_to_procfs("/net/ipx_interface")) == NULL)
2832 || lstat(path, &stat_buf) < 0) {
2833 error("IPX support is not present in the kernel\n");
2834 ipxcp_protent.enabled_flag = 0;
2838 if (demand && driver_is_old) {
2839 option_error("demand dialling is not supported by kernel driver "
2840 "version %d.%d.%d", driver_version, driver_modification,
2844 if (multilink && !new_style_driver) {
2845 warn("Warning: multilink is not supported by the kernel driver");
2853 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2855 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2856 * that the system has a properly configured Ethernet interface for this
2857 * function to return non-zero.
2860 ether_to_eui64(eui64_t *p_eui64)
2864 const unsigned char *ptr;
2866 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2869 warn("could not open IPv6 socket");
2873 strcpy(ifr.ifr_name, "eth0");
2874 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2877 warn("could not obtain hardware address for eth0");
2883 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2885 ptr = (unsigned char *) ifr.ifr_hwaddr.sa_data;
2886 p_eui64->e8[0] = ptr[0] | 0x02;
2887 p_eui64->e8[1] = ptr[1];
2888 p_eui64->e8[2] = ptr[2];
2889 p_eui64->e8[3] = 0xFF;
2890 p_eui64->e8[4] = 0xFE;
2891 p_eui64->e8[5] = ptr[3];
2892 p_eui64->e8[6] = ptr[4];
2893 p_eui64->e8[7] = ptr[5];