2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1989 Carnegie Mellon University.
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by Carnegie Mellon University. The name of the
14 * University may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 #include <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
25 #include <sys/errno.h>
28 #include <sys/utsname.h>
29 #include <sys/sysmacros.h>
45 /* This is in netdevice.h. However, this compile will fail miserably if
46 you attempt to include netdevice.h because it has so many references
47 to __memcpy functions which it should not attempt to do. So, since I
48 really don't use it, but it must be defined, define it now. */
51 #define MAX_ADDR_LEN 7
55 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
57 #include <net/if_arp.h>
58 #include <net/route.h>
59 #include <netinet/if_ether.h>
61 #include <linux/types.h>
63 #include <linux/if_arp.h>
64 #include <linux/route.h>
65 #include <linux/if_ether.h>
67 #include <netinet/in.h>
68 #include <arpa/inet.h>
70 #include <linux/ppp_defs.h>
71 #include <linux/if_ppp.h>
79 #if __GLIBC__ >= 2 && \
80 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
81 #include <netipx/ipx.h>
83 #include <linux/ipx.h>
85 #endif /* IPX_CHANGE */
89 #include <linux/filter.h>
90 #endif /* PPP_FILTER */
93 #include <sys/locks.h>
99 * This is in linux/include/net/ipv6.h.
103 struct in6_addr ifr6_addr;
104 __u32 ifr6_prefixlen;
105 unsigned int ifr6_ifindex;
109 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
110 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
111 sin6.s6_addr16[0] = htons(0xfe80); \
112 eui64_copy(eui64, sin6.s6_addr32[2]); \
117 /* We can get an EIO error on an ioctl if the modem has hung up */
118 #define ok_error(num) ((num)==EIO)
120 static int tty_disc = N_TTY; /* The TTY discipline */
121 static int ppp_disc = N_PPP; /* The PPP discpline */
122 static int initfdflags = -1; /* Initial file descriptor flags for fd */
123 static int ppp_fd = -1; /* fd which is set to PPP discipline */
124 static int sock_fd = -1; /* socket for doing interface ioctls */
125 static int slave_fd = -1;
126 static int master_fd = -1;
128 static int sock6_fd = -1;
130 int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
131 static int chindex; /* channel index (new style driver) */
133 static fd_set in_fds; /* set of fds that wait_input waits for */
134 static int max_in_fd; /* highest fd set in in_fds */
136 static int has_proxy_arp = 0;
137 static int driver_version = 0;
138 static int driver_modification = 0;
139 static int driver_patch = 0;
140 static int driver_is_old = 0;
141 static int restore_term = 0; /* 1 => we've munged the terminal */
142 static struct termios inittermios; /* Initial TTY termios */
144 int new_style_driver = 0;
146 static char loop_name[20];
147 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
149 static int if_is_up; /* Interface has been marked up */
150 static u_int32_t default_route_gateway; /* Gateway for default route added */
151 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
152 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
153 static u_int32_t our_old_addr; /* for detecting address changes */
154 static int dynaddr_set; /* 1 if ip_dynaddr set */
155 static int looped; /* 1 if using loop */
156 static int link_mtu; /* mtu for the link (not bundle) */
158 static struct utsname utsname; /* for the kernel version */
159 static int kernel_version;
160 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
164 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
165 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
166 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
168 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
170 /* Prototypes for procedures local to this file. */
171 static int get_flags (int fd);
172 static void set_flags (int fd, int flags);
173 static int translate_speed (int bps);
174 static int baud_rate_of (int speed);
175 static void close_route_table (void);
176 static int open_route_table (void);
177 static int read_route_table (struct rtentry *rt);
178 static int defaultroute_exists (struct rtentry *rt);
179 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
180 char *name, int namelen);
181 static void decode_version (char *buf, int *version, int *mod, int *patch);
182 static int set_kdebugflag(int level);
183 static int ppp_registered(void);
184 static int make_ppp_unit(void);
186 extern u_char inpacket_buf[]; /* borrowed from main.c */
189 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
193 #define SET_SA_FAMILY(addr, family) \
194 memset ((char *) &(addr), '\0', sizeof(addr)); \
195 addr.sa_family = (family);
198 * Determine if the PPP connection should still be present.
203 /* new_fd is the fd of a tty */
204 static void set_ppp_fd (int new_fd)
206 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
208 if (!new_style_driver)
212 static int still_ppp(void)
214 if (new_style_driver)
215 return !hungup && ppp_fd >= 0;
216 if (!hungup || ppp_fd == slave_fd)
219 set_ppp_fd(slave_fd);
225 /********************************************************************
227 * Functions to read and set the flags value in the device driver
230 static int get_flags (int fd)
234 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
235 if ( ok_error (errno) )
238 fatal("ioctl(PPPIOCGFLAGS): %m (line %d)", __LINE__);
241 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
245 /********************************************************************/
247 static void set_flags (int fd, int flags)
249 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
251 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
252 if (! ok_error (errno) )
253 fatal("ioctl(PPPIOCSFLAGS, %x): %m (line %d)", flags, errno, __LINE__);
257 /********************************************************************
259 * sys_init - System-dependent initialization.
266 if (new_style_driver) {
267 ppp_dev_fd = open("/dev/ppp", O_RDWR);
269 fatal("Couldn't open /dev/ppp: %m");
270 flags = fcntl(ppp_dev_fd, F_GETFL);
272 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
273 warn("Couldn't set /dev/ppp to nonblock: %m");
276 /* Get an internet socket for doing socket ioctls. */
277 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
279 fatal("Couldn't create IP socket: %m(%d)", errno);
282 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
284 sock6_fd = -errno; /* save errno for later */
291 /********************************************************************
293 * sys_cleanup - restore any system state we modified before exiting:
294 * mark the interface down, delete default route and/or proxy arp entry.
295 * This shouldn't call die() because it's called from die().
298 void sys_cleanup(void)
301 * Take down the device
308 * Delete any routes through the device.
310 if (default_route_gateway != 0)
311 cifdefaultroute(0, 0, default_route_gateway);
314 cifproxyarp(0, proxy_arp_addr);
317 /********************************************************************
319 * sys_close - Clean up in a child process before execing.
324 if (new_style_driver)
335 /********************************************************************
337 * set_kdebugflag - Define the debugging level for the kernel
340 static int set_kdebugflag (int requested_level)
342 if (new_style_driver && ifunit < 0)
344 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
345 if ( ! ok_error (errno) )
346 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
349 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
354 /********************************************************************
356 * tty_establish_ppp - Turn the serial port into a ppp interface.
359 int tty_establish_ppp (int tty_fd)
364 * Ensure that the tty device is in exclusive mode.
366 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
367 if ( ! ok_error ( errno ))
368 warn("Couldn't make tty exclusive: %m");
371 * Demand mode - prime the old ppp device to relinquish the unit.
373 if (!new_style_driver && looped
374 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
375 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
379 * Set the current tty to the PPP discpline
383 #define N_SYNC_PPP 14
385 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
386 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
387 if ( ! ok_error (errno) ) {
388 error("Couldn't set tty to PPP discipline: %m");
393 ret_fd = generic_establish_ppp(tty_fd);
395 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
396 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
400 set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
401 | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
403 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
404 warn("Couldn't reset tty to normal line discipline: %m");
410 /********************************************************************
412 * generic_establish_ppp - Turn the fd into a ppp interface.
414 int generic_establish_ppp (int fd)
418 if (new_style_driver) {
419 /* Open another instance of /dev/ppp and connect the channel to it */
422 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
423 error("Couldn't get channel number: %m");
426 dbglog("using channel %d", chindex);
427 fd = open("/dev/ppp", O_RDWR);
429 error("Couldn't reopen /dev/ppp: %m");
432 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
433 error("Couldn't attach to channel %d: %m", chindex);
436 flags = fcntl(fd, F_GETFL);
437 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
438 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
443 if (!looped && !multilink) {
445 * Create a new PPP unit.
447 if (make_ppp_unit() < 0)
452 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
456 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
457 error("Couldn't attach to PPP unit %d: %m", ifunit);
464 * Old-style driver: find out which interface we were given.
467 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
468 if (ok_error (errno))
470 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
472 /* Check that we got the same unit again. */
473 if (looped && x != ifunit)
474 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
478 * Fetch the initial file flags and reset blocking mode on the file.
480 initfdflags = fcntl(fd, F_GETFL);
481 if (initfdflags == -1 ||
482 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
483 if ( ! ok_error (errno))
484 warn("Couldn't set device to non-blocking mode: %m");
491 * Enable debug in the driver if requested.
494 set_kdebugflag (kdebugflag);
496 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
497 driver_version, driver_modification, driver_patch));
507 /********************************************************************
509 * tty_disestablish_ppp - Restore the serial port to normal operation.
510 * This shouldn't call die() because it's called from die().
513 void tty_disestablish_ppp(int tty_fd)
517 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
519 if (tcflush(tty_fd, TCIOFLUSH) < 0)
520 warn("tcflush failed: %m");
522 * Restore the previous line discipline
524 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
525 if ( ! ok_error (errno))
526 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
529 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
530 if ( ! ok_error (errno))
531 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
534 /* Reset non-blocking mode on fd. */
535 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
536 if ( ! ok_error (errno))
537 warn("Couldn't restore device fd flags: %m");
542 generic_disestablish_ppp(tty_fd);
545 /********************************************************************
547 * generic_disestablish_ppp - Restore device components to normal
548 * operation, and reconnect the ppp unit to the loopback if in demand
549 * mode. This shouldn't call die() because it's called from die().
551 void generic_disestablish_ppp(int dev_fd)
553 if (new_style_driver) {
557 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
559 } else if (ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
560 error("Couldn't release PPP unit: %m");
562 remove_fd(ppp_dev_fd);
564 /* old-style driver */
566 set_ppp_fd(slave_fd);
571 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
572 * Assumes new_style_driver.
574 static int make_ppp_unit()
579 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
580 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
581 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
583 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
586 error("Couldn't create new ppp unit: %m");
591 * cfg_bundle - configure the existing bundle.
592 * Used in demand mode.
594 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
598 if (!new_style_driver)
601 /* set the mrru, mtu and flags */
602 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
603 error("Couldn't set MRRU: %m");
604 flags = get_flags(ppp_dev_fd);
605 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
606 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
607 | (mrru? SC_MULTILINK: 0);
609 set_flags(ppp_dev_fd, flags);
611 /* connect up the channel */
612 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
613 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
618 * make_new_bundle - create a new PPP unit (i.e. a bundle)
619 * and connect our channel to it. This should only get called
620 * if `multilink' was set at the time establish_ppp was called.
621 * In demand mode this uses our existing bundle instead of making
624 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
626 if (!new_style_driver)
629 /* make us a ppp unit */
630 if (make_ppp_unit() < 0)
633 /* set the mrru and flags */
634 cfg_bundle(mrru, mtru, rssn, tssn);
638 * bundle_attach - attach our link to a given PPP unit.
639 * We assume the unit is controlled by another pppd.
641 int bundle_attach(int ifnum)
643 if (!new_style_driver)
646 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
648 return 0; /* doesn't still exist */
649 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
651 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
652 fatal("Couldn't connect to interface unit %d: %m", ifnum);
653 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
659 /********************************************************************
661 * clean_check - Fetch the flags for the device and generate
662 * appropriate error messages.
664 void clean_check(void)
670 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
672 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
674 s = "all had bit 7 set to 1";
678 s = "all had bit 7 set to 0";
682 s = "all had odd parity";
686 s = "all had even parity";
691 warn("Receive serial link is not 8-bit clean:");
692 warn("Problem: %s", s);
700 * List of valid speeds.
704 int speed_int, speed_val;
787 /********************************************************************
789 * Translate from bits/second to a speed_t.
792 static int translate_speed (int bps)
794 struct speed *speedp;
797 for (speedp = speeds; speedp->speed_int; speedp++) {
798 if (bps == speedp->speed_int)
799 return speedp->speed_val;
801 warn("speed %d not supported", bps);
806 /********************************************************************
808 * Translate from a speed_t to bits/second.
811 static int baud_rate_of (int speed)
813 struct speed *speedp;
816 for (speedp = speeds; speedp->speed_int; speedp++) {
817 if (speed == speedp->speed_val)
818 return speedp->speed_int;
824 /********************************************************************
826 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
827 * at the requested speed, etc. If `local' is true, set CLOCAL
828 * regardless of whether the modem option was specified.
831 void set_up_tty(int tty_fd, int local)
837 if (tcgetattr(tty_fd, &tios) < 0) {
838 if (!ok_error(errno))
839 fatal("tcgetattr: %m (line %d)", __LINE__);
846 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
847 tios.c_cflag |= CS8 | CREAD | HUPCL;
849 tios.c_iflag = IGNBRK | IGNPAR;
853 tios.c_cc[VTIME] = 0;
856 tios.c_cflag ^= (CLOCAL | HUPCL);
860 tios.c_cflag |= CRTSCTS;
864 tios.c_iflag |= IXON | IXOFF;
865 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
866 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
870 tios.c_cflag &= ~CRTSCTS;
877 speed = translate_speed(inspeed);
879 cfsetospeed (&tios, speed);
880 cfsetispeed (&tios, speed);
883 * We can't proceed if the serial port speed is B0,
884 * since that implies that the serial port is disabled.
887 speed = cfgetospeed(&tios);
889 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
892 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
893 if (!ok_error(errno))
894 fatal("tcsetattr: %m (line %d)", __LINE__);
896 baud_rate = baud_rate_of(speed);
900 /********************************************************************
902 * setdtr - control the DTR line on the serial port.
903 * This is called from die(), so it shouldn't call die().
906 void setdtr (int tty_fd, int on)
908 int modembits = TIOCM_DTR;
910 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
913 /********************************************************************
915 * restore_tty - restore the terminal to the saved settings.
918 void restore_tty (int tty_fd)
923 * Turn off echoing, because otherwise we can get into
924 * a loop with the tty and the modem echoing to each other.
925 * We presume we are the sole user of this tty device, so
926 * when we close it, it will revert to its defaults anyway.
929 inittermios.c_lflag &= ~(ECHO | ECHONL);
931 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
932 if (! ok_error (errno))
933 warn("tcsetattr: %m (line %d)", __LINE__);
938 /********************************************************************
940 * output - Output PPP packet.
943 void output (int unit, unsigned char *p, int len)
948 dump_packet("sent", p, len);
949 if (snoop_send_hook) snoop_send_hook(p, len);
951 if (len < PPP_HDRLEN)
953 if (new_style_driver) {
956 proto = (p[0] << 8) + p[1];
957 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
960 if (write(fd, p, len) < 0) {
961 if (errno == EWOULDBLOCK || errno == ENOBUFS
962 || errno == ENXIO || errno == EIO || errno == EINTR)
963 warn("write: warning: %m (%d)", errno);
965 error("write: %m (%d)", errno);
969 /********************************************************************
971 * wait_input - wait until there is data available,
972 * for the length of time specified by *timo (indefinite
976 void wait_input(struct timeval *timo)
983 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
984 if (n < 0 && errno != EINTR)
989 * add_fd - add an fd to the set that wait_input waits for.
999 * remove_fd - remove an fd from the set that wait_input waits for.
1001 void remove_fd(int fd)
1003 FD_CLR(fd, &in_fds);
1007 /********************************************************************
1009 * read_packet - get a PPP packet from the serial device.
1012 int read_packet (unsigned char *buf)
1016 len = PPP_MRU + PPP_HDRLEN;
1017 if (new_style_driver) {
1018 *buf++ = PPP_ALLSTATIONS;
1024 nr = read(ppp_fd, buf, len);
1025 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1027 if (nr < 0 && errno == ENXIO)
1030 if (nr < 0 && new_style_driver && ifunit >= 0) {
1031 /* N.B. we read ppp_fd first since LCP packets come in there. */
1032 nr = read(ppp_dev_fd, buf, len);
1033 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1034 error("read /dev/ppp: %m");
1035 if (nr < 0 && errno == ENXIO)
1038 return (new_style_driver && nr > 0)? nr+2: nr;
1041 /********************************************************************
1043 * get_loop_output - get outgoing packets from the ppp device,
1044 * and detect when we want to bring the real link up.
1045 * Return value is 1 if we need to bring up the link, 0 otherwise.
1048 get_loop_output(void)
1053 if (new_style_driver) {
1054 while ((n = read_packet(inpacket_buf)) > 0)
1055 if (loop_frame(inpacket_buf, n))
1060 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1061 if (loop_chars(inbuf, n))
1065 fatal("eof on loopback");
1067 if (errno != EWOULDBLOCK)
1068 fatal("read from loopback: %m(%d)", errno);
1074 * netif_set_mtu - set the MTU on the PPP network interface.
1077 netif_set_mtu(int unit, int mtu)
1081 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1083 memset (&ifr, '\0', sizeof (ifr));
1084 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1087 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1088 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1092 * netif_get_mtu - get the MTU on the PPP network interface.
1095 netif_get_mtu(int unit)
1099 memset (&ifr, '\0', sizeof (ifr));
1100 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1102 if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1103 error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1109 /********************************************************************
1111 * tty_send_config - configure the transmit characteristics of
1112 * the ppp interface.
1115 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1120 * Set the asyncmap and other parameters for the ppp device
1125 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1126 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1127 if (!ok_error(errno))
1128 fatal("ioctl(PPPIOCSASYNCMAP): %m (line %d)", __LINE__);
1132 x = get_flags(ppp_fd);
1133 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1134 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1135 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1136 set_flags(ppp_fd, x);
1139 /********************************************************************
1141 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1144 void tty_set_xaccm (ext_accm accm)
1146 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1147 accm[0], accm[1], accm[2], accm[3]));
1151 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1152 if ( ! ok_error (errno))
1153 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1157 /********************************************************************
1159 * tty_recv_config - configure the receive-side characteristics of
1160 * the ppp interface.
1163 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1165 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1167 * If we were called because the link has gone down then there is nothing
1168 * which may be done. Just return without incident.
1173 * Set the receiver parameters
1175 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1176 if ( ! ok_error (errno))
1177 error("ioctl(PPPIOCSMRU): %m (line %d)", __LINE__);
1179 if (new_style_driver && ifunit >= 0
1180 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1181 error("Couldn't set MRU in generic PPP layer: %m");
1183 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1184 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1185 if (!ok_error(errno))
1186 error("ioctl(PPPIOCSRASYNCMAP): %m (line %d)", __LINE__);
1190 /********************************************************************
1192 * ccp_test - ask kernel whether a given compression method
1193 * is acceptable for use.
1197 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1199 struct ppp_option_data data;
1201 memset (&data, '\0', sizeof (data));
1203 data.length = opt_len;
1204 data.transmit = for_transmit;
1206 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1209 return (errno == ENOBUFS)? 0: -1;
1212 /********************************************************************
1214 * ccp_flags_set - inform kernel about the current state of CCP.
1217 void ccp_flags_set (int unit, int isopen, int isup)
1219 if (still_ppp() && ifunit >= 0) {
1220 int x = get_flags(ppp_dev_fd);
1221 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1222 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1223 set_flags (ppp_dev_fd, x);
1229 * set_filters - set the active and pass filters in the kernel driver.
1231 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1233 struct sock_fprog fp;
1235 fp.len = pass->bf_len;
1236 fp.filter = (struct sock_filter *) pass->bf_insns;
1237 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1238 if (errno == ENOTTY)
1239 warn("kernel does not support PPP filtering");
1241 error("Couldn't set pass-filter in kernel: %m");
1244 fp.len = active->bf_len;
1245 fp.filter = (struct sock_filter *) active->bf_insns;
1246 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1247 error("Couldn't set active-filter in kernel: %m");
1252 #endif /* PPP_FILTER */
1254 /********************************************************************
1256 * get_idle_time - return how long the link has been idle.
1259 get_idle_time(u, ip)
1261 struct ppp_idle *ip;
1263 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1266 /********************************************************************
1268 * get_ppp_stats - return statistics for the link.
1271 get_ppp_stats(u, stats)
1273 struct pppd_stats *stats;
1275 struct ifpppstatsreq req;
1277 memset (&req, 0, sizeof (req));
1279 req.stats_ptr = (caddr_t) &req.stats;
1280 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1281 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1282 error("Couldn't get PPP statistics: %m");
1285 stats->bytes_in = req.stats.p.ppp_ibytes;
1286 stats->bytes_out = req.stats.p.ppp_obytes;
1287 stats->pkts_in = req.stats.p.ppp_ipackets;
1288 stats->pkts_out = req.stats.p.ppp_opackets;
1292 /********************************************************************
1294 * ccp_fatal_error - returns 1 if decompression was disabled as a
1295 * result of an error detected after decompression of a packet,
1296 * 0 otherwise. This is necessary because of patent nonsense.
1299 int ccp_fatal_error (int unit)
1301 int x = get_flags(ppp_dev_fd);
1303 return x & SC_DC_FERROR;
1306 /********************************************************************
1308 * path_to_procfs - find the path to the proc file system mount point
1310 static char proc_path[MAXPATHLEN];
1311 static int proc_path_len;
1313 static char *path_to_procfs(const char *tail)
1315 struct mntent *mntent;
1318 if (proc_path_len == 0) {
1319 /* Default the mount location of /proc */
1320 strlcpy (proc_path, "/proc", sizeof(proc_path));
1322 fp = fopen(MOUNTED, "r");
1324 while ((mntent = getmntent(fp)) != NULL) {
1325 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1327 if (strcmp(mntent->mnt_type, "proc") == 0) {
1328 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1329 proc_path_len = strlen(proc_path);
1337 strlcpy(proc_path + proc_path_len, tail,
1338 sizeof(proc_path) - proc_path_len);
1343 * /proc/net/route parsing stuff.
1345 #define ROUTE_MAX_COLS 12
1346 FILE *route_fd = (FILE *) 0;
1347 static char route_buffer[512];
1348 static int route_dev_col, route_dest_col, route_gw_col;
1349 static int route_flags_col, route_mask_col;
1350 static int route_num_cols;
1352 static int open_route_table (void);
1353 static void close_route_table (void);
1354 static int read_route_table (struct rtentry *rt);
1356 /********************************************************************
1358 * close_route_table - close the interface to the route table
1361 static void close_route_table (void)
1363 if (route_fd != (FILE *) 0) {
1365 route_fd = (FILE *) 0;
1369 /********************************************************************
1371 * open_route_table - open the interface to the route table
1373 static char route_delims[] = " \t\n";
1375 static int open_route_table (void)
1379 close_route_table();
1381 path = path_to_procfs("/net/route");
1382 route_fd = fopen (path, "r");
1383 if (route_fd == NULL) {
1384 error("can't open routing table %s: %m", path);
1388 route_dev_col = 0; /* default to usual columns */
1391 route_flags_col = 3;
1395 /* parse header line */
1396 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1397 char *p = route_buffer, *q;
1399 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1401 if ((q = strtok(p, route_delims)) == 0)
1403 if (strcasecmp(q, "iface") == 0)
1404 route_dev_col = col;
1405 else if (strcasecmp(q, "destination") == 0)
1406 route_dest_col = col;
1407 else if (strcasecmp(q, "gateway") == 0)
1409 else if (strcasecmp(q, "flags") == 0)
1410 route_flags_col = col;
1411 else if (strcasecmp(q, "mask") == 0)
1412 route_mask_col = col;
1415 if (used && col >= route_num_cols)
1416 route_num_cols = col + 1;
1424 /********************************************************************
1426 * read_route_table - read the next entry from the route table
1429 static int read_route_table(struct rtentry *rt)
1431 char *cols[ROUTE_MAX_COLS], *p;
1434 memset (rt, '\0', sizeof (struct rtentry));
1436 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1440 for (col = 0; col < route_num_cols; ++col) {
1441 cols[col] = strtok(p, route_delims);
1442 if (cols[col] == NULL)
1443 return 0; /* didn't get enough columns */
1447 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1448 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1449 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1451 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1452 rt->rt_dev = cols[route_dev_col];
1457 /********************************************************************
1459 * defaultroute_exists - determine if there is a default route
1462 static int defaultroute_exists (struct rtentry *rt)
1466 if (!open_route_table())
1469 while (read_route_table(rt) != 0) {
1470 if ((rt->rt_flags & RTF_UP) == 0)
1473 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1475 if (SIN_ADDR(rt->rt_dst) == 0L) {
1481 close_route_table();
1486 * have_route_to - determine if the system has any route to
1487 * a given IP address. `addr' is in network byte order.
1488 * Return value is 1 if yes, 0 if no, -1 if don't know.
1489 * For demand mode to work properly, we have to ignore routes
1490 * through our own interface.
1492 int have_route_to(u_int32_t addr)
1497 if (!open_route_table())
1498 return -1; /* don't know */
1500 while (read_route_table(&rt)) {
1501 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1503 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1509 close_route_table();
1513 /********************************************************************
1515 * sifdefaultroute - assign a default route through the address given.
1518 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1522 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1523 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1525 if (old_gateway != gateway)
1526 error("not replacing existing default route to %s [%I]",
1527 rt.rt_dev, old_gateway);
1531 memset (&rt, '\0', sizeof (rt));
1532 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1533 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1537 if (kernel_version > KVERSION(2,1,0)) {
1538 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1539 SIN_ADDR(rt.rt_genmask) = 0L;
1542 SIN_ADDR(rt.rt_gateway) = gateway;
1544 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1545 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1546 if ( ! ok_error ( errno ))
1547 error("default route ioctl(SIOCADDRT): %m");
1551 default_route_gateway = gateway;
1555 /********************************************************************
1557 * cifdefaultroute - delete a default route through the address given.
1560 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1564 default_route_gateway = 0;
1566 memset (&rt, '\0', sizeof (rt));
1567 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1568 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1570 if (kernel_version > KVERSION(2,1,0)) {
1571 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1572 SIN_ADDR(rt.rt_genmask) = 0L;
1575 SIN_ADDR(rt.rt_gateway) = gateway;
1577 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1578 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1580 if ( ! ok_error ( errno ))
1581 error("default route ioctl(SIOCDELRT): %m");
1589 /********************************************************************
1591 * sifproxyarp - Make a proxy ARP entry for the peer.
1594 int sifproxyarp (int unit, u_int32_t his_adr)
1596 struct arpreq arpreq;
1599 if (has_proxy_arp == 0) {
1600 memset (&arpreq, '\0', sizeof(arpreq));
1602 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1603 SIN_ADDR(arpreq.arp_pa) = his_adr;
1604 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1606 * Get the hardware address of an interface on the same subnet
1607 * as our local address.
1609 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1610 sizeof(proxy_arp_dev))) {
1611 error("Cannot determine ethernet address for proxy ARP");
1614 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1616 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1617 if ( ! ok_error ( errno ))
1618 error("ioctl(SIOCSARP): %m");
1621 proxy_arp_addr = his_adr;
1625 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1626 if (forw_path != 0) {
1627 int fd = open(forw_path, O_WRONLY);
1629 if (write(fd, "1", 1) != 1)
1630 error("Couldn't enable IP forwarding: %m");
1640 /********************************************************************
1642 * cifproxyarp - Delete the proxy ARP entry for the peer.
1645 int cifproxyarp (int unit, u_int32_t his_adr)
1647 struct arpreq arpreq;
1649 if (has_proxy_arp) {
1651 memset (&arpreq, '\0', sizeof(arpreq));
1652 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1653 SIN_ADDR(arpreq.arp_pa) = his_adr;
1654 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1655 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1657 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1658 if ( ! ok_error ( errno ))
1659 warn("ioctl(SIOCDARP): %m");
1666 /********************************************************************
1668 * get_ether_addr - get the hardware address of an interface on the
1669 * the same subnet as ipaddr.
1672 static int get_ether_addr (u_int32_t ipaddr,
1673 struct sockaddr *hwaddr,
1674 char *name, int namelen)
1676 struct ifreq *ifr, *ifend;
1677 u_int32_t ina, mask;
1679 struct ifreq ifreq, bestifreq;
1681 struct ifreq ifs[MAX_IFS];
1683 u_int32_t bestmask=0;
1684 int found_interface = 0;
1686 ifc.ifc_len = sizeof(ifs);
1688 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1689 if ( ! ok_error ( errno ))
1690 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1694 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1695 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1697 * Scan through looking for an interface with an Internet
1698 * address on the same subnet as `ipaddr'.
1700 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1701 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1702 if (ifr->ifr_addr.sa_family == AF_INET) {
1703 ina = SIN_ADDR(ifr->ifr_addr);
1704 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1705 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1708 * Check that the interface is up, and not point-to-point
1711 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1714 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1717 * Get its netmask and check that it's on the right subnet.
1719 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1722 mask = SIN_ADDR(ifreq.ifr_addr);
1723 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1724 ip_ntoa(ina), ntohl(mask)));
1726 if (((ipaddr ^ ina) & mask) != 0)
1727 continue; /* no match */
1729 if (mask >= bestmask) {
1730 /* Compare using >= instead of > -- it is possible for
1731 an interface to have a netmask of 0.0.0.0 */
1732 found_interface = 1;
1739 if (!found_interface) return 0;
1741 strlcpy(name, bestifreq.ifr_name, namelen);
1743 /* trim off the :1 in eth0:1 */
1744 aliasp = strchr(name, ':');
1748 info("found interface %s for proxy arp", name);
1750 * Now get the hardware address.
1752 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1753 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1754 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1759 &bestifreq.ifr_hwaddr,
1760 sizeof (struct sockaddr));
1762 SYSDEBUG ((LOG_DEBUG,
1763 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1764 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1765 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1766 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1767 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1768 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1769 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1770 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1771 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1776 * get_if_hwaddr - get the hardware address for the specified
1777 * network interface device.
1780 get_if_hwaddr(u_char *addr, char *name)
1785 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1788 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1789 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1790 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1793 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1798 * get_first_ethernet - return the name of the first ethernet-style
1799 * interface on this system.
1802 get_first_ethernet()
1807 /********************************************************************
1809 * Return user specified netmask, modified by any mask we might determine
1810 * for address `addr' (in network byte order).
1811 * Here we scan through the system's list of interfaces, looking for
1812 * any non-point-to-point interfaces which might appear to be on the same
1813 * network as `addr'. If we find any, we OR in their netmask to the
1814 * user-specified netmask.
1817 u_int32_t GetMask (u_int32_t addr)
1819 u_int32_t mask, nmask, ina;
1820 struct ifreq *ifr, *ifend, ifreq;
1822 struct ifreq ifs[MAX_IFS];
1826 if (IN_CLASSA(addr)) /* determine network mask for address class */
1827 nmask = IN_CLASSA_NET;
1828 else if (IN_CLASSB(addr))
1829 nmask = IN_CLASSB_NET;
1831 nmask = IN_CLASSC_NET;
1833 /* class D nets are disallowed by bad_ip_adrs */
1834 mask = netmask | htonl(nmask);
1836 * Scan through the system's network interfaces.
1838 ifc.ifc_len = sizeof(ifs);
1840 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1841 if ( ! ok_error ( errno ))
1842 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1846 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1847 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1849 * Check the interface's internet address.
1851 if (ifr->ifr_addr.sa_family != AF_INET)
1853 ina = SIN_ADDR(ifr->ifr_addr);
1854 if (((ntohl(ina) ^ addr) & nmask) != 0)
1857 * Check that the interface is up, and not point-to-point nor loopback.
1859 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1860 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1863 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1866 * Get its netmask and OR it into our mask.
1868 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1870 mask |= SIN_ADDR(ifreq.ifr_addr);
1876 /********************************************************************
1878 * Internal routine to decode the version.modification.patch level
1881 static void decode_version (char *buf, int *version,
1882 int *modification, int *patch)
1886 *version = (int) strtoul (buf, &endp, 10);
1890 if (endp != buf && *endp == '.') {
1892 *modification = (int) strtoul (buf, &endp, 10);
1893 if (endp != buf && *endp == '.') {
1895 *patch = (int) strtoul (buf, &buf, 10);
1900 /********************************************************************
1902 * Procedure to determine if the PPP line discipline is registered.
1906 ppp_registered(void)
1914 * We used to open the serial device and set it to the ppp line
1915 * discipline here, in order to create a ppp unit. But that is
1916 * not a good idea - the user might have specified a device that
1917 * they can't open (permission, or maybe it doesn't really exist).
1918 * So we grab a pty master/slave pair and use that.
1920 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1921 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1926 * Try to put the device into the PPP discipline.
1928 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1929 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
1938 /********************************************************************
1940 * ppp_available - check whether the system has any ppp interfaces
1941 * (in fact we check whether we can do an ioctl on ppp0).
1944 int ppp_available(void)
1949 int my_version, my_modification, my_patch;
1950 int osmaj, osmin, ospatch;
1953 "This system lacks kernel support for PPP. This could be because\n"
1954 "the PPP kernel module could not be loaded, or because PPP was not\n"
1955 "included in the kernel configuration. If PPP was included as a\n"
1956 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1957 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1958 "See README.linux file in the ppp distribution for more details.\n";
1960 /* get the kernel version now, since we are called before sys_init */
1962 osmaj = osmin = ospatch = 0;
1963 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1964 kernel_version = KVERSION(osmaj, osmin, ospatch);
1966 fd = open("/dev/ppp", O_RDWR);
1968 if (fd < 0 && errno == ENOENT) {
1969 /* try making it and see if that helps. */
1970 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1971 makedev(108, 0)) >= 0) {
1972 fd = open("/dev/ppp", O_RDWR);
1974 info("Created /dev/ppp device node");
1976 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1977 } else if (errno == EEXIST) {
1978 fd = open("/dev/ppp", O_RDWR);
1983 new_style_driver = 1;
1985 /* XXX should get from driver */
1987 driver_modification = 4;
1992 if (kernel_version >= KVERSION(2,3,13)) {
1993 if (errno == ENOENT)
1995 "pppd is unable to open the /dev/ppp device.\n"
1996 "You need to create the /dev/ppp device node by\n"
1997 "executing the following command as root:\n"
1998 " mknod /dev/ppp c 108 0\n";
2003 * Open a socket for doing the ioctl operations.
2005 s = socket(AF_INET, SOCK_DGRAM, 0);
2009 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2010 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2012 * If the device did not exist then attempt to create one by putting the
2013 * current tty into the PPP discipline. If this works then obtain the
2014 * flags for the device again.
2017 if (ppp_registered()) {
2018 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2019 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2023 * Ensure that the hardware address is for PPP and not something else
2026 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2028 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2032 * This is the PPP device. Validate the version of the driver at this
2033 * point to ensure that this program will work with the driver.
2036 char abBuffer [1024];
2038 ifr.ifr_data = abBuffer;
2039 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2041 error("Couldn't read driver version: %m");
2043 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2046 decode_version(abBuffer,
2048 &driver_modification,
2051 * Validate the version of the driver against the version that we used.
2053 decode_version(VERSION,
2058 /* The version numbers must match */
2059 if (driver_version != my_version)
2062 /* The modification levels must be legal */
2063 if (driver_modification < 3) {
2064 if (driver_modification >= 2) {
2065 /* we can cope with 2.2.0 and above */
2074 slprintf(route_buffer, sizeof(route_buffer),
2075 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2076 driver_version, driver_modification, driver_patch);
2078 no_ppp_msg = route_buffer;
2085 /********************************************************************
2087 * Update the wtmp file with the appropriate user name and tty device.
2090 void logwtmp (const char *line, const char *name, const char *host)
2092 struct utmp ut, *utp;
2093 pid_t mypid = getpid();
2099 * Update the signon database for users.
2100 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2102 utmpname(_PATH_UTMP);
2104 while ((utp = getutent()) && (utp->ut_pid != mypid))
2108 memcpy(&ut, utp, sizeof(ut));
2110 /* some gettys/telnetds don't initialize utmp... */
2111 memset(&ut, 0, sizeof(ut));
2113 if (ut.ut_id[0] == 0)
2114 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2116 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2117 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2121 ut.ut_type = USER_PROCESS;
2124 /* Insert the host name if one is supplied */
2126 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2128 /* Insert the IP address of the remote system if IP is enabled */
2129 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2130 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2131 sizeof(ut.ut_addr));
2133 /* CL: Makes sure that the logout works */
2134 if (*host == 0 && *name==0)
2140 * Update the wtmp file.
2143 updwtmp(_PATH_WTMP, &ut);
2145 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2147 flock(wtmp, LOCK_EX);
2149 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2150 warn("error writing %s: %m", _PATH_WTMP);
2152 flock(wtmp, LOCK_UN);
2160 /********************************************************************
2162 * sifvjcomp - config tcp header compression
2165 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2167 u_int x = get_flags(ppp_dev_fd);
2170 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2171 if (! ok_error (errno))
2172 error("ioctl(PPPIOCSMAXCID): %m (line %d)", __LINE__);
2177 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2178 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2179 set_flags (ppp_dev_fd, x);
2184 /********************************************************************
2186 * sifup - Config the interface up and enable IP packets to pass.
2193 memset (&ifr, '\0', sizeof (ifr));
2194 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2195 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2196 if (! ok_error (errno))
2197 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2201 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2202 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2203 if (! ok_error (errno))
2204 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2212 /********************************************************************
2214 * sifdown - Disable the indicated protocol and config the interface
2215 * down if there are no remaining protocols.
2222 if (if_is_up && --if_is_up > 0)
2225 memset (&ifr, '\0', sizeof (ifr));
2226 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2227 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2228 if (! ok_error (errno))
2229 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2233 ifr.ifr_flags &= ~IFF_UP;
2234 ifr.ifr_flags |= IFF_POINTOPOINT;
2235 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2236 if (! ok_error (errno))
2237 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2243 /********************************************************************
2245 * sifaddr - Config the interface IP addresses and netmask.
2248 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2254 memset (&ifr, '\0', sizeof (ifr));
2255 memset (&rt, '\0', sizeof (rt));
2257 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2258 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2259 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2261 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2263 * Set our IP address
2265 SIN_ADDR(ifr.ifr_addr) = our_adr;
2266 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2267 if (errno != EEXIST) {
2268 if (! ok_error (errno))
2269 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2272 warn("ioctl(SIOCSIFADDR): Address already exists");
2277 * Set the gateway address
2279 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2280 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2281 if (! ok_error (errno))
2282 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2287 * For recent kernels, force the netmask to 255.255.255.255.
2289 if (kernel_version >= KVERSION(2,1,16))
2291 if (net_mask != 0) {
2292 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2293 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2294 if (! ok_error (errno))
2295 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2300 * Add the device route
2302 if (kernel_version < KVERSION(2,1,16)) {
2303 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2304 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2307 SIN_ADDR(rt.rt_gateway) = 0L;
2308 SIN_ADDR(rt.rt_dst) = his_adr;
2309 rt.rt_flags = RTF_UP | RTF_HOST;
2311 if (kernel_version > KVERSION(2,1,0)) {
2312 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2313 SIN_ADDR(rt.rt_genmask) = -1L;
2316 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2317 if (! ok_error (errno))
2318 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2323 /* set ip_dynaddr in demand mode if address changes */
2324 if (demand && tune_kernel && !dynaddr_set
2325 && our_old_addr && our_old_addr != our_adr) {
2326 /* set ip_dynaddr if possible */
2330 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2331 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2332 if (write(fd, "1", 1) != 1)
2333 error("Couldn't enable dynamic IP addressing: %m");
2336 dynaddr_set = 1; /* only 1 attempt */
2343 /********************************************************************
2345 * cifaddr - Clear the interface IP addresses, and delete routes
2346 * through the interface if possible.
2349 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2353 if (kernel_version < KVERSION(2,1,16)) {
2355 * Delete the route through the device
2358 memset (&rt, '\0', sizeof (rt));
2360 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2361 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2364 SIN_ADDR(rt.rt_gateway) = 0;
2365 SIN_ADDR(rt.rt_dst) = his_adr;
2366 rt.rt_flags = RTF_UP | RTF_HOST;
2368 if (kernel_version > KVERSION(2,1,0)) {
2369 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2370 SIN_ADDR(rt.rt_genmask) = -1L;
2373 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2374 if (still_ppp() && ! ok_error (errno))
2375 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2380 /* This way it is possible to have an IPX-only or IPv6-only interface */
2381 memset(&ifr, 0, sizeof(ifr));
2382 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2383 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2385 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2386 if (! ok_error (errno)) {
2387 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2392 our_old_addr = our_adr;
2398 /********************************************************************
2400 * sif6addr - Config the interface with an IPv6 link-local address
2402 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2404 struct in6_ifreq ifr6;
2406 struct in6_rtmsg rt6;
2410 error("IPv6 socket creation failed: %m");
2413 memset(&ifr, 0, sizeof (ifr));
2414 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2415 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2416 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2420 /* Local interface */
2421 memset(&ifr6, 0, sizeof(ifr6));
2422 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2423 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2424 ifr6.ifr6_prefixlen = 10;
2426 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2427 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2431 /* Route to remote host */
2432 memset(&rt6, 0, sizeof(rt6));
2433 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2434 rt6.rtmsg_flags = RTF_UP;
2435 rt6.rtmsg_dst_len = 10;
2436 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2437 rt6.rtmsg_metric = 1;
2439 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2440 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2448 /********************************************************************
2450 * cif6addr - Remove IPv6 address from interface
2452 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2455 struct in6_ifreq ifr6;
2459 error("IPv6 socket creation failed: %m");
2462 memset(&ifr, 0, sizeof(ifr));
2463 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2464 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2465 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2469 memset(&ifr6, 0, sizeof(ifr6));
2470 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2471 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2472 ifr6.ifr6_prefixlen = 10;
2474 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2475 if (errno != EADDRNOTAVAIL) {
2476 if (! ok_error (errno))
2477 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2480 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2489 * get_pty - get a pty master/slave pair and chown the slave side
2490 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2493 get_pty(master_fdp, slave_fdp, slave_name, uid)
2499 int i, mfd, sfd = -1;
2501 struct termios tios;
2505 * Try the unix98 way first.
2507 mfd = open("/dev/ptmx", O_RDWR);
2510 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2511 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2512 chmod(pty_name, S_IRUSR | S_IWUSR);
2515 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2516 warn("Couldn't unlock pty slave %s: %m", pty_name);
2518 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2519 warn("Couldn't open pty slave %s: %m", pty_name);
2522 #endif /* TIOCGPTN */
2525 /* the old way - scan through the pty name space */
2526 for (i = 0; i < 64; ++i) {
2527 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2528 'p' + i / 16, i % 16);
2529 mfd = open(pty_name, O_RDWR, 0);
2532 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2534 fchown(sfd, uid, -1);
2535 fchmod(sfd, S_IRUSR | S_IWUSR);
2546 strlcpy(slave_name, pty_name, 16);
2549 if (tcgetattr(sfd, &tios) == 0) {
2550 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2551 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2552 tios.c_iflag = IGNPAR;
2555 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2556 warn("couldn't set attributes on pty: %m");
2558 warn("couldn't get attributes on pty: %m");
2563 /********************************************************************
2565 * open_loopback - open the device we use for getting packets
2566 * in demand mode. Under Linux, we use a pty master/slave pair.
2569 open_ppp_loopback(void)
2574 if (new_style_driver) {
2575 /* allocate ourselves a ppp unit */
2576 if (make_ppp_unit() < 0)
2578 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2579 set_kdebugflag(kdebugflag);
2584 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2585 fatal("No free pty for loopback");
2586 SYSDEBUG(("using %s for loopback", loop_name));
2588 set_ppp_fd(slave_fd);
2590 flags = fcntl(master_fd, F_GETFL);
2592 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2593 warn("couldn't set master loopback to nonblock: %m");
2595 flags = fcntl(ppp_fd, F_GETFL);
2597 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2598 warn("couldn't set slave loopback to nonblock: %m");
2600 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2601 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2603 * Find out which interface we were given.
2605 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2606 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2608 * Enable debug in the driver if requested.
2610 set_kdebugflag (kdebugflag);
2615 /********************************************************************
2617 * sifnpmode - Set the mode for handling packets for a given NP.
2621 sifnpmode(u, proto, mode)
2628 npi.protocol = proto;
2630 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2631 if (! ok_error (errno))
2632 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2639 /********************************************************************
2641 * sipxfaddr - Config the interface IPX networknumber
2644 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2651 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2653 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2655 if (! ok_error (errno))
2656 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2660 memset (&ifr, '\0', sizeof (ifr));
2661 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2663 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2664 sipx->sipx_family = AF_IPX;
2665 sipx->sipx_port = 0;
2666 sipx->sipx_network = htonl (network);
2667 sipx->sipx_type = IPX_FRAME_ETHERII;
2668 sipx->sipx_action = IPX_CRTITF;
2670 * Set the IPX device
2672 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2674 if (errno != EEXIST) {
2675 if (! ok_error (errno))
2676 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2679 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2688 /********************************************************************
2690 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2691 * are removed and the device is no longer able to pass IPX
2695 int cipxfaddr (int unit)
2702 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2704 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2706 if (! ok_error (errno))
2707 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2711 memset (&ifr, '\0', sizeof (ifr));
2712 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2714 sipx->sipx_type = IPX_FRAME_ETHERII;
2715 sipx->sipx_action = IPX_DLTITF;
2716 sipx->sipx_family = AF_IPX;
2718 * Set the IPX device
2720 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2721 if (! ok_error (errno))
2722 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2732 * Use the hostname as part of the random number seed.
2741 for (p = hostname; *p != 0; ++p)
2746 /********************************************************************
2748 * sys_check_options - check the options that the user specified
2752 sys_check_options(void)
2756 * Disable the IPX protocol if the support is not present in the kernel.
2760 if (ipxcp_protent.enabled_flag) {
2761 struct stat stat_buf;
2762 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2763 || lstat(path, &stat_buf) < 0) {
2764 error("IPX support is not present in the kernel\n");
2765 ipxcp_protent.enabled_flag = 0;
2769 if (demand && driver_is_old) {
2770 option_error("demand dialling is not supported by kernel driver "
2771 "version %d.%d.%d", driver_version, driver_modification,
2775 if (multilink && !new_style_driver) {
2776 warn("Warning: multilink is not supported by the kernel driver");
2784 * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
2786 * convert the 48-bit MAC address of eth0 into EUI 64. caller also assumes
2787 * that the system has a properly configured Ethernet interface for this
2788 * function to return non-zero.
2791 ether_to_eui64(eui64_t *p_eui64)
2795 const unsigned char *ptr;
2797 skfd = socket(PF_INET6, SOCK_DGRAM, 0);
2800 warn("could not open IPv6 socket");
2804 strcpy(ifr.ifr_name, "eth0");
2805 if(ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0)
2808 warn("could not obtain hardware address for eth0");
2814 * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
2816 ptr = ifr.ifr_hwaddr.sa_data;
2817 p_eui64->e8[0] = ptr[0] | 0x02;
2818 p_eui64->e8[1] = ptr[1];
2819 p_eui64->e8[2] = ptr[2];
2820 p_eui64->e8[3] = 0xFF;
2821 p_eui64->e8[4] = 0xFE;
2822 p_eui64->e8[5] = ptr[3];
2823 p_eui64->e8[6] = ptr[4];
2824 p_eui64->e8[7] = ptr[5];