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;
186 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
187 static int chindex; /* channel index (new style driver) */
189 static fd_set in_fds; /* set of fds that wait_input waits for */
190 static int max_in_fd; /* highest fd set in in_fds */
192 static int has_proxy_arp = 0;
193 static int driver_version = 0;
194 static int driver_modification = 0;
195 static int driver_patch = 0;
196 static int driver_is_old = 0;
197 static int restore_term = 0; /* 1 => we've munged the terminal */
198 static struct termios inittermios; /* Initial TTY termios */
200 int new_style_driver = 0;
202 static char loop_name[20];
203 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
205 static int if_is_up; /* Interface has been marked up */
206 static u_int32_t default_route_gateway; /* Gateway for default route added */
207 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
208 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
209 static u_int32_t our_old_addr; /* for detecting address changes */
210 static int dynaddr_set; /* 1 if ip_dynaddr set */
211 static int looped; /* 1 if using loop */
212 static int link_mtu; /* mtu for the link (not bundle) */
214 static struct utsname utsname; /* for the kernel version */
215 static int kernel_version;
216 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
220 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
221 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
222 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
224 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
226 /* Prototypes for procedures local to this file. */
227 static int get_flags (int fd);
228 static void set_flags (int fd, int flags);
229 static int translate_speed (int bps);
230 static int baud_rate_of (int speed);
231 static void close_route_table (void);
232 static int open_route_table (void);
233 static int read_route_table (struct rtentry *rt);
234 static int defaultroute_exists (struct rtentry *rt);
235 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
236 char *name, int namelen);
237 static void decode_version (char *buf, int *version, int *mod, int *patch);
238 static int set_kdebugflag(int level);
239 static int ppp_registered(void);
240 static int make_ppp_unit(void);
242 extern u_char inpacket_buf[]; /* borrowed from main.c */
245 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
249 #define SET_SA_FAMILY(addr, family) \
250 memset ((char *) &(addr), '\0', sizeof(addr)); \
251 addr.sa_family = (family);
254 * Determine if the PPP connection should still be present.
259 /* new_fd is the fd of a tty */
260 static void set_ppp_fd (int new_fd)
262 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
264 if (!new_style_driver)
268 static int still_ppp(void)
270 if (new_style_driver)
271 return !hungup && ppp_fd >= 0;
272 if (!hungup || ppp_fd == slave_fd)
275 set_ppp_fd(slave_fd);
281 /********************************************************************
283 * Functions to read and set the flags value in the device driver
286 static int get_flags (int fd)
290 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
291 if ( ok_error (errno) )
294 fatal("ioctl(PPPIOCGFLAGS): %m (line %d)", __LINE__);
297 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
301 /********************************************************************/
303 static void set_flags (int fd, int flags)
305 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
307 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
308 if (! ok_error (errno) )
309 fatal("ioctl(PPPIOCSFLAGS, %x): %m (line %d)", flags, errno, __LINE__);
313 /********************************************************************
315 * sys_init - System-dependent initialization.
322 if (new_style_driver) {
323 ppp_dev_fd = open("/dev/ppp", O_RDWR);
325 fatal("Couldn't open /dev/ppp: %m");
326 flags = fcntl(ppp_dev_fd, F_GETFL);
328 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
329 warn("Couldn't set /dev/ppp to nonblock: %m");
332 /* Get an internet socket for doing socket ioctls. */
333 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
335 fatal("Couldn't create IP socket: %m(%d)", errno);
338 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
340 sock6_fd = -errno; /* save errno for later */
347 /********************************************************************
349 * sys_cleanup - restore any system state we modified before exiting:
350 * mark the interface down, delete default route and/or proxy arp entry.
351 * This shouldn't call die() because it's called from die().
354 void sys_cleanup(void)
357 * Take down the device
364 * Delete any routes through the device.
366 if (default_route_gateway != 0)
367 cifdefaultroute(0, 0, default_route_gateway);
370 cifproxyarp(0, proxy_arp_addr);
373 /********************************************************************
375 * sys_close - Clean up in a child process before execing.
380 if (new_style_driver)
391 /********************************************************************
393 * set_kdebugflag - Define the debugging level for the kernel
396 static int set_kdebugflag (int requested_level)
398 if (new_style_driver && ifunit < 0)
400 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
401 if ( ! ok_error (errno) )
402 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
405 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
410 /********************************************************************
412 * tty_establish_ppp - Turn the serial port into a ppp interface.
415 int tty_establish_ppp (int tty_fd)
420 * Ensure that the tty device is in exclusive mode.
422 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
423 if ( ! ok_error ( errno ))
424 warn("Couldn't make tty exclusive: %m");
427 * Demand mode - prime the old ppp device to relinquish the unit.
429 if (!new_style_driver && looped
430 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
431 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
435 * Set the current tty to the PPP discpline
439 #define N_SYNC_PPP 14
441 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
442 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
443 if ( ! ok_error (errno) ) {
444 error("Couldn't set tty to PPP discipline: %m");
449 ret_fd = generic_establish_ppp(tty_fd);
451 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
452 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
456 set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
457 | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
459 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
460 warn("Couldn't reset tty to normal line discipline: %m");
466 /********************************************************************
468 * generic_establish_ppp - Turn the fd into a ppp interface.
470 int generic_establish_ppp (int fd)
474 if (new_style_driver) {
475 /* Open another instance of /dev/ppp and connect the channel to it */
478 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
479 error("Couldn't get channel number: %m");
482 dbglog("using channel %d", chindex);
483 fd = open("/dev/ppp", O_RDWR);
485 error("Couldn't reopen /dev/ppp: %m");
488 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
489 error("Couldn't attach to channel %d: %m", chindex);
492 flags = fcntl(fd, F_GETFL);
493 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
494 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
499 if (!looped && !multilink) {
501 * Create a new PPP unit.
503 if (make_ppp_unit() < 0)
508 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
512 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
513 error("Couldn't attach to PPP unit %d: %m", ifunit);
520 * Old-style driver: find out which interface we were given.
523 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
524 if (ok_error (errno))
526 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
528 /* Check that we got the same unit again. */
529 if (looped && x != ifunit)
530 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
534 * Fetch the initial file flags and reset blocking mode on the file.
536 initfdflags = fcntl(fd, F_GETFL);
537 if (initfdflags == -1 ||
538 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
539 if ( ! ok_error (errno))
540 warn("Couldn't set device to non-blocking mode: %m");
547 * Enable debug in the driver if requested.
550 set_kdebugflag (kdebugflag);
552 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
553 driver_version, driver_modification, driver_patch));
563 /********************************************************************
565 * tty_disestablish_ppp - Restore the serial port to normal operation.
566 * This shouldn't call die() because it's called from die().
569 void tty_disestablish_ppp(int tty_fd)
573 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
575 if (tcflush(tty_fd, TCIOFLUSH) < 0)
577 warn("tcflush failed: %m");
581 * Restore the previous line discipline
583 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
584 if ( ! ok_error (errno))
585 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
588 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
589 if ( ! ok_error (errno))
590 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
593 /* Reset non-blocking mode on fd. */
594 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
595 if ( ! ok_error (errno))
596 warn("Couldn't restore device fd flags: %m");
602 generic_disestablish_ppp(tty_fd);
605 /********************************************************************
607 * generic_disestablish_ppp - Restore device components to normal
608 * operation, and reconnect the ppp unit to the loopback if in demand
609 * mode. This shouldn't call die() because it's called from die().
611 void generic_disestablish_ppp(int dev_fd)
613 if (new_style_driver) {
617 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
619 } else if (ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
620 error("Couldn't release PPP unit: %m");
622 remove_fd(ppp_dev_fd);
624 /* old-style driver */
626 set_ppp_fd(slave_fd);
631 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
632 * Assumes new_style_driver.
634 static int make_ppp_unit()
639 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
640 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
641 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
643 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
646 error("Couldn't create new ppp unit: %m");
651 * cfg_bundle - configure the existing bundle.
652 * Used in demand mode.
654 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
658 if (!new_style_driver)
661 /* set the mrru, mtu and flags */
662 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
663 error("Couldn't set MRRU: %m");
664 flags = get_flags(ppp_dev_fd);
665 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
666 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
667 | (mrru? SC_MULTILINK: 0);
669 set_flags(ppp_dev_fd, flags);
671 /* connect up the channel */
672 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
673 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
678 * make_new_bundle - create a new PPP unit (i.e. a bundle)
679 * and connect our channel to it. This should only get called
680 * if `multilink' was set at the time establish_ppp was called.
681 * In demand mode this uses our existing bundle instead of making
684 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
686 if (!new_style_driver)
689 /* make us a ppp unit */
690 if (make_ppp_unit() < 0)
693 /* set the mrru and flags */
694 cfg_bundle(mrru, mtru, rssn, tssn);
698 * bundle_attach - attach our link to a given PPP unit.
699 * We assume the unit is controlled by another pppd.
701 int bundle_attach(int ifnum)
703 if (!new_style_driver)
706 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
708 return 0; /* doesn't still exist */
709 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
711 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
712 fatal("Couldn't connect to interface unit %d: %m", ifnum);
713 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
719 /********************************************************************
721 * clean_check - Fetch the flags for the device and generate
722 * appropriate error messages.
724 void clean_check(void)
730 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
732 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
734 s = "all had bit 7 set to 1";
738 s = "all had bit 7 set to 0";
742 s = "all had odd parity";
746 s = "all had even parity";
751 warn("Receive serial link is not 8-bit clean:");
752 warn("Problem: %s", s);
760 * List of valid speeds.
764 int speed_int, speed_val;
847 /********************************************************************
849 * Translate from bits/second to a speed_t.
852 static int translate_speed (int bps)
854 struct speed *speedp;
857 for (speedp = speeds; speedp->speed_int; speedp++) {
858 if (bps == speedp->speed_int)
859 return speedp->speed_val;
861 warn("speed %d not supported", bps);
866 /********************************************************************
868 * Translate from a speed_t to bits/second.
871 static int baud_rate_of (int speed)
873 struct speed *speedp;
876 for (speedp = speeds; speedp->speed_int; speedp++) {
877 if (speed == speedp->speed_val)
878 return speedp->speed_int;
884 /********************************************************************
886 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
887 * at the requested speed, etc. If `local' is true, set CLOCAL
888 * regardless of whether the modem option was specified.
891 void set_up_tty(int tty_fd, int local)
897 if (tcgetattr(tty_fd, &tios) < 0) {
898 if (!ok_error(errno))
899 fatal("tcgetattr: %m (line %d)", __LINE__);
906 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
907 tios.c_cflag |= CS8 | CREAD | HUPCL;
909 tios.c_iflag = IGNBRK | IGNPAR;
913 tios.c_cc[VTIME] = 0;
916 tios.c_cflag ^= (CLOCAL | HUPCL);
920 tios.c_cflag |= CRTSCTS;
924 tios.c_iflag |= IXON | IXOFF;
925 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
926 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
930 tios.c_cflag &= ~CRTSCTS;
937 speed = translate_speed(inspeed);
939 cfsetospeed (&tios, speed);
940 cfsetispeed (&tios, speed);
943 * We can't proceed if the serial port speed is B0,
944 * since that implies that the serial port is disabled.
947 speed = cfgetospeed(&tios);
949 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
952 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
953 if (!ok_error(errno))
954 fatal("tcsetattr: %m (line %d)", __LINE__);
956 baud_rate = baud_rate_of(speed);
960 /********************************************************************
962 * setdtr - control the DTR line on the serial port.
963 * This is called from die(), so it shouldn't call die().
966 void setdtr (int tty_fd, int on)
968 int modembits = TIOCM_DTR;
970 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
973 /********************************************************************
975 * restore_tty - restore the terminal to the saved settings.
978 void restore_tty (int tty_fd)
983 * Turn off echoing, because otherwise we can get into
984 * a loop with the tty and the modem echoing to each other.
985 * We presume we are the sole user of this tty device, so
986 * when we close it, it will revert to its defaults anyway.
989 inittermios.c_lflag &= ~(ECHO | ECHONL);
991 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
992 if (! ok_error (errno))
993 warn("tcsetattr: %m (line %d)", __LINE__);
998 /********************************************************************
1000 * output - Output PPP packet.
1003 void output (int unit, unsigned char *p, int len)
1008 dump_packet("sent", p, len);
1009 if (snoop_send_hook) snoop_send_hook(p, len);
1011 if (len < PPP_HDRLEN)
1013 if (new_style_driver) {
1016 proto = (p[0] << 8) + p[1];
1017 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1020 if (write(fd, p, len) < 0) {
1021 if (errno == EWOULDBLOCK || errno == ENOBUFS
1022 || errno == ENXIO || errno == EIO || errno == EINTR)
1023 warn("write: warning: %m (%d)", errno);
1025 error("write: %m (%d)", errno);
1029 /********************************************************************
1031 * wait_input - wait until there is data available,
1032 * for the length of time specified by *timo (indefinite
1036 void wait_input(struct timeval *timo)
1043 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1044 if (n < 0 && errno != EINTR)
1045 fatal("select: %m");
1049 * add_fd - add an fd to the set that wait_input waits for.
1053 FD_SET(fd, &in_fds);
1059 * remove_fd - remove an fd from the set that wait_input waits for.
1061 void remove_fd(int fd)
1063 FD_CLR(fd, &in_fds);
1067 /********************************************************************
1069 * read_packet - get a PPP packet from the serial device.
1072 int read_packet (unsigned char *buf)
1076 len = PPP_MRU + PPP_HDRLEN;
1077 if (new_style_driver) {
1078 *buf++ = PPP_ALLSTATIONS;
1084 nr = read(ppp_fd, buf, len);
1085 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1087 if (nr < 0 && errno == ENXIO)
1090 if (nr < 0 && new_style_driver && ifunit >= 0) {
1091 /* N.B. we read ppp_fd first since LCP packets come in there. */
1092 nr = read(ppp_dev_fd, buf, len);
1093 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1094 error("read /dev/ppp: %m");
1095 if (nr < 0 && errno == ENXIO)
1098 return (new_style_driver && nr > 0)? nr+2: nr;
1101 /********************************************************************
1103 * get_loop_output - get outgoing packets from the ppp device,
1104 * and detect when we want to bring the real link up.
1105 * Return value is 1 if we need to bring up the link, 0 otherwise.
1108 get_loop_output(void)
1113 if (new_style_driver) {
1114 while ((n = read_packet(inpacket_buf)) > 0)
1115 if (loop_frame(inpacket_buf, n))
1120 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1121 if (loop_chars(inbuf, n))
1125 fatal("eof on loopback");
1127 if (errno != EWOULDBLOCK)
1128 fatal("read from loopback: %m(%d)", errno);
1134 * netif_set_mtu - set the MTU on the PPP network interface.
1137 netif_set_mtu(int unit, int mtu)
1141 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1143 memset (&ifr, '\0', sizeof (ifr));
1144 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1147 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1148 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1152 * netif_get_mtu - get the MTU on the PPP network interface.
1155 netif_get_mtu(int unit)
1159 memset (&ifr, '\0', sizeof (ifr));
1160 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1162 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1163 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1169 /********************************************************************
1171 * tty_send_config - configure the transmit characteristics of
1172 * the ppp interface.
1175 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1180 * Set the asyncmap and other parameters for the ppp device
1185 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1186 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1187 if (!ok_error(errno))
1188 fatal("ioctl(PPPIOCSASYNCMAP): %m (line %d)", __LINE__);
1192 x = get_flags(ppp_fd);
1193 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1194 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1195 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1196 set_flags(ppp_fd, x);
1199 /********************************************************************
1201 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1204 void tty_set_xaccm (ext_accm accm)
1206 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1207 accm[0], accm[1], accm[2], accm[3]));
1211 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1212 if ( ! ok_error (errno))
1213 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1217 /********************************************************************
1219 * tty_recv_config - configure the receive-side characteristics of
1220 * the ppp interface.
1223 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1225 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
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 ( ! ok_error (errno))
1237 error("ioctl(PPPIOCSMRU): %m (line %d)", __LINE__);
1239 if (new_style_driver && ifunit >= 0
1240 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1241 error("Couldn't set MRU in generic PPP layer: %m");
1243 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1244 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1245 if (!ok_error(errno))
1246 error("ioctl(PPPIOCSRASYNCMAP): %m (line %d)", __LINE__);
1250 /********************************************************************
1252 * ccp_test - ask kernel whether a given compression method
1253 * is acceptable for use.
1257 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1259 struct ppp_option_data data;
1261 memset (&data, '\0', sizeof (data));
1263 data.length = opt_len;
1264 data.transmit = for_transmit;
1266 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1269 return (errno == ENOBUFS)? 0: -1;
1272 /********************************************************************
1274 * ccp_flags_set - inform kernel about the current state of CCP.
1277 void ccp_flags_set (int unit, int isopen, int isup)
1279 if (still_ppp() && ifunit >= 0) {
1280 int x = get_flags(ppp_dev_fd);
1281 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1282 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1283 set_flags (ppp_dev_fd, x);
1289 * set_filters - set the active and pass filters in the kernel driver.
1291 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1293 struct sock_fprog fp;
1295 fp.len = pass->bf_len;
1296 fp.filter = (struct sock_filter *) pass->bf_insns;
1297 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1298 if (errno == ENOTTY)
1299 warn("kernel does not support PPP filtering");
1301 error("Couldn't set pass-filter in kernel: %m");
1304 fp.len = active->bf_len;
1305 fp.filter = (struct sock_filter *) active->bf_insns;
1306 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1307 error("Couldn't set active-filter in kernel: %m");
1312 #endif /* PPP_FILTER */
1314 /********************************************************************
1316 * get_idle_time - return how long the link has been idle.
1319 get_idle_time(u, ip)
1321 struct ppp_idle *ip;
1323 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1326 /********************************************************************
1328 * get_ppp_stats - return statistics for the link.
1331 get_ppp_stats(u, stats)
1333 struct pppd_stats *stats;
1335 struct ifpppstatsreq req;
1337 memset (&req, 0, sizeof (req));
1339 req.stats_ptr = (caddr_t) &req.stats;
1340 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1341 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1342 error("Couldn't get PPP statistics: %m");
1345 stats->bytes_in = req.stats.p.ppp_ibytes;
1346 stats->bytes_out = req.stats.p.ppp_obytes;
1347 stats->pkts_in = req.stats.p.ppp_ipackets;
1348 stats->pkts_out = req.stats.p.ppp_opackets;
1352 /********************************************************************
1354 * ccp_fatal_error - returns 1 if decompression was disabled as a
1355 * result of an error detected after decompression of a packet,
1356 * 0 otherwise. This is necessary because of patent nonsense.
1359 int ccp_fatal_error (int unit)
1361 int x = get_flags(ppp_dev_fd);
1363 return x & SC_DC_FERROR;
1366 /********************************************************************
1368 * path_to_procfs - find the path to the proc file system mount point
1370 static char proc_path[MAXPATHLEN];
1371 static int proc_path_len;
1373 static char *path_to_procfs(const char *tail)
1375 struct mntent *mntent;
1378 if (proc_path_len == 0) {
1379 /* Default the mount location of /proc */
1380 strlcpy (proc_path, "/proc", sizeof(proc_path));
1382 fp = fopen(MOUNTED, "r");
1384 while ((mntent = getmntent(fp)) != NULL) {
1385 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1387 if (strcmp(mntent->mnt_type, "proc") == 0) {
1388 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1389 proc_path_len = strlen(proc_path);
1397 strlcpy(proc_path + proc_path_len, tail,
1398 sizeof(proc_path) - proc_path_len);
1403 * /proc/net/route parsing stuff.
1405 #define ROUTE_MAX_COLS 12
1406 FILE *route_fd = (FILE *) 0;
1407 static char route_buffer[512];
1408 static int route_dev_col, route_dest_col, route_gw_col;
1409 static int route_flags_col, route_mask_col;
1410 static int route_num_cols;
1412 static int open_route_table (void);
1413 static void close_route_table (void);
1414 static int read_route_table (struct rtentry *rt);
1416 /********************************************************************
1418 * close_route_table - close the interface to the route table
1421 static void close_route_table (void)
1423 if (route_fd != (FILE *) 0) {
1425 route_fd = (FILE *) 0;
1429 /********************************************************************
1431 * open_route_table - open the interface to the route table
1433 static char route_delims[] = " \t\n";
1435 static int open_route_table (void)
1439 close_route_table();
1441 path = path_to_procfs("/net/route");
1442 route_fd = fopen (path, "r");
1443 if (route_fd == NULL) {
1444 error("can't open routing table %s: %m", path);
1448 route_dev_col = 0; /* default to usual columns */
1451 route_flags_col = 3;
1455 /* parse header line */
1456 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1457 char *p = route_buffer, *q;
1459 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1461 if ((q = strtok(p, route_delims)) == 0)
1463 if (strcasecmp(q, "iface") == 0)
1464 route_dev_col = col;
1465 else if (strcasecmp(q, "destination") == 0)
1466 route_dest_col = col;
1467 else if (strcasecmp(q, "gateway") == 0)
1469 else if (strcasecmp(q, "flags") == 0)
1470 route_flags_col = col;
1471 else if (strcasecmp(q, "mask") == 0)
1472 route_mask_col = col;
1475 if (used && col >= route_num_cols)
1476 route_num_cols = col + 1;
1484 /********************************************************************
1486 * read_route_table - read the next entry from the route table
1489 static int read_route_table(struct rtentry *rt)
1491 char *cols[ROUTE_MAX_COLS], *p;
1494 memset (rt, '\0', sizeof (struct rtentry));
1496 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1500 for (col = 0; col < route_num_cols; ++col) {
1501 cols[col] = strtok(p, route_delims);
1502 if (cols[col] == NULL)
1503 return 0; /* didn't get enough columns */
1507 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1508 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1509 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1511 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1512 rt->rt_dev = cols[route_dev_col];
1517 /********************************************************************
1519 * defaultroute_exists - determine if there is a default route
1522 static int defaultroute_exists (struct rtentry *rt)
1526 if (!open_route_table())
1529 while (read_route_table(rt) != 0) {
1530 if ((rt->rt_flags & RTF_UP) == 0)
1533 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1535 if (SIN_ADDR(rt->rt_dst) == 0L) {
1541 close_route_table();
1546 * have_route_to - determine if the system has any route to
1547 * a given IP address. `addr' is in network byte order.
1548 * Return value is 1 if yes, 0 if no, -1 if don't know.
1549 * For demand mode to work properly, we have to ignore routes
1550 * through our own interface.
1552 int have_route_to(u_int32_t addr)
1557 if (!open_route_table())
1558 return -1; /* don't know */
1560 while (read_route_table(&rt)) {
1561 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1563 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1569 close_route_table();
1573 /********************************************************************
1575 * sifdefaultroute - assign a default route through the address given.
1578 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1582 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1583 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1585 if (old_gateway != gateway)
1586 error("not replacing existing default route to %s [%I]",
1587 rt.rt_dev, old_gateway);
1591 memset (&rt, '\0', sizeof (rt));
1592 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1593 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1597 if (kernel_version > KVERSION(2,1,0)) {
1598 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1599 SIN_ADDR(rt.rt_genmask) = 0L;
1602 SIN_ADDR(rt.rt_gateway) = gateway;
1604 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1605 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1606 if ( ! ok_error ( errno ))
1607 error("default route ioctl(SIOCADDRT): %m");
1611 default_route_gateway = gateway;
1615 /********************************************************************
1617 * cifdefaultroute - delete a default route through the address given.
1620 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1624 default_route_gateway = 0;
1626 memset (&rt, '\0', sizeof (rt));
1627 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1628 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1630 if (kernel_version > KVERSION(2,1,0)) {
1631 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1632 SIN_ADDR(rt.rt_genmask) = 0L;
1635 SIN_ADDR(rt.rt_gateway) = gateway;
1637 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1638 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1640 if ( ! ok_error ( errno ))
1641 error("default route ioctl(SIOCDELRT): %m");
1649 /********************************************************************
1651 * sifproxyarp - Make a proxy ARP entry for the peer.
1654 int sifproxyarp (int unit, u_int32_t his_adr)
1656 struct arpreq arpreq;
1659 if (has_proxy_arp == 0) {
1660 memset (&arpreq, '\0', sizeof(arpreq));
1662 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1663 SIN_ADDR(arpreq.arp_pa) = his_adr;
1664 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1666 * Get the hardware address of an interface on the same subnet
1667 * as our local address.
1669 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1670 sizeof(proxy_arp_dev))) {
1671 error("Cannot determine ethernet address for proxy ARP");
1674 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1676 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1677 if ( ! ok_error ( errno ))
1678 error("ioctl(SIOCSARP): %m");
1681 proxy_arp_addr = his_adr;
1685 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1686 if (forw_path != 0) {
1687 int fd = open(forw_path, O_WRONLY);
1689 if (write(fd, "1", 1) != 1)
1690 error("Couldn't enable IP forwarding: %m");
1700 /********************************************************************
1702 * cifproxyarp - Delete the proxy ARP entry for the peer.
1705 int cifproxyarp (int unit, u_int32_t his_adr)
1707 struct arpreq arpreq;
1709 if (has_proxy_arp) {
1711 memset (&arpreq, '\0', sizeof(arpreq));
1712 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1713 SIN_ADDR(arpreq.arp_pa) = his_adr;
1714 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1715 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1717 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1718 if ( ! ok_error ( errno ))
1719 warn("ioctl(SIOCDARP): %m");
1726 /********************************************************************
1728 * get_ether_addr - get the hardware address of an interface on the
1729 * the same subnet as ipaddr.
1732 static int get_ether_addr (u_int32_t ipaddr,
1733 struct sockaddr *hwaddr,
1734 char *name, int namelen)
1736 struct ifreq *ifr, *ifend;
1737 u_int32_t ina, mask;
1739 struct ifreq ifreq, bestifreq;
1741 struct ifreq ifs[MAX_IFS];
1743 u_int32_t bestmask=0;
1744 int found_interface = 0;
1746 ifc.ifc_len = sizeof(ifs);
1748 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1749 if ( ! ok_error ( errno ))
1750 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1754 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1755 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1757 * Scan through looking for an interface with an Internet
1758 * address on the same subnet as `ipaddr'.
1760 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1761 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1762 if (ifr->ifr_addr.sa_family == AF_INET) {
1763 ina = SIN_ADDR(ifr->ifr_addr);
1764 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1765 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1768 * Check that the interface is up, and not point-to-point
1771 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1774 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1777 * Get its netmask and check that it's on the right subnet.
1779 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1782 mask = SIN_ADDR(ifreq.ifr_addr);
1783 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1784 ip_ntoa(ina), ntohl(mask)));
1786 if (((ipaddr ^ ina) & mask) != 0)
1787 continue; /* no match */
1789 if (mask >= bestmask) {
1790 /* Compare using >= instead of > -- it is possible for
1791 an interface to have a netmask of 0.0.0.0 */
1792 found_interface = 1;
1799 if (!found_interface) return 0;
1801 strlcpy(name, bestifreq.ifr_name, namelen);
1803 /* trim off the :1 in eth0:1 */
1804 aliasp = strchr(name, ':');
1808 info("found interface %s for proxy arp", name);
1810 * Now get the hardware address.
1812 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1813 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1814 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1819 &bestifreq.ifr_hwaddr,
1820 sizeof (struct sockaddr));
1822 SYSDEBUG ((LOG_DEBUG,
1823 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1824 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1825 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1826 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1827 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1828 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1829 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1830 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1831 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1836 * get_if_hwaddr - get the hardware address for the specified
1837 * network interface device.
1840 get_if_hwaddr(u_char *addr, char *name)
1845 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1848 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1849 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1850 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1853 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1858 * get_first_ethernet - return the name of the first ethernet-style
1859 * interface on this system.
1862 get_first_ethernet()
1867 /********************************************************************
1869 * Return user specified netmask, modified by any mask we might determine
1870 * for address `addr' (in network byte order).
1871 * Here we scan through the system's list of interfaces, looking for
1872 * any non-point-to-point interfaces which might appear to be on the same
1873 * network as `addr'. If we find any, we OR in their netmask to the
1874 * user-specified netmask.
1877 u_int32_t GetMask (u_int32_t addr)
1879 u_int32_t mask, nmask, ina;
1880 struct ifreq *ifr, *ifend, ifreq;
1882 struct ifreq ifs[MAX_IFS];
1886 if (IN_CLASSA(addr)) /* determine network mask for address class */
1887 nmask = IN_CLASSA_NET;
1888 else if (IN_CLASSB(addr))
1889 nmask = IN_CLASSB_NET;
1891 nmask = IN_CLASSC_NET;
1893 /* class D nets are disallowed by bad_ip_adrs */
1894 mask = netmask | htonl(nmask);
1896 * Scan through the system's network interfaces.
1898 ifc.ifc_len = sizeof(ifs);
1900 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1901 if ( ! ok_error ( errno ))
1902 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1906 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1907 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1909 * Check the interface's internet address.
1911 if (ifr->ifr_addr.sa_family != AF_INET)
1913 ina = SIN_ADDR(ifr->ifr_addr);
1914 if (((ntohl(ina) ^ addr) & nmask) != 0)
1917 * Check that the interface is up, and not point-to-point nor loopback.
1919 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1920 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1923 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1926 * Get its netmask and OR it into our mask.
1928 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1930 mask |= SIN_ADDR(ifreq.ifr_addr);
1936 /********************************************************************
1938 * Internal routine to decode the version.modification.patch level
1941 static void decode_version (char *buf, int *version,
1942 int *modification, int *patch)
1946 *version = (int) strtoul (buf, &endp, 10);
1950 if (endp != buf && *endp == '.') {
1952 *modification = (int) strtoul (buf, &endp, 10);
1953 if (endp != buf && *endp == '.') {
1955 *patch = (int) strtoul (buf, &buf, 10);
1960 /********************************************************************
1962 * Procedure to determine if the PPP line discipline is registered.
1966 ppp_registered(void)
1974 * We used to open the serial device and set it to the ppp line
1975 * discipline here, in order to create a ppp unit. But that is
1976 * not a good idea - the user might have specified a device that
1977 * they can't open (permission, or maybe it doesn't really exist).
1978 * So we grab a pty master/slave pair and use that.
1980 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1981 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1986 * Try to put the device into the PPP discipline.
1988 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1989 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
1998 /********************************************************************
2000 * ppp_available - check whether the system has any ppp interfaces
2001 * (in fact we check whether we can do an ioctl on ppp0).
2004 int ppp_available(void)
2009 int my_version, my_modification, my_patch;
2010 int osmaj, osmin, ospatch;
2013 "This system lacks kernel support for PPP. This could be because\n"
2014 "the PPP kernel module could not be loaded, or because PPP was not\n"
2015 "included in the kernel configuration. If PPP was included as a\n"
2016 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
2017 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2018 "See README.linux file in the ppp distribution for more details.\n";
2020 /* get the kernel version now, since we are called before sys_init */
2022 osmaj = osmin = ospatch = 0;
2023 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2024 kernel_version = KVERSION(osmaj, osmin, ospatch);
2026 fd = open("/dev/ppp", O_RDWR);
2028 if (fd < 0 && errno == ENOENT) {
2029 /* try making it and see if that helps. */
2030 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
2031 makedev(108, 0)) >= 0) {
2032 fd = open("/dev/ppp", O_RDWR);
2034 info("Created /dev/ppp device node");
2036 unlink("/dev/ppp"); /* didn't work, undo the mknod */
2037 } else if (errno == EEXIST) {
2038 fd = open("/dev/ppp", O_RDWR);
2043 new_style_driver = 1;
2045 /* XXX should get from driver */
2047 driver_modification = 4;
2052 if (kernel_version >= KVERSION(2,3,13)) {
2053 if (errno == ENOENT)
2055 "pppd is unable to open the /dev/ppp device.\n"
2056 "You need to create the /dev/ppp device node by\n"
2057 "executing the following command as root:\n"
2058 " mknod /dev/ppp c 108 0\n";
2063 * Open a socket for doing the ioctl operations.
2065 s = socket(AF_INET, SOCK_DGRAM, 0);
2069 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2070 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2072 * If the device did not exist then attempt to create one by putting the
2073 * current tty into the PPP discipline. If this works then obtain the
2074 * flags for the device again.
2077 if (ppp_registered()) {
2078 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2079 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2083 * Ensure that the hardware address is for PPP and not something else
2086 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2088 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2092 * This is the PPP device. Validate the version of the driver at this
2093 * point to ensure that this program will work with the driver.
2096 char abBuffer [1024];
2098 ifr.ifr_data = abBuffer;
2099 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2101 error("Couldn't read driver version: %m");
2103 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2106 decode_version(abBuffer,
2108 &driver_modification,
2111 * Validate the version of the driver against the version that we used.
2113 decode_version(VERSION,
2118 /* The version numbers must match */
2119 if (driver_version != my_version)
2122 /* The modification levels must be legal */
2123 if (driver_modification < 3) {
2124 if (driver_modification >= 2) {
2125 /* we can cope with 2.2.0 and above */
2134 slprintf(route_buffer, sizeof(route_buffer),
2135 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2136 driver_version, driver_modification, driver_patch);
2138 no_ppp_msg = route_buffer;
2145 /********************************************************************
2147 * Update the wtmp file with the appropriate user name and tty device.
2150 void logwtmp (const char *line, const char *name, const char *host)
2152 struct utmp ut, *utp;
2153 pid_t mypid = getpid();
2159 * Update the signon database for users.
2160 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2162 utmpname(_PATH_UTMP);
2164 while ((utp = getutent()) && (utp->ut_pid != mypid))
2168 memcpy(&ut, utp, sizeof(ut));
2170 /* some gettys/telnetds don't initialize utmp... */
2171 memset(&ut, 0, sizeof(ut));
2173 if (ut.ut_id[0] == 0)
2174 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2176 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2177 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2181 ut.ut_type = USER_PROCESS;
2184 /* Insert the host name if one is supplied */
2186 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2188 /* Insert the IP address of the remote system if IP is enabled */
2189 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2190 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2191 sizeof(ut.ut_addr));
2193 /* CL: Makes sure that the logout works */
2194 if (*host == 0 && *name==0)
2200 * Update the wtmp file.
2203 updwtmp(_PATH_WTMP, &ut);
2205 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2207 flock(wtmp, LOCK_EX);
2209 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2210 warn("error writing %s: %m", _PATH_WTMP);
2212 flock(wtmp, LOCK_UN);
2220 /********************************************************************
2222 * sifvjcomp - config tcp header compression
2225 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2227 u_int x = get_flags(ppp_dev_fd);
2230 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2231 if (! ok_error (errno))
2232 error("ioctl(PPPIOCSMAXCID): %m (line %d)", __LINE__);
2237 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2238 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2239 set_flags (ppp_dev_fd, x);
2244 /********************************************************************
2246 * sifup - Config the interface up and enable IP packets to pass.
2253 memset (&ifr, '\0', sizeof (ifr));
2254 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2255 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2256 if (! ok_error (errno))
2257 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2261 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2262 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2263 if (! ok_error (errno))
2264 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2272 /********************************************************************
2274 * sifdown - Disable the indicated protocol and config the interface
2275 * down if there are no remaining protocols.
2282 if (if_is_up && --if_is_up > 0)
2285 memset (&ifr, '\0', sizeof (ifr));
2286 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2287 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2288 if (! ok_error (errno))
2289 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2293 ifr.ifr_flags &= ~IFF_UP;
2294 ifr.ifr_flags |= IFF_POINTOPOINT;
2295 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2296 if (! ok_error (errno))
2297 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2303 /********************************************************************
2305 * sifaddr - Config the interface IP addresses and netmask.
2308 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2314 memset (&ifr, '\0', sizeof (ifr));
2315 memset (&rt, '\0', sizeof (rt));
2317 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2318 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2319 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2321 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2323 * Set our IP address
2325 SIN_ADDR(ifr.ifr_addr) = our_adr;
2326 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2327 if (errno != EEXIST) {
2328 if (! ok_error (errno))
2329 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2332 warn("ioctl(SIOCSIFADDR): Address already exists");
2337 * Set the gateway address
2339 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2340 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2341 if (! ok_error (errno))
2342 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2347 * For recent kernels, force the netmask to 255.255.255.255.
2349 if (kernel_version >= KVERSION(2,1,16))
2351 if (net_mask != 0) {
2352 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2353 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2354 if (! ok_error (errno))
2355 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2360 * Add the device route
2362 if (kernel_version < KVERSION(2,1,16)) {
2363 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2364 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2367 SIN_ADDR(rt.rt_gateway) = 0L;
2368 SIN_ADDR(rt.rt_dst) = his_adr;
2369 rt.rt_flags = RTF_UP | RTF_HOST;
2371 if (kernel_version > KVERSION(2,1,0)) {
2372 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2373 SIN_ADDR(rt.rt_genmask) = -1L;
2376 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2377 if (! ok_error (errno))
2378 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2383 /* set ip_dynaddr in demand mode if address changes */
2384 if (demand && tune_kernel && !dynaddr_set
2385 && our_old_addr && our_old_addr != our_adr) {
2386 /* set ip_dynaddr if possible */
2390 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2391 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2392 if (write(fd, "1", 1) != 1)
2393 error("Couldn't enable dynamic IP addressing: %m");
2396 dynaddr_set = 1; /* only 1 attempt */
2403 /********************************************************************
2405 * cifaddr - Clear the interface IP addresses, and delete routes
2406 * through the interface if possible.
2409 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2413 if (kernel_version < KVERSION(2,1,16)) {
2415 * Delete the route through the device
2418 memset (&rt, '\0', sizeof (rt));
2420 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2421 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2424 SIN_ADDR(rt.rt_gateway) = 0;
2425 SIN_ADDR(rt.rt_dst) = his_adr;
2426 rt.rt_flags = RTF_UP | RTF_HOST;
2428 if (kernel_version > KVERSION(2,1,0)) {
2429 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2430 SIN_ADDR(rt.rt_genmask) = -1L;
2433 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2434 if (still_ppp() && ! ok_error (errno))
2435 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2440 /* This way it is possible to have an IPX-only or IPv6-only interface */
2441 memset(&ifr, 0, sizeof(ifr));
2442 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2443 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2445 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2446 if (! ok_error (errno)) {
2447 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2452 our_old_addr = our_adr;
2458 /********************************************************************
2460 * sif6addr - Config the interface with an IPv6 link-local address
2462 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2464 struct in6_ifreq ifr6;
2466 struct in6_rtmsg rt6;
2470 error("IPv6 socket creation failed: %m");
2473 memset(&ifr, 0, sizeof (ifr));
2474 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2475 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2476 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2480 /* Local interface */
2481 memset(&ifr6, 0, sizeof(ifr6));
2482 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2483 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2484 ifr6.ifr6_prefixlen = 10;
2486 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2487 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2491 /* Route to remote host */
2492 memset(&rt6, 0, sizeof(rt6));
2493 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2494 rt6.rtmsg_flags = RTF_UP;
2495 rt6.rtmsg_dst_len = 10;
2496 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2497 rt6.rtmsg_metric = 1;
2499 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2500 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2508 /********************************************************************
2510 * cif6addr - Remove IPv6 address from interface
2512 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2515 struct in6_ifreq ifr6;
2519 error("IPv6 socket creation failed: %m");
2522 memset(&ifr, 0, sizeof(ifr));
2523 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2524 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2525 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2529 memset(&ifr6, 0, sizeof(ifr6));
2530 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2531 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2532 ifr6.ifr6_prefixlen = 10;
2534 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2535 if (errno != EADDRNOTAVAIL) {
2536 if (! ok_error (errno))
2537 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2540 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2549 * get_pty - get a pty master/slave pair and chown the slave side
2550 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2553 get_pty(master_fdp, slave_fdp, slave_name, uid)
2559 int i, mfd, sfd = -1;
2561 struct termios tios;
2565 * Try the unix98 way first.
2567 mfd = open("/dev/ptmx", O_RDWR);
2570 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2571 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2572 chmod(pty_name, S_IRUSR | S_IWUSR);
2575 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2576 warn("Couldn't unlock pty slave %s: %m", pty_name);
2578 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2579 warn("Couldn't open pty slave %s: %m", pty_name);
2582 #endif /* TIOCGPTN */
2585 /* the old way - scan through the pty name space */
2586 for (i = 0; i < 64; ++i) {
2587 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2588 'p' + i / 16, i % 16);
2589 mfd = open(pty_name, O_RDWR, 0);
2592 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2594 fchown(sfd, uid, -1);
2595 fchmod(sfd, S_IRUSR | S_IWUSR);
2606 strlcpy(slave_name, pty_name, 16);
2609 if (tcgetattr(sfd, &tios) == 0) {
2610 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2611 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2612 tios.c_iflag = IGNPAR;
2615 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2616 warn("couldn't set attributes on pty: %m");
2618 warn("couldn't get attributes on pty: %m");
2623 /********************************************************************
2625 * open_loopback - open the device we use for getting packets
2626 * in demand mode. Under Linux, we use a pty master/slave pair.
2629 open_ppp_loopback(void)
2634 if (new_style_driver) {
2635 /* allocate ourselves a ppp unit */
2636 if (make_ppp_unit() < 0)
2638 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2639 set_kdebugflag(kdebugflag);
2644 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2645 fatal("No free pty for loopback");
2646 SYSDEBUG(("using %s for loopback", loop_name));
2648 set_ppp_fd(slave_fd);
2650 flags = fcntl(master_fd, F_GETFL);
2652 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2653 warn("couldn't set master loopback to nonblock: %m");
2655 flags = fcntl(ppp_fd, F_GETFL);
2657 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2658 warn("couldn't set slave loopback to nonblock: %m");
2660 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2661 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2663 * Find out which interface we were given.
2665 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2666 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2668 * Enable debug in the driver if requested.
2670 set_kdebugflag (kdebugflag);
2675 /********************************************************************
2677 * sifnpmode - Set the mode for handling packets for a given NP.
2681 sifnpmode(u, proto, mode)
2688 npi.protocol = proto;
2690 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2691 if (! ok_error (errno))
2692 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2699 /********************************************************************
2701 * sipxfaddr - Config the interface IPX networknumber
2704 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2711 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2713 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2715 if (! ok_error (errno))
2716 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2720 memset (&ifr, '\0', sizeof (ifr));
2721 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2723 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2724 sipx->sipx_family = AF_IPX;
2725 sipx->sipx_port = 0;
2726 sipx->sipx_network = htonl (network);
2727 sipx->sipx_type = IPX_FRAME_ETHERII;
2728 sipx->sipx_action = IPX_CRTITF;
2730 * Set the IPX device
2732 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2734 if (errno != EEXIST) {
2735 if (! ok_error (errno))
2736 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2739 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2748 /********************************************************************
2750 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2751 * are removed and the device is no longer able to pass IPX
2755 int cipxfaddr (int unit)
2762 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2764 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2766 if (! ok_error (errno))
2767 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2771 memset (&ifr, '\0', sizeof (ifr));
2772 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2774 sipx->sipx_type = IPX_FRAME_ETHERII;
2775 sipx->sipx_action = IPX_DLTITF;
2776 sipx->sipx_family = AF_IPX;
2778 * Set the IPX device
2780 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2781 if (! ok_error (errno))
2782 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2792 * Use the hostname as part of the random number seed.
2801 for (p = hostname; *p != 0; ++p)
2806 /********************************************************************
2808 * sys_check_options - check the options that the user specified
2812 sys_check_options(void)
2816 * Disable the IPX protocol if the support is not present in the kernel.
2820 if (ipxcp_protent.enabled_flag) {
2821 struct stat stat_buf;
2822 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2823 || lstat(path, &stat_buf) < 0) {
2824 error("IPX support is not present in the kernel\n");
2825 ipxcp_protent.enabled_flag = 0;
2829 if (demand && driver_is_old) {
2830 option_error("demand dialling is not supported by kernel driver "
2831 "version %d.%d.%d", driver_version, driver_modification,
2835 if (multilink && !new_style_driver) {
2836 warn("Warning: multilink is not supported by the kernel driver");
2844 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2846 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2847 * that the system has a properly configured Ethernet interface for this
2848 * function to return non-zero.
2851 ether_to_eui64(eui64_t *p_eui64)
2855 const unsigned char *ptr;
2857 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2860 warn("could not open IPv6 socket");
2864 strcpy(ifr.ifr_name, "eth0");
2865 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2868 warn("could not obtain hardware address for eth0");
2874 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2876 ptr = ifr.ifr_hwaddr.sa_data;
2877 p_eui64->e8[0] = ptr[0] | 0x02;
2878 p_eui64->e8[1] = ptr[1];
2879 p_eui64->e8[2] = ptr[2];
2880 p_eui64->e8[3] = 0xFF;
2881 p_eui64->e8[4] = 0xFE;
2882 p_eui64->e8[5] = ptr[3];
2883 p_eui64->e8[6] = ptr[4];
2884 p_eui64->e8[7] = ptr[5];