2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1994-2002 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. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
19 * 3. The name(s) of the authors of this software must not be used to
20 * endorse or promote products derived from this software without
21 * prior written permission.
23 * 4. Redistributions of any form whatsoever must retain the following
25 * "This product includes software developed by Paul Mackerras
26 * <paulus@samba.org>".
28 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
29 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
30 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
31 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
32 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
33 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
34 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
36 * Derived from main.c and pppd.h, which are:
38 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
44 * 1. Redistributions of source code must retain the above copyright
45 * notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 * notice, this list of conditions and the following disclaimer in
49 * the documentation and/or other materials provided with the
52 * 3. The name "Carnegie Mellon University" must not be used to
53 * endorse or promote products derived from this software without
54 * prior written permission. For permission or any legal
55 * details, please contact
56 * Office of Technology Transfer
57 * Carnegie Mellon University
59 * Pittsburgh, PA 15213-3890
60 * (412) 268-4387, fax: (412) 268-7395
61 * tech-transfer@andrew.cmu.edu
63 * 4. Redistributions of any form whatsoever must retain the following
65 * "This product includes software developed by Computing Services
66 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
68 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
69 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
70 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
71 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
72 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
73 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
74 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
77 #include <sys/ioctl.h>
78 #include <sys/types.h>
79 #include <sys/socket.h>
81 #include <sys/errno.h>
84 #include <sys/utsname.h>
85 #include <sys/sysmacros.h>
101 /* This is in netdevice.h. However, this compile will fail miserably if
102 you attempt to include netdevice.h because it has so many references
103 to __memcpy functions which it should not attempt to do. So, since I
104 really don't use it, but it must be defined, define it now. */
107 #define MAX_ADDR_LEN 7
111 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
113 #include <net/if_arp.h>
114 #include <net/route.h>
115 #include <netinet/if_ether.h>
117 #include <linux/types.h>
118 #include <linux/if.h>
119 #include <linux/if_arp.h>
120 #include <linux/route.h>
121 #include <linux/if_ether.h>
123 #include <netinet/in.h>
124 #include <arpa/inet.h>
126 #include <linux/ppp_defs.h>
127 #include <linux/if_ppp.h>
135 #if __GLIBC__ >= 2 && \
136 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
137 #include <netipx/ipx.h>
139 #include <linux/ipx.h>
141 #endif /* IPX_CHANGE */
145 #include <linux/filter.h>
146 #endif /* PPP_FILTER */
149 #include <sys/locks.h>
155 * This is in linux/include/net/ipv6.h.
159 struct in6_addr ifr6_addr;
160 __u32 ifr6_prefixlen;
161 unsigned int ifr6_ifindex;
165 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
166 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
167 sin6.s6_addr16[0] = htons(0xfe80); \
168 eui64_copy(eui64, sin6.s6_addr32[2]); \
173 /* We can get an EIO error on an ioctl if the modem has hung up */
174 #define ok_error(num) ((num)==EIO)
176 static int tty_disc = N_TTY; /* The TTY discipline */
177 static int ppp_disc = N_PPP; /* The PPP discpline */
178 static int initfdflags = -1; /* Initial file descriptor flags for fd */
179 static int ppp_fd = -1; /* fd which is set to PPP discipline */
180 static int sock_fd = -1; /* socket for doing interface ioctls */
181 static int slave_fd = -1;
182 static int master_fd = -1;
184 static int sock6_fd = -1;
188 * For the old-style kernel driver, this is the same as ppp_fd.
189 * For the new-style driver, it is the fd of an instance of /dev/ppp
190 * which is attached to the ppp unit and is used for controlling it.
192 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
194 static int chindex; /* channel index (new style driver) */
196 static fd_set in_fds; /* set of fds that wait_input waits for */
197 static int max_in_fd; /* highest fd set in in_fds */
199 static int has_proxy_arp = 0;
200 static int driver_version = 0;
201 static int driver_modification = 0;
202 static int driver_patch = 0;
203 static int driver_is_old = 0;
204 static int restore_term = 0; /* 1 => we've munged the terminal */
205 static struct termios inittermios; /* Initial TTY termios */
207 int new_style_driver = 0;
209 static char loop_name[20];
210 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
212 static int if_is_up; /* Interface has been marked up */
213 static u_int32_t default_route_gateway; /* Gateway for default route added */
214 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
215 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
216 static u_int32_t our_old_addr; /* for detecting address changes */
217 static int dynaddr_set; /* 1 if ip_dynaddr set */
218 static int looped; /* 1 if using loop */
219 static int link_mtu; /* mtu for the link (not bundle) */
221 static struct utsname utsname; /* for the kernel version */
222 static int kernel_version;
223 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
227 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
228 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
229 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
231 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
233 /* Prototypes for procedures local to this file. */
234 static int modify_flags(int fd, int clear_bits, int set_bits);
235 static int translate_speed (int bps);
236 static int baud_rate_of (int speed);
237 static void close_route_table (void);
238 static int open_route_table (void);
239 static int read_route_table (struct rtentry *rt);
240 static int defaultroute_exists (struct rtentry *rt);
241 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
242 char *name, int namelen);
243 static void decode_version (char *buf, int *version, int *mod, int *patch);
244 static int set_kdebugflag(int level);
245 static int ppp_registered(void);
246 static int make_ppp_unit(void);
248 extern u_char inpacket_buf[]; /* borrowed from main.c */
251 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
255 #define SET_SA_FAMILY(addr, family) \
256 memset ((char *) &(addr), '\0', sizeof(addr)); \
257 addr.sa_family = (family);
260 * Determine if the PPP connection should still be present.
265 /* new_fd is the fd of a tty */
266 static void set_ppp_fd (int new_fd)
268 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
270 if (!new_style_driver)
274 static int still_ppp(void)
276 if (new_style_driver)
277 return !hungup && ppp_fd >= 0;
278 if (!hungup || ppp_fd == slave_fd)
281 set_ppp_fd(slave_fd);
288 * modify_flags - set and clear flag bits controlling the kernel
291 static int modify_flags(int fd, int clear_bits, int set_bits)
295 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
297 flags = (flags & ~clear_bits) | set_bits;
298 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
305 error("Failed to set PPP kernel option flags: %m");
309 /********************************************************************
311 * sys_init - System-dependent initialization.
316 /* Get an internet socket for doing socket ioctls. */
317 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
319 fatal("Couldn't create IP socket: %m(%d)", errno);
322 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
324 sock6_fd = -errno; /* save errno for later */
331 /********************************************************************
333 * sys_cleanup - restore any system state we modified before exiting:
334 * mark the interface down, delete default route and/or proxy arp entry.
335 * This shouldn't call die() because it's called from die().
338 void sys_cleanup(void)
341 * Take down the device
348 * Delete any routes through the device.
350 if (default_route_gateway != 0)
351 cifdefaultroute(0, 0, default_route_gateway);
354 cifproxyarp(0, proxy_arp_addr);
357 /********************************************************************
359 * sys_close - Clean up in a child process before execing.
364 if (new_style_driver && ppp_dev_fd >= 0)
378 /********************************************************************
380 * set_kdebugflag - Define the debugging level for the kernel
383 static int set_kdebugflag (int requested_level)
387 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
388 if ( ! ok_error (errno) )
389 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
392 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
397 /********************************************************************
399 * tty_establish_ppp - Turn the serial port into a ppp interface.
402 int tty_establish_ppp (int tty_fd)
407 * Ensure that the tty device is in exclusive mode.
409 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
410 if ( ! ok_error ( errno ))
411 warn("Couldn't make tty exclusive: %m");
414 * Demand mode - prime the old ppp device to relinquish the unit.
416 if (!new_style_driver && looped
417 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
418 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
422 * Set the current tty to the PPP discpline
426 #define N_SYNC_PPP 14
428 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
429 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
430 if ( ! ok_error (errno) ) {
431 error("Couldn't set tty to PPP discipline: %m");
436 ret_fd = generic_establish_ppp(tty_fd);
438 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
439 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
443 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
444 (kdebugflag * SC_DEBUG) & SC_LOGB);
446 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
447 warn("Couldn't reset tty to normal line discipline: %m");
453 /********************************************************************
455 * generic_establish_ppp - Turn the fd into a ppp interface.
457 int generic_establish_ppp (int fd)
461 if (new_style_driver) {
464 /* Open an instance of /dev/ppp and connect the channel to it */
465 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
466 error("Couldn't get channel number: %m");
469 dbglog("using channel %d", chindex);
470 fd = open("/dev/ppp", O_RDWR);
472 error("Couldn't reopen /dev/ppp: %m");
475 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
476 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
477 error("Couldn't attach to channel %d: %m", chindex);
480 flags = fcntl(fd, F_GETFL);
481 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
482 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
487 if (!looped && !multilink) {
489 * Create a new PPP unit.
491 if (make_ppp_unit() < 0)
496 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
500 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
501 error("Couldn't attach to PPP unit %d: %m", ifunit);
508 * Old-style driver: find out which interface we were given.
511 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
512 if (ok_error (errno))
514 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
516 /* Check that we got the same unit again. */
517 if (looped && x != ifunit)
518 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
522 * Fetch the initial file flags and reset blocking mode on the file.
524 initfdflags = fcntl(fd, F_GETFL);
525 if (initfdflags == -1 ||
526 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
527 if ( ! ok_error (errno))
528 warn("Couldn't set device to non-blocking mode: %m");
533 * Enable debug in the driver if requested.
536 set_kdebugflag (kdebugflag);
540 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
541 driver_version, driver_modification, driver_patch));
551 /********************************************************************
553 * tty_disestablish_ppp - Restore the serial port to normal operation.
554 * This shouldn't call die() because it's called from die().
557 void tty_disestablish_ppp(int tty_fd)
561 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
563 if (tcflush(tty_fd, TCIOFLUSH) < 0)
565 warn("tcflush failed: %m");
569 * Restore the previous line discipline
571 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
572 if ( ! ok_error (errno))
573 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
576 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
577 if ( ! ok_error (errno))
578 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
581 /* Reset non-blocking mode on fd. */
582 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
583 if ( ! ok_error (errno))
584 warn("Couldn't restore device fd flags: %m");
590 generic_disestablish_ppp(tty_fd);
593 /********************************************************************
595 * generic_disestablish_ppp - Restore device components to normal
596 * operation, and reconnect the ppp unit to the loopback if in demand
597 * mode. This shouldn't call die() because it's called from die().
599 void generic_disestablish_ppp(int dev_fd)
601 if (new_style_driver) {
605 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
607 } else if (ppp_dev_fd >= 0) {
609 remove_fd(ppp_dev_fd);
613 /* old-style driver */
615 set_ppp_fd(slave_fd);
622 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
623 * Assumes new_style_driver.
625 static int make_ppp_unit()
629 if (ppp_dev_fd >= 0) {
630 dbglog("in make_ppp_unit, already had /dev/ppp open?");
633 ppp_dev_fd = open("/dev/ppp", O_RDWR);
635 fatal("Couldn't open /dev/ppp: %m");
636 flags = fcntl(ppp_dev_fd, F_GETFL);
638 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
639 warn("Couldn't set /dev/ppp to nonblock: %m");
642 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
643 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
644 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
646 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
649 error("Couldn't create new ppp unit: %m");
654 * cfg_bundle - configure the existing bundle.
655 * Used in demand mode.
657 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
659 if (!new_style_driver)
662 /* set the mrru, mtu and flags */
663 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
664 error("Couldn't set MRRU: %m");
666 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
667 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
668 | (mrru? SC_MULTILINK: 0)));
670 /* connect up the channel */
671 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
672 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
677 * make_new_bundle - create a new PPP unit (i.e. a bundle)
678 * and connect our channel to it. This should only get called
679 * if `multilink' was set at the time establish_ppp was called.
680 * In demand mode this uses our existing bundle instead of making
683 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
685 if (!new_style_driver)
688 /* make us a ppp unit */
689 if (make_ppp_unit() < 0)
692 /* set the mrru and flags */
693 cfg_bundle(mrru, mtru, rssn, tssn);
697 * bundle_attach - attach our link to a given PPP unit.
698 * We assume the unit is controlled by another pppd.
700 int bundle_attach(int ifnum)
704 if (!new_style_driver)
707 master_fd = open("/dev/ppp", O_RDWR);
709 fatal("Couldn't open /dev/ppp: %m");
710 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
711 if (errno == ENXIO) {
713 return 0; /* doesn't still exist */
715 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
717 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
718 fatal("Couldn't connect to interface unit %d: %m", ifnum);
719 modify_flags(master_fd, 0, SC_MULTILINK);
726 /********************************************************************
728 * clean_check - Fetch the flags for the device and generate
729 * appropriate error messages.
731 void clean_check(void)
737 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
739 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
741 s = "all had bit 7 set to 1";
745 s = "all had bit 7 set to 0";
749 s = "all had odd parity";
753 s = "all had even parity";
758 warn("Receive serial link is not 8-bit clean:");
759 warn("Problem: %s", s);
767 * List of valid speeds.
771 int speed_int, speed_val;
854 /********************************************************************
856 * Translate from bits/second to a speed_t.
859 static int translate_speed (int bps)
861 struct speed *speedp;
864 for (speedp = speeds; speedp->speed_int; speedp++) {
865 if (bps == speedp->speed_int)
866 return speedp->speed_val;
868 warn("speed %d not supported", bps);
873 /********************************************************************
875 * Translate from a speed_t to bits/second.
878 static int baud_rate_of (int speed)
880 struct speed *speedp;
883 for (speedp = speeds; speedp->speed_int; speedp++) {
884 if (speed == speedp->speed_val)
885 return speedp->speed_int;
891 /********************************************************************
893 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
894 * at the requested speed, etc. If `local' is true, set CLOCAL
895 * regardless of whether the modem option was specified.
898 void set_up_tty(int tty_fd, int local)
904 if (tcgetattr(tty_fd, &tios) < 0) {
905 if (!ok_error(errno))
906 fatal("tcgetattr: %m (line %d)", __LINE__);
913 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
914 tios.c_cflag |= CS8 | CREAD | HUPCL;
916 tios.c_iflag = IGNBRK | IGNPAR;
920 tios.c_cc[VTIME] = 0;
923 tios.c_cflag ^= (CLOCAL | HUPCL);
927 tios.c_cflag |= CRTSCTS;
931 tios.c_iflag |= IXON | IXOFF;
932 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
933 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
937 tios.c_cflag &= ~CRTSCTS;
944 speed = translate_speed(inspeed);
946 cfsetospeed (&tios, speed);
947 cfsetispeed (&tios, speed);
950 * We can't proceed if the serial port speed is B0,
951 * since that implies that the serial port is disabled.
954 speed = cfgetospeed(&tios);
956 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
959 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
960 if (!ok_error(errno))
961 fatal("tcsetattr: %m (line %d)", __LINE__);
963 baud_rate = baud_rate_of(speed);
967 /********************************************************************
969 * setdtr - control the DTR line on the serial port.
970 * This is called from die(), so it shouldn't call die().
973 void setdtr (int tty_fd, int on)
975 int modembits = TIOCM_DTR;
977 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
980 /********************************************************************
982 * restore_tty - restore the terminal to the saved settings.
985 void restore_tty (int tty_fd)
990 * Turn off echoing, because otherwise we can get into
991 * a loop with the tty and the modem echoing to each other.
992 * We presume we are the sole user of this tty device, so
993 * when we close it, it will revert to its defaults anyway.
996 inittermios.c_lflag &= ~(ECHO | ECHONL);
998 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
999 if (! ok_error (errno))
1000 warn("tcsetattr: %m (line %d)", __LINE__);
1005 /********************************************************************
1007 * output - Output PPP packet.
1010 void output (int unit, unsigned char *p, int len)
1015 dump_packet("sent", p, len);
1016 if (snoop_send_hook) snoop_send_hook(p, len);
1018 if (len < PPP_HDRLEN)
1020 if (new_style_driver) {
1023 proto = (p[0] << 8) + p[1];
1024 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1027 if (write(fd, p, len) < 0) {
1028 if (errno == EWOULDBLOCK || errno == ENOBUFS
1029 || errno == ENXIO || errno == EIO || errno == EINTR)
1030 warn("write: warning: %m (%d)", errno);
1032 error("write: %m (%d)", errno);
1036 /********************************************************************
1038 * wait_input - wait until there is data available,
1039 * for the length of time specified by *timo (indefinite
1043 void wait_input(struct timeval *timo)
1050 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1051 if (n < 0 && errno != EINTR)
1052 fatal("select: %m");
1056 * add_fd - add an fd to the set that wait_input waits for.
1060 if (fd >= FD_SETSIZE)
1061 fatal("internal error: file descriptor too large (%d)", fd);
1062 FD_SET(fd, &in_fds);
1068 * remove_fd - remove an fd from the set that wait_input waits for.
1070 void remove_fd(int fd)
1072 FD_CLR(fd, &in_fds);
1076 /********************************************************************
1078 * read_packet - get a PPP packet from the serial device.
1081 int read_packet (unsigned char *buf)
1085 len = PPP_MRU + PPP_HDRLEN;
1086 if (new_style_driver) {
1087 *buf++ = PPP_ALLSTATIONS;
1093 nr = read(ppp_fd, buf, len);
1094 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1096 if (nr < 0 && errno == ENXIO)
1099 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0) {
1100 /* N.B. we read ppp_fd first since LCP packets come in there. */
1101 nr = read(ppp_dev_fd, buf, len);
1102 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1103 error("read /dev/ppp: %m");
1104 if (nr < 0 && errno == ENXIO)
1107 return (new_style_driver && nr > 0)? nr+2: nr;
1110 /********************************************************************
1112 * get_loop_output - get outgoing packets from the ppp device,
1113 * and detect when we want to bring the real link up.
1114 * Return value is 1 if we need to bring up the link, 0 otherwise.
1117 get_loop_output(void)
1122 if (new_style_driver) {
1123 while ((n = read_packet(inpacket_buf)) > 0)
1124 if (loop_frame(inpacket_buf, n))
1129 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1130 if (loop_chars(inbuf, n))
1134 fatal("eof on loopback");
1136 if (errno != EWOULDBLOCK)
1137 fatal("read from loopback: %m(%d)", errno);
1143 * netif_set_mtu - set the MTU on the PPP network interface.
1146 netif_set_mtu(int unit, int mtu)
1150 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1152 memset (&ifr, '\0', sizeof (ifr));
1153 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1156 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1157 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1161 * netif_get_mtu - get the MTU on the PPP network interface.
1164 netif_get_mtu(int unit)
1168 memset (&ifr, '\0', sizeof (ifr));
1169 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1171 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1172 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1178 /********************************************************************
1180 * tty_send_config - configure the transmit characteristics of
1181 * the ppp interface.
1184 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1191 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1192 if (errno != EIO && errno != ENOTTY)
1193 error("Couldn't set transmit async character map: %m");
1198 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1199 | (sync_serial? SC_SYNC: 0);
1200 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1203 /********************************************************************
1205 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1208 void tty_set_xaccm (ext_accm accm)
1210 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1211 accm[0], accm[1], accm[2], accm[3]));
1215 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1216 if ( ! ok_error (errno))
1217 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1221 /********************************************************************
1223 * tty_recv_config - configure the receive-side characteristics of
1224 * the ppp interface.
1227 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1230 * If we were called because the link has gone down then there is nothing
1231 * which may be done. Just return without incident.
1236 * Set the receiver parameters
1238 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1239 if (errno != EIO && errno != ENOTTY)
1240 error("Couldn't set channel receive MRU: %m");
1242 if (new_style_driver && ppp_dev_fd >= 0
1243 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1244 error("Couldn't set MRU in generic PPP layer: %m");
1246 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1247 if (errno != EIO && errno != ENOTTY)
1248 error("Couldn't set channel receive asyncmap: %m");
1252 /********************************************************************
1254 * ccp_test - ask kernel whether a given compression method
1255 * is acceptable for use.
1259 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1261 struct ppp_option_data data;
1263 memset (&data, '\0', sizeof (data));
1265 data.length = opt_len;
1266 data.transmit = for_transmit;
1268 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1271 return (errno == ENOBUFS)? 0: -1;
1274 /********************************************************************
1276 * ccp_flags_set - inform kernel about the current state of CCP.
1279 void ccp_flags_set (int unit, int isopen, int isup)
1283 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1284 if (still_ppp() && ppp_dev_fd >= 0)
1285 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1290 * set_filters - set the active and pass filters in the kernel driver.
1292 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1294 struct sock_fprog fp;
1296 fp.len = pass->bf_len;
1297 fp.filter = (struct sock_filter *) pass->bf_insns;
1298 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1299 if (errno == ENOTTY)
1300 warn("kernel does not support PPP filtering");
1302 error("Couldn't set pass-filter in kernel: %m");
1305 fp.len = active->bf_len;
1306 fp.filter = (struct sock_filter *) active->bf_insns;
1307 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1308 error("Couldn't set active-filter in kernel: %m");
1313 #endif /* PPP_FILTER */
1315 /********************************************************************
1317 * get_idle_time - return how long the link has been idle.
1320 get_idle_time(u, ip)
1322 struct ppp_idle *ip;
1324 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1327 /********************************************************************
1329 * get_ppp_stats - return statistics for the link.
1332 get_ppp_stats(u, stats)
1334 struct pppd_stats *stats;
1336 struct ifpppstatsreq req;
1338 memset (&req, 0, sizeof (req));
1340 req.stats_ptr = (caddr_t) &req.stats;
1341 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1342 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1343 error("Couldn't get PPP statistics: %m");
1346 stats->bytes_in = req.stats.p.ppp_ibytes;
1347 stats->bytes_out = req.stats.p.ppp_obytes;
1348 stats->pkts_in = req.stats.p.ppp_ipackets;
1349 stats->pkts_out = req.stats.p.ppp_opackets;
1353 /********************************************************************
1355 * ccp_fatal_error - returns 1 if decompression was disabled as a
1356 * result of an error detected after decompression of a packet,
1357 * 0 otherwise. This is necessary because of patent nonsense.
1360 int ccp_fatal_error (int unit)
1364 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1365 error("Couldn't read compression error flags: %m");
1368 return flags & SC_DC_FERROR;
1371 /********************************************************************
1373 * path_to_procfs - find the path to the proc file system mount point
1375 static char proc_path[MAXPATHLEN];
1376 static int proc_path_len;
1378 static char *path_to_procfs(const char *tail)
1380 struct mntent *mntent;
1383 if (proc_path_len == 0) {
1384 /* Default the mount location of /proc */
1385 strlcpy (proc_path, "/proc", sizeof(proc_path));
1387 fp = fopen(MOUNTED, "r");
1389 while ((mntent = getmntent(fp)) != NULL) {
1390 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1392 if (strcmp(mntent->mnt_type, "proc") == 0) {
1393 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1394 proc_path_len = strlen(proc_path);
1402 strlcpy(proc_path + proc_path_len, tail,
1403 sizeof(proc_path) - proc_path_len);
1408 * /proc/net/route parsing stuff.
1410 #define ROUTE_MAX_COLS 12
1411 FILE *route_fd = (FILE *) 0;
1412 static char route_buffer[512];
1413 static int route_dev_col, route_dest_col, route_gw_col;
1414 static int route_flags_col, route_mask_col;
1415 static int route_num_cols;
1417 static int open_route_table (void);
1418 static void close_route_table (void);
1419 static int read_route_table (struct rtentry *rt);
1421 /********************************************************************
1423 * close_route_table - close the interface to the route table
1426 static void close_route_table (void)
1428 if (route_fd != (FILE *) 0) {
1430 route_fd = (FILE *) 0;
1434 /********************************************************************
1436 * open_route_table - open the interface to the route table
1438 static char route_delims[] = " \t\n";
1440 static int open_route_table (void)
1444 close_route_table();
1446 path = path_to_procfs("/net/route");
1447 route_fd = fopen (path, "r");
1448 if (route_fd == NULL) {
1449 error("can't open routing table %s: %m", path);
1453 route_dev_col = 0; /* default to usual columns */
1456 route_flags_col = 3;
1460 /* parse header line */
1461 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1462 char *p = route_buffer, *q;
1464 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1466 if ((q = strtok(p, route_delims)) == 0)
1468 if (strcasecmp(q, "iface") == 0)
1469 route_dev_col = col;
1470 else if (strcasecmp(q, "destination") == 0)
1471 route_dest_col = col;
1472 else if (strcasecmp(q, "gateway") == 0)
1474 else if (strcasecmp(q, "flags") == 0)
1475 route_flags_col = col;
1476 else if (strcasecmp(q, "mask") == 0)
1477 route_mask_col = col;
1480 if (used && col >= route_num_cols)
1481 route_num_cols = col + 1;
1489 /********************************************************************
1491 * read_route_table - read the next entry from the route table
1494 static int read_route_table(struct rtentry *rt)
1496 char *cols[ROUTE_MAX_COLS], *p;
1499 memset (rt, '\0', sizeof (struct rtentry));
1501 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1505 for (col = 0; col < route_num_cols; ++col) {
1506 cols[col] = strtok(p, route_delims);
1507 if (cols[col] == NULL)
1508 return 0; /* didn't get enough columns */
1512 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1513 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1514 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1516 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1517 rt->rt_dev = cols[route_dev_col];
1522 /********************************************************************
1524 * defaultroute_exists - determine if there is a default route
1527 static int defaultroute_exists (struct rtentry *rt)
1531 if (!open_route_table())
1534 while (read_route_table(rt) != 0) {
1535 if ((rt->rt_flags & RTF_UP) == 0)
1538 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1540 if (SIN_ADDR(rt->rt_dst) == 0L) {
1546 close_route_table();
1551 * have_route_to - determine if the system has any route to
1552 * a given IP address. `addr' is in network byte order.
1553 * Return value is 1 if yes, 0 if no, -1 if don't know.
1554 * For demand mode to work properly, we have to ignore routes
1555 * through our own interface.
1557 int have_route_to(u_int32_t addr)
1562 if (!open_route_table())
1563 return -1; /* don't know */
1565 while (read_route_table(&rt)) {
1566 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1568 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1574 close_route_table();
1578 /********************************************************************
1580 * sifdefaultroute - assign a default route through the address given.
1583 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1587 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1588 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1590 if (old_gateway != gateway)
1591 error("not replacing existing default route to %s [%I]",
1592 rt.rt_dev, old_gateway);
1596 memset (&rt, '\0', sizeof (rt));
1597 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1598 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1602 if (kernel_version > KVERSION(2,1,0)) {
1603 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1604 SIN_ADDR(rt.rt_genmask) = 0L;
1607 SIN_ADDR(rt.rt_gateway) = gateway;
1609 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1610 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1611 if ( ! ok_error ( errno ))
1612 error("default route ioctl(SIOCADDRT): %m");
1616 default_route_gateway = gateway;
1620 /********************************************************************
1622 * cifdefaultroute - delete a default route through the address given.
1625 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1629 default_route_gateway = 0;
1631 memset (&rt, '\0', sizeof (rt));
1632 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1633 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1635 if (kernel_version > KVERSION(2,1,0)) {
1636 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1637 SIN_ADDR(rt.rt_genmask) = 0L;
1640 SIN_ADDR(rt.rt_gateway) = gateway;
1642 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1643 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1645 if ( ! ok_error ( errno ))
1646 error("default route ioctl(SIOCDELRT): %m");
1654 /********************************************************************
1656 * sifproxyarp - Make a proxy ARP entry for the peer.
1659 int sifproxyarp (int unit, u_int32_t his_adr)
1661 struct arpreq arpreq;
1664 if (has_proxy_arp == 0) {
1665 memset (&arpreq, '\0', sizeof(arpreq));
1667 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1668 SIN_ADDR(arpreq.arp_pa) = his_adr;
1669 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1671 * Get the hardware address of an interface on the same subnet
1672 * as our local address.
1674 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1675 sizeof(proxy_arp_dev))) {
1676 error("Cannot determine ethernet address for proxy ARP");
1679 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1681 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1682 if ( ! ok_error ( errno ))
1683 error("ioctl(SIOCSARP): %m");
1686 proxy_arp_addr = his_adr;
1690 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1691 if (forw_path != 0) {
1692 int fd = open(forw_path, O_WRONLY);
1694 if (write(fd, "1", 1) != 1)
1695 error("Couldn't enable IP forwarding: %m");
1705 /********************************************************************
1707 * cifproxyarp - Delete the proxy ARP entry for the peer.
1710 int cifproxyarp (int unit, u_int32_t his_adr)
1712 struct arpreq arpreq;
1714 if (has_proxy_arp) {
1716 memset (&arpreq, '\0', sizeof(arpreq));
1717 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1718 SIN_ADDR(arpreq.arp_pa) = his_adr;
1719 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1720 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1722 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1723 if ( ! ok_error ( errno ))
1724 warn("ioctl(SIOCDARP): %m");
1731 /********************************************************************
1733 * get_ether_addr - get the hardware address of an interface on the
1734 * the same subnet as ipaddr.
1737 static int get_ether_addr (u_int32_t ipaddr,
1738 struct sockaddr *hwaddr,
1739 char *name, int namelen)
1741 struct ifreq *ifr, *ifend;
1742 u_int32_t ina, mask;
1744 struct ifreq ifreq, bestifreq;
1746 struct ifreq ifs[MAX_IFS];
1748 u_int32_t bestmask=0;
1749 int found_interface = 0;
1751 ifc.ifc_len = sizeof(ifs);
1753 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1754 if ( ! ok_error ( errno ))
1755 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1759 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1760 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1762 * Scan through looking for an interface with an Internet
1763 * address on the same subnet as `ipaddr'.
1765 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1766 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1767 if (ifr->ifr_addr.sa_family == AF_INET) {
1768 ina = SIN_ADDR(ifr->ifr_addr);
1769 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1770 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1773 * Check that the interface is up, and not point-to-point
1776 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1779 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1782 * Get its netmask and check that it's on the right subnet.
1784 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1787 mask = SIN_ADDR(ifreq.ifr_addr);
1788 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1789 ip_ntoa(ina), ntohl(mask)));
1791 if (((ipaddr ^ ina) & mask) != 0)
1792 continue; /* no match */
1794 if (mask >= bestmask) {
1795 /* Compare using >= instead of > -- it is possible for
1796 an interface to have a netmask of 0.0.0.0 */
1797 found_interface = 1;
1804 if (!found_interface) return 0;
1806 strlcpy(name, bestifreq.ifr_name, namelen);
1808 /* trim off the :1 in eth0:1 */
1809 aliasp = strchr(name, ':');
1813 info("found interface %s for proxy arp", name);
1815 * Now get the hardware address.
1817 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1818 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1819 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1824 &bestifreq.ifr_hwaddr,
1825 sizeof (struct sockaddr));
1827 SYSDEBUG ((LOG_DEBUG,
1828 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1829 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1830 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1831 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1832 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1833 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1834 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1835 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1836 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1841 * get_if_hwaddr - get the hardware address for the specified
1842 * network interface device.
1845 get_if_hwaddr(u_char *addr, char *name)
1850 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1853 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1854 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1855 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1858 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1863 * get_first_ethernet - return the name of the first ethernet-style
1864 * interface on this system.
1867 get_first_ethernet()
1872 /********************************************************************
1874 * Return user specified netmask, modified by any mask we might determine
1875 * for address `addr' (in network byte order).
1876 * Here we scan through the system's list of interfaces, looking for
1877 * any non-point-to-point interfaces which might appear to be on the same
1878 * network as `addr'. If we find any, we OR in their netmask to the
1879 * user-specified netmask.
1882 u_int32_t GetMask (u_int32_t addr)
1884 u_int32_t mask, nmask, ina;
1885 struct ifreq *ifr, *ifend, ifreq;
1887 struct ifreq ifs[MAX_IFS];
1891 if (IN_CLASSA(addr)) /* determine network mask for address class */
1892 nmask = IN_CLASSA_NET;
1893 else if (IN_CLASSB(addr))
1894 nmask = IN_CLASSB_NET;
1896 nmask = IN_CLASSC_NET;
1898 /* class D nets are disallowed by bad_ip_adrs */
1899 mask = netmask | htonl(nmask);
1901 * Scan through the system's network interfaces.
1903 ifc.ifc_len = sizeof(ifs);
1905 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1906 if ( ! ok_error ( errno ))
1907 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1911 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1912 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1914 * Check the interface's internet address.
1916 if (ifr->ifr_addr.sa_family != AF_INET)
1918 ina = SIN_ADDR(ifr->ifr_addr);
1919 if (((ntohl(ina) ^ addr) & nmask) != 0)
1922 * Check that the interface is up, and not point-to-point nor loopback.
1924 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1925 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1928 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1931 * Get its netmask and OR it into our mask.
1933 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1935 mask |= SIN_ADDR(ifreq.ifr_addr);
1941 /********************************************************************
1943 * Internal routine to decode the version.modification.patch level
1946 static void decode_version (char *buf, int *version,
1947 int *modification, int *patch)
1951 *version = (int) strtoul (buf, &endp, 10);
1955 if (endp != buf && *endp == '.') {
1957 *modification = (int) strtoul (buf, &endp, 10);
1958 if (endp != buf && *endp == '.') {
1960 *patch = (int) strtoul (buf, &buf, 10);
1965 /********************************************************************
1967 * Procedure to determine if the PPP line discipline is registered.
1971 ppp_registered(void)
1979 * We used to open the serial device and set it to the ppp line
1980 * discipline here, in order to create a ppp unit. But that is
1981 * not a good idea - the user might have specified a device that
1982 * they can't open (permission, or maybe it doesn't really exist).
1983 * So we grab a pty master/slave pair and use that.
1985 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1986 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1991 * Try to put the device into the PPP discipline.
1993 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1994 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2003 /********************************************************************
2005 * ppp_available - check whether the system has any ppp interfaces
2006 * (in fact we check whether we can do an ioctl on ppp0).
2009 int ppp_available(void)
2014 int my_version, my_modification, my_patch;
2015 int osmaj, osmin, ospatch;
2018 "This system lacks kernel support for PPP. This could be because\n"
2019 "the PPP kernel module could not be loaded, or because PPP was not\n"
2020 "included in the kernel configuration. If PPP was included as a\n"
2021 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2022 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2023 "See README.linux file in the ppp distribution for more details.\n";
2025 /* get the kernel version now, since we are called before sys_init */
2027 osmaj = osmin = ospatch = 0;
2028 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2029 kernel_version = KVERSION(osmaj, osmin, ospatch);
2031 fd = open("/dev/ppp", O_RDWR);
2033 if (fd < 0 && errno == ENOENT) {
2034 /* try making it and see if that helps. */
2035 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
2036 makedev(108, 0)) >= 0) {
2037 fd = open("/dev/ppp", O_RDWR);
2039 info("Created /dev/ppp device node");
2041 unlink("/dev/ppp"); /* didn't work, undo the mknod */
2042 } else if (errno == EEXIST) {
2043 fd = open("/dev/ppp", O_RDWR);
2048 new_style_driver = 1;
2050 /* XXX should get from driver */
2052 driver_modification = 4;
2057 if (kernel_version >= KVERSION(2,3,13)) {
2058 if (errno == ENOENT)
2060 "pppd is unable to open the /dev/ppp device.\n"
2061 "You need to create the /dev/ppp device node by\n"
2062 "executing the following command as root:\n"
2063 " mknod /dev/ppp c 108 0\n";
2068 * Open a socket for doing the ioctl operations.
2070 s = socket(AF_INET, SOCK_DGRAM, 0);
2074 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2075 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2077 * If the device did not exist then attempt to create one by putting the
2078 * current tty into the PPP discipline. If this works then obtain the
2079 * flags for the device again.
2082 if (ppp_registered()) {
2083 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2084 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2088 * Ensure that the hardware address is for PPP and not something else
2091 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2093 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2097 * This is the PPP device. Validate the version of the driver at this
2098 * point to ensure that this program will work with the driver.
2101 char abBuffer [1024];
2103 ifr.ifr_data = abBuffer;
2104 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2106 error("Couldn't read driver version: %m");
2108 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2111 decode_version(abBuffer,
2113 &driver_modification,
2116 * Validate the version of the driver against the version that we used.
2118 decode_version(VERSION,
2123 /* The version numbers must match */
2124 if (driver_version != my_version)
2127 /* The modification levels must be legal */
2128 if (driver_modification < 3) {
2129 if (driver_modification >= 2) {
2130 /* we can cope with 2.2.0 and above */
2139 slprintf(route_buffer, sizeof(route_buffer),
2140 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2141 driver_version, driver_modification, driver_patch);
2143 no_ppp_msg = route_buffer;
2150 /********************************************************************
2152 * Update the wtmp file with the appropriate user name and tty device.
2155 void logwtmp (const char *line, const char *name, const char *host)
2157 struct utmp ut, *utp;
2158 pid_t mypid = getpid();
2164 * Update the signon database for users.
2165 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2167 utmpname(_PATH_UTMP);
2169 while ((utp = getutent()) && (utp->ut_pid != mypid))
2173 memcpy(&ut, utp, sizeof(ut));
2175 /* some gettys/telnetds don't initialize utmp... */
2176 memset(&ut, 0, sizeof(ut));
2178 if (ut.ut_id[0] == 0)
2179 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2181 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2182 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2186 ut.ut_type = USER_PROCESS;
2189 /* Insert the host name if one is supplied */
2191 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2193 /* Insert the IP address of the remote system if IP is enabled */
2194 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2195 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2196 sizeof(ut.ut_addr));
2198 /* CL: Makes sure that the logout works */
2199 if (*host == 0 && *name==0)
2205 * Update the wtmp file.
2208 updwtmp(_PATH_WTMP, &ut);
2210 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2212 flock(wtmp, LOCK_EX);
2214 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2215 warn("error writing %s: %m", _PATH_WTMP);
2217 flock(wtmp, LOCK_UN);
2225 /********************************************************************
2227 * sifvjcomp - config tcp header compression
2230 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2235 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2236 error("Couldn't set up TCP header compression: %m");
2240 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2241 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2246 /********************************************************************
2248 * sifup - Config the interface up and enable IP packets to pass.
2255 memset (&ifr, '\0', sizeof (ifr));
2256 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2257 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2258 if (! ok_error (errno))
2259 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2263 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2264 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2265 if (! ok_error (errno))
2266 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2274 /********************************************************************
2276 * sifdown - Disable the indicated protocol and config the interface
2277 * down if there are no remaining protocols.
2284 if (if_is_up && --if_is_up > 0)
2287 memset (&ifr, '\0', sizeof (ifr));
2288 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2289 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2290 if (! ok_error (errno))
2291 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2295 ifr.ifr_flags &= ~IFF_UP;
2296 ifr.ifr_flags |= IFF_POINTOPOINT;
2297 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2298 if (! ok_error (errno))
2299 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2305 /********************************************************************
2307 * sifaddr - Config the interface IP addresses and netmask.
2310 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2316 memset (&ifr, '\0', sizeof (ifr));
2317 memset (&rt, '\0', sizeof (rt));
2319 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2320 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2321 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2323 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2325 * Set our IP address
2327 SIN_ADDR(ifr.ifr_addr) = our_adr;
2328 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2329 if (errno != EEXIST) {
2330 if (! ok_error (errno))
2331 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2334 warn("ioctl(SIOCSIFADDR): Address already exists");
2339 * Set the gateway address
2341 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2342 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2343 if (! ok_error (errno))
2344 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2349 * For recent kernels, force the netmask to 255.255.255.255.
2351 if (kernel_version >= KVERSION(2,1,16))
2353 if (net_mask != 0) {
2354 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2355 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2356 if (! ok_error (errno))
2357 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2362 * Add the device route
2364 if (kernel_version < KVERSION(2,1,16)) {
2365 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2366 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2369 SIN_ADDR(rt.rt_gateway) = 0L;
2370 SIN_ADDR(rt.rt_dst) = his_adr;
2371 rt.rt_flags = RTF_UP | RTF_HOST;
2373 if (kernel_version > KVERSION(2,1,0)) {
2374 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2375 SIN_ADDR(rt.rt_genmask) = -1L;
2378 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2379 if (! ok_error (errno))
2380 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2385 /* set ip_dynaddr in demand mode if address changes */
2386 if (demand && tune_kernel && !dynaddr_set
2387 && our_old_addr && our_old_addr != our_adr) {
2388 /* set ip_dynaddr if possible */
2392 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2393 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2394 if (write(fd, "1", 1) != 1)
2395 error("Couldn't enable dynamic IP addressing: %m");
2398 dynaddr_set = 1; /* only 1 attempt */
2405 /********************************************************************
2407 * cifaddr - Clear the interface IP addresses, and delete routes
2408 * through the interface if possible.
2411 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2415 if (kernel_version < KVERSION(2,1,16)) {
2417 * Delete the route through the device
2420 memset (&rt, '\0', sizeof (rt));
2422 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2423 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2426 SIN_ADDR(rt.rt_gateway) = 0;
2427 SIN_ADDR(rt.rt_dst) = his_adr;
2428 rt.rt_flags = RTF_UP | RTF_HOST;
2430 if (kernel_version > KVERSION(2,1,0)) {
2431 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2432 SIN_ADDR(rt.rt_genmask) = -1L;
2435 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2436 if (still_ppp() && ! ok_error (errno))
2437 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2442 /* This way it is possible to have an IPX-only or IPv6-only interface */
2443 memset(&ifr, 0, sizeof(ifr));
2444 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2445 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2447 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2448 if (! ok_error (errno)) {
2449 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2454 our_old_addr = our_adr;
2460 /********************************************************************
2462 * sif6addr - Config the interface with an IPv6 link-local address
2464 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2466 struct in6_ifreq ifr6;
2468 struct in6_rtmsg rt6;
2472 error("IPv6 socket creation failed: %m");
2475 memset(&ifr, 0, sizeof (ifr));
2476 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2477 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2478 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2482 /* Local interface */
2483 memset(&ifr6, 0, sizeof(ifr6));
2484 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2485 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2486 ifr6.ifr6_prefixlen = 10;
2488 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2489 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2493 /* Route to remote host */
2494 memset(&rt6, 0, sizeof(rt6));
2495 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2496 rt6.rtmsg_flags = RTF_UP;
2497 rt6.rtmsg_dst_len = 10;
2498 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2499 rt6.rtmsg_metric = 1;
2501 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2502 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2510 /********************************************************************
2512 * cif6addr - Remove IPv6 address from interface
2514 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2517 struct in6_ifreq ifr6;
2521 error("IPv6 socket creation failed: %m");
2524 memset(&ifr, 0, sizeof(ifr));
2525 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2526 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2527 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2531 memset(&ifr6, 0, sizeof(ifr6));
2532 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2533 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2534 ifr6.ifr6_prefixlen = 10;
2536 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2537 if (errno != EADDRNOTAVAIL) {
2538 if (! ok_error (errno))
2539 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2542 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2551 * get_pty - get a pty master/slave pair and chown the slave side
2552 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2555 get_pty(master_fdp, slave_fdp, slave_name, uid)
2561 int i, mfd, sfd = -1;
2563 struct termios tios;
2567 * Try the unix98 way first.
2569 mfd = open("/dev/ptmx", O_RDWR);
2572 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2573 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2574 chmod(pty_name, S_IRUSR | S_IWUSR);
2577 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2578 warn("Couldn't unlock pty slave %s: %m", pty_name);
2580 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2581 warn("Couldn't open pty slave %s: %m", pty_name);
2584 #endif /* TIOCGPTN */
2587 /* the old way - scan through the pty name space */
2588 for (i = 0; i < 64; ++i) {
2589 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2590 'p' + i / 16, i % 16);
2591 mfd = open(pty_name, O_RDWR, 0);
2594 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2596 fchown(sfd, uid, -1);
2597 fchmod(sfd, S_IRUSR | S_IWUSR);
2608 strlcpy(slave_name, pty_name, 16);
2611 if (tcgetattr(sfd, &tios) == 0) {
2612 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2613 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2614 tios.c_iflag = IGNPAR;
2617 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2618 warn("couldn't set attributes on pty: %m");
2620 warn("couldn't get attributes on pty: %m");
2625 /********************************************************************
2627 * open_loopback - open the device we use for getting packets
2628 * in demand mode. Under Linux, we use a pty master/slave pair.
2631 open_ppp_loopback(void)
2636 if (new_style_driver) {
2637 /* allocate ourselves a ppp unit */
2638 if (make_ppp_unit() < 0)
2640 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2641 set_kdebugflag(kdebugflag);
2646 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2647 fatal("No free pty for loopback");
2648 SYSDEBUG(("using %s for loopback", loop_name));
2650 set_ppp_fd(slave_fd);
2652 flags = fcntl(master_fd, F_GETFL);
2654 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2655 warn("couldn't set master loopback to nonblock: %m");
2657 flags = fcntl(ppp_fd, F_GETFL);
2659 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2660 warn("couldn't set slave loopback to nonblock: %m");
2662 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2663 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2665 * Find out which interface we were given.
2667 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2668 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2670 * Enable debug in the driver if requested.
2672 set_kdebugflag (kdebugflag);
2677 /********************************************************************
2679 * sifnpmode - Set the mode for handling packets for a given NP.
2683 sifnpmode(u, proto, mode)
2690 npi.protocol = proto;
2692 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2693 if (! ok_error (errno))
2694 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2701 /********************************************************************
2703 * sipxfaddr - Config the interface IPX networknumber
2706 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2713 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2715 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2717 if (! ok_error (errno))
2718 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2722 memset (&ifr, '\0', sizeof (ifr));
2723 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2725 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2726 sipx->sipx_family = AF_IPX;
2727 sipx->sipx_port = 0;
2728 sipx->sipx_network = htonl (network);
2729 sipx->sipx_type = IPX_FRAME_ETHERII;
2730 sipx->sipx_action = IPX_CRTITF;
2732 * Set the IPX device
2734 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2736 if (errno != EEXIST) {
2737 if (! ok_error (errno))
2738 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2741 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2750 /********************************************************************
2752 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2753 * are removed and the device is no longer able to pass IPX
2757 int cipxfaddr (int unit)
2764 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2766 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2768 if (! ok_error (errno))
2769 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2773 memset (&ifr, '\0', sizeof (ifr));
2774 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2776 sipx->sipx_type = IPX_FRAME_ETHERII;
2777 sipx->sipx_action = IPX_DLTITF;
2778 sipx->sipx_family = AF_IPX;
2780 * Set the IPX device
2782 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2783 if (! ok_error (errno))
2784 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2794 * Use the hostname as part of the random number seed.
2803 for (p = hostname; *p != 0; ++p)
2808 /********************************************************************
2810 * sys_check_options - check the options that the user specified
2814 sys_check_options(void)
2818 * Disable the IPX protocol if the support is not present in the kernel.
2822 if (ipxcp_protent.enabled_flag) {
2823 struct stat stat_buf;
2824 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2825 || lstat(path, &stat_buf) < 0) {
2826 error("IPX support is not present in the kernel\n");
2827 ipxcp_protent.enabled_flag = 0;
2831 if (demand && driver_is_old) {
2832 option_error("demand dialling is not supported by kernel driver "
2833 "version %d.%d.%d", driver_version, driver_modification,
2837 if (multilink && !new_style_driver) {
2838 warn("Warning: multilink is not supported by the kernel driver");
2846 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2848 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2849 * that the system has a properly configured Ethernet interface for this
2850 * function to return non-zero.
2853 ether_to_eui64(eui64_t *p_eui64)
2857 const unsigned char *ptr;
2859 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2862 warn("could not open IPv6 socket");
2866 strcpy(ifr.ifr_name, "eth0");
2867 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2870 warn("could not obtain hardware address for eth0");
2876 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2878 ptr = ifr.ifr_hwaddr.sa_data;
2879 p_eui64->e8[0] = ptr[0] | 0x02;
2880 p_eui64->e8[1] = ptr[1];
2881 p_eui64->e8[2] = ptr[2];
2882 p_eui64->e8[3] = 0xFF;
2883 p_eui64->e8[4] = 0xFE;
2884 p_eui64->e8[5] = ptr[3];
2885 p_eui64->e8[6] = ptr[4];
2886 p_eui64->e8[7] = ptr[5];