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)
263 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
265 if (!new_style_driver)
269 static int still_ppp(void)
271 if (new_style_driver)
272 return !hungup && ppp_fd >= 0;
273 if (!hungup || ppp_fd == slave_fd)
276 set_ppp_fd(slave_fd);
283 * modify_flags - set and clear flag bits controlling the kernel
286 static int modify_flags(int fd, int clear_bits, int set_bits)
290 if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
292 flags = (flags & ~clear_bits) | set_bits;
293 if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
300 error("Failed to set PPP kernel option flags: %m");
304 /********************************************************************
306 * sys_init - System-dependent initialization.
311 /* Get an internet socket for doing socket ioctls. */
312 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
314 fatal("Couldn't create IP socket: %m(%d)", errno);
317 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
319 sock6_fd = -errno; /* save errno for later */
326 /********************************************************************
328 * sys_cleanup - restore any system state we modified before exiting:
329 * mark the interface down, delete default route and/or proxy arp entry.
330 * This shouldn't call die() because it's called from die().
333 void sys_cleanup(void)
336 * Take down the device
343 * Delete any routes through the device.
345 if (default_route_gateway != 0)
346 cifdefaultroute(0, 0, default_route_gateway);
349 cifproxyarp(0, proxy_arp_addr);
352 /********************************************************************
354 * sys_close - Clean up in a child process before execing.
359 if (new_style_driver && ppp_dev_fd >= 0)
373 /********************************************************************
375 * set_kdebugflag - Define the debugging level for the kernel
378 static int set_kdebugflag (int requested_level)
382 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
383 if ( ! ok_error (errno) )
384 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
387 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
392 /********************************************************************
394 * tty_establish_ppp - Turn the serial port into a ppp interface.
397 int tty_establish_ppp (int tty_fd)
402 * Ensure that the tty device is in exclusive mode.
404 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
405 if ( ! ok_error ( errno ))
406 warn("Couldn't make tty exclusive: %m");
409 * Demand mode - prime the old ppp device to relinquish the unit.
411 if (!new_style_driver && looped
412 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
413 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
417 * Set the current tty to the PPP discpline
421 #define N_SYNC_PPP 14
423 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
424 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
425 if ( ! ok_error (errno) ) {
426 error("Couldn't set tty to PPP discipline: %m");
431 ret_fd = generic_establish_ppp(tty_fd);
433 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
434 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
438 modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
439 (kdebugflag * SC_DEBUG) & SC_LOGB);
441 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
442 warn("Couldn't reset tty to normal line discipline: %m");
448 /********************************************************************
450 * generic_establish_ppp - Turn the fd into a ppp interface.
452 int generic_establish_ppp (int fd)
456 if (new_style_driver) {
459 /* Open an instance of /dev/ppp and connect the channel to it */
460 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
461 error("Couldn't get channel number: %m");
464 dbglog("using channel %d", chindex);
465 fd = open("/dev/ppp", O_RDWR);
467 error("Couldn't reopen /dev/ppp: %m");
470 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
471 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
472 error("Couldn't attach to channel %d: %m", chindex);
475 flags = fcntl(fd, F_GETFL);
476 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
477 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
482 if (!looped && !multilink) {
484 * Create a new PPP unit.
486 if (make_ppp_unit() < 0)
491 modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
495 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
496 error("Couldn't attach to PPP unit %d: %m", ifunit);
503 * Old-style driver: find out which interface we were given.
506 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
507 if (ok_error (errno))
509 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
511 /* Check that we got the same unit again. */
512 if (looped && x != ifunit)
513 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
517 * Fetch the initial file flags and reset blocking mode on the file.
519 initfdflags = fcntl(fd, F_GETFL);
520 if (initfdflags == -1 ||
521 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
522 if ( ! ok_error (errno))
523 warn("Couldn't set device to non-blocking mode: %m");
528 * Enable debug in the driver if requested.
531 set_kdebugflag (kdebugflag);
535 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
536 driver_version, driver_modification, driver_patch));
546 /********************************************************************
548 * tty_disestablish_ppp - Restore the serial port to normal operation.
549 * This shouldn't call die() because it's called from die().
552 void tty_disestablish_ppp(int tty_fd)
556 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
558 if (tcflush(tty_fd, TCIOFLUSH) < 0)
560 warn("tcflush failed: %m");
564 * Restore the previous line discipline
566 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
567 if ( ! ok_error (errno))
568 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
571 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
572 if ( ! ok_error (errno))
573 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
576 /* Reset non-blocking mode on fd. */
577 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
578 if ( ! ok_error (errno))
579 warn("Couldn't restore device fd flags: %m");
585 generic_disestablish_ppp(tty_fd);
588 /********************************************************************
590 * generic_disestablish_ppp - Restore device components to normal
591 * operation, and reconnect the ppp unit to the loopback if in demand
592 * mode. This shouldn't call die() because it's called from die().
594 void generic_disestablish_ppp(int dev_fd)
596 if (new_style_driver) {
600 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
602 } else if (ppp_dev_fd >= 0) {
604 remove_fd(ppp_dev_fd);
608 /* old-style driver */
610 set_ppp_fd(slave_fd);
617 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
618 * Assumes new_style_driver.
620 static int make_ppp_unit()
624 if (ppp_dev_fd >= 0) {
625 dbglog("in make_ppp_unit, already had /dev/ppp open?");
628 ppp_dev_fd = open("/dev/ppp", O_RDWR);
630 fatal("Couldn't open /dev/ppp: %m");
631 flags = fcntl(ppp_dev_fd, F_GETFL);
633 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
634 warn("Couldn't set /dev/ppp to nonblock: %m");
637 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
638 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
639 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
641 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
644 error("Couldn't create new ppp unit: %m");
649 * cfg_bundle - configure the existing bundle.
650 * Used in demand mode.
652 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
654 if (!new_style_driver)
657 /* set the mrru, mtu and flags */
658 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
659 error("Couldn't set MRRU: %m");
661 modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
662 ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
663 | (mrru? SC_MULTILINK: 0)));
665 /* connect up the channel */
666 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
667 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
672 * make_new_bundle - create a new PPP unit (i.e. a bundle)
673 * and connect our channel to it. This should only get called
674 * if `multilink' was set at the time establish_ppp was called.
675 * In demand mode this uses our existing bundle instead of making
678 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
680 if (!new_style_driver)
683 /* make us a ppp unit */
684 if (make_ppp_unit() < 0)
687 /* set the mrru and flags */
688 cfg_bundle(mrru, mtru, rssn, tssn);
692 * bundle_attach - attach our link to a given PPP unit.
693 * We assume the unit is controlled by another pppd.
695 int bundle_attach(int ifnum)
699 if (!new_style_driver)
702 master_fd = open("/dev/ppp", O_RDWR);
704 fatal("Couldn't open /dev/ppp: %m");
705 if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
706 if (errno == ENXIO) {
708 return 0; /* doesn't still exist */
710 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
712 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
713 fatal("Couldn't connect to interface unit %d: %m", ifnum);
714 modify_flags(master_fd, 0, SC_MULTILINK);
721 /********************************************************************
723 * clean_check - Fetch the flags for the device and generate
724 * appropriate error messages.
726 void clean_check(void)
732 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
734 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
736 s = "all had bit 7 set to 1";
740 s = "all had bit 7 set to 0";
744 s = "all had odd parity";
748 s = "all had even parity";
753 warn("Receive serial link is not 8-bit clean:");
754 warn("Problem: %s", s);
762 * List of valid speeds.
766 int speed_int, speed_val;
849 /********************************************************************
851 * Translate from bits/second to a speed_t.
854 static int translate_speed (int bps)
856 struct speed *speedp;
859 for (speedp = speeds; speedp->speed_int; speedp++) {
860 if (bps == speedp->speed_int)
861 return speedp->speed_val;
863 warn("speed %d not supported", bps);
868 /********************************************************************
870 * Translate from a speed_t to bits/second.
873 static int baud_rate_of (int speed)
875 struct speed *speedp;
878 for (speedp = speeds; speedp->speed_int; speedp++) {
879 if (speed == speedp->speed_val)
880 return speedp->speed_int;
886 /********************************************************************
888 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
889 * at the requested speed, etc. If `local' is true, set CLOCAL
890 * regardless of whether the modem option was specified.
893 void set_up_tty(int tty_fd, int local)
899 if (tcgetattr(tty_fd, &tios) < 0) {
900 if (!ok_error(errno))
901 fatal("tcgetattr: %m (line %d)", __LINE__);
908 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
909 tios.c_cflag |= CS8 | CREAD | HUPCL;
911 tios.c_iflag = IGNBRK | IGNPAR;
915 tios.c_cc[VTIME] = 0;
918 tios.c_cflag ^= (CLOCAL | HUPCL);
922 tios.c_cflag |= CRTSCTS;
926 tios.c_iflag |= IXON | IXOFF;
927 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
928 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
932 tios.c_cflag &= ~CRTSCTS;
939 speed = translate_speed(inspeed);
941 cfsetospeed (&tios, speed);
942 cfsetispeed (&tios, speed);
945 * We can't proceed if the serial port speed is B0,
946 * since that implies that the serial port is disabled.
949 speed = cfgetospeed(&tios);
951 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
954 while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
956 fatal("tcsetattr: %m (line %d)", __LINE__);
958 baud_rate = baud_rate_of(speed);
962 /********************************************************************
964 * setdtr - control the DTR line on the serial port.
965 * This is called from die(), so it shouldn't call die().
968 void setdtr (int tty_fd, int on)
970 int modembits = TIOCM_DTR;
972 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
975 /********************************************************************
977 * restore_tty - restore the terminal to the saved settings.
980 void restore_tty (int tty_fd)
985 * Turn off echoing, because otherwise we can get into
986 * a loop with the tty and the modem echoing to each other.
987 * We presume we are the sole user of this tty device, so
988 * when we close it, it will revert to its defaults anyway.
991 inittermios.c_lflag &= ~(ECHO | ECHONL);
993 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
994 if (! ok_error (errno))
995 warn("tcsetattr: %m (line %d)", __LINE__);
1000 /********************************************************************
1002 * output - Output PPP packet.
1005 void output (int unit, unsigned char *p, int len)
1010 dump_packet("sent", p, len);
1011 if (snoop_send_hook) snoop_send_hook(p, len);
1013 if (len < PPP_HDRLEN)
1015 if (new_style_driver) {
1018 proto = (p[0] << 8) + p[1];
1019 if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1022 if (write(fd, p, len) < 0) {
1023 if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1024 || errno == ENXIO || errno == EIO || errno == EINTR)
1025 warn("write: warning: %m (%d)", errno);
1027 error("write: %m (%d)", errno);
1031 /********************************************************************
1033 * wait_input - wait until there is data available,
1034 * for the length of time specified by *timo (indefinite
1038 void wait_input(struct timeval *timo)
1045 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1046 if (n < 0 && errno != EINTR)
1047 fatal("select: %m");
1051 * add_fd - add an fd to the set that wait_input waits for.
1055 if (fd >= FD_SETSIZE)
1056 fatal("internal error: file descriptor too large (%d)", fd);
1057 FD_SET(fd, &in_fds);
1063 * remove_fd - remove an fd from the set that wait_input waits for.
1065 void remove_fd(int fd)
1067 FD_CLR(fd, &in_fds);
1071 /********************************************************************
1073 * read_packet - get a PPP packet from the serial device.
1076 int read_packet (unsigned char *buf)
1080 len = PPP_MRU + PPP_HDRLEN;
1081 if (new_style_driver) {
1082 *buf++ = PPP_ALLSTATIONS;
1088 nr = read(ppp_fd, buf, len);
1089 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1090 && errno != EIO && errno != EINTR)
1092 if (nr < 0 && errno == ENXIO)
1095 if (nr < 0 && new_style_driver && ppp_dev_fd >= 0) {
1096 /* N.B. we read ppp_fd first since LCP packets come in there. */
1097 nr = read(ppp_dev_fd, buf, len);
1098 if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1099 && errno != EIO && errno != EINTR)
1100 error("read /dev/ppp: %m");
1101 if (nr < 0 && errno == ENXIO)
1104 return (new_style_driver && nr > 0)? nr+2: nr;
1107 /********************************************************************
1109 * get_loop_output - get outgoing packets from the ppp device,
1110 * and detect when we want to bring the real link up.
1111 * Return value is 1 if we need to bring up the link, 0 otherwise.
1114 get_loop_output(void)
1119 if (new_style_driver) {
1120 while ((n = read_packet(inpacket_buf)) > 0)
1121 if (loop_frame(inpacket_buf, n))
1126 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1127 if (loop_chars(inbuf, n))
1131 fatal("eof on loopback");
1133 if (errno != EWOULDBLOCK && errno != EAGAIN)
1134 fatal("read from loopback: %m(%d)", errno);
1140 * netif_set_mtu - set the MTU on the PPP network interface.
1143 netif_set_mtu(int unit, int mtu)
1147 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1149 memset (&ifr, '\0', sizeof (ifr));
1150 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1153 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1154 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1158 * netif_get_mtu - get the MTU on the PPP network interface.
1161 netif_get_mtu(int unit)
1165 memset (&ifr, '\0', sizeof (ifr));
1166 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1168 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1169 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1175 /********************************************************************
1177 * tty_send_config - configure the transmit characteristics of
1178 * the ppp interface.
1181 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1188 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1189 if (errno != EIO && errno != ENOTTY)
1190 error("Couldn't set transmit async character map: %m");
1195 x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1196 | (sync_serial? SC_SYNC: 0);
1197 modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1200 /********************************************************************
1202 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1205 void tty_set_xaccm (ext_accm accm)
1207 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1208 accm[0], accm[1], accm[2], accm[3]));
1212 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1213 if ( ! ok_error (errno))
1214 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1218 /********************************************************************
1220 * tty_recv_config - configure the receive-side characteristics of
1221 * the ppp interface.
1224 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1227 * If we were called because the link has gone down then there is nothing
1228 * which may be done. Just return without incident.
1233 * Set the receiver parameters
1235 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1236 if (errno != EIO && errno != ENOTTY)
1237 error("Couldn't set channel receive MRU: %m");
1239 if (new_style_driver && ppp_dev_fd >= 0
1240 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1241 error("Couldn't set MRU in generic PPP layer: %m");
1243 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1244 if (errno != EIO && errno != ENOTTY)
1245 error("Couldn't set channel receive asyncmap: %m");
1249 /********************************************************************
1251 * ccp_test - ask kernel whether a given compression method
1252 * is acceptable for use.
1256 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1258 struct ppp_option_data data;
1260 memset (&data, '\0', sizeof (data));
1262 data.length = opt_len;
1263 data.transmit = for_transmit;
1265 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1268 return (errno == ENOBUFS)? 0: -1;
1271 /********************************************************************
1273 * ccp_flags_set - inform kernel about the current state of CCP.
1276 void ccp_flags_set (int unit, int isopen, int isup)
1280 x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1281 if (still_ppp() && ppp_dev_fd >= 0)
1282 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1287 * set_filters - set the active and pass filters in the kernel driver.
1289 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1291 struct sock_fprog fp;
1293 fp.len = pass->bf_len;
1294 fp.filter = (struct sock_filter *) pass->bf_insns;
1295 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1296 if (errno == ENOTTY)
1297 warn("kernel does not support PPP filtering");
1299 error("Couldn't set pass-filter in kernel: %m");
1302 fp.len = active->bf_len;
1303 fp.filter = (struct sock_filter *) active->bf_insns;
1304 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1305 error("Couldn't set active-filter in kernel: %m");
1310 #endif /* PPP_FILTER */
1312 /********************************************************************
1314 * get_idle_time - return how long the link has been idle.
1317 get_idle_time(u, ip)
1319 struct ppp_idle *ip;
1321 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1324 /********************************************************************
1326 * get_ppp_stats - return statistics for the link.
1329 get_ppp_stats(u, stats)
1331 struct pppd_stats *stats;
1333 struct ifpppstatsreq req;
1335 memset (&req, 0, sizeof (req));
1337 req.stats_ptr = (caddr_t) &req.stats;
1338 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1339 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1340 error("Couldn't get PPP statistics: %m");
1343 stats->bytes_in = req.stats.p.ppp_ibytes;
1344 stats->bytes_out = req.stats.p.ppp_obytes;
1345 stats->pkts_in = req.stats.p.ppp_ipackets;
1346 stats->pkts_out = req.stats.p.ppp_opackets;
1350 /********************************************************************
1352 * ccp_fatal_error - returns 1 if decompression was disabled as a
1353 * result of an error detected after decompression of a packet,
1354 * 0 otherwise. This is necessary because of patent nonsense.
1357 int ccp_fatal_error (int unit)
1361 if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1362 error("Couldn't read compression error flags: %m");
1365 return flags & SC_DC_FERROR;
1368 /********************************************************************
1370 * path_to_procfs - find the path to the proc file system mount point
1372 static char proc_path[MAXPATHLEN];
1373 static int proc_path_len;
1375 static char *path_to_procfs(const char *tail)
1377 struct mntent *mntent;
1380 if (proc_path_len == 0) {
1381 /* Default the mount location of /proc */
1382 strlcpy (proc_path, "/proc", sizeof(proc_path));
1384 fp = fopen(MOUNTED, "r");
1386 while ((mntent = getmntent(fp)) != NULL) {
1387 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1389 if (strcmp(mntent->mnt_type, "proc") == 0) {
1390 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1391 proc_path_len = strlen(proc_path);
1399 strlcpy(proc_path + proc_path_len, tail,
1400 sizeof(proc_path) - proc_path_len);
1405 * /proc/net/route parsing stuff.
1407 #define ROUTE_MAX_COLS 12
1408 FILE *route_fd = (FILE *) 0;
1409 static char route_buffer[512];
1410 static int route_dev_col, route_dest_col, route_gw_col;
1411 static int route_flags_col, route_mask_col;
1412 static int route_num_cols;
1414 static int open_route_table (void);
1415 static void close_route_table (void);
1416 static int read_route_table (struct rtentry *rt);
1418 /********************************************************************
1420 * close_route_table - close the interface to the route table
1423 static void close_route_table (void)
1425 if (route_fd != (FILE *) 0) {
1427 route_fd = (FILE *) 0;
1431 /********************************************************************
1433 * open_route_table - open the interface to the route table
1435 static char route_delims[] = " \t\n";
1437 static int open_route_table (void)
1441 close_route_table();
1443 path = path_to_procfs("/net/route");
1444 route_fd = fopen (path, "r");
1445 if (route_fd == NULL) {
1446 error("can't open routing table %s: %m", path);
1450 route_dev_col = 0; /* default to usual columns */
1453 route_flags_col = 3;
1457 /* parse header line */
1458 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1459 char *p = route_buffer, *q;
1461 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1463 if ((q = strtok(p, route_delims)) == 0)
1465 if (strcasecmp(q, "iface") == 0)
1466 route_dev_col = col;
1467 else if (strcasecmp(q, "destination") == 0)
1468 route_dest_col = col;
1469 else if (strcasecmp(q, "gateway") == 0)
1471 else if (strcasecmp(q, "flags") == 0)
1472 route_flags_col = col;
1473 else if (strcasecmp(q, "mask") == 0)
1474 route_mask_col = col;
1477 if (used && col >= route_num_cols)
1478 route_num_cols = col + 1;
1486 /********************************************************************
1488 * read_route_table - read the next entry from the route table
1491 static int read_route_table(struct rtentry *rt)
1493 char *cols[ROUTE_MAX_COLS], *p;
1496 memset (rt, '\0', sizeof (struct rtentry));
1498 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1502 for (col = 0; col < route_num_cols; ++col) {
1503 cols[col] = strtok(p, route_delims);
1504 if (cols[col] == NULL)
1505 return 0; /* didn't get enough columns */
1509 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1510 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1511 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1513 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1514 rt->rt_dev = cols[route_dev_col];
1519 /********************************************************************
1521 * defaultroute_exists - determine if there is a default route
1524 static int defaultroute_exists (struct rtentry *rt)
1528 if (!open_route_table())
1531 while (read_route_table(rt) != 0) {
1532 if ((rt->rt_flags & RTF_UP) == 0)
1535 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1537 if (SIN_ADDR(rt->rt_dst) == 0L) {
1543 close_route_table();
1548 * have_route_to - determine if the system has any route to
1549 * a given IP address. `addr' is in network byte order.
1550 * Return value is 1 if yes, 0 if no, -1 if don't know.
1551 * For demand mode to work properly, we have to ignore routes
1552 * through our own interface.
1554 int have_route_to(u_int32_t addr)
1559 if (!open_route_table())
1560 return -1; /* don't know */
1562 while (read_route_table(&rt)) {
1563 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1565 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1571 close_route_table();
1575 /********************************************************************
1577 * sifdefaultroute - assign a default route through the address given.
1580 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1584 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1585 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1587 if (old_gateway != gateway)
1588 error("not replacing existing default route to %s [%I]",
1589 rt.rt_dev, old_gateway);
1593 memset (&rt, '\0', sizeof (rt));
1594 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1595 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1599 if (kernel_version > KVERSION(2,1,0)) {
1600 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1601 SIN_ADDR(rt.rt_genmask) = 0L;
1604 SIN_ADDR(rt.rt_gateway) = gateway;
1606 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1607 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1608 if ( ! ok_error ( errno ))
1609 error("default route ioctl(SIOCADDRT): %m");
1613 default_route_gateway = gateway;
1617 /********************************************************************
1619 * cifdefaultroute - delete a default route through the address given.
1622 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1626 default_route_gateway = 0;
1628 memset (&rt, '\0', sizeof (rt));
1629 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1630 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1632 if (kernel_version > KVERSION(2,1,0)) {
1633 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1634 SIN_ADDR(rt.rt_genmask) = 0L;
1637 SIN_ADDR(rt.rt_gateway) = gateway;
1639 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1640 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1642 if ( ! ok_error ( errno ))
1643 error("default route ioctl(SIOCDELRT): %m");
1651 /********************************************************************
1653 * sifproxyarp - Make a proxy ARP entry for the peer.
1656 int sifproxyarp (int unit, u_int32_t his_adr)
1658 struct arpreq arpreq;
1661 if (has_proxy_arp == 0) {
1662 memset (&arpreq, '\0', sizeof(arpreq));
1664 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1665 SIN_ADDR(arpreq.arp_pa) = his_adr;
1666 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1668 * Get the hardware address of an interface on the same subnet
1669 * as our local address.
1671 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1672 sizeof(proxy_arp_dev))) {
1673 error("Cannot determine ethernet address for proxy ARP");
1676 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1678 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1679 if ( ! ok_error ( errno ))
1680 error("ioctl(SIOCSARP): %m");
1683 proxy_arp_addr = his_adr;
1687 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1688 if (forw_path != 0) {
1689 int fd = open(forw_path, O_WRONLY);
1691 if (write(fd, "1", 1) != 1)
1692 error("Couldn't enable IP forwarding: %m");
1702 /********************************************************************
1704 * cifproxyarp - Delete the proxy ARP entry for the peer.
1707 int cifproxyarp (int unit, u_int32_t his_adr)
1709 struct arpreq arpreq;
1711 if (has_proxy_arp) {
1713 memset (&arpreq, '\0', sizeof(arpreq));
1714 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1715 SIN_ADDR(arpreq.arp_pa) = his_adr;
1716 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1717 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1719 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1720 if ( ! ok_error ( errno ))
1721 warn("ioctl(SIOCDARP): %m");
1728 /********************************************************************
1730 * get_ether_addr - get the hardware address of an interface on the
1731 * the same subnet as ipaddr.
1734 static int get_ether_addr (u_int32_t ipaddr,
1735 struct sockaddr *hwaddr,
1736 char *name, int namelen)
1738 struct ifreq *ifr, *ifend;
1739 u_int32_t ina, mask;
1741 struct ifreq ifreq, bestifreq;
1743 struct ifreq ifs[MAX_IFS];
1745 u_int32_t bestmask=0;
1746 int found_interface = 0;
1748 ifc.ifc_len = sizeof(ifs);
1750 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1751 if ( ! ok_error ( errno ))
1752 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1756 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1757 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1759 * Scan through looking for an interface with an Internet
1760 * address on the same subnet as `ipaddr'.
1762 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1763 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1764 if (ifr->ifr_addr.sa_family == AF_INET) {
1765 ina = SIN_ADDR(ifr->ifr_addr);
1766 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1767 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1770 * Check that the interface is up, and not point-to-point
1773 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1776 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1779 * Get its netmask and check that it's on the right subnet.
1781 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1784 mask = SIN_ADDR(ifreq.ifr_addr);
1785 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1786 ip_ntoa(ina), ntohl(mask)));
1788 if (((ipaddr ^ ina) & mask) != 0)
1789 continue; /* no match */
1791 if (mask >= bestmask) {
1792 /* Compare using >= instead of > -- it is possible for
1793 an interface to have a netmask of 0.0.0.0 */
1794 found_interface = 1;
1801 if (!found_interface) return 0;
1803 strlcpy(name, bestifreq.ifr_name, namelen);
1805 /* trim off the :1 in eth0:1 */
1806 aliasp = strchr(name, ':');
1810 info("found interface %s for proxy arp", name);
1812 * Now get the hardware address.
1814 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1815 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1816 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1821 &bestifreq.ifr_hwaddr,
1822 sizeof (struct sockaddr));
1824 SYSDEBUG ((LOG_DEBUG,
1825 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1826 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1827 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1828 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1829 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1830 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1831 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1832 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1833 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1838 * get_if_hwaddr - get the hardware address for the specified
1839 * network interface device.
1842 get_if_hwaddr(u_char *addr, char *name)
1847 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1850 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1851 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1852 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1855 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1860 * get_first_ethernet - return the name of the first ethernet-style
1861 * interface on this system.
1864 get_first_ethernet()
1869 /********************************************************************
1871 * Return user specified netmask, modified by any mask we might determine
1872 * for address `addr' (in network byte order).
1873 * Here we scan through the system's list of interfaces, looking for
1874 * any non-point-to-point interfaces which might appear to be on the same
1875 * network as `addr'. If we find any, we OR in their netmask to the
1876 * user-specified netmask.
1879 u_int32_t GetMask (u_int32_t addr)
1881 u_int32_t mask, nmask, ina;
1882 struct ifreq *ifr, *ifend, ifreq;
1884 struct ifreq ifs[MAX_IFS];
1888 if (IN_CLASSA(addr)) /* determine network mask for address class */
1889 nmask = IN_CLASSA_NET;
1890 else if (IN_CLASSB(addr))
1891 nmask = IN_CLASSB_NET;
1893 nmask = IN_CLASSC_NET;
1895 /* class D nets are disallowed by bad_ip_adrs */
1896 mask = netmask | htonl(nmask);
1898 * Scan through the system's network interfaces.
1900 ifc.ifc_len = sizeof(ifs);
1902 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1903 if ( ! ok_error ( errno ))
1904 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1908 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1909 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1911 * Check the interface's internet address.
1913 if (ifr->ifr_addr.sa_family != AF_INET)
1915 ina = SIN_ADDR(ifr->ifr_addr);
1916 if (((ntohl(ina) ^ addr) & nmask) != 0)
1919 * Check that the interface is up, and not point-to-point nor loopback.
1921 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1922 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1925 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1928 * Get its netmask and OR it into our mask.
1930 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1932 mask |= SIN_ADDR(ifreq.ifr_addr);
1938 /********************************************************************
1940 * Internal routine to decode the version.modification.patch level
1943 static void decode_version (char *buf, int *version,
1944 int *modification, int *patch)
1948 *version = (int) strtoul (buf, &endp, 10);
1952 if (endp != buf && *endp == '.') {
1954 *modification = (int) strtoul (buf, &endp, 10);
1955 if (endp != buf && *endp == '.') {
1957 *patch = (int) strtoul (buf, &buf, 10);
1962 /********************************************************************
1964 * Procedure to determine if the PPP line discipline is registered.
1968 ppp_registered(void)
1976 * We used to open the serial device and set it to the ppp line
1977 * discipline here, in order to create a ppp unit. But that is
1978 * not a good idea - the user might have specified a device that
1979 * they can't open (permission, or maybe it doesn't really exist).
1980 * So we grab a pty master/slave pair and use that.
1982 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1983 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1988 * Try to put the device into the PPP discipline.
1990 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1991 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2000 /********************************************************************
2002 * ppp_available - check whether the system has any ppp interfaces
2003 * (in fact we check whether we can do an ioctl on ppp0).
2006 int ppp_available(void)
2011 int my_version, my_modification, my_patch;
2012 int osmaj, osmin, ospatch;
2015 "This system lacks kernel support for PPP. This could be because\n"
2016 "the PPP kernel module could not be loaded, or because PPP was not\n"
2017 "included in the kernel configuration. If PPP was included as a\n"
2018 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2019 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2020 "See README.linux file in the ppp distribution for more details.\n";
2022 /* get the kernel version now, since we are called before sys_init */
2024 osmaj = osmin = ospatch = 0;
2025 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2026 kernel_version = KVERSION(osmaj, osmin, ospatch);
2028 fd = open("/dev/ppp", O_RDWR);
2030 if (fd < 0 && errno == ENOENT) {
2031 /* try making it and see if that helps. */
2032 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
2033 makedev(108, 0)) >= 0) {
2034 fd = open("/dev/ppp", O_RDWR);
2036 info("Created /dev/ppp device node");
2038 unlink("/dev/ppp"); /* didn't work, undo the mknod */
2039 } else if (errno == EEXIST) {
2040 fd = open("/dev/ppp", O_RDWR);
2045 new_style_driver = 1;
2047 /* XXX should get from driver */
2049 driver_modification = 4;
2054 if (kernel_version >= KVERSION(2,3,13)) {
2055 if (errno == ENOENT)
2057 "pppd is unable to open the /dev/ppp device.\n"
2058 "You need to create the /dev/ppp device node by\n"
2059 "executing the following command as root:\n"
2060 " mknod /dev/ppp c 108 0\n";
2065 * Open a socket for doing the ioctl operations.
2067 s = socket(AF_INET, SOCK_DGRAM, 0);
2071 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2072 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2074 * If the device did not exist then attempt to create one by putting the
2075 * current tty into the PPP discipline. If this works then obtain the
2076 * flags for the device again.
2079 if (ppp_registered()) {
2080 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2081 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2085 * Ensure that the hardware address is for PPP and not something else
2088 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2090 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2094 * This is the PPP device. Validate the version of the driver at this
2095 * point to ensure that this program will work with the driver.
2098 char abBuffer [1024];
2100 ifr.ifr_data = abBuffer;
2101 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2103 error("Couldn't read driver version: %m");
2105 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2108 decode_version(abBuffer,
2110 &driver_modification,
2113 * Validate the version of the driver against the version that we used.
2115 decode_version(VERSION,
2120 /* The version numbers must match */
2121 if (driver_version != my_version)
2124 /* The modification levels must be legal */
2125 if (driver_modification < 3) {
2126 if (driver_modification >= 2) {
2127 /* we can cope with 2.2.0 and above */
2136 slprintf(route_buffer, sizeof(route_buffer),
2137 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2138 driver_version, driver_modification, driver_patch);
2140 no_ppp_msg = route_buffer;
2147 /********************************************************************
2149 * Update the wtmp file with the appropriate user name and tty device.
2152 void logwtmp (const char *line, const char *name, const char *host)
2154 struct utmp ut, *utp;
2155 pid_t mypid = getpid();
2161 * Update the signon database for users.
2162 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2164 utmpname(_PATH_UTMP);
2166 while ((utp = getutent()) && (utp->ut_pid != mypid))
2170 memcpy(&ut, utp, sizeof(ut));
2172 /* some gettys/telnetds don't initialize utmp... */
2173 memset(&ut, 0, sizeof(ut));
2175 if (ut.ut_id[0] == 0)
2176 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2178 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2179 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2183 ut.ut_type = USER_PROCESS;
2186 /* Insert the host name if one is supplied */
2188 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2190 /* Insert the IP address of the remote system if IP is enabled */
2191 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2192 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2193 sizeof(ut.ut_addr));
2195 /* CL: Makes sure that the logout works */
2196 if (*host == 0 && *name==0)
2202 * Update the wtmp file.
2205 updwtmp(_PATH_WTMP, &ut);
2207 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2209 flock(wtmp, LOCK_EX);
2211 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2212 warn("error writing %s: %m", _PATH_WTMP);
2214 flock(wtmp, LOCK_UN);
2222 /********************************************************************
2224 * sifvjcomp - config tcp header compression
2227 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2232 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2233 error("Couldn't set up TCP header compression: %m");
2237 x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2238 modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2243 /********************************************************************
2245 * sifup - Config the interface up and enable IP packets to pass.
2252 memset (&ifr, '\0', sizeof (ifr));
2253 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2254 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2255 if (! ok_error (errno))
2256 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2260 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2261 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2262 if (! ok_error (errno))
2263 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2271 /********************************************************************
2273 * sifdown - Disable the indicated protocol and config the interface
2274 * down if there are no remaining protocols.
2281 if (if_is_up && --if_is_up > 0)
2284 memset (&ifr, '\0', sizeof (ifr));
2285 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2286 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2287 if (! ok_error (errno))
2288 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2292 ifr.ifr_flags &= ~IFF_UP;
2293 ifr.ifr_flags |= IFF_POINTOPOINT;
2294 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2295 if (! ok_error (errno))
2296 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2302 /********************************************************************
2304 * sifaddr - Config the interface IP addresses and netmask.
2307 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2313 memset (&ifr, '\0', sizeof (ifr));
2314 memset (&rt, '\0', sizeof (rt));
2316 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2317 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2318 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2320 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2322 * Set our IP address
2324 SIN_ADDR(ifr.ifr_addr) = our_adr;
2325 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2326 if (errno != EEXIST) {
2327 if (! ok_error (errno))
2328 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2331 warn("ioctl(SIOCSIFADDR): Address already exists");
2336 * Set the gateway address
2338 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2339 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2340 if (! ok_error (errno))
2341 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2346 * For recent kernels, force the netmask to 255.255.255.255.
2348 if (kernel_version >= KVERSION(2,1,16))
2350 if (net_mask != 0) {
2351 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2352 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2353 if (! ok_error (errno))
2354 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2359 * Add the device route
2361 if (kernel_version < KVERSION(2,1,16)) {
2362 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2363 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2366 SIN_ADDR(rt.rt_gateway) = 0L;
2367 SIN_ADDR(rt.rt_dst) = his_adr;
2368 rt.rt_flags = RTF_UP | RTF_HOST;
2370 if (kernel_version > KVERSION(2,1,0)) {
2371 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2372 SIN_ADDR(rt.rt_genmask) = -1L;
2375 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2376 if (! ok_error (errno))
2377 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2382 /* set ip_dynaddr in demand mode if address changes */
2383 if (demand && tune_kernel && !dynaddr_set
2384 && our_old_addr && our_old_addr != our_adr) {
2385 /* set ip_dynaddr if possible */
2389 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2390 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2391 if (write(fd, "1", 1) != 1)
2392 error("Couldn't enable dynamic IP addressing: %m");
2395 dynaddr_set = 1; /* only 1 attempt */
2402 /********************************************************************
2404 * cifaddr - Clear the interface IP addresses, and delete routes
2405 * through the interface if possible.
2408 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2412 if (kernel_version < KVERSION(2,1,16)) {
2414 * Delete the route through the device
2417 memset (&rt, '\0', sizeof (rt));
2419 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2420 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2423 SIN_ADDR(rt.rt_gateway) = 0;
2424 SIN_ADDR(rt.rt_dst) = his_adr;
2425 rt.rt_flags = RTF_UP | RTF_HOST;
2427 if (kernel_version > KVERSION(2,1,0)) {
2428 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2429 SIN_ADDR(rt.rt_genmask) = -1L;
2432 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2433 if (still_ppp() && ! ok_error (errno))
2434 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2439 /* This way it is possible to have an IPX-only or IPv6-only interface */
2440 memset(&ifr, 0, sizeof(ifr));
2441 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2442 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2444 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2445 if (! ok_error (errno)) {
2446 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2451 our_old_addr = our_adr;
2457 /********************************************************************
2459 * sif6addr - Config the interface with an IPv6 link-local address
2461 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2463 struct in6_ifreq ifr6;
2465 struct in6_rtmsg rt6;
2469 error("IPv6 socket creation failed: %m");
2472 memset(&ifr, 0, sizeof (ifr));
2473 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2474 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2475 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2479 /* Local interface */
2480 memset(&ifr6, 0, sizeof(ifr6));
2481 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2482 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2483 ifr6.ifr6_prefixlen = 10;
2485 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2486 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2490 /* Route to remote host */
2491 memset(&rt6, 0, sizeof(rt6));
2492 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2493 rt6.rtmsg_flags = RTF_UP;
2494 rt6.rtmsg_dst_len = 10;
2495 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2496 rt6.rtmsg_metric = 1;
2498 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2499 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2507 /********************************************************************
2509 * cif6addr - Remove IPv6 address from interface
2511 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2514 struct in6_ifreq ifr6;
2518 error("IPv6 socket creation failed: %m");
2521 memset(&ifr, 0, sizeof(ifr));
2522 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2523 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2524 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2528 memset(&ifr6, 0, sizeof(ifr6));
2529 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2530 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2531 ifr6.ifr6_prefixlen = 10;
2533 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2534 if (errno != EADDRNOTAVAIL) {
2535 if (! ok_error (errno))
2536 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2539 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2548 * get_pty - get a pty master/slave pair and chown the slave side
2549 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2552 get_pty(master_fdp, slave_fdp, slave_name, uid)
2558 int i, mfd, sfd = -1;
2560 struct termios tios;
2564 * Try the unix98 way first.
2566 mfd = open("/dev/ptmx", O_RDWR);
2569 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2570 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2571 chmod(pty_name, S_IRUSR | S_IWUSR);
2574 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2575 warn("Couldn't unlock pty slave %s: %m", pty_name);
2577 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2578 warn("Couldn't open pty slave %s: %m", pty_name);
2581 #endif /* TIOCGPTN */
2584 /* the old way - scan through the pty name space */
2585 for (i = 0; i < 64; ++i) {
2586 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2587 'p' + i / 16, i % 16);
2588 mfd = open(pty_name, O_RDWR, 0);
2591 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2593 fchown(sfd, uid, -1);
2594 fchmod(sfd, S_IRUSR | S_IWUSR);
2605 strlcpy(slave_name, pty_name, 16);
2608 if (tcgetattr(sfd, &tios) == 0) {
2609 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2610 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2611 tios.c_iflag = IGNPAR;
2614 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2615 warn("couldn't set attributes on pty: %m");
2617 warn("couldn't get attributes on pty: %m");
2622 /********************************************************************
2624 * open_loopback - open the device we use for getting packets
2625 * in demand mode. Under Linux, we use a pty master/slave pair.
2628 open_ppp_loopback(void)
2633 if (new_style_driver) {
2634 /* allocate ourselves a ppp unit */
2635 if (make_ppp_unit() < 0)
2637 modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
2638 set_kdebugflag(kdebugflag);
2643 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2644 fatal("No free pty for loopback");
2645 SYSDEBUG(("using %s for loopback", loop_name));
2647 set_ppp_fd(slave_fd);
2649 flags = fcntl(master_fd, F_GETFL);
2651 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2652 warn("couldn't set master loopback to nonblock: %m");
2654 flags = fcntl(ppp_fd, F_GETFL);
2656 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2657 warn("couldn't set slave loopback to nonblock: %m");
2659 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2660 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2662 * Find out which interface we were given.
2664 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2665 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2667 * Enable debug in the driver if requested.
2669 set_kdebugflag (kdebugflag);
2674 /********************************************************************
2676 * sifnpmode - Set the mode for handling packets for a given NP.
2680 sifnpmode(u, proto, mode)
2687 npi.protocol = proto;
2689 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2690 if (! ok_error (errno))
2691 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2698 /********************************************************************
2700 * sipxfaddr - Config the interface IPX networknumber
2703 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2710 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2712 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2714 if (! ok_error (errno))
2715 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2719 memset (&ifr, '\0', sizeof (ifr));
2720 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2722 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2723 sipx->sipx_family = AF_IPX;
2724 sipx->sipx_port = 0;
2725 sipx->sipx_network = htonl (network);
2726 sipx->sipx_type = IPX_FRAME_ETHERII;
2727 sipx->sipx_action = IPX_CRTITF;
2729 * Set the IPX device
2731 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2733 if (errno != EEXIST) {
2734 if (! ok_error (errno))
2735 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2738 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2747 /********************************************************************
2749 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2750 * are removed and the device is no longer able to pass IPX
2754 int cipxfaddr (int unit)
2761 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2763 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2765 if (! ok_error (errno))
2766 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2770 memset (&ifr, '\0', sizeof (ifr));
2771 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2773 sipx->sipx_type = IPX_FRAME_ETHERII;
2774 sipx->sipx_action = IPX_DLTITF;
2775 sipx->sipx_family = AF_IPX;
2777 * Set the IPX device
2779 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2780 if (! ok_error (errno))
2781 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2791 * Use the hostname as part of the random number seed.
2800 for (p = hostname; *p != 0; ++p)
2805 /********************************************************************
2807 * sys_check_options - check the options that the user specified
2811 sys_check_options(void)
2815 * Disable the IPX protocol if the support is not present in the kernel.
2819 if (ipxcp_protent.enabled_flag) {
2820 struct stat stat_buf;
2821 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2822 || lstat(path, &stat_buf) < 0) {
2823 error("IPX support is not present in the kernel\n");
2824 ipxcp_protent.enabled_flag = 0;
2828 if (demand && driver_is_old) {
2829 option_error("demand dialling is not supported by kernel driver "
2830 "version %d.%d.%d", driver_version, driver_modification,
2834 if (multilink && !new_style_driver) {
2835 warn("Warning: multilink is not supported by the kernel driver");
2843 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2845 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2846 * that the system has a properly configured Ethernet interface for this
2847 * function to return non-zero.
2850 ether_to_eui64(eui64_t *p_eui64)
2854 const unsigned char *ptr;
2856 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2859 warn("could not open IPv6 socket");
2863 strcpy(ifr.ifr_name, "eth0");
2864 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2867 warn("could not obtain hardware address for eth0");
2873 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2875 ptr = ifr.ifr_hwaddr.sa_data;
2876 p_eui64->e8[0] = ptr[0] | 0x02;
2877 p_eui64->e8[1] = ptr[1];
2878 p_eui64->e8[2] = ptr[2];
2879 p_eui64->e8[3] = 0xFF;
2880 p_eui64->e8[4] = 0xFE;
2881 p_eui64->e8[5] = ptr[3];
2882 p_eui64->e8[6] = ptr[4];
2883 p_eui64->e8[7] = ptr[5];