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;
854 nr = read(ppp_fd, buf, len);
855 if (new_style_driver && nr < 0 && (errno == EWOULDBLOCK || errno == EIO))
856 nr = read(ppp_dev_fd, buf, len);
858 if (errno == EWOULDBLOCK || errno == EIO)
860 fatal("read: %m(%d)", errno);
862 return (new_style_driver && nr > 0)? nr+2: nr;
865 /********************************************************************
867 * get_loop_output - get outgoing packets from the ppp device,
868 * and detect when we want to bring the real link up.
869 * Return value is 1 if we need to bring up the link, 0 otherwise.
872 get_loop_output(void)
877 if (new_style_driver) {
878 while ((n = read_packet(inpacket_buf)) > 0)
879 if (loop_frame(inpacket_buf, n))
884 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
885 if (loop_chars(inbuf, n))
889 fatal("eof on loopback");
891 if (errno != EWOULDBLOCK)
892 fatal("read from loopback: %m(%d)", errno);
897 /********************************************************************
899 * ppp_send_config - configure the transmit characteristics of
903 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
908 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
910 * Set the MTU and other parameters for the ppp device
912 memset (&ifr, '\0', sizeof (ifr));
913 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
916 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
917 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
921 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
922 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
923 if (!ok_error(errno))
924 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
928 x = get_flags(ppp_fd);
929 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
930 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
931 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
932 set_flags(ppp_fd, x);
935 /********************************************************************
937 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
940 void ppp_set_xaccm (int unit, ext_accm accm)
942 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
943 accm[0], accm[1], accm[2], accm[3]));
947 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
948 if ( ! ok_error (errno))
949 warn("ioctl(set extended ACCM): %m(%d)", errno);
953 /********************************************************************
955 * ppp_recv_config - configure the receive-side characteristics of
959 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
961 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
963 * If we were called because the link has gone down then there is nothing
964 * which may be done. Just return without incident.
969 * Set the receiver parameters
971 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
972 if ( ! ok_error (errno))
973 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
975 if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
976 error("Couldn't set MRU in generic PPP layer: %m");
978 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
979 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
980 if (!ok_error(errno))
981 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
985 /********************************************************************
987 * ccp_test - ask kernel whether a given compression method
988 * is acceptable for use.
991 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
993 struct ppp_option_data data;
995 memset (&data, '\0', sizeof (data));
997 data.length = opt_len;
998 data.transmit = for_transmit;
1000 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1003 return (errno == ENOBUFS)? 0: -1;
1006 /********************************************************************
1008 * ccp_flags_set - inform kernel about the current state of CCP.
1011 void ccp_flags_set (int unit, int isopen, int isup)
1014 int x = get_flags(ppp_dev_fd);
1015 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1016 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1017 set_flags (ppp_dev_fd, x);
1021 /********************************************************************
1023 * get_idle_time - return how long the link has been idle.
1026 get_idle_time(u, ip)
1028 struct ppp_idle *ip;
1030 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1033 /********************************************************************
1035 * get_ppp_stats - return statistics for the link.
1038 get_ppp_stats(u, stats)
1040 struct pppd_stats *stats;
1042 struct ifpppstatsreq req;
1044 memset (&req, 0, sizeof (req));
1046 req.stats_ptr = (caddr_t) &req.stats;
1047 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1048 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1049 error("Couldn't get PPP statistics: %m");
1052 stats->bytes_in = req.stats.p.ppp_ibytes;
1053 stats->bytes_out = req.stats.p.ppp_obytes;
1057 /********************************************************************
1059 * ccp_fatal_error - returns 1 if decompression was disabled as a
1060 * result of an error detected after decompression of a packet,
1061 * 0 otherwise. This is necessary because of patent nonsense.
1064 int ccp_fatal_error (int unit)
1066 int x = get_flags(ppp_dev_fd);
1068 return x & SC_DC_FERROR;
1071 /********************************************************************
1073 * path_to_procfs - find the path to the proc file system mount point
1075 static char proc_path[MAXPATHLEN];
1076 static int proc_path_len;
1078 static char *path_to_procfs(const char *tail)
1080 struct mntent *mntent;
1083 if (proc_path_len == 0) {
1084 /* Default the mount location of /proc */
1085 strlcpy (proc_path, "/proc", sizeof(proc_path));
1087 fp = fopen(MOUNTED, "r");
1089 while ((mntent = getmntent(fp)) != NULL) {
1090 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1092 if (strcmp(mntent->mnt_type, "proc") == 0) {
1093 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1094 proc_path_len = strlen(proc_path);
1102 strlcpy(proc_path + proc_path_len, tail,
1103 sizeof(proc_path) - proc_path_len);
1108 * /proc/net/route parsing stuff.
1110 #define ROUTE_MAX_COLS 12
1111 FILE *route_fd = (FILE *) 0;
1112 static char route_buffer[512];
1113 static int route_dev_col, route_dest_col, route_gw_col;
1114 static int route_flags_col, route_mask_col;
1115 static int route_num_cols;
1117 static int open_route_table (void);
1118 static void close_route_table (void);
1119 static int read_route_table (struct rtentry *rt);
1121 /********************************************************************
1123 * close_route_table - close the interface to the route table
1126 static void close_route_table (void)
1128 if (route_fd != (FILE *) 0) {
1130 route_fd = (FILE *) 0;
1134 /********************************************************************
1136 * open_route_table - open the interface to the route table
1138 static char route_delims[] = " \t\n";
1140 static int open_route_table (void)
1144 close_route_table();
1146 path = path_to_procfs("/net/route");
1147 route_fd = fopen (path, "r");
1148 if (route_fd == NULL) {
1149 error("can't open routing table %s: %m", path);
1153 route_dev_col = 0; /* default to usual columns */
1156 route_flags_col = 3;
1160 /* parse header line */
1161 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1162 char *p = route_buffer, *q;
1164 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1166 if ((q = strtok(p, route_delims)) == 0)
1168 if (strcasecmp(q, "iface") == 0)
1169 route_dev_col = col;
1170 else if (strcasecmp(q, "destination") == 0)
1171 route_dest_col = col;
1172 else if (strcasecmp(q, "gateway") == 0)
1174 else if (strcasecmp(q, "flags") == 0)
1175 route_flags_col = col;
1176 else if (strcasecmp(q, "mask") == 0)
1177 route_mask_col = col;
1180 if (used && col >= route_num_cols)
1181 route_num_cols = col + 1;
1189 /********************************************************************
1191 * read_route_table - read the next entry from the route table
1194 static int read_route_table(struct rtentry *rt)
1196 char *cols[ROUTE_MAX_COLS], *p;
1199 memset (rt, '\0', sizeof (struct rtentry));
1201 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1205 for (col = 0; col < route_num_cols; ++col) {
1206 cols[col] = strtok(p, route_delims);
1207 if (cols[col] == NULL)
1208 return 0; /* didn't get enough columns */
1212 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1213 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1214 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1216 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1217 rt->rt_dev = cols[route_dev_col];
1222 /********************************************************************
1224 * defaultroute_exists - determine if there is a default route
1227 static int defaultroute_exists (struct rtentry *rt)
1231 if (!open_route_table())
1234 while (read_route_table(rt) != 0) {
1235 if ((rt->rt_flags & RTF_UP) == 0)
1238 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1240 if (SIN_ADDR(rt->rt_dst) == 0L) {
1246 close_route_table();
1251 * have_route_to - determine if the system has any route to
1252 * a given IP address. `addr' is in network byte order.
1253 * Return value is 1 if yes, 0 if no, -1 if don't know.
1254 * For demand mode to work properly, we have to ignore routes
1255 * through our own interface.
1257 int have_route_to(u_int32_t addr)
1262 if (!open_route_table())
1263 return -1; /* don't know */
1265 while (read_route_table(&rt)) {
1266 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1268 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1274 close_route_table();
1278 /********************************************************************
1280 * sifdefaultroute - assign a default route through the address given.
1283 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1287 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1288 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1290 if (old_gateway != gateway)
1291 error("not replacing existing default route to %s [%I]",
1292 rt.rt_dev, old_gateway);
1296 memset (&rt, '\0', sizeof (rt));
1297 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1298 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1300 if (kernel_version > KVERSION(2,1,0)) {
1301 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1302 SIN_ADDR(rt.rt_genmask) = 0L;
1305 SIN_ADDR(rt.rt_gateway) = gateway;
1307 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1308 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1309 if ( ! ok_error ( errno ))
1310 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1314 default_route_gateway = gateway;
1318 /********************************************************************
1320 * cifdefaultroute - delete a default route through the address given.
1323 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1327 default_route_gateway = 0;
1329 memset (&rt, '\0', sizeof (rt));
1330 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1331 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1333 if (kernel_version > KVERSION(2,1,0)) {
1334 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1335 SIN_ADDR(rt.rt_genmask) = 0L;
1338 SIN_ADDR(rt.rt_gateway) = gateway;
1340 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1341 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1343 if ( ! ok_error ( errno ))
1344 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1352 /********************************************************************
1354 * sifproxyarp - Make a proxy ARP entry for the peer.
1357 int sifproxyarp (int unit, u_int32_t his_adr)
1359 struct arpreq arpreq;
1362 if (has_proxy_arp == 0) {
1363 memset (&arpreq, '\0', sizeof(arpreq));
1365 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1366 SIN_ADDR(arpreq.arp_pa) = his_adr;
1367 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1369 * Get the hardware address of an interface on the same subnet
1370 * as our local address.
1372 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1373 sizeof(proxy_arp_dev))) {
1374 error("Cannot determine ethernet address for proxy ARP");
1377 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1379 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1380 if ( ! ok_error ( errno ))
1381 error("ioctl(SIOCSARP): %m(%d)", errno);
1384 proxy_arp_addr = his_adr;
1388 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1389 if (forw_path != 0) {
1390 int fd = open(forw_path, O_WRONLY);
1392 if (write(fd, "1", 1) != 1)
1393 error("Couldn't enable IP forwarding: %m");
1403 /********************************************************************
1405 * cifproxyarp - Delete the proxy ARP entry for the peer.
1408 int cifproxyarp (int unit, u_int32_t his_adr)
1410 struct arpreq arpreq;
1412 if (has_proxy_arp) {
1414 memset (&arpreq, '\0', sizeof(arpreq));
1415 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1416 SIN_ADDR(arpreq.arp_pa) = his_adr;
1417 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1418 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1420 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1421 if ( ! ok_error ( errno ))
1422 warn("ioctl(SIOCDARP): %m(%d)", errno);
1429 /********************************************************************
1431 * get_ether_addr - get the hardware address of an interface on the
1432 * the same subnet as ipaddr.
1435 static int get_ether_addr (u_int32_t ipaddr,
1436 struct sockaddr *hwaddr,
1437 char *name, int namelen)
1439 struct ifreq *ifr, *ifend;
1440 u_int32_t ina, mask;
1444 struct ifreq ifs[MAX_IFS];
1446 ifc.ifc_len = sizeof(ifs);
1448 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1449 if ( ! ok_error ( errno ))
1450 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1454 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1455 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1457 * Scan through looking for an interface with an Internet
1458 * address on the same subnet as `ipaddr'.
1460 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1461 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1462 if (ifr->ifr_addr.sa_family == AF_INET) {
1463 ina = SIN_ADDR(ifr->ifr_addr);
1464 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1465 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1468 * Check that the interface is up, and not point-to-point
1471 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1474 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1477 * Get its netmask and check that it's on the right subnet.
1479 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1482 mask = SIN_ADDR(ifreq.ifr_addr);
1483 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1484 ip_ntoa(ina), ntohl(mask)));
1486 if (((ipaddr ^ ina) & mask) != 0)
1495 strlcpy(name, ifreq.ifr_name, namelen);
1497 /* trim off the :1 in eth0:1 */
1498 aliasp = strchr(name, ':');
1502 info("found interface %s for proxy arp", name);
1504 * Now get the hardware address.
1506 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1507 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1508 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1514 sizeof (struct sockaddr));
1516 SYSDEBUG ((LOG_DEBUG,
1517 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1518 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1519 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1520 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1521 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1522 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1523 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1524 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1525 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1529 /********************************************************************
1531 * Return user specified netmask, modified by any mask we might determine
1532 * for address `addr' (in network byte order).
1533 * Here we scan through the system's list of interfaces, looking for
1534 * any non-point-to-point interfaces which might appear to be on the same
1535 * network as `addr'. If we find any, we OR in their netmask to the
1536 * user-specified netmask.
1539 u_int32_t GetMask (u_int32_t addr)
1541 u_int32_t mask, nmask, ina;
1542 struct ifreq *ifr, *ifend, ifreq;
1544 struct ifreq ifs[MAX_IFS];
1548 if (IN_CLASSA(addr)) /* determine network mask for address class */
1549 nmask = IN_CLASSA_NET;
1550 else if (IN_CLASSB(addr))
1551 nmask = IN_CLASSB_NET;
1553 nmask = IN_CLASSC_NET;
1555 /* class D nets are disallowed by bad_ip_adrs */
1556 mask = netmask | htonl(nmask);
1558 * Scan through the system's network interfaces.
1560 ifc.ifc_len = sizeof(ifs);
1562 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1563 if ( ! ok_error ( errno ))
1564 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1568 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1569 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1571 * Check the interface's internet address.
1573 if (ifr->ifr_addr.sa_family != AF_INET)
1575 ina = SIN_ADDR(ifr->ifr_addr);
1576 if (((ntohl(ina) ^ addr) & nmask) != 0)
1579 * Check that the interface is up, and not point-to-point nor loopback.
1581 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1582 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1585 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1588 * Get its netmask and OR it into our mask.
1590 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1592 mask |= SIN_ADDR(ifreq.ifr_addr);
1598 /********************************************************************
1600 * Internal routine to decode the version.modification.patch level
1603 static void decode_version (char *buf, int *version,
1604 int *modification, int *patch)
1606 *version = (int) strtoul (buf, &buf, 10);
1612 *modification = (int) strtoul (buf, &buf, 10);
1615 *patch = (int) strtoul (buf, &buf, 10);
1626 /********************************************************************
1628 * Procedure to determine if the PPP line discipline is registered.
1632 ppp_registered(void)
1640 * We used to open the serial device and set it to the ppp line
1641 * discipline here, in order to create a ppp unit. But that is
1642 * not a good idea - the user might have specified a device that
1643 * they can't open (permission, or maybe it doesn't really exist).
1644 * So we grab a pty master/slave pair and use that.
1646 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1647 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1652 * Try to put the device into the PPP discipline.
1654 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1655 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1664 /********************************************************************
1666 * ppp_available - check whether the system has any ppp interfaces
1667 * (in fact we check whether we can do an ioctl on ppp0).
1670 int ppp_available(void)
1675 int my_version, my_modification, my_patch;
1676 int osmaj, osmin, ospatch;
1679 "This system lacks kernel support for PPP. This could be because\n"
1680 "the PPP kernel module could not be loaded, or because PPP was not\n"
1681 "included in the kernel configuration. If PPP was included as a\n"
1682 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1683 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1684 "See README.linux file in the ppp distribution for more details.\n";
1686 /* get the kernel version now, since we are called before sys_init */
1688 osmaj = osmin = ospatch = 0;
1689 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1690 kernel_version = KVERSION(osmaj, osmin, ospatch);
1692 if (kernel_version >= KVERSION(2,3,13)) {
1693 fd = open("/dev/ppp", O_RDWR);
1694 if (fd < 0 && errno == ENOENT) {
1695 /* try making it and see if that helps. */
1696 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1697 makedev(108, 0)) >= 0) {
1698 fd = open("/dev/ppp", O_RDWR);
1700 info("Created /dev/ppp device node");
1702 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1703 } else if (errno == EEXIST) {
1704 fd = open("/dev/ppp", O_RDWR);
1708 new_style_driver = 1;
1710 /* XXX should get from driver */
1712 driver_modification = 4;
1720 * Open a socket for doing the ioctl operations.
1722 s = socket(AF_INET, SOCK_DGRAM, 0);
1726 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1727 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1729 * If the device did not exist then attempt to create one by putting the
1730 * current tty into the PPP discipline. If this works then obtain the
1731 * flags for the device again.
1734 if (ppp_registered()) {
1735 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1736 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1740 * Ensure that the hardware address is for PPP and not something else
1743 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1745 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1749 * This is the PPP device. Validate the version of the driver at this
1750 * point to ensure that this program will work with the driver.
1753 char abBuffer [1024];
1755 ifr.ifr_data = abBuffer;
1756 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1758 error("Couldn't read driver version: %m");
1760 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1763 decode_version(abBuffer,
1765 &driver_modification,
1768 * Validate the version of the driver against the version that we used.
1770 decode_version(VERSION,
1775 /* The version numbers must match */
1776 if (driver_version != my_version)
1779 /* The modification levels must be legal */
1780 if (driver_modification < 3) {
1781 if (driver_modification >= 2) {
1782 /* we can cope with 2.2.0 and above */
1791 slprintf(route_buffer, sizeof(route_buffer),
1792 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1793 driver_version, driver_modification, driver_patch);
1795 no_ppp_msg = route_buffer;
1802 /********************************************************************
1804 * Update the wtmp file with the appropriate user name and tty device.
1807 void logwtmp (const char *line, const char *name, const char *host)
1809 struct utmp ut, *utp;
1810 pid_t mypid = getpid();
1816 * Update the signon database for users.
1817 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1819 utmpname(_PATH_UTMP);
1821 while ((utp = getutent()) && (utp->ut_pid != mypid))
1824 /* Is this call really necessary? There is another one after the 'put' */
1828 memcpy(&ut, utp, sizeof(ut));
1830 /* some gettys/telnetds don't initialize utmp... */
1831 memset(&ut, 0, sizeof(ut));
1833 if (ut.ut_id[0] == 0)
1834 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1836 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1837 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1841 ut.ut_type = USER_PROCESS;
1844 /* Insert the host name if one is supplied */
1846 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1848 /* Insert the IP address of the remote system if IP is enabled */
1849 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1850 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1851 sizeof(ut.ut_addr));
1853 /* CL: Makes sure that the logout works */
1854 if (*host == 0 && *name==0)
1860 * Update the wtmp file.
1863 updwtmp(_PATH_WTMP, &ut);
1865 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1867 flock(wtmp, LOCK_EX);
1869 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1870 warn("error writing %s: %m", _PATH_WTMP);
1872 flock(wtmp, LOCK_UN);
1880 /********************************************************************
1882 * sifvjcomp - config tcp header compression
1885 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1887 u_int x = get_flags(ppp_dev_fd);
1890 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1891 if (! ok_error (errno))
1892 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1897 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1898 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1899 set_flags (ppp_dev_fd, x);
1904 /********************************************************************
1906 * sifup - Config the interface up and enable IP packets to pass.
1913 memset (&ifr, '\0', sizeof (ifr));
1914 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1915 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1916 if (! ok_error (errno))
1917 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1921 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1922 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1923 if (! ok_error (errno))
1924 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1932 /********************************************************************
1934 * sifdown - Disable the indicated protocol and config the interface
1935 * down if there are no remaining protocols.
1942 if (if_is_up && --if_is_up > 0)
1945 memset (&ifr, '\0', sizeof (ifr));
1946 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1947 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1948 if (! ok_error (errno))
1949 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1953 ifr.ifr_flags &= ~IFF_UP;
1954 ifr.ifr_flags |= IFF_POINTOPOINT;
1955 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1956 if (! ok_error (errno))
1957 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1963 /********************************************************************
1965 * sifaddr - Config the interface IP addresses and netmask.
1968 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1974 memset (&ifr, '\0', sizeof (ifr));
1975 memset (&rt, '\0', sizeof (rt));
1977 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
1978 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
1979 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
1981 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1983 * Set our IP address
1985 SIN_ADDR(ifr.ifr_addr) = our_adr;
1986 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
1987 if (errno != EEXIST) {
1988 if (! ok_error (errno))
1989 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
1992 warn("ioctl(SIOCSIFADDR): Address already exists");
1997 * Set the gateway address
1999 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2000 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2001 if (! ok_error (errno))
2002 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2007 * For recent kernels, force the netmask to 255.255.255.255.
2009 if (kernel_version >= KVERSION(2,1,16))
2011 if (net_mask != 0) {
2012 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2013 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2014 if (! ok_error (errno))
2015 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2020 * Add the device route
2022 if (kernel_version < KVERSION(2,1,16)) {
2023 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2024 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2027 SIN_ADDR(rt.rt_gateway) = 0L;
2028 SIN_ADDR(rt.rt_dst) = his_adr;
2029 rt.rt_flags = RTF_UP | RTF_HOST;
2031 if (kernel_version > KVERSION(2,1,0)) {
2032 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2033 SIN_ADDR(rt.rt_genmask) = -1L;
2036 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2037 if (! ok_error (errno))
2038 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2043 /* set ip_dynaddr in demand mode if address changes */
2044 if (demand && tune_kernel && !dynaddr_set
2045 && our_old_addr && our_old_addr != our_adr) {
2046 /* set ip_dynaddr if possible */
2050 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2051 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2052 if (write(fd, "1", 1) != 1)
2053 error("Couldn't enable dynamic IP addressing: %m");
2056 dynaddr_set = 1; /* only 1 attempt */
2063 /********************************************************************
2065 * cifaddr - Clear the interface IP addresses, and delete routes
2066 * through the interface if possible.
2069 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2073 if (kernel_version < KVERSION(2,1,16)) {
2075 * Delete the route through the device
2078 memset (&rt, '\0', sizeof (rt));
2080 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2081 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2084 SIN_ADDR(rt.rt_gateway) = 0;
2085 SIN_ADDR(rt.rt_dst) = his_adr;
2086 rt.rt_flags = RTF_UP | RTF_HOST;
2088 if (kernel_version > KVERSION(2,1,0)) {
2089 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2090 SIN_ADDR(rt.rt_genmask) = -1L;
2093 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2094 if (still_ppp() && ! ok_error (errno))
2095 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2100 /* This way it is possible to have an IPX-only or IPv6-only interface */
2101 memset(&ifr, 0, sizeof(ifr));
2102 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2103 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2105 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2106 if (! ok_error (errno)) {
2107 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2112 our_old_addr = our_adr;
2118 /********************************************************************
2120 * sif6addr - Config the interface with an IPv6 link-local address
2122 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2124 struct in6_ifreq ifr6;
2126 struct in6_rtmsg rt6;
2128 memset(&ifr, 0, sizeof (ifr));
2129 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2130 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2131 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2135 /* Local interface */
2136 memset(&ifr6, 0, sizeof(ifr6));
2137 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2138 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2139 ifr6.ifr6_prefixlen = 10;
2141 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2142 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2146 /* Route to remote host */
2147 memset(&rt6, 0, sizeof(rt6));
2148 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2149 rt6.rtmsg_flags = RTF_UP;
2150 rt6.rtmsg_dst_len = 10;
2151 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2152 rt6.rtmsg_metric = 1;
2154 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2155 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2163 /********************************************************************
2165 * cif6addr - Remove IPv6 address from interface
2167 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2170 struct in6_ifreq ifr6;
2172 memset(&ifr, 0, sizeof(ifr));
2173 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2174 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2175 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2179 memset(&ifr6, 0, sizeof(ifr6));
2180 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2181 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2182 ifr6.ifr6_prefixlen = 10;
2184 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2185 if (errno != EADDRNOTAVAIL) {
2186 if (! ok_error (errno))
2187 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2190 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2199 * get_pty - get a pty master/slave pair and chown the slave side
2200 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2203 get_pty(master_fdp, slave_fdp, slave_name, uid)
2209 int i, mfd, sfd = -1;
2211 struct termios tios;
2215 * Try the unix98 way first.
2217 mfd = open("/dev/ptmx", O_RDWR);
2220 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2221 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2222 chmod(pty_name, S_IRUSR | S_IWUSR);
2225 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2226 warn("Couldn't unlock pty slave %s: %m", pty_name);
2228 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2229 warn("Couldn't open pty slave %s: %m", pty_name);
2232 #endif /* TIOCGPTN */
2235 /* the old way - scan through the pty name space */
2236 for (i = 0; i < 64; ++i) {
2237 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2238 'p' + i / 16, i % 16);
2239 mfd = open(pty_name, O_RDWR, 0);
2242 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2244 fchown(sfd, uid, -1);
2245 fchmod(sfd, S_IRUSR | S_IWUSR);
2256 strlcpy(slave_name, pty_name, 16);
2259 if (tcgetattr(sfd, &tios) == 0) {
2260 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2261 tios.c_cflag |= CS8 | CREAD;
2262 tios.c_iflag = IGNPAR | CLOCAL;
2265 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2266 warn("couldn't set attributes on pty: %m");
2268 warn("couldn't get attributes on pty: %m");
2273 /********************************************************************
2275 * open_loopback - open the device we use for getting packets
2276 * in demand mode. Under Linux, we use a pty master/slave pair.
2279 open_ppp_loopback(void)
2284 if (new_style_driver) {
2285 /* allocate ourselves a ppp unit */
2287 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
2288 fatal("Couldn't create PPP unit: %m");
2289 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2290 set_kdebugflag(kdebugflag);
2295 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2296 fatal("No free pty for loopback");
2297 SYSDEBUG(("using %s for loopback", loop_name));
2299 set_ppp_fd(slave_fd);
2301 flags = fcntl(master_fd, F_GETFL);
2303 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2304 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2306 flags = fcntl(ppp_fd, F_GETFL);
2308 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2309 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2311 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2312 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2314 * Find out which interface we were given.
2316 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2317 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2319 * Enable debug in the driver if requested.
2321 set_kdebugflag (kdebugflag);
2326 /********************************************************************
2328 * restore_loop - reattach the ppp unit to the loopback.
2330 * The kernel ppp driver automatically reattaches the ppp unit to
2331 * the loopback if the serial port is set to a line discipline other
2332 * than ppp, or if it detects a modem hangup. The former will happen
2333 * in disestablish_ppp if the latter hasn't already happened, so we
2334 * shouldn't need to do anything.
2336 * Just to be sure, set the real serial port to the normal discipline.
2343 if (new_style_driver) {
2344 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2347 if (ppp_fd != slave_fd) {
2348 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2349 set_ppp_fd(slave_fd);
2353 /********************************************************************
2355 * sifnpmode - Set the mode for handling packets for a given NP.
2359 sifnpmode(u, proto, mode)
2366 npi.protocol = proto;
2368 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2369 if (! ok_error (errno))
2370 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2371 proto, mode, errno);
2378 /********************************************************************
2380 * sipxfaddr - Config the interface IPX networknumber
2383 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2390 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2392 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2394 if (! ok_error (errno))
2395 dbglog("socket(AF_IPX): %m (%d)", errno);
2399 memset (&ifr, '\0', sizeof (ifr));
2400 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2402 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2403 sipx->sipx_family = AF_IPX;
2404 sipx->sipx_port = 0;
2405 sipx->sipx_network = htonl (network);
2406 sipx->sipx_type = IPX_FRAME_ETHERII;
2407 sipx->sipx_action = IPX_CRTITF;
2409 * Set the IPX device
2411 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2413 if (errno != EEXIST) {
2414 if (! ok_error (errno))
2415 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2418 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2427 /********************************************************************
2429 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2430 * are removed and the device is no longer able to pass IPX
2434 int cipxfaddr (int unit)
2441 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2443 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2445 if (! ok_error (errno))
2446 dbglog("socket(AF_IPX): %m (%d)", errno);
2450 memset (&ifr, '\0', sizeof (ifr));
2451 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2453 sipx->sipx_type = IPX_FRAME_ETHERII;
2454 sipx->sipx_action = IPX_DLTITF;
2455 sipx->sipx_family = AF_IPX;
2457 * Set the IPX device
2459 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2460 if (! ok_error (errno))
2461 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2471 * Use the hostname as part of the random number seed.
2480 for (p = hostname; *p != 0; ++p)
2485 /********************************************************************
2487 * sys_check_options - check the options that the user specified
2491 sys_check_options(void)
2495 * Disable the IPX protocol if the support is not present in the kernel.
2499 if (ipxcp_protent.enabled_flag) {
2500 struct stat stat_buf;
2501 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2502 || lstat(path, &stat_buf) < 0) {
2503 error("IPX support is not present in the kernel\n");
2504 ipxcp_protent.enabled_flag = 0;
2508 if (demand && driver_is_old) {
2509 option_error("demand dialling is not supported by kernel driver "
2510 "version %d.%d.%d", driver_version, driver_modification,