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>
76 #include "patchlevel.h"
80 #if __GLIBC__ >= 2 && \
81 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
82 #include <netipx/ipx.h>
84 #include <linux/ipx.h>
86 #endif /* IPX_CHANGE */
89 #include <sys/locks.h>
95 * This is in linux/include/net/ipv6.h.
99 struct in6_addr ifr6_addr;
100 __u32 ifr6_prefixlen;
101 unsigned int ifr6_ifindex;
105 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
106 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
107 sin6.s6_addr16[0] = htons(0xfe80); \
108 eui64_copy(eui64, sin6.s6_addr32[2]); \
113 /* We can get an EIO error on an ioctl if the modem has hung up */
114 #define ok_error(num) ((num)==EIO)
116 static int tty_disc = N_TTY; /* The TTY discipline */
117 static int ppp_disc = N_PPP; /* The PPP discpline */
118 static int initfdflags = -1; /* Initial file descriptor flags for fd */
119 static int ppp_fd = -1; /* fd which is set to PPP discipline */
120 static int sock_fd = -1; /* socket for doing interface ioctls */
121 static int slave_fd = -1;
122 static int master_fd = -1;
124 static int sock6_fd = -1;
126 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
128 static fd_set in_fds; /* set of fds that wait_input waits for */
129 static int max_in_fd; /* highest fd set in in_fds */
131 static int has_proxy_arp = 0;
132 static int driver_version = 0;
133 static int driver_modification = 0;
134 static int driver_patch = 0;
135 static int driver_is_old = 0;
136 static int restore_term = 0; /* 1 => we've munged the terminal */
137 static struct termios inittermios; /* Initial TTY termios */
139 static int new_style_driver = 0;
141 static char loop_name[20];
142 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
144 static int if_is_up; /* Interface has been marked up */
145 static u_int32_t default_route_gateway; /* Gateway for default route added */
146 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
147 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
148 static u_int32_t our_old_addr; /* for detecting address changes */
149 static int dynaddr_set; /* 1 if ip_dynaddr set */
150 static int looped; /* 1 if using loop */
152 static struct utsname utsname; /* for the kernel version */
153 static int kernel_version;
154 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
158 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
159 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
160 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
162 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
164 /* Prototypes for procedures local to this file. */
165 static int get_flags (int fd);
166 static void set_flags (int fd, int flags);
167 static int translate_speed (int bps);
168 static int baud_rate_of (int speed);
169 static void close_route_table (void);
170 static int open_route_table (void);
171 static int read_route_table (struct rtentry *rt);
172 static int defaultroute_exists (struct rtentry *rt);
173 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
174 char *name, int namelen);
175 static void decode_version (char *buf, int *version, int *mod, int *patch);
176 static int set_kdebugflag(int level);
177 static int ppp_registered(void);
179 extern u_char inpacket_buf[]; /* borrowed from main.c */
182 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
186 #define SET_SA_FAMILY(addr, family) \
187 memset ((char *) &(addr), '\0', sizeof(addr)); \
188 addr.sa_family = (family);
191 * Determine if the PPP connection should still be present.
196 /* new_fd is the fd of a tty */
197 static void set_ppp_fd (int new_fd)
199 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
201 if (!new_style_driver)
205 static int still_ppp(void)
207 if (new_style_driver)
208 return !hungup && ppp_fd >= 0;
209 if (!hungup || ppp_fd == slave_fd)
212 set_ppp_fd(slave_fd);
218 /********************************************************************
220 * Functions to read and set the flags value in the device driver
223 static int get_flags (int fd)
227 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
228 if ( ok_error (errno) )
231 fatal("ioctl(PPPIOCGFLAGS): %m");
234 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
238 /********************************************************************/
240 static void set_flags (int fd, int flags)
242 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
244 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
245 if (! ok_error (errno) )
246 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
250 /********************************************************************
252 * sys_init - System-dependent initialization.
259 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
260 setlogmask(LOG_UPTO(LOG_INFO));
262 setlogmask(LOG_UPTO(LOG_DEBUG));
264 if (new_style_driver) {
265 ppp_dev_fd = open("/dev/ppp", O_RDWR);
267 fatal("Couldn't open /dev/ppp: %m");
268 flags = fcntl(ppp_dev_fd, F_GETFL);
270 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
271 warn("Couldn't set /dev/ppp to nonblock: %m");
274 /* Get an internet socket for doing socket ioctls. */
275 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
277 fatal("Couldn't create IP socket: %m(%d)", errno);
280 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
282 fatal("Couldn't create IPv6 socket: %m(%d)", errno);
289 /********************************************************************
291 * sys_cleanup - restore any system state we modified before exiting:
292 * mark the interface down, delete default route and/or proxy arp entry.
293 * This shouldn't call die() because it's called from die().
296 void sys_cleanup(void)
299 * Take down the device
306 * Delete any routes through the device.
308 if (default_route_gateway != 0)
309 cifdefaultroute(0, 0, default_route_gateway);
312 cifproxyarp(0, proxy_arp_addr);
315 /********************************************************************
317 * sys_close - Clean up in a child process before execing.
322 if (new_style_driver)
333 /********************************************************************
335 * set_kdebugflag - Define the debugging level for the kernel
338 static int set_kdebugflag (int requested_level)
340 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
341 if ( ! ok_error (errno) )
342 error("ioctl(PPPIOCSDEBUG): %m");
345 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
350 /********************************************************************
352 * establish_ppp - Turn the serial port into a ppp interface.
355 int establish_ppp (int tty_fd)
360 * The current PPP device will be the tty file.
363 if (new_style_driver)
366 * Ensure that the tty device is in exclusive mode.
368 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
369 if ( ! ok_error ( errno ))
370 warn("ioctl(TIOCEXCL): %m");
373 * Demand mode - prime the old ppp device to relinquish the unit.
375 if (!new_style_driver && looped
376 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
377 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
379 * Set the current tty to the PPP discpline
383 #define N_SYNC_PPP 14
385 if (new_style_driver)
386 ppp_disc = sync_serial ? N_SYNC_PPP:N_PPP;
388 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
389 if ( ! ok_error (errno) )
390 fatal("ioctl(TIOCSETD): %m(%d)", errno);
393 * Find out which interface we were given.
395 if (new_style_driver) {
397 /* allocate ourselves a ppp unit */
399 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
400 fatal("Couldn't create new ppp unit: %m");
401 set_kdebugflag(kdebugflag);
403 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
405 if (ioctl(tty_fd, PPPIOCATTACH, &ifunit) < 0) {
408 fatal("Couldn't attach tty to PPP unit %d: %m", ifunit);
411 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
412 if ( ! ok_error (errno))
413 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
415 /* Check that we got the same unit again. */
416 if (looped && x != ifunit)
417 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
422 * Enable debug in the driver if requested.
425 set_kdebugflag (kdebugflag);
428 set_flags(tty_fd, get_flags(tty_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
429 SC_RCV_EVNP | SC_RCV_ODDP));
431 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
432 driver_version, driver_modification, driver_patch));
435 * Fetch the initial file flags and reset blocking mode on the file.
437 initfdflags = fcntl(tty_fd, F_GETFL);
438 if (initfdflags == -1 ||
439 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
440 if ( ! ok_error (errno))
441 warn("Couldn't set device to non-blocking mode: %m");
447 /********************************************************************
449 * disestablish_ppp - Restore the serial port to normal operation.
450 * This shouldn't call die() because it's called from die().
453 void disestablish_ppp(int tty_fd)
455 if (new_style_driver)
459 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
461 if (tcflush(tty_fd, TCIOFLUSH) < 0)
462 warn("tcflush failed: %m");
464 * Restore the previous line discipline
466 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
467 if ( ! ok_error (errno))
468 error("ioctl(TIOCSETD, N_TTY): %m");
471 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
472 if ( ! ok_error (errno))
473 warn("ioctl(TIOCNXCL): %m(%d)", errno);
476 /* Reset non-blocking mode on fd. */
477 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
478 if ( ! ok_error (errno))
479 warn("Couldn't restore device fd flags: %m");
483 if (new_style_driver && !looped) {
484 if (ioctl(ppp_dev_fd, PPPIOCDETACH) < 0) {
485 if (errno == ENOTTY) {
486 /* first version of new driver didn't have PPPIOCDETACH */
490 ppp_dev_fd = open("/dev/ppp", O_RDWR);
492 fatal("Couldn't reopen /dev/ppp: %m");
493 flags = fcntl(ppp_dev_fd, F_GETFL);
495 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
496 warn("Couldn't set /dev/ppp to nonblock: %m");
498 error("Couldn't release PPP unit: %m");
504 /********************************************************************
506 * clean_check - Fetch the flags for the device and generate
507 * appropriate error messages.
509 void clean_check(void)
515 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
517 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
519 s = "all had bit 7 set to 1";
523 s = "all had bit 7 set to 0";
527 s = "all had odd parity";
531 s = "all had even parity";
536 warn("Receive serial link is not 8-bit clean:");
537 warn("Problem: %s", s);
545 * List of valid speeds.
549 int speed_int, speed_val;
626 /********************************************************************
628 * Translate from bits/second to a speed_t.
631 static int translate_speed (int bps)
633 struct speed *speedp;
636 for (speedp = speeds; speedp->speed_int; speedp++) {
637 if (bps == speedp->speed_int)
638 return speedp->speed_val;
640 warn("speed %d not supported", bps);
645 /********************************************************************
647 * Translate from a speed_t to bits/second.
650 static int baud_rate_of (int speed)
652 struct speed *speedp;
655 for (speedp = speeds; speedp->speed_int; speedp++) {
656 if (speed == speedp->speed_val)
657 return speedp->speed_int;
663 /********************************************************************
665 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
666 * at the requested speed, etc. If `local' is true, set CLOCAL
667 * regardless of whether the modem option was specified.
670 void set_up_tty(int tty_fd, int local)
676 if (tcgetattr(tty_fd, &tios) < 0) {
677 if (!ok_error(errno))
678 fatal("tcgetattr: %m(%d)", errno);
685 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
686 tios.c_cflag |= CS8 | CREAD | HUPCL;
688 tios.c_iflag = IGNBRK | IGNPAR;
692 tios.c_cc[VTIME] = 0;
695 tios.c_cflag ^= (CLOCAL | HUPCL);
699 tios.c_cflag |= CRTSCTS;
703 tios.c_iflag |= IXON | IXOFF;
704 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
705 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
709 tios.c_cflag &= ~CRTSCTS;
716 speed = translate_speed(inspeed);
718 cfsetospeed (&tios, speed);
719 cfsetispeed (&tios, speed);
722 * We can't proceed if the serial port speed is B0,
723 * since that implies that the serial port is disabled.
726 speed = cfgetospeed(&tios);
728 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
731 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
732 if (!ok_error(errno))
733 fatal("tcsetattr: %m");
735 baud_rate = baud_rate_of(speed);
739 /********************************************************************
741 * setdtr - control the DTR line on the serial port.
742 * This is called from die(), so it shouldn't call die().
745 void setdtr (int tty_fd, int on)
747 int modembits = TIOCM_DTR;
749 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
752 /********************************************************************
754 * restore_tty - restore the terminal to the saved settings.
757 void restore_tty (int tty_fd)
762 * Turn off echoing, because otherwise we can get into
763 * a loop with the tty and the modem echoing to each other.
764 * We presume we are the sole user of this tty device, so
765 * when we close it, it will revert to its defaults anyway.
768 inittermios.c_lflag &= ~(ECHO | ECHONL);
770 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
771 if (! ok_error (errno))
772 warn("tcsetattr: %m");
777 /********************************************************************
779 * output - Output PPP packet.
782 void output (int unit, unsigned char *p, int len)
785 dbglog("sent %P", p, len);
787 if (len < PPP_HDRLEN)
789 if (new_style_driver) {
793 if (write(ppp_dev_fd, p, len) < 0) {
794 if (errno == EWOULDBLOCK || errno == ENOBUFS
795 || errno == ENXIO || errno == EIO || errno == EINTR)
796 warn("write: warning: %m (%d)", errno);
798 error("write: %m (%d)", errno);
802 /********************************************************************
804 * wait_input - wait until there is data available,
805 * for the length of time specified by *timo (indefinite
809 void wait_input(struct timeval *timo)
815 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
816 if (n < 0 && errno != EINTR)
817 fatal("select: %m(%d)", errno);
821 * add_fd - add an fd to the set that wait_input waits for.
831 * remove_fd - remove an fd from the set that wait_input waits for.
833 void remove_fd(int fd)
839 /********************************************************************
841 * read_packet - get a PPP packet from the serial device.
844 int read_packet (unsigned char *buf)
848 len = PPP_MRU + PPP_HDRLEN;
849 if (new_style_driver) {
850 *buf++ = PPP_ALLSTATIONS;
855 if (new_style_driver) {
856 nr = read(ppp_dev_fd, buf, len);
857 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
858 error("read /dev/ppp: %m");
860 if (nr < 0 && ppp_fd >= 0) {
861 nr = read(ppp_fd, buf, len);
862 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
865 return (new_style_driver && nr > 0)? nr+2: nr;
868 /********************************************************************
870 * get_loop_output - get outgoing packets from the ppp device,
871 * and detect when we want to bring the real link up.
872 * Return value is 1 if we need to bring up the link, 0 otherwise.
875 get_loop_output(void)
880 if (new_style_driver) {
881 while ((n = read_packet(inpacket_buf)) > 0)
882 if (loop_frame(inpacket_buf, n))
887 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
888 if (loop_chars(inbuf, n))
892 fatal("eof on loopback");
894 if (errno != EWOULDBLOCK)
895 fatal("read from loopback: %m(%d)", errno);
900 /********************************************************************
902 * ppp_send_config - configure the transmit characteristics of
906 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
911 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
913 * Set the MTU and other parameters for the ppp device
915 memset (&ifr, '\0', sizeof (ifr));
916 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
919 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
920 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
924 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
925 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
926 if (!ok_error(errno))
927 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
931 x = get_flags(ppp_fd);
932 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
933 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
934 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
935 set_flags(ppp_fd, x);
938 /********************************************************************
940 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
943 void ppp_set_xaccm (int unit, ext_accm accm)
945 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
946 accm[0], accm[1], accm[2], accm[3]));
950 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
951 if ( ! ok_error (errno))
952 warn("ioctl(set extended ACCM): %m(%d)", errno);
956 /********************************************************************
958 * ppp_recv_config - configure the receive-side characteristics of
962 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
964 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
966 * If we were called because the link has gone down then there is nothing
967 * which may be done. Just return without incident.
972 * Set the receiver parameters
974 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
975 if ( ! ok_error (errno))
976 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
978 if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
979 error("Couldn't set MRU in generic PPP layer: %m");
981 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
982 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
983 if (!ok_error(errno))
984 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
988 /********************************************************************
990 * ccp_test - ask kernel whether a given compression method
991 * is acceptable for use.
994 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
996 struct ppp_option_data data;
998 memset (&data, '\0', sizeof (data));
1000 data.length = opt_len;
1001 data.transmit = for_transmit;
1003 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1006 return (errno == ENOBUFS)? 0: -1;
1009 /********************************************************************
1011 * ccp_flags_set - inform kernel about the current state of CCP.
1014 void ccp_flags_set (int unit, int isopen, int isup)
1017 int x = get_flags(ppp_dev_fd);
1018 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1019 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1020 set_flags (ppp_dev_fd, x);
1024 /********************************************************************
1026 * get_idle_time - return how long the link has been idle.
1029 get_idle_time(u, ip)
1031 struct ppp_idle *ip;
1033 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1036 /********************************************************************
1038 * get_ppp_stats - return statistics for the link.
1041 get_ppp_stats(u, stats)
1043 struct pppd_stats *stats;
1045 struct ifpppstatsreq req;
1047 memset (&req, 0, sizeof (req));
1049 req.stats_ptr = (caddr_t) &req.stats;
1050 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1051 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1052 error("Couldn't get PPP statistics: %m");
1055 stats->bytes_in = req.stats.p.ppp_ibytes;
1056 stats->bytes_out = req.stats.p.ppp_obytes;
1060 /********************************************************************
1062 * ccp_fatal_error - returns 1 if decompression was disabled as a
1063 * result of an error detected after decompression of a packet,
1064 * 0 otherwise. This is necessary because of patent nonsense.
1067 int ccp_fatal_error (int unit)
1069 int x = get_flags(ppp_dev_fd);
1071 return x & SC_DC_FERROR;
1074 /********************************************************************
1076 * path_to_procfs - find the path to the proc file system mount point
1078 static char proc_path[MAXPATHLEN];
1079 static int proc_path_len;
1081 static char *path_to_procfs(const char *tail)
1083 struct mntent *mntent;
1086 if (proc_path_len == 0) {
1087 /* Default the mount location of /proc */
1088 strlcpy (proc_path, "/proc", sizeof(proc_path));
1090 fp = fopen(MOUNTED, "r");
1092 while ((mntent = getmntent(fp)) != NULL) {
1093 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1095 if (strcmp(mntent->mnt_type, "proc") == 0) {
1096 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1097 proc_path_len = strlen(proc_path);
1105 strlcpy(proc_path + proc_path_len, tail,
1106 sizeof(proc_path) - proc_path_len);
1111 * /proc/net/route parsing stuff.
1113 #define ROUTE_MAX_COLS 12
1114 FILE *route_fd = (FILE *) 0;
1115 static char route_buffer[512];
1116 static int route_dev_col, route_dest_col, route_gw_col;
1117 static int route_flags_col, route_mask_col;
1118 static int route_num_cols;
1120 static int open_route_table (void);
1121 static void close_route_table (void);
1122 static int read_route_table (struct rtentry *rt);
1124 /********************************************************************
1126 * close_route_table - close the interface to the route table
1129 static void close_route_table (void)
1131 if (route_fd != (FILE *) 0) {
1133 route_fd = (FILE *) 0;
1137 /********************************************************************
1139 * open_route_table - open the interface to the route table
1141 static char route_delims[] = " \t\n";
1143 static int open_route_table (void)
1147 close_route_table();
1149 path = path_to_procfs("/net/route");
1150 route_fd = fopen (path, "r");
1151 if (route_fd == NULL) {
1152 error("can't open routing table %s: %m", path);
1156 route_dev_col = 0; /* default to usual columns */
1159 route_flags_col = 3;
1163 /* parse header line */
1164 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1165 char *p = route_buffer, *q;
1167 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1169 if ((q = strtok(p, route_delims)) == 0)
1171 if (strcasecmp(q, "iface") == 0)
1172 route_dev_col = col;
1173 else if (strcasecmp(q, "destination") == 0)
1174 route_dest_col = col;
1175 else if (strcasecmp(q, "gateway") == 0)
1177 else if (strcasecmp(q, "flags") == 0)
1178 route_flags_col = col;
1179 else if (strcasecmp(q, "mask") == 0)
1180 route_mask_col = col;
1183 if (used && col >= route_num_cols)
1184 route_num_cols = col + 1;
1192 /********************************************************************
1194 * read_route_table - read the next entry from the route table
1197 static int read_route_table(struct rtentry *rt)
1199 char *cols[ROUTE_MAX_COLS], *p;
1202 memset (rt, '\0', sizeof (struct rtentry));
1204 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1208 for (col = 0; col < route_num_cols; ++col) {
1209 cols[col] = strtok(p, route_delims);
1210 if (cols[col] == NULL)
1211 return 0; /* didn't get enough columns */
1215 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1216 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1217 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1219 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1220 rt->rt_dev = cols[route_dev_col];
1225 /********************************************************************
1227 * defaultroute_exists - determine if there is a default route
1230 static int defaultroute_exists (struct rtentry *rt)
1234 if (!open_route_table())
1237 while (read_route_table(rt) != 0) {
1238 if ((rt->rt_flags & RTF_UP) == 0)
1241 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1243 if (SIN_ADDR(rt->rt_dst) == 0L) {
1249 close_route_table();
1254 * have_route_to - determine if the system has any route to
1255 * a given IP address. `addr' is in network byte order.
1256 * Return value is 1 if yes, 0 if no, -1 if don't know.
1257 * For demand mode to work properly, we have to ignore routes
1258 * through our own interface.
1260 int have_route_to(u_int32_t addr)
1265 if (!open_route_table())
1266 return -1; /* don't know */
1268 while (read_route_table(&rt)) {
1269 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1271 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1277 close_route_table();
1281 /********************************************************************
1283 * sifdefaultroute - assign a default route through the address given.
1286 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1290 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1291 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1293 if (old_gateway != gateway)
1294 error("not replacing existing default route to %s [%I]",
1295 rt.rt_dev, old_gateway);
1299 memset (&rt, '\0', sizeof (rt));
1300 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1301 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1303 if (kernel_version > KVERSION(2,1,0)) {
1304 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1305 SIN_ADDR(rt.rt_genmask) = 0L;
1308 SIN_ADDR(rt.rt_gateway) = gateway;
1310 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1311 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1312 if ( ! ok_error ( errno ))
1313 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1317 default_route_gateway = gateway;
1321 /********************************************************************
1323 * cifdefaultroute - delete a default route through the address given.
1326 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1330 default_route_gateway = 0;
1332 memset (&rt, '\0', sizeof (rt));
1333 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1334 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1336 if (kernel_version > KVERSION(2,1,0)) {
1337 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1338 SIN_ADDR(rt.rt_genmask) = 0L;
1341 SIN_ADDR(rt.rt_gateway) = gateway;
1343 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1344 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1346 if ( ! ok_error ( errno ))
1347 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1355 /********************************************************************
1357 * sifproxyarp - Make a proxy ARP entry for the peer.
1360 int sifproxyarp (int unit, u_int32_t his_adr)
1362 struct arpreq arpreq;
1365 if (has_proxy_arp == 0) {
1366 memset (&arpreq, '\0', sizeof(arpreq));
1368 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1369 SIN_ADDR(arpreq.arp_pa) = his_adr;
1370 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1372 * Get the hardware address of an interface on the same subnet
1373 * as our local address.
1375 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1376 sizeof(proxy_arp_dev))) {
1377 error("Cannot determine ethernet address for proxy ARP");
1380 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1382 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1383 if ( ! ok_error ( errno ))
1384 error("ioctl(SIOCSARP): %m(%d)", errno);
1387 proxy_arp_addr = his_adr;
1391 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1392 if (forw_path != 0) {
1393 int fd = open(forw_path, O_WRONLY);
1395 if (write(fd, "1", 1) != 1)
1396 error("Couldn't enable IP forwarding: %m");
1406 /********************************************************************
1408 * cifproxyarp - Delete the proxy ARP entry for the peer.
1411 int cifproxyarp (int unit, u_int32_t his_adr)
1413 struct arpreq arpreq;
1415 if (has_proxy_arp) {
1417 memset (&arpreq, '\0', sizeof(arpreq));
1418 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1419 SIN_ADDR(arpreq.arp_pa) = his_adr;
1420 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1421 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1423 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1424 if ( ! ok_error ( errno ))
1425 warn("ioctl(SIOCDARP): %m(%d)", errno);
1432 /********************************************************************
1434 * get_ether_addr - get the hardware address of an interface on the
1435 * the same subnet as ipaddr.
1438 static int get_ether_addr (u_int32_t ipaddr,
1439 struct sockaddr *hwaddr,
1440 char *name, int namelen)
1442 struct ifreq *ifr, *ifend;
1443 u_int32_t ina, mask;
1447 struct ifreq ifs[MAX_IFS];
1449 ifc.ifc_len = sizeof(ifs);
1451 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1452 if ( ! ok_error ( errno ))
1453 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1457 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1458 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1460 * Scan through looking for an interface with an Internet
1461 * address on the same subnet as `ipaddr'.
1463 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1464 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1465 if (ifr->ifr_addr.sa_family == AF_INET) {
1466 ina = SIN_ADDR(ifr->ifr_addr);
1467 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1468 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1471 * Check that the interface is up, and not point-to-point
1474 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1477 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1480 * Get its netmask and check that it's on the right subnet.
1482 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1485 mask = SIN_ADDR(ifreq.ifr_addr);
1486 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1487 ip_ntoa(ina), ntohl(mask)));
1489 if (((ipaddr ^ ina) & mask) != 0)
1498 strlcpy(name, ifreq.ifr_name, namelen);
1500 /* trim off the :1 in eth0:1 */
1501 aliasp = strchr(name, ':');
1505 info("found interface %s for proxy arp", name);
1507 * Now get the hardware address.
1509 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1510 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1511 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1517 sizeof (struct sockaddr));
1519 SYSDEBUG ((LOG_DEBUG,
1520 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1521 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1522 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1523 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1524 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1525 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1526 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1527 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1528 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1532 /********************************************************************
1534 * Return user specified netmask, modified by any mask we might determine
1535 * for address `addr' (in network byte order).
1536 * Here we scan through the system's list of interfaces, looking for
1537 * any non-point-to-point interfaces which might appear to be on the same
1538 * network as `addr'. If we find any, we OR in their netmask to the
1539 * user-specified netmask.
1542 u_int32_t GetMask (u_int32_t addr)
1544 u_int32_t mask, nmask, ina;
1545 struct ifreq *ifr, *ifend, ifreq;
1547 struct ifreq ifs[MAX_IFS];
1551 if (IN_CLASSA(addr)) /* determine network mask for address class */
1552 nmask = IN_CLASSA_NET;
1553 else if (IN_CLASSB(addr))
1554 nmask = IN_CLASSB_NET;
1556 nmask = IN_CLASSC_NET;
1558 /* class D nets are disallowed by bad_ip_adrs */
1559 mask = netmask | htonl(nmask);
1561 * Scan through the system's network interfaces.
1563 ifc.ifc_len = sizeof(ifs);
1565 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1566 if ( ! ok_error ( errno ))
1567 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1571 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1572 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1574 * Check the interface's internet address.
1576 if (ifr->ifr_addr.sa_family != AF_INET)
1578 ina = SIN_ADDR(ifr->ifr_addr);
1579 if (((ntohl(ina) ^ addr) & nmask) != 0)
1582 * Check that the interface is up, and not point-to-point nor loopback.
1584 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1585 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1588 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1591 * Get its netmask and OR it into our mask.
1593 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1595 mask |= SIN_ADDR(ifreq.ifr_addr);
1601 /********************************************************************
1603 * Internal routine to decode the version.modification.patch level
1606 static void decode_version (char *buf, int *version,
1607 int *modification, int *patch)
1609 *version = (int) strtoul (buf, &buf, 10);
1615 *modification = (int) strtoul (buf, &buf, 10);
1618 *patch = (int) strtoul (buf, &buf, 10);
1629 /********************************************************************
1631 * Procedure to determine if the PPP line discipline is registered.
1635 ppp_registered(void)
1643 * We used to open the serial device and set it to the ppp line
1644 * discipline here, in order to create a ppp unit. But that is
1645 * not a good idea - the user might have specified a device that
1646 * they can't open (permission, or maybe it doesn't really exist).
1647 * So we grab a pty master/slave pair and use that.
1649 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1650 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1655 * Try to put the device into the PPP discipline.
1657 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1658 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1667 /********************************************************************
1669 * ppp_available - check whether the system has any ppp interfaces
1670 * (in fact we check whether we can do an ioctl on ppp0).
1673 int ppp_available(void)
1678 int my_version, my_modification, my_patch;
1679 int osmaj, osmin, ospatch;
1682 "This system lacks kernel support for PPP. This could be because\n"
1683 "the PPP kernel module could not be loaded, or because PPP was not\n"
1684 "included in the kernel configuration. If PPP was included as a\n"
1685 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1686 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1687 "See README.linux file in the ppp distribution for more details.\n";
1689 /* get the kernel version now, since we are called before sys_init */
1691 osmaj = osmin = ospatch = 0;
1692 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1693 kernel_version = KVERSION(osmaj, osmin, ospatch);
1695 if (kernel_version >= KVERSION(2,3,13)) {
1696 fd = open("/dev/ppp", O_RDWR);
1697 if (fd < 0 && errno == ENOENT) {
1698 /* try making it and see if that helps. */
1699 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1700 makedev(108, 0)) >= 0) {
1701 fd = open("/dev/ppp", O_RDWR);
1703 info("Created /dev/ppp device node");
1705 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1706 } else if (errno == EEXIST) {
1707 fd = open("/dev/ppp", O_RDWR);
1711 new_style_driver = 1;
1713 /* XXX should get from driver */
1715 driver_modification = 4;
1723 * Open a socket for doing the ioctl operations.
1725 s = socket(AF_INET, SOCK_DGRAM, 0);
1729 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1730 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1732 * If the device did not exist then attempt to create one by putting the
1733 * current tty into the PPP discipline. If this works then obtain the
1734 * flags for the device again.
1737 if (ppp_registered()) {
1738 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1739 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1743 * Ensure that the hardware address is for PPP and not something else
1746 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1748 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1752 * This is the PPP device. Validate the version of the driver at this
1753 * point to ensure that this program will work with the driver.
1756 char abBuffer [1024];
1758 ifr.ifr_data = abBuffer;
1759 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1761 error("Couldn't read driver version: %m");
1763 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1766 decode_version(abBuffer,
1768 &driver_modification,
1771 * Validate the version of the driver against the version that we used.
1773 decode_version(VERSION,
1778 /* The version numbers must match */
1779 if (driver_version != my_version)
1782 /* The modification levels must be legal */
1783 if (driver_modification < 3) {
1784 if (driver_modification >= 2) {
1785 /* we can cope with 2.2.0 and above */
1794 slprintf(route_buffer, sizeof(route_buffer),
1795 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1796 driver_version, driver_modification, driver_patch);
1798 no_ppp_msg = route_buffer;
1805 /********************************************************************
1807 * Update the wtmp file with the appropriate user name and tty device.
1810 void logwtmp (const char *line, const char *name, const char *host)
1812 struct utmp ut, *utp;
1813 pid_t mypid = getpid();
1819 * Update the signon database for users.
1820 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1822 utmpname(_PATH_UTMP);
1824 while ((utp = getutent()) && (utp->ut_pid != mypid))
1827 /* Is this call really necessary? There is another one after the 'put' */
1831 memcpy(&ut, utp, sizeof(ut));
1833 /* some gettys/telnetds don't initialize utmp... */
1834 memset(&ut, 0, sizeof(ut));
1836 if (ut.ut_id[0] == 0)
1837 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1839 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1840 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1844 ut.ut_type = USER_PROCESS;
1847 /* Insert the host name if one is supplied */
1849 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1851 /* Insert the IP address of the remote system if IP is enabled */
1852 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1853 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1854 sizeof(ut.ut_addr));
1856 /* CL: Makes sure that the logout works */
1857 if (*host == 0 && *name==0)
1863 * Update the wtmp file.
1866 updwtmp(_PATH_WTMP, &ut);
1868 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1870 flock(wtmp, LOCK_EX);
1872 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1873 warn("error writing %s: %m", _PATH_WTMP);
1875 flock(wtmp, LOCK_UN);
1883 /********************************************************************
1885 * sifvjcomp - config tcp header compression
1888 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1890 u_int x = get_flags(ppp_dev_fd);
1893 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1894 if (! ok_error (errno))
1895 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1900 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1901 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1902 set_flags (ppp_dev_fd, x);
1907 /********************************************************************
1909 * sifup - Config the interface up and enable IP packets to pass.
1916 memset (&ifr, '\0', sizeof (ifr));
1917 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1918 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1919 if (! ok_error (errno))
1920 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1924 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1925 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1926 if (! ok_error (errno))
1927 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1935 /********************************************************************
1937 * sifdown - Disable the indicated protocol and config the interface
1938 * down if there are no remaining protocols.
1945 if (if_is_up && --if_is_up > 0)
1948 memset (&ifr, '\0', sizeof (ifr));
1949 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1950 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1951 if (! ok_error (errno))
1952 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1956 ifr.ifr_flags &= ~IFF_UP;
1957 ifr.ifr_flags |= IFF_POINTOPOINT;
1958 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1959 if (! ok_error (errno))
1960 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1966 /********************************************************************
1968 * sifaddr - Config the interface IP addresses and netmask.
1971 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1977 memset (&ifr, '\0', sizeof (ifr));
1978 memset (&rt, '\0', sizeof (rt));
1980 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
1981 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
1982 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
1984 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1986 * Set our IP address
1988 SIN_ADDR(ifr.ifr_addr) = our_adr;
1989 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
1990 if (errno != EEXIST) {
1991 if (! ok_error (errno))
1992 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
1995 warn("ioctl(SIOCSIFADDR): Address already exists");
2000 * Set the gateway address
2002 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2003 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2004 if (! ok_error (errno))
2005 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2010 * For recent kernels, force the netmask to 255.255.255.255.
2012 if (kernel_version >= KVERSION(2,1,16))
2014 if (net_mask != 0) {
2015 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2016 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2017 if (! ok_error (errno))
2018 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2023 * Add the device route
2025 if (kernel_version < KVERSION(2,1,16)) {
2026 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2027 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2030 SIN_ADDR(rt.rt_gateway) = 0L;
2031 SIN_ADDR(rt.rt_dst) = his_adr;
2032 rt.rt_flags = RTF_UP | RTF_HOST;
2034 if (kernel_version > KVERSION(2,1,0)) {
2035 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2036 SIN_ADDR(rt.rt_genmask) = -1L;
2039 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2040 if (! ok_error (errno))
2041 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2046 /* set ip_dynaddr in demand mode if address changes */
2047 if (demand && tune_kernel && !dynaddr_set
2048 && our_old_addr && our_old_addr != our_adr) {
2049 /* set ip_dynaddr if possible */
2053 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2054 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2055 if (write(fd, "1", 1) != 1)
2056 error("Couldn't enable dynamic IP addressing: %m");
2059 dynaddr_set = 1; /* only 1 attempt */
2066 /********************************************************************
2068 * cifaddr - Clear the interface IP addresses, and delete routes
2069 * through the interface if possible.
2072 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2076 if (kernel_version < KVERSION(2,1,16)) {
2078 * Delete the route through the device
2081 memset (&rt, '\0', sizeof (rt));
2083 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2084 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2087 SIN_ADDR(rt.rt_gateway) = 0;
2088 SIN_ADDR(rt.rt_dst) = his_adr;
2089 rt.rt_flags = RTF_UP | RTF_HOST;
2091 if (kernel_version > KVERSION(2,1,0)) {
2092 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2093 SIN_ADDR(rt.rt_genmask) = -1L;
2096 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2097 if (still_ppp() && ! ok_error (errno))
2098 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2103 /* This way it is possible to have an IPX-only or IPv6-only interface */
2104 memset(&ifr, 0, sizeof(ifr));
2105 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2106 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2108 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2109 if (! ok_error (errno)) {
2110 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2115 our_old_addr = our_adr;
2121 /********************************************************************
2123 * sif6addr - Config the interface with an IPv6 link-local address
2125 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2127 struct in6_ifreq ifr6;
2129 struct in6_rtmsg rt6;
2131 memset(&ifr, 0, sizeof (ifr));
2132 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2133 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2134 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2138 /* Local interface */
2139 memset(&ifr6, 0, sizeof(ifr6));
2140 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2141 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2142 ifr6.ifr6_prefixlen = 10;
2144 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2145 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2149 /* Route to remote host */
2150 memset(&rt6, 0, sizeof(rt6));
2151 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2152 rt6.rtmsg_flags = RTF_UP;
2153 rt6.rtmsg_dst_len = 10;
2154 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2155 rt6.rtmsg_metric = 1;
2157 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2158 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2166 /********************************************************************
2168 * cif6addr - Remove IPv6 address from interface
2170 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2173 struct in6_ifreq ifr6;
2175 memset(&ifr, 0, sizeof(ifr));
2176 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2177 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2178 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2182 memset(&ifr6, 0, sizeof(ifr6));
2183 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2184 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2185 ifr6.ifr6_prefixlen = 10;
2187 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2188 if (errno != EADDRNOTAVAIL) {
2189 if (! ok_error (errno))
2190 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2193 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2202 * get_pty - get a pty master/slave pair and chown the slave side
2203 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2206 get_pty(master_fdp, slave_fdp, slave_name, uid)
2212 int i, mfd, sfd = -1;
2214 struct termios tios;
2218 * Try the unix98 way first.
2220 mfd = open("/dev/ptmx", O_RDWR);
2223 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2224 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2225 chmod(pty_name, S_IRUSR | S_IWUSR);
2228 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2229 warn("Couldn't unlock pty slave %s: %m", pty_name);
2231 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2232 warn("Couldn't open pty slave %s: %m", pty_name);
2235 #endif /* TIOCGPTN */
2238 /* the old way - scan through the pty name space */
2239 for (i = 0; i < 64; ++i) {
2240 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2241 'p' + i / 16, i % 16);
2242 mfd = open(pty_name, O_RDWR, 0);
2245 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2247 fchown(sfd, uid, -1);
2248 fchmod(sfd, S_IRUSR | S_IWUSR);
2259 strlcpy(slave_name, pty_name, 16);
2262 if (tcgetattr(sfd, &tios) == 0) {
2263 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2264 tios.c_cflag |= CS8 | CREAD;
2265 tios.c_iflag = IGNPAR | CLOCAL;
2268 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2269 warn("couldn't set attributes on pty: %m");
2271 warn("couldn't get attributes on pty: %m");
2276 /********************************************************************
2278 * open_loopback - open the device we use for getting packets
2279 * in demand mode. Under Linux, we use a pty master/slave pair.
2282 open_ppp_loopback(void)
2287 if (new_style_driver) {
2288 /* allocate ourselves a ppp unit */
2290 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
2291 fatal("Couldn't create PPP unit: %m");
2292 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2293 set_kdebugflag(kdebugflag);
2298 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2299 fatal("No free pty for loopback");
2300 SYSDEBUG(("using %s for loopback", loop_name));
2302 set_ppp_fd(slave_fd);
2304 flags = fcntl(master_fd, F_GETFL);
2306 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2307 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2309 flags = fcntl(ppp_fd, F_GETFL);
2311 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2312 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2314 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2315 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2317 * Find out which interface we were given.
2319 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2320 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2322 * Enable debug in the driver if requested.
2324 set_kdebugflag (kdebugflag);
2329 /********************************************************************
2331 * restore_loop - reattach the ppp unit to the loopback.
2333 * The kernel ppp driver automatically reattaches the ppp unit to
2334 * the loopback if the serial port is set to a line discipline other
2335 * than ppp, or if it detects a modem hangup. The former will happen
2336 * in disestablish_ppp if the latter hasn't already happened, so we
2337 * shouldn't need to do anything.
2339 * Just to be sure, set the real serial port to the normal discipline.
2346 if (new_style_driver) {
2347 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2350 if (ppp_fd != slave_fd) {
2351 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2352 set_ppp_fd(slave_fd);
2356 /********************************************************************
2358 * sifnpmode - Set the mode for handling packets for a given NP.
2362 sifnpmode(u, proto, mode)
2369 npi.protocol = proto;
2371 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2372 if (! ok_error (errno))
2373 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2374 proto, mode, errno);
2381 /********************************************************************
2383 * sipxfaddr - Config the interface IPX networknumber
2386 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2393 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2395 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2397 if (! ok_error (errno))
2398 dbglog("socket(AF_IPX): %m (%d)", errno);
2402 memset (&ifr, '\0', sizeof (ifr));
2403 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2405 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2406 sipx->sipx_family = AF_IPX;
2407 sipx->sipx_port = 0;
2408 sipx->sipx_network = htonl (network);
2409 sipx->sipx_type = IPX_FRAME_ETHERII;
2410 sipx->sipx_action = IPX_CRTITF;
2412 * Set the IPX device
2414 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2416 if (errno != EEXIST) {
2417 if (! ok_error (errno))
2418 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2421 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2430 /********************************************************************
2432 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2433 * are removed and the device is no longer able to pass IPX
2437 int cipxfaddr (int unit)
2444 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2446 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2448 if (! ok_error (errno))
2449 dbglog("socket(AF_IPX): %m (%d)", errno);
2453 memset (&ifr, '\0', sizeof (ifr));
2454 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2456 sipx->sipx_type = IPX_FRAME_ETHERII;
2457 sipx->sipx_action = IPX_DLTITF;
2458 sipx->sipx_family = AF_IPX;
2460 * Set the IPX device
2462 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2463 if (! ok_error (errno))
2464 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2474 * Use the hostname as part of the random number seed.
2483 for (p = hostname; *p != 0; ++p)
2488 /********************************************************************
2490 * sys_check_options - check the options that the user specified
2494 sys_check_options(void)
2498 * Disable the IPX protocol if the support is not present in the kernel.
2502 if (ipxcp_protent.enabled_flag) {
2503 struct stat stat_buf;
2504 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2505 || lstat(path, &stat_buf) < 0) {
2506 error("IPX support is not present in the kernel\n");
2507 ipxcp_protent.enabled_flag = 0;
2511 if (demand && driver_is_old) {
2512 option_error("demand dialling is not supported by kernel driver "
2513 "version %d.%d.%d", driver_version, driver_modification,