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;
177 static int master_fd = -1;
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 u_int32_t default_route_gateway; /* 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 (default_route_gateway != 0)
345 cifdefaultroute(0, 0, default_route_gateway);
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 (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);
715 /********************************************************************
717 * clean_check - Fetch the flags for the device and generate
718 * appropriate error messages.
720 void clean_check(void)
726 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
728 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
730 s = "all had bit 7 set to 1";
734 s = "all had bit 7 set to 0";
738 s = "all had odd parity";
742 s = "all had even parity";
747 warn("Receive serial link is not 8-bit clean:");
748 warn("Problem: %s", s);
756 * List of valid speeds.
760 int speed_int, speed_val;
843 /********************************************************************
845 * Translate from bits/second to a speed_t.
848 static int translate_speed (int bps)
850 struct speed *speedp;
853 for (speedp = speeds; speedp->speed_int; speedp++) {
854 if (bps == speedp->speed_int)
855 return speedp->speed_val;
857 warn("speed %d not supported", bps);
862 /********************************************************************
864 * Translate from a speed_t to bits/second.
867 static int baud_rate_of (int speed)
869 struct speed *speedp;
872 for (speedp = speeds; speedp->speed_int; speedp++) {
873 if (speed == speedp->speed_val)
874 return speedp->speed_int;
880 /********************************************************************
882 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
883 * at the requested speed, etc. If `local' is true, set CLOCAL
884 * regardless of whether the modem option was specified.
887 void set_up_tty(int tty_fd, int local)
893 if (tcgetattr(tty_fd, &tios) < 0) {
894 if (!ok_error(errno))
895 fatal("tcgetattr: %m (line %d)", __LINE__);
902 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
903 tios.c_cflag |= CS8 | CREAD | HUPCL;
905 tios.c_iflag = IGNBRK | IGNPAR;
909 tios.c_cc[VTIME] = 0;
912 tios.c_cflag ^= (CLOCAL | HUPCL);
916 tios.c_cflag |= CRTSCTS;
920 tios.c_iflag |= IXON | IXOFF;
921 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
922 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
926 tios.c_cflag &= ~CRTSCTS;
933 speed = translate_speed(inspeed);
935 cfsetospeed (&tios, speed);
936 cfsetispeed (&tios, speed);
939 * We can't proceed if the serial port speed is B0,
940 * since that implies that the serial port is disabled.
943 speed = cfgetospeed(&tios);
945 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
948 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
950 fatal("tcsetattr: %m (line %d)", __LINE__);
952 baud_rate = baud_rate_of(speed);
956 /********************************************************************
958 * setdtr - control the DTR line on the serial port.
959 * This is called from die(), so it shouldn't call die().
962 void setdtr (int tty_fd, int on)
964 int modembits = TIOCM_DTR;
966 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
969 /********************************************************************
971 * restore_tty - restore the terminal to the saved settings.
974 void restore_tty (int tty_fd)
979 * Turn off echoing, because otherwise we can get into
980 * a loop with the tty and the modem echoing to each other.
981 * We presume we are the sole user of this tty device, so
982 * when we close it, it will revert to its defaults anyway.
985 inittermios.c_lflag &= ~(ECHO | ECHONL);
987 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
988 if (! ok_error (errno))
989 warn("tcsetattr: %m (line %d)", __LINE__);
994 /********************************************************************
996 * output - Output PPP packet.
999 void output (int unit, unsigned char *p, int len)
1004 dump_packet("sent", p, len);
1005 if (snoop_send_hook) snoop_send_hook(p, len);
1007 if (len < PPP_HDRLEN)
1009 if (new_style_driver) {
1012 proto = (p[0] << 8) + p[1];
1013 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1016 if (write(fd, p, len) < 0) {
1017 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1018 || errno == ENXIO || errno == EIO || errno == EINTR)
1019 warn("write: warning: %m (%d)", errno);
1021 error("write: %m (%d)", errno);
1025 /********************************************************************
1027 * wait_input - wait until there is data available,
1028 * for the length of time specified by *timo (indefinite
1032 void wait_input(struct timeval *timo)
1039 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1040 if (n < 0 && errno != EINTR)
1041 fatal("select: %m");
1045 * add_fd - add an fd to the set that wait_input waits for.
1049 if (fd >= FD_SETSIZE)
1050 fatal("internal error: file descriptor too large (%d)", fd);
1051 FD_SET(fd, &in_fds);
1057 * remove_fd - remove an fd from the set that wait_input waits for.
1059 void remove_fd(int fd)
1061 FD_CLR(fd, &in_fds);
1065 /********************************************************************
1067 * read_packet - get a PPP packet from the serial device.
1070 int read_packet (unsigned char *buf)
1074 len = PPP_MRU + PPP_HDRLEN;
1075 if (new_style_driver) {
1076 *buf++ = PPP_ALLSTATIONS;
1082 nr = read(ppp_fd, buf, len);
1083 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1084 && errno != EIO && errno != EINTR)
1086 if (nr < 0 && errno == ENXIO)
1089 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0) {
1090 /* N.B. we read ppp_fd first since LCP packets come in there. */
1091 nr = read(ppp_dev_fd, buf, len);
1092 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1093 && errno != EIO && errno != EINTR)
1094 error("read /dev/ppp: %m");
1095 if (nr < 0 && errno == ENXIO)
1098 return (new_style_driver && nr > 0)? nr+2: nr;
1101 /********************************************************************
1103 * get_loop_output - get outgoing packets from the ppp device,
1104 * and detect when we want to bring the real link up.
1105 * Return value is 1 if we need to bring up the link, 0 otherwise.
1108 get_loop_output(void)
1113 if (new_style_driver) {
1114 while ((n = read_packet(inpacket_buf)) > 0)
1115 if (loop_frame(inpacket_buf, n))
1120 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1121 if (loop_chars(inbuf, n))
1125 fatal("eof on loopback");
1127 if (errno != EWOULDBLOCK && errno != EAGAIN)
1128 fatal("read from loopback: %m(%d)", errno);
1134 * netif_set_mtu - set the MTU on the PPP network interface.
1137 netif_set_mtu(int unit, int mtu)
1141 memset (&ifr, '\0', sizeof (ifr));
1142 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1145 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1146 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1150 * netif_get_mtu - get the MTU on the PPP network interface.
1153 netif_get_mtu(int unit)
1157 memset (&ifr, '\0', sizeof (ifr));
1158 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1160 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1161 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1167 /********************************************************************
1169 * tty_send_config - configure the transmit characteristics of
1170 * the ppp interface.
1173 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1180 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1181 if (errno != EIO && errno != ENOTTY)
1182 error("Couldn't set transmit async character map: %m");
1187 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1188 | (sync_serial? SC_SYNC: 0);
1189 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1192 /********************************************************************
1194 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1197 void tty_set_xaccm (ext_accm accm)
1201 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1202 if ( ! ok_error (errno))
1203 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1207 /********************************************************************
1209 * tty_recv_config - configure the receive-side characteristics of
1210 * the ppp interface.
1213 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1216 * If we were called because the link has gone down then there is nothing
1217 * which may be done. Just return without incident.
1222 * Set the receiver parameters
1224 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1225 if (errno != EIO && errno != ENOTTY)
1226 error("Couldn't set channel receive MRU: %m");
1228 if (new_style_driver && ppp_dev_fd >= 0
1229 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1230 error("Couldn't set MRU in generic PPP layer: %m");
1232 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1233 if (errno != EIO && errno != ENOTTY)
1234 error("Couldn't set channel receive asyncmap: %m");
1238 /********************************************************************
1240 * ccp_test - ask kernel whether a given compression method
1241 * is acceptable for use.
1245 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1247 struct ppp_option_data data;
1249 memset (&data, '\0', sizeof (data));
1251 data.length = opt_len;
1252 data.transmit = for_transmit;
1254 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1257 return (errno == ENOBUFS)? 0: -1;
1260 /********************************************************************
1262 * ccp_flags_set - inform kernel about the current state of CCP.
1265 void ccp_flags_set (int unit, int isopen, int isup)
1269 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1270 if (still_ppp() && ppp_dev_fd >= 0)
1271 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1276 * set_filters - set the active and pass filters in the kernel driver.
1278 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1280 struct sock_fprog fp;
1282 fp.len = pass->bf_len;
1283 fp.filter = (struct sock_filter *) pass->bf_insns;
1284 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1285 if (errno == ENOTTY)
1286 warn("kernel does not support PPP filtering");
1288 error("Couldn't set pass-filter in kernel: %m");
1291 fp.len = active->bf_len;
1292 fp.filter = (struct sock_filter *) active->bf_insns;
1293 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1294 error("Couldn't set active-filter in kernel: %m");
1299 #endif /* PPP_FILTER */
1301 /********************************************************************
1303 * get_idle_time - return how long the link has been idle.
1306 get_idle_time(u, ip)
1308 struct ppp_idle *ip;
1310 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1313 /********************************************************************
1315 * get_ppp_stats - return statistics for the link.
1318 get_ppp_stats(u, stats)
1320 struct pppd_stats *stats;
1322 struct ifpppstatsreq req;
1324 memset (&req, 0, sizeof (req));
1326 req.stats_ptr = (caddr_t) &req.stats;
1327 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1328 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1329 error("Couldn't get PPP statistics: %m");
1332 stats->bytes_in = req.stats.p.ppp_ibytes;
1333 stats->bytes_out = req.stats.p.ppp_obytes;
1334 stats->pkts_in = req.stats.p.ppp_ipackets;
1335 stats->pkts_out = req.stats.p.ppp_opackets;
1339 /********************************************************************
1341 * ccp_fatal_error - returns 1 if decompression was disabled as a
1342 * result of an error detected after decompression of a packet,
1343 * 0 otherwise. This is necessary because of patent nonsense.
1346 int ccp_fatal_error (int unit)
1350 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1351 error("Couldn't read compression error flags: %m");
1354 return flags & SC_DC_FERROR;
1357 /********************************************************************
1359 * path_to_procfs - find the path to the proc file system mount point
1361 static char proc_path[MAXPATHLEN];
1362 static int proc_path_len;
1364 static char *path_to_procfs(const char *tail)
1366 struct mntent *mntent;
1369 if (proc_path_len == 0) {
1370 /* Default the mount location of /proc */
1371 strlcpy (proc_path, "/proc", sizeof(proc_path));
1373 fp = fopen(MOUNTED, "r");
1375 while ((mntent = getmntent(fp)) != NULL) {
1376 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1378 if (strcmp(mntent->mnt_type, "proc") == 0) {
1379 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1380 proc_path_len = strlen(proc_path);
1388 strlcpy(proc_path + proc_path_len, tail,
1389 sizeof(proc_path) - proc_path_len);
1394 * /proc/net/route parsing stuff.
1396 #define ROUTE_MAX_COLS 12
1397 FILE *route_fd = (FILE *) 0;
1398 static char route_buffer[512];
1399 static int route_dev_col, route_dest_col, route_gw_col;
1400 static int route_flags_col, route_mask_col;
1401 static int route_num_cols;
1403 static int open_route_table (void);
1404 static void close_route_table (void);
1405 static int read_route_table (struct rtentry *rt);
1407 /********************************************************************
1409 * close_route_table - close the interface to the route table
1412 static void close_route_table (void)
1414 if (route_fd != (FILE *) 0) {
1416 route_fd = (FILE *) 0;
1420 /********************************************************************
1422 * open_route_table - open the interface to the route table
1424 static char route_delims[] = " \t\n";
1426 static int open_route_table (void)
1430 close_route_table();
1432 path = path_to_procfs("/net/route");
1433 route_fd = fopen (path, "r");
1434 if (route_fd == NULL) {
1435 error("can't open routing table %s: %m", path);
1439 route_dev_col = 0; /* default to usual columns */
1442 route_flags_col = 3;
1446 /* parse header line */
1447 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1448 char *p = route_buffer, *q;
1450 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1452 if ((q = strtok(p, route_delims)) == 0)
1454 if (strcasecmp(q, "iface") == 0)
1455 route_dev_col = col;
1456 else if (strcasecmp(q, "destination") == 0)
1457 route_dest_col = col;
1458 else if (strcasecmp(q, "gateway") == 0)
1460 else if (strcasecmp(q, "flags") == 0)
1461 route_flags_col = col;
1462 else if (strcasecmp(q, "mask") == 0)
1463 route_mask_col = col;
1466 if (used && col >= route_num_cols)
1467 route_num_cols = col + 1;
1475 /********************************************************************
1477 * read_route_table - read the next entry from the route table
1480 static int read_route_table(struct rtentry *rt)
1482 char *cols[ROUTE_MAX_COLS], *p;
1485 memset (rt, '\0', sizeof (struct rtentry));
1487 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1491 for (col = 0; col < route_num_cols; ++col) {
1492 cols[col] = strtok(p, route_delims);
1493 if (cols[col] == NULL)
1494 return 0; /* didn't get enough columns */
1498 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1499 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1500 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1502 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1503 rt->rt_dev = cols[route_dev_col];
1508 /********************************************************************
1510 * defaultroute_exists - determine if there is a default route
1513 static int defaultroute_exists (struct rtentry *rt)
1517 if (!open_route_table())
1520 while (read_route_table(rt) != 0) {
1521 if ((rt->rt_flags & RTF_UP) == 0)
1524 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1526 if (SIN_ADDR(rt->rt_dst) == 0L) {
1532 close_route_table();
1537 * have_route_to - determine if the system has any route to
1538 * a given IP address. `addr' is in network byte order.
1539 * Return value is 1 if yes, 0 if no, -1 if don't know.
1540 * For demand mode to work properly, we have to ignore routes
1541 * through our own interface.
1543 int have_route_to(u_int32_t addr)
1548 if (!open_route_table())
1549 return -1; /* don't know */
1551 while (read_route_table(&rt)) {
1552 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1554 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1560 close_route_table();
1564 /********************************************************************
1566 * sifdefaultroute - assign a default route through the address given.
1569 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1573 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1574 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1576 if (old_gateway != gateway)
1577 error("not replacing existing default route to %s [%I]",
1578 rt.rt_dev, old_gateway);
1582 memset (&rt, '\0', sizeof (rt));
1583 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1584 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1588 if (kernel_version > KVERSION(2,1,0)) {
1589 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1590 SIN_ADDR(rt.rt_genmask) = 0L;
1593 SIN_ADDR(rt.rt_gateway) = gateway;
1595 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1596 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1597 if ( ! ok_error ( errno ))
1598 error("default route ioctl(SIOCADDRT): %m");
1602 default_route_gateway = gateway;
1606 /********************************************************************
1608 * cifdefaultroute - delete a default route through the address given.
1611 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1615 default_route_gateway = 0;
1617 memset (&rt, '\0', sizeof (rt));
1618 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1619 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1621 if (kernel_version > KVERSION(2,1,0)) {
1622 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1623 SIN_ADDR(rt.rt_genmask) = 0L;
1626 SIN_ADDR(rt.rt_gateway) = gateway;
1628 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1629 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1631 if ( ! ok_error ( errno ))
1632 error("default route ioctl(SIOCDELRT): %m");
1640 /********************************************************************
1642 * sifproxyarp - Make a proxy ARP entry for the peer.
1645 int sifproxyarp (int unit, u_int32_t his_adr)
1647 struct arpreq arpreq;
1650 if (has_proxy_arp == 0) {
1651 memset (&arpreq, '\0', sizeof(arpreq));
1653 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1654 SIN_ADDR(arpreq.arp_pa) = his_adr;
1655 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1657 * Get the hardware address of an interface on the same subnet
1658 * as our local address.
1660 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1661 sizeof(proxy_arp_dev))) {
1662 error("Cannot determine ethernet address for proxy ARP");
1665 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1667 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1668 if ( ! ok_error ( errno ))
1669 error("ioctl(SIOCSARP): %m");
1672 proxy_arp_addr = his_adr;
1676 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1677 if (forw_path != 0) {
1678 int fd = open(forw_path, O_WRONLY);
1680 if (write(fd, "1", 1) != 1)
1681 error("Couldn't enable IP forwarding: %m");
1691 /********************************************************************
1693 * cifproxyarp - Delete the proxy ARP entry for the peer.
1696 int cifproxyarp (int unit, u_int32_t his_adr)
1698 struct arpreq arpreq;
1700 if (has_proxy_arp) {
1702 memset (&arpreq, '\0', sizeof(arpreq));
1703 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1704 SIN_ADDR(arpreq.arp_pa) = his_adr;
1705 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1706 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1708 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1709 if ( ! ok_error ( errno ))
1710 warn("ioctl(SIOCDARP): %m");
1717 /********************************************************************
1719 * get_ether_addr - get the hardware address of an interface on the
1720 * the same subnet as ipaddr.
1723 static int get_ether_addr (u_int32_t ipaddr,
1724 struct sockaddr *hwaddr,
1725 char *name, int namelen)
1727 struct ifreq *ifr, *ifend;
1728 u_int32_t ina, mask;
1730 struct ifreq ifreq, bestifreq;
1732 struct ifreq ifs[MAX_IFS];
1734 u_int32_t bestmask=0;
1735 int found_interface = 0;
1737 ifc.ifc_len = sizeof(ifs);
1739 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1740 if ( ! ok_error ( errno ))
1741 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1746 * Scan through looking for an interface with an Internet
1747 * address on the same subnet as `ipaddr'.
1749 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1750 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1751 if (ifr->ifr_addr.sa_family == AF_INET) {
1752 ina = SIN_ADDR(ifr->ifr_addr);
1753 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1755 * Check that the interface is up, and not point-to-point
1758 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1761 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1764 * Get its netmask and check that it's on the right subnet.
1766 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1769 mask = SIN_ADDR(ifreq.ifr_addr);
1771 if (((ipaddr ^ ina) & mask) != 0)
1772 continue; /* no match */
1774 if (mask >= bestmask) {
1775 /* Compare using >= instead of > -- it is possible for
1776 an interface to have a netmask of 0.0.0.0 */
1777 found_interface = 1;
1784 if (!found_interface) return 0;
1786 strlcpy(name, bestifreq.ifr_name, namelen);
1788 /* trim off the :1 in eth0:1 */
1789 aliasp = strchr(name, ':');
1793 info("found interface %s for proxy arp", name);
1795 * Now get the hardware address.
1797 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1798 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1799 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1804 &bestifreq.ifr_hwaddr,
1805 sizeof (struct sockaddr));
1811 * get_if_hwaddr - get the hardware address for the specified
1812 * network interface device.
1815 get_if_hwaddr(u_char *addr, char *name)
1820 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1823 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1824 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1825 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1828 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1833 * get_first_ethernet - return the name of the first ethernet-style
1834 * interface on this system.
1837 get_first_ethernet()
1842 /********************************************************************
1844 * Return user specified netmask, modified by any mask we might determine
1845 * for address `addr' (in network byte order).
1846 * Here we scan through the system's list of interfaces, looking for
1847 * any non-point-to-point interfaces which might appear to be on the same
1848 * network as `addr'. If we find any, we OR in their netmask to the
1849 * user-specified netmask.
1852 u_int32_t GetMask (u_int32_t addr)
1854 u_int32_t mask, nmask, ina;
1855 struct ifreq *ifr, *ifend, ifreq;
1857 struct ifreq ifs[MAX_IFS];
1861 if (IN_CLASSA(addr)) /* determine network mask for address class */
1862 nmask = IN_CLASSA_NET;
1863 else if (IN_CLASSB(addr))
1864 nmask = IN_CLASSB_NET;
1866 nmask = IN_CLASSC_NET;
1868 /* class D nets are disallowed by bad_ip_adrs */
1869 mask = netmask | htonl(nmask);
1871 * Scan through the system's network interfaces.
1873 ifc.ifc_len = sizeof(ifs);
1875 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1876 if ( ! ok_error ( errno ))
1877 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1881 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1882 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1884 * Check the interface's internet address.
1886 if (ifr->ifr_addr.sa_family != AF_INET)
1888 ina = SIN_ADDR(ifr->ifr_addr);
1889 if (((ntohl(ina) ^ addr) & nmask) != 0)
1892 * Check that the interface is up, and not point-to-point nor loopback.
1894 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1895 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1898 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1901 * Get its netmask and OR it into our mask.
1903 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1905 mask |= SIN_ADDR(ifreq.ifr_addr);
1911 /********************************************************************
1913 * Internal routine to decode the version.modification.patch level
1916 static void decode_version (char *buf, int *version,
1917 int *modification, int *patch)
1921 *version = (int) strtoul (buf, &endp, 10);
1925 if (endp != buf && *endp == '.') {
1927 *modification = (int) strtoul (buf, &endp, 10);
1928 if (endp != buf && *endp == '.') {
1930 *patch = (int) strtoul (buf, &buf, 10);
1935 /********************************************************************
1937 * Procedure to determine if the PPP line discipline is registered.
1941 ppp_registered(void)
1949 * We used to open the serial device and set it to the ppp line
1950 * discipline here, in order to create a ppp unit. But that is
1951 * not a good idea - the user might have specified a device that
1952 * they can't open (permission, or maybe it doesn't really exist).
1953 * So we grab a pty master/slave pair and use that.
1955 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1956 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1961 * Try to put the device into the PPP discipline.
1963 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1964 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
1973 /********************************************************************
1975 * ppp_available - check whether the system has any ppp interfaces
1976 * (in fact we check whether we can do an ioctl on ppp0).
1979 int ppp_available(void)
1984 int my_version, my_modification, my_patch;
1985 int osmaj, osmin, ospatch;
1988 "This system lacks kernel support for PPP. This could be because\n"
1989 "the PPP kernel module could not be loaded, or because PPP was not\n"
1990 "included in the kernel configuration. If PPP was included as a\n"
1991 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1992 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1993 "See README.linux file in the ppp distribution for more details.\n";
1995 /* get the kernel version now, since we are called before sys_init */
1997 osmaj = osmin = ospatch = 0;
1998 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1999 kernel_version = KVERSION(osmaj, osmin, ospatch);
2001 fd = open("/dev/ppp", O_RDWR);
2003 if (fd < 0 && errno == ENOENT) {
2004 /* try making it and see if that helps. */
2005 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
2006 makedev(108, 0)) >= 0) {
2007 fd = open("/dev/ppp", O_RDWR);
2009 info("Created /dev/ppp device node");
2011 unlink("/dev/ppp"); /* didn't work, undo the mknod */
2012 } else if (errno == EEXIST) {
2013 fd = open("/dev/ppp", O_RDWR);
2018 new_style_driver = 1;
2020 /* XXX should get from driver */
2022 driver_modification = 4;
2027 if (kernel_version >= KVERSION(2,3,13)) {
2028 if (errno == ENOENT)
2030 "pppd is unable to open the /dev/ppp device.\n"
2031 "You need to create the /dev/ppp device node by\n"
2032 "executing the following command as root:\n"
2033 " mknod /dev/ppp c 108 0\n";
2038 * Open a socket for doing the ioctl operations.
2040 s = socket(AF_INET, SOCK_DGRAM, 0);
2044 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2045 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2047 * If the device did not exist then attempt to create one by putting the
2048 * current tty into the PPP discipline. If this works then obtain the
2049 * flags for the device again.
2052 if (ppp_registered()) {
2053 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2054 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2058 * Ensure that the hardware address is for PPP and not something else
2061 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2063 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2067 * This is the PPP device. Validate the version of the driver at this
2068 * point to ensure that this program will work with the driver.
2071 char abBuffer [1024];
2073 ifr.ifr_data = abBuffer;
2074 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2076 error("Couldn't read driver version: %m");
2078 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2081 decode_version(abBuffer,
2083 &driver_modification,
2086 * Validate the version of the driver against the version that we used.
2088 decode_version(VERSION,
2093 /* The version numbers must match */
2094 if (driver_version != my_version)
2097 /* The modification levels must be legal */
2098 if (driver_modification < 3) {
2099 if (driver_modification >= 2) {
2100 /* we can cope with 2.2.0 and above */
2109 slprintf(route_buffer, sizeof(route_buffer),
2110 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2111 driver_version, driver_modification, driver_patch);
2113 no_ppp_msg = route_buffer;
2120 /********************************************************************
2122 * Update the wtmp file with the appropriate user name and tty device.
2125 void logwtmp (const char *line, const char *name, const char *host)
2127 struct utmp ut, *utp;
2128 pid_t mypid = getpid();
2134 * Update the signon database for users.
2135 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2137 utmpname(_PATH_UTMP);
2139 while ((utp = getutent()) && (utp->ut_pid != mypid))
2143 memcpy(&ut, utp, sizeof(ut));
2145 /* some gettys/telnetds don't initialize utmp... */
2146 memset(&ut, 0, sizeof(ut));
2148 if (ut.ut_id[0] == 0)
2149 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2151 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2152 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2156 ut.ut_type = USER_PROCESS;
2159 /* Insert the host name if one is supplied */
2161 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2163 /* Insert the IP address of the remote system if IP is enabled */
2164 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2165 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2166 sizeof(ut.ut_addr));
2168 /* CL: Makes sure that the logout works */
2169 if (*host == 0 && *name==0)
2175 * Update the wtmp file.
2178 updwtmp(_PATH_WTMP, &ut);
2180 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2182 flock(wtmp, LOCK_EX);
2184 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2185 warn("error writing %s: %m", _PATH_WTMP);
2187 flock(wtmp, LOCK_UN);
2195 /********************************************************************
2197 * sifvjcomp - config tcp header compression
2200 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2205 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2206 error("Couldn't set up TCP header compression: %m");
2210 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2211 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2216 /********************************************************************
2218 * sifup - Config the interface up and enable IP packets to pass.
2225 memset (&ifr, '\0', sizeof (ifr));
2226 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2227 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2228 if (! ok_error (errno))
2229 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2233 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2234 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2235 if (! ok_error (errno))
2236 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2244 /********************************************************************
2246 * sifdown - Disable the indicated protocol and config the interface
2247 * down if there are no remaining protocols.
2254 if (if_is_up && --if_is_up > 0)
2257 memset (&ifr, '\0', sizeof (ifr));
2258 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2259 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2260 if (! ok_error (errno))
2261 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2265 ifr.ifr_flags &= ~IFF_UP;
2266 ifr.ifr_flags |= IFF_POINTOPOINT;
2267 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2268 if (! ok_error (errno))
2269 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2275 /********************************************************************
2277 * sifaddr - Config the interface IP addresses and netmask.
2280 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2286 memset (&ifr, '\0', sizeof (ifr));
2287 memset (&rt, '\0', sizeof (rt));
2289 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2290 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2291 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2293 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2295 * Set our IP address
2297 SIN_ADDR(ifr.ifr_addr) = our_adr;
2298 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2299 if (errno != EEXIST) {
2300 if (! ok_error (errno))
2301 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2304 warn("ioctl(SIOCSIFADDR): Address already exists");
2309 * Set the gateway address
2311 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2312 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2313 if (! ok_error (errno))
2314 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2319 * For recent kernels, force the netmask to 255.255.255.255.
2321 if (kernel_version >= KVERSION(2,1,16))
2323 if (net_mask != 0) {
2324 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2325 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2326 if (! ok_error (errno))
2327 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2332 * Add the device route
2334 if (kernel_version < KVERSION(2,1,16)) {
2335 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2336 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2339 SIN_ADDR(rt.rt_gateway) = 0L;
2340 SIN_ADDR(rt.rt_dst) = his_adr;
2341 rt.rt_flags = RTF_UP | RTF_HOST;
2343 if (kernel_version > KVERSION(2,1,0)) {
2344 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2345 SIN_ADDR(rt.rt_genmask) = -1L;
2348 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2349 if (! ok_error (errno))
2350 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2355 /* set ip_dynaddr in demand mode if address changes */
2356 if (demand && tune_kernel && !dynaddr_set
2357 && our_old_addr && our_old_addr != our_adr) {
2358 /* set ip_dynaddr if possible */
2362 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2363 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2364 if (write(fd, "1", 1) != 1)
2365 error("Couldn't enable dynamic IP addressing: %m");
2368 dynaddr_set = 1; /* only 1 attempt */
2375 /********************************************************************
2377 * cifaddr - Clear the interface IP addresses, and delete routes
2378 * through the interface if possible.
2381 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2385 if (kernel_version < KVERSION(2,1,16)) {
2387 * Delete the route through the device
2390 memset (&rt, '\0', sizeof (rt));
2392 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2393 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2396 SIN_ADDR(rt.rt_gateway) = 0;
2397 SIN_ADDR(rt.rt_dst) = his_adr;
2398 rt.rt_flags = RTF_UP | RTF_HOST;
2400 if (kernel_version > KVERSION(2,1,0)) {
2401 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2402 SIN_ADDR(rt.rt_genmask) = -1L;
2405 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2406 if (still_ppp() && ! ok_error (errno))
2407 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2412 /* This way it is possible to have an IPX-only or IPv6-only interface */
2413 memset(&ifr, 0, sizeof(ifr));
2414 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2415 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2417 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2418 if (! ok_error (errno)) {
2419 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2424 our_old_addr = our_adr;
2430 /********************************************************************
2432 * sif6addr - Config the interface with an IPv6 link-local address
2434 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2436 struct in6_ifreq ifr6;
2438 struct in6_rtmsg rt6;
2442 error("IPv6 socket creation failed: %m");
2445 memset(&ifr, 0, sizeof (ifr));
2446 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2447 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2448 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2452 /* Local interface */
2453 memset(&ifr6, 0, sizeof(ifr6));
2454 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2455 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2456 ifr6.ifr6_prefixlen = 10;
2458 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2459 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2463 /* Route to remote host */
2464 memset(&rt6, 0, sizeof(rt6));
2465 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2466 rt6.rtmsg_flags = RTF_UP;
2467 rt6.rtmsg_dst_len = 10;
2468 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2469 rt6.rtmsg_metric = 1;
2471 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2472 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2480 /********************************************************************
2482 * cif6addr - Remove IPv6 address from interface
2484 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2487 struct in6_ifreq ifr6;
2491 error("IPv6 socket creation failed: %m");
2494 memset(&ifr, 0, sizeof(ifr));
2495 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2496 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2497 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2501 memset(&ifr6, 0, sizeof(ifr6));
2502 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2503 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2504 ifr6.ifr6_prefixlen = 10;
2506 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2507 if (errno != EADDRNOTAVAIL) {
2508 if (! ok_error (errno))
2509 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2512 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2521 * get_pty - get a pty master/slave pair and chown the slave side
2522 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2525 get_pty(master_fdp, slave_fdp, slave_name, uid)
2531 int i, mfd, sfd = -1;
2533 struct termios tios;
2537 * Try the unix98 way first.
2539 mfd = open("/dev/ptmx", O_RDWR);
2542 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2543 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2544 chmod(pty_name, S_IRUSR | S_IWUSR);
2547 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2548 warn("Couldn't unlock pty slave %s: %m", pty_name);
2550 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2551 warn("Couldn't open pty slave %s: %m", pty_name);
2554 #endif /* TIOCGPTN */
2557 /* the old way - scan through the pty name space */
2558 for (i = 0; i < 64; ++i) {
2559 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2560 'p' + i / 16, i % 16);
2561 mfd = open(pty_name, O_RDWR, 0);
2564 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2566 fchown(sfd, uid, -1);
2567 fchmod(sfd, S_IRUSR | S_IWUSR);
2578 strlcpy(slave_name, pty_name, 16);
2581 if (tcgetattr(sfd, &tios) == 0) {
2582 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2583 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2584 tios.c_iflag = IGNPAR;
2587 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2588 warn("couldn't set attributes on pty: %m");
2590 warn("couldn't get attributes on pty: %m");
2595 /********************************************************************
2597 * open_loopback - open the device we use for getting packets
2598 * in demand mode. Under Linux, we use a pty master/slave pair.
2601 open_ppp_loopback(void)
2606 if (new_style_driver) {
2607 /* allocate ourselves a ppp unit */
2608 if (make_ppp_unit() < 0)
2610 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2611 set_kdebugflag(kdebugflag);
2616 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2617 fatal("No free pty for loopback");
2619 set_ppp_fd(slave_fd);
2621 flags = fcntl(master_fd, F_GETFL);
2623 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2624 warn("couldn't set master loopback to nonblock: %m");
2626 flags = fcntl(ppp_fd, F_GETFL);
2628 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2629 warn("couldn't set slave loopback to nonblock: %m");
2631 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2632 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2634 * Find out which interface we were given.
2636 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2637 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2639 * Enable debug in the driver if requested.
2641 set_kdebugflag (kdebugflag);
2646 /********************************************************************
2648 * sifnpmode - Set the mode for handling packets for a given NP.
2652 sifnpmode(u, proto, mode)
2659 npi.protocol = proto;
2661 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2662 if (! ok_error (errno))
2663 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2670 /********************************************************************
2672 * sipxfaddr - Config the interface IPX networknumber
2675 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2682 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2684 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2686 if (! ok_error (errno))
2687 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2691 memset (&ifr, '\0', sizeof (ifr));
2692 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2694 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2695 sipx->sipx_family = AF_IPX;
2696 sipx->sipx_port = 0;
2697 sipx->sipx_network = htonl (network);
2698 sipx->sipx_type = IPX_FRAME_ETHERII;
2699 sipx->sipx_action = IPX_CRTITF;
2701 * Set the IPX device
2703 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2705 if (errno != EEXIST) {
2706 if (! ok_error (errno))
2707 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2710 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2719 /********************************************************************
2721 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2722 * are removed and the device is no longer able to pass IPX
2726 int cipxfaddr (int unit)
2733 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2735 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2737 if (! ok_error (errno))
2738 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2742 memset (&ifr, '\0', sizeof (ifr));
2743 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2745 sipx->sipx_type = IPX_FRAME_ETHERII;
2746 sipx->sipx_action = IPX_DLTITF;
2747 sipx->sipx_family = AF_IPX;
2749 * Set the IPX device
2751 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2752 if (! ok_error (errno))
2753 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2763 * Use the hostname as part of the random number seed.
2772 for (p = hostname; *p != 0; ++p)
2777 /********************************************************************
2779 * sys_check_options - check the options that the user specified
2783 sys_check_options(void)
2787 * Disable the IPX protocol if the support is not present in the kernel.
2791 if (ipxcp_protent.enabled_flag) {
2792 struct stat stat_buf;
2793 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2794 || lstat(path, &stat_buf) < 0) {
2795 error("IPX support is not present in the kernel\n");
2796 ipxcp_protent.enabled_flag = 0;
2800 if (demand && driver_is_old) {
2801 option_error("demand dialling is not supported by kernel driver "
2802 "version %d.%d.%d", driver_version, driver_modification,
2806 if (multilink && !new_style_driver) {
2807 warn("Warning: multilink is not supported by the kernel driver");
2815 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2817 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2818 * that the system has a properly configured Ethernet interface for this
2819 * function to return non-zero.
2822 ether_to_eui64(eui64_t *p_eui64)
2826 const unsigned char *ptr;
2828 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2831 warn("could not open IPv6 socket");
2835 strcpy(ifr.ifr_name, "eth0");
2836 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2839 warn("could not obtain hardware address for eth0");
2845 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2847 ptr = ifr.ifr_hwaddr.sa_data;
2848 p_eui64->e8[0] = ptr[0] | 0x02;
2849 p_eui64->e8[1] = ptr[1];
2850 p_eui64->e8[2] = ptr[2];
2851 p_eui64->e8[3] = 0xFF;
2852 p_eui64->e8[4] = 0xFE;
2853 p_eui64->e8[5] = ptr[3];
2854 p_eui64->e8[6] = ptr[4];
2855 p_eui64->e8[7] = ptr[5];