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 char *path_to_route (void);
170 static void close_route_table (void);
171 static int open_route_table (void);
172 static int read_route_table (struct rtentry *rt);
173 static int defaultroute_exists (struct rtentry *rt);
174 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
175 char *name, int namelen);
176 static void decode_version (char *buf, int *version, int *mod, int *patch);
177 static int set_kdebugflag(int level);
178 static int ppp_registered(void);
180 extern u_char inpacket_buf[]; /* borrowed from main.c */
183 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
187 #define SET_SA_FAMILY(addr, family) \
188 memset ((char *) &(addr), '\0', sizeof(addr)); \
189 addr.sa_family = (family);
192 * Determine if the PPP connection should still be present.
197 /* new_fd is the fd of a tty */
198 static void set_ppp_fd (int new_fd)
200 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
202 if (!new_style_driver)
206 static int still_ppp(void)
208 if (new_style_driver)
209 return !hungup && ppp_fd >= 0;
210 if (!hungup || ppp_fd == slave_fd)
213 set_ppp_fd(slave_fd);
219 /********************************************************************
221 * Functions to read and set the flags value in the device driver
224 static int get_flags (int fd)
228 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
229 if ( ok_error (errno) )
232 fatal("ioctl(PPPIOCGFLAGS): %m");
235 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
239 /********************************************************************/
241 static void set_flags (int fd, int flags)
243 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
245 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
246 if (! ok_error (errno) )
247 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
251 /********************************************************************
253 * sys_init - System-dependent initialization.
258 int osmaj, osmin, ospatch;
261 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
262 setlogmask(LOG_UPTO(LOG_INFO));
264 setlogmask(LOG_UPTO(LOG_DEBUG));
266 if (new_style_driver) {
267 ppp_dev_fd = open("/dev/ppp", O_RDWR);
269 fatal("Couldn't open /dev/ppp: %m");
270 flags = fcntl(ppp_dev_fd, F_GETFL);
272 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
273 warn("Couldn't set /dev/ppp to nonblock: %m");
276 /* Get an internet socket for doing socket ioctls. */
277 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
279 fatal("Couldn't create IP socket: %m(%d)", errno);
282 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
284 fatal("Couldn't create IPv6 socket: %m(%d)", errno);
291 osmaj = osmin = ospatch = 0;
292 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
293 kernel_version = KVERSION(osmaj, osmin, ospatch);
296 /********************************************************************
298 * sys_cleanup - restore any system state we modified before exiting:
299 * mark the interface down, delete default route and/or proxy arp entry.
300 * This shouldn't call die() because it's called from die().
303 void sys_cleanup(void)
306 * Take down the device
313 * Delete any routes through the device.
315 if (default_route_gateway != 0)
316 cifdefaultroute(0, 0, default_route_gateway);
319 cifproxyarp(0, proxy_arp_addr);
322 /********************************************************************
324 * sys_close - Clean up in a child process before execing.
329 if (new_style_driver)
340 /********************************************************************
342 * set_kdebugflag - Define the debugging level for the kernel
345 static int set_kdebugflag (int requested_level)
347 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
348 if ( ! ok_error (errno) )
349 error("ioctl(PPPIOCSDEBUG): %m");
352 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
357 /********************************************************************
359 * establish_ppp - Turn the serial port into a ppp interface.
362 int establish_ppp (int tty_fd)
367 * The current PPP device will be the tty file.
371 * Ensure that the tty device is in exclusive mode.
373 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
374 if ( ! ok_error ( errno ))
375 warn("ioctl(TIOCEXCL): %m");
378 * Demand mode - prime the old ppp device to relinquish the unit.
380 if (!new_style_driver && looped
381 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
382 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
384 * Set the current tty to the PPP discpline
386 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
387 if ( ! ok_error (errno) )
388 fatal("ioctl(TIOCSETD): %m(%d)", errno);
391 * Find out which interface we were given.
393 if (new_style_driver) {
395 /* allocate ourselves a ppp unit */
397 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
398 fatal("Couldn't create new ppp unit: %m");
399 set_kdebugflag(kdebugflag);
401 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
403 if (ioctl(tty_fd, PPPIOCATTACH, &ifunit) < 0) {
406 fatal("Couldn't attach tty to PPP unit %d: %m", ifunit);
409 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
410 if ( ! ok_error (errno))
411 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
413 /* Check that we got the same unit again. */
414 if (looped && x != ifunit)
415 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
420 * Enable debug in the driver if requested.
423 set_kdebugflag (kdebugflag);
426 set_flags(tty_fd, get_flags(tty_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
427 SC_RCV_EVNP | SC_RCV_ODDP));
429 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
430 driver_version, driver_modification, driver_patch));
433 * Fetch the initial file flags and reset blocking mode on the file.
435 initfdflags = fcntl(tty_fd, F_GETFL);
436 if (initfdflags == -1 ||
437 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
438 if ( ! ok_error (errno))
439 warn("Couldn't set device to non-blocking mode: %m");
445 /********************************************************************
447 * disestablish_ppp - Restore the serial port to normal operation.
448 * This shouldn't call die() because it's called from die().
451 void disestablish_ppp(int tty_fd)
455 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
457 if (tcflush(tty_fd, TCIOFLUSH) < 0)
458 warn("tcflush failed: %m");
460 * Restore the previous line discipline
462 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
463 if ( ! ok_error (errno))
464 error("ioctl(TIOCSETD, N_TTY): %m");
467 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
468 if ( ! ok_error (errno))
469 warn("ioctl(TIOCNXCL): %m(%d)", errno);
472 /* Reset non-blocking mode on fd. */
473 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
474 if ( ! ok_error (errno))
475 warn("Couldn't restore device fd flags: %m");
479 if (new_style_driver && !looped) {
480 if (ioctl(ppp_dev_fd, PPPIOCDETACH) < 0) {
481 if (errno == ENOTTY) {
482 /* first version of new driver didn't have PPPIOCDETACH */
486 ppp_dev_fd = open("/dev/ppp", O_RDWR);
488 fatal("Couldn't reopen /dev/ppp: %m");
489 flags = fcntl(ppp_dev_fd, F_GETFL);
491 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
492 warn("Couldn't set /dev/ppp to nonblock: %m");
494 error("Couldn't release PPP unit: %m");
500 /********************************************************************
502 * clean_check - Fetch the flags for the device and generate
503 * appropriate error messages.
505 void clean_check(void)
511 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
513 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
515 s = "all had bit 7 set to 1";
519 s = "all had bit 7 set to 0";
523 s = "all had odd parity";
527 s = "all had even parity";
532 warn("Receive serial link is not 8-bit clean:");
533 warn("Problem: %s", s);
541 * List of valid speeds.
545 int speed_int, speed_val;
622 /********************************************************************
624 * Translate from bits/second to a speed_t.
627 static int translate_speed (int bps)
629 struct speed *speedp;
632 for (speedp = speeds; speedp->speed_int; speedp++) {
633 if (bps == speedp->speed_int)
634 return speedp->speed_val;
636 warn("speed %d not supported", bps);
641 /********************************************************************
643 * Translate from a speed_t to bits/second.
646 static int baud_rate_of (int speed)
648 struct speed *speedp;
651 for (speedp = speeds; speedp->speed_int; speedp++) {
652 if (speed == speedp->speed_val)
653 return speedp->speed_int;
659 /********************************************************************
661 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
662 * at the requested speed, etc. If `local' is true, set CLOCAL
663 * regardless of whether the modem option was specified.
666 void set_up_tty(int tty_fd, int local)
672 if (tcgetattr(tty_fd, &tios) < 0) {
673 if (!ok_error(errno))
674 fatal("tcgetattr: %m(%d)", errno);
681 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
682 tios.c_cflag |= CS8 | CREAD | HUPCL;
684 tios.c_iflag = IGNBRK | IGNPAR;
688 tios.c_cc[VTIME] = 0;
691 tios.c_cflag ^= (CLOCAL | HUPCL);
695 tios.c_cflag |= CRTSCTS;
699 tios.c_iflag |= IXON | IXOFF;
700 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
701 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
705 tios.c_cflag &= ~CRTSCTS;
712 speed = translate_speed(inspeed);
714 cfsetospeed (&tios, speed);
715 cfsetispeed (&tios, speed);
718 * We can't proceed if the serial port speed is B0,
719 * since that implies that the serial port is disabled.
722 speed = cfgetospeed(&tios);
724 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
727 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
728 if (!ok_error(errno))
729 fatal("tcsetattr: %m");
731 baud_rate = baud_rate_of(speed);
735 /********************************************************************
737 * setdtr - control the DTR line on the serial port.
738 * This is called from die(), so it shouldn't call die().
741 void setdtr (int tty_fd, int on)
743 int modembits = TIOCM_DTR;
745 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
748 /********************************************************************
750 * restore_tty - restore the terminal to the saved settings.
753 void restore_tty (int tty_fd)
758 * Turn off echoing, because otherwise we can get into
759 * a loop with the tty and the modem echoing to each other.
760 * We presume we are the sole user of this tty device, so
761 * when we close it, it will revert to its defaults anyway.
764 inittermios.c_lflag &= ~(ECHO | ECHONL);
766 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
767 if (! ok_error (errno))
768 warn("tcsetattr: %m");
773 /********************************************************************
775 * output - Output PPP packet.
778 void output (int unit, unsigned char *p, int len)
781 dbglog("sent %P", p, len);
783 if (len < PPP_HDRLEN)
785 if (new_style_driver) {
789 if (write(ppp_dev_fd, p, len) < 0) {
790 if (errno == EWOULDBLOCK || errno == ENOBUFS
791 || errno == ENXIO || errno == EIO || errno == EINTR)
792 warn("write: warning: %m (%d)", errno);
794 error("write: %m (%d)", errno);
798 /********************************************************************
800 * wait_input - wait until there is data available,
801 * for the length of time specified by *timo (indefinite
805 void wait_input(struct timeval *timo)
811 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
812 if (n < 0 && errno != EINTR)
813 fatal("select: %m(%d)", errno);
817 * add_fd - add an fd to the set that wait_input waits for.
827 * remove_fd - remove an fd from the set that wait_input waits for.
829 void remove_fd(int fd)
835 /********************************************************************
837 * read_packet - get a PPP packet from the serial device.
840 int read_packet (unsigned char *buf)
844 len = PPP_MRU + PPP_HDRLEN;
845 if (new_style_driver) {
846 *buf++ = PPP_ALLSTATIONS;
850 len = read(ppp_dev_fd, buf, len);
852 if (errno == EWOULDBLOCK || errno == EIO)
854 fatal("read: %m(%d)", errno);
856 return new_style_driver? len+2: len;
859 /********************************************************************
861 * get_loop_output - get outgoing packets from the ppp device,
862 * and detect when we want to bring the real link up.
863 * Return value is 1 if we need to bring up the link, 0 otherwise.
866 get_loop_output(void)
871 if (new_style_driver) {
872 while ((n = read_packet(inpacket_buf)) > 0)
873 if (loop_frame(inpacket_buf, n))
878 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
879 if (loop_chars(inbuf, n))
883 fatal("eof on loopback");
885 if (errno != EWOULDBLOCK)
886 fatal("read from loopback: %m(%d)", errno);
891 /********************************************************************
893 * ppp_send_config - configure the transmit characteristics of
897 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
902 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
904 * Set the MTU and other parameters for the ppp device
906 memset (&ifr, '\0', sizeof (ifr));
907 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
910 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
911 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
915 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
916 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
917 if (!ok_error(errno))
918 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
922 x = get_flags(ppp_fd);
923 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
924 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
925 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
926 set_flags(ppp_fd, x);
929 /********************************************************************
931 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
934 void ppp_set_xaccm (int unit, ext_accm accm)
936 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
937 accm[0], accm[1], accm[2], accm[3]));
941 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
942 if ( ! ok_error (errno))
943 warn("ioctl(set extended ACCM): %m(%d)", errno);
947 /********************************************************************
949 * ppp_recv_config - configure the receive-side characteristics of
953 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
955 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
957 * If we were called because the link has gone down then there is nothing
958 * which may be done. Just return without incident.
963 * Set the receiver parameters
965 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
966 if ( ! ok_error (errno))
967 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
969 if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
970 error("Couldn't set MRU in generic PPP layer: %m");
972 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
973 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
974 if (!ok_error(errno))
975 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
979 /********************************************************************
981 * ccp_test - ask kernel whether a given compression method
982 * is acceptable for use.
985 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
987 struct ppp_option_data data;
989 memset (&data, '\0', sizeof (data));
991 data.length = opt_len;
992 data.transmit = for_transmit;
994 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
997 return (errno == ENOBUFS)? 0: -1;
1000 /********************************************************************
1002 * ccp_flags_set - inform kernel about the current state of CCP.
1005 void ccp_flags_set (int unit, int isopen, int isup)
1008 int x = get_flags(ppp_dev_fd);
1009 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1010 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1011 set_flags (ppp_dev_fd, x);
1015 /********************************************************************
1017 * get_idle_time - return how long the link has been idle.
1020 get_idle_time(u, ip)
1022 struct ppp_idle *ip;
1024 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1027 /********************************************************************
1029 * get_ppp_stats - return statistics for the link.
1032 get_ppp_stats(u, stats)
1034 struct pppd_stats *stats;
1036 struct ifpppstatsreq req;
1038 memset (&req, 0, sizeof (req));
1040 req.stats_ptr = (caddr_t) &req.stats;
1041 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1042 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1043 error("Couldn't get PPP statistics: %m");
1046 stats->bytes_in = req.stats.p.ppp_ibytes;
1047 stats->bytes_out = req.stats.p.ppp_obytes;
1051 /********************************************************************
1053 * ccp_fatal_error - returns 1 if decompression was disabled as a
1054 * result of an error detected after decompression of a packet,
1055 * 0 otherwise. This is necessary because of patent nonsense.
1058 int ccp_fatal_error (int unit)
1060 int x = get_flags(ppp_dev_fd);
1062 return x & SC_DC_FERROR;
1065 /********************************************************************
1067 * path_to_procfs - find the path to the proc file system mount point
1069 static char proc_path[MAXPATHLEN];
1070 static int proc_path_len;
1072 static char *path_to_procfs(const char *tail)
1074 struct mntent *mntent;
1077 if (proc_path_len == 0) {
1078 fp = fopen(MOUNTED, "r");
1080 /* Default the mount location of /proc */
1081 strlcpy (proc_path, "/proc", sizeof(proc_path));
1085 while ((mntent = getmntent(fp)) != NULL) {
1086 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1088 if (strcmp(mntent->mnt_type, "proc") == 0)
1095 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1096 proc_path_len = strlen(proc_path);
1101 if (proc_path_len < 0)
1104 strlcpy(proc_path + proc_path_len, tail,
1105 sizeof(proc_path) - proc_path_len);
1110 * path_to_route - determine the path to the proc file system data
1112 #define ROUTE_MAX_COLS 12
1113 FILE *route_fd = (FILE *) 0;
1114 static char route_buffer[512];
1115 static int route_dev_col, route_dest_col, route_gw_col;
1116 static int route_flags_col, route_mask_col;
1117 static int route_num_cols;
1119 static char *path_to_route (void);
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 * path_to_route - find the path to the route tables in the proc file system
1129 static char *path_to_route (void)
1133 path = path_to_procfs("/net/route");
1135 error("proc file system not mounted");
1139 /********************************************************************
1141 * close_route_table - close the interface to the route table
1144 static void close_route_table (void)
1146 if (route_fd != (FILE *) 0) {
1148 route_fd = (FILE *) 0;
1152 /********************************************************************
1154 * open_route_table - open the interface to the route table
1156 static char route_delims[] = " \t\n";
1158 static int open_route_table (void)
1162 close_route_table();
1164 path = path_to_route();
1168 route_fd = fopen (path, "r");
1169 if (route_fd == NULL) {
1170 error("can't open %s: %m (%d)", path, errno);
1174 route_dev_col = 0; /* default to usual columns */
1177 route_flags_col = 3;
1181 /* parse header line */
1182 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1183 char *p = route_buffer, *q;
1185 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1187 if ((q = strtok(p, route_delims)) == 0)
1189 if (strcasecmp(q, "iface") == 0)
1190 route_dev_col = col;
1191 else if (strcasecmp(q, "destination") == 0)
1192 route_dest_col = col;
1193 else if (strcasecmp(q, "gateway") == 0)
1195 else if (strcasecmp(q, "flags") == 0)
1196 route_flags_col = col;
1197 else if (strcasecmp(q, "mask") == 0)
1198 route_mask_col = col;
1201 if (used && col >= route_num_cols)
1202 route_num_cols = col + 1;
1210 /********************************************************************
1212 * read_route_table - read the next entry from the route table
1215 static int read_route_table(struct rtentry *rt)
1217 char *cols[ROUTE_MAX_COLS], *p;
1220 memset (rt, '\0', sizeof (struct rtentry));
1222 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1226 for (col = 0; col < route_num_cols; ++col) {
1227 cols[col] = strtok(p, route_delims);
1228 if (cols[col] == NULL)
1229 return 0; /* didn't get enough columns */
1233 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1234 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1235 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1237 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1238 rt->rt_dev = cols[route_dev_col];
1243 /********************************************************************
1245 * defaultroute_exists - determine if there is a default route
1248 static int defaultroute_exists (struct rtentry *rt)
1252 if (!open_route_table())
1255 while (read_route_table(rt) != 0) {
1256 if ((rt->rt_flags & RTF_UP) == 0)
1259 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1261 if (SIN_ADDR(rt->rt_dst) == 0L) {
1267 close_route_table();
1272 * have_route_to - determine if the system has any route to
1273 * a given IP address. `addr' is in network byte order.
1274 * Return value is 1 if yes, 0 if no, -1 if don't know.
1275 * For demand mode to work properly, we have to ignore routes
1276 * through our own interface.
1278 int have_route_to(u_int32_t addr)
1283 if (!open_route_table())
1284 return -1; /* don't know */
1286 while (read_route_table(&rt)) {
1287 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1289 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1295 close_route_table();
1299 /********************************************************************
1301 * sifdefaultroute - assign a default route through the address given.
1304 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1308 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1309 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1311 if (old_gateway != gateway)
1312 error("not replacing existing default route to %s [%I]",
1313 rt.rt_dev, old_gateway);
1317 memset (&rt, '\0', sizeof (rt));
1318 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1319 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1321 if (kernel_version > KVERSION(2,1,0)) {
1322 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1323 SIN_ADDR(rt.rt_genmask) = 0L;
1326 SIN_ADDR(rt.rt_gateway) = gateway;
1328 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1329 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1330 if ( ! ok_error ( errno ))
1331 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1335 default_route_gateway = gateway;
1339 /********************************************************************
1341 * cifdefaultroute - delete a default route through the address given.
1344 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1348 default_route_gateway = 0;
1350 memset (&rt, '\0', sizeof (rt));
1351 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1352 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1354 if (kernel_version > KVERSION(2,1,0)) {
1355 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1356 SIN_ADDR(rt.rt_genmask) = 0L;
1359 SIN_ADDR(rt.rt_gateway) = gateway;
1361 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1362 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1364 if ( ! ok_error ( errno ))
1365 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1373 /********************************************************************
1375 * sifproxyarp - Make a proxy ARP entry for the peer.
1378 int sifproxyarp (int unit, u_int32_t his_adr)
1380 struct arpreq arpreq;
1383 if (has_proxy_arp == 0) {
1384 memset (&arpreq, '\0', sizeof(arpreq));
1386 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1387 SIN_ADDR(arpreq.arp_pa) = his_adr;
1388 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1390 * Get the hardware address of an interface on the same subnet
1391 * as our local address.
1393 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1394 sizeof(proxy_arp_dev))) {
1395 error("Cannot determine ethernet address for proxy ARP");
1398 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1400 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1401 if ( ! ok_error ( errno ))
1402 error("ioctl(SIOCSARP): %m(%d)", errno);
1405 proxy_arp_addr = his_adr;
1409 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1410 if (forw_path != 0) {
1411 int fd = open(forw_path, O_WRONLY);
1413 if (write(fd, "1", 1) != 1)
1414 error("Couldn't enable IP forwarding: %m");
1424 /********************************************************************
1426 * cifproxyarp - Delete the proxy ARP entry for the peer.
1429 int cifproxyarp (int unit, u_int32_t his_adr)
1431 struct arpreq arpreq;
1433 if (has_proxy_arp) {
1435 memset (&arpreq, '\0', sizeof(arpreq));
1436 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1437 SIN_ADDR(arpreq.arp_pa) = his_adr;
1438 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1439 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1441 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1442 if ( ! ok_error ( errno ))
1443 warn("ioctl(SIOCDARP): %m(%d)", errno);
1450 /********************************************************************
1452 * get_ether_addr - get the hardware address of an interface on the
1453 * the same subnet as ipaddr.
1456 static int get_ether_addr (u_int32_t ipaddr,
1457 struct sockaddr *hwaddr,
1458 char *name, int namelen)
1460 struct ifreq *ifr, *ifend;
1461 u_int32_t ina, mask;
1465 struct ifreq ifs[MAX_IFS];
1467 ifc.ifc_len = sizeof(ifs);
1469 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1470 if ( ! ok_error ( errno ))
1471 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1475 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1476 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1478 * Scan through looking for an interface with an Internet
1479 * address on the same subnet as `ipaddr'.
1481 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1482 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1483 if (ifr->ifr_addr.sa_family == AF_INET) {
1484 ina = SIN_ADDR(ifr->ifr_addr);
1485 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1486 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1489 * Check that the interface is up, and not point-to-point
1492 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1495 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1498 * Get its netmask and check that it's on the right subnet.
1500 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1503 mask = SIN_ADDR(ifreq.ifr_addr);
1504 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1505 ip_ntoa(ina), ntohl(mask)));
1507 if (((ipaddr ^ ina) & mask) != 0)
1516 strlcpy(name, ifreq.ifr_name, namelen);
1518 /* trim off the :1 in eth0:1 */
1519 aliasp = strchr(name, ':');
1523 info("found interface %s for proxy arp", name);
1525 * Now get the hardware address.
1527 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1528 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1529 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1535 sizeof (struct sockaddr));
1537 SYSDEBUG ((LOG_DEBUG,
1538 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1539 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1540 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1541 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1542 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1543 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1544 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1545 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1546 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1550 /********************************************************************
1552 * Return user specified netmask, modified by any mask we might determine
1553 * for address `addr' (in network byte order).
1554 * Here we scan through the system's list of interfaces, looking for
1555 * any non-point-to-point interfaces which might appear to be on the same
1556 * network as `addr'. If we find any, we OR in their netmask to the
1557 * user-specified netmask.
1560 u_int32_t GetMask (u_int32_t addr)
1562 u_int32_t mask, nmask, ina;
1563 struct ifreq *ifr, *ifend, ifreq;
1565 struct ifreq ifs[MAX_IFS];
1569 if (IN_CLASSA(addr)) /* determine network mask for address class */
1570 nmask = IN_CLASSA_NET;
1571 else if (IN_CLASSB(addr))
1572 nmask = IN_CLASSB_NET;
1574 nmask = IN_CLASSC_NET;
1576 /* class D nets are disallowed by bad_ip_adrs */
1577 mask = netmask | htonl(nmask);
1579 * Scan through the system's network interfaces.
1581 ifc.ifc_len = sizeof(ifs);
1583 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1584 if ( ! ok_error ( errno ))
1585 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1589 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1590 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1592 * Check the interface's internet address.
1594 if (ifr->ifr_addr.sa_family != AF_INET)
1596 ina = SIN_ADDR(ifr->ifr_addr);
1597 if (((ntohl(ina) ^ addr) & nmask) != 0)
1600 * Check that the interface is up, and not point-to-point nor loopback.
1602 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1603 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1606 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1609 * Get its netmask and OR it into our mask.
1611 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1613 mask |= SIN_ADDR(ifreq.ifr_addr);
1619 /********************************************************************
1621 * Internal routine to decode the version.modification.patch level
1624 static void decode_version (char *buf, int *version,
1625 int *modification, int *patch)
1627 *version = (int) strtoul (buf, &buf, 10);
1633 *modification = (int) strtoul (buf, &buf, 10);
1636 *patch = (int) strtoul (buf, &buf, 10);
1647 /********************************************************************
1649 * Procedure to determine if the PPP line discipline is registered.
1653 ppp_registered(void)
1661 * We used to open the serial device and set it to the ppp line
1662 * discipline here, in order to create a ppp unit. But that is
1663 * not a good idea - the user might have specified a device that
1664 * they can't open (permission, or maybe it doesn't really exist).
1665 * So we grab a pty master/slave pair and use that.
1667 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1668 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1673 * Try to put the device into the PPP discipline.
1675 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1676 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1685 /********************************************************************
1687 * ppp_available - check whether the system has any ppp interfaces
1688 * (in fact we check whether we can do an ioctl on ppp0).
1691 int ppp_available(void)
1696 int my_version, my_modification, my_patch;
1699 "This system lacks kernel support for PPP. This could be because\n"
1700 "the PPP kernel module could not be loaded, or because PPP was not\n"
1701 "included in the kernel configuration. If PPP was included as a\n"
1702 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1703 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1704 "See README.linux file in the ppp distribution for more details.\n";
1706 fd = open("/dev/ppp", O_RDWR);
1707 if (fd < 0 && errno == ENOENT) {
1708 /* try making it and see if that helps. */
1709 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1710 makedev(108, 0)) >= 0) {
1711 fd = open("/dev/ppp", O_RDWR);
1713 info("Created /dev/ppp device node");
1715 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1716 } else if (errno == EEXIST) {
1717 fd = open("/dev/ppp", O_RDWR);
1721 new_style_driver = 1;
1723 /* XXX should get from driver */
1725 driver_modification = 4;
1732 * Open a socket for doing the ioctl operations.
1734 s = socket(AF_INET, SOCK_DGRAM, 0);
1738 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1739 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1741 * If the device did not exist then attempt to create one by putting the
1742 * current tty into the PPP discipline. If this works then obtain the
1743 * flags for the device again.
1746 if (ppp_registered()) {
1747 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1748 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1752 * Ensure that the hardware address is for PPP and not something else
1755 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1757 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1761 * This is the PPP device. Validate the version of the driver at this
1762 * point to ensure that this program will work with the driver.
1765 char abBuffer [1024];
1767 ifr.ifr_data = abBuffer;
1768 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1770 error("Couldn't read driver version: %m");
1772 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1775 decode_version(abBuffer,
1777 &driver_modification,
1780 * Validate the version of the driver against the version that we used.
1782 decode_version(VERSION,
1787 /* The version numbers must match */
1788 if (driver_version != my_version)
1791 /* The modification levels must be legal */
1792 if (driver_modification < 3) {
1793 if (driver_modification >= 2) {
1794 /* we can cope with 2.2.0 and above */
1803 slprintf(route_buffer, sizeof(route_buffer),
1804 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1805 driver_version, driver_modification, driver_patch);
1807 no_ppp_msg = route_buffer;
1814 /********************************************************************
1816 * Update the wtmp file with the appropriate user name and tty device.
1819 void logwtmp (const char *line, const char *name, const char *host)
1821 struct utmp ut, *utp;
1822 pid_t mypid = getpid();
1828 * Update the signon database for users.
1829 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1831 utmpname(_PATH_UTMP);
1833 while ((utp = getutent()) && (utp->ut_pid != mypid))
1836 /* Is this call really necessary? There is another one after the 'put' */
1840 memcpy(&ut, utp, sizeof(ut));
1842 /* some gettys/telnetds don't initialize utmp... */
1843 memset(&ut, 0, sizeof(ut));
1845 if (ut.ut_id[0] == 0)
1846 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1848 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1849 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1853 ut.ut_type = USER_PROCESS;
1856 /* Insert the host name if one is supplied */
1858 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1860 /* Insert the IP address of the remote system if IP is enabled */
1861 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1862 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1863 sizeof(ut.ut_addr));
1865 /* CL: Makes sure that the logout works */
1866 if (*host == 0 && *name==0)
1872 * Update the wtmp file.
1875 updwtmp(_PATH_WTMP, &ut);
1877 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1879 flock(wtmp, LOCK_EX);
1881 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1882 warn("error writing %s: %m", _PATH_WTMP);
1884 flock(wtmp, LOCK_UN);
1892 /********************************************************************
1894 * sifvjcomp - config tcp header compression
1897 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1899 u_int x = get_flags(ppp_dev_fd);
1902 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1903 if (! ok_error (errno))
1904 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1909 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1910 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1911 set_flags (ppp_dev_fd, x);
1916 /********************************************************************
1918 * sifup - Config the interface up and enable IP packets to pass.
1925 memset (&ifr, '\0', sizeof (ifr));
1926 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1927 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1928 if (! ok_error (errno))
1929 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1933 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1934 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1935 if (! ok_error (errno))
1936 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1944 /********************************************************************
1946 * sifdown - Disable the indicated protocol and config the interface
1947 * down if there are no remaining protocols.
1954 if (if_is_up && --if_is_up > 0)
1957 memset (&ifr, '\0', sizeof (ifr));
1958 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1959 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1960 if (! ok_error (errno))
1961 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1965 ifr.ifr_flags &= ~IFF_UP;
1966 ifr.ifr_flags |= IFF_POINTOPOINT;
1967 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1968 if (! ok_error (errno))
1969 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1975 /********************************************************************
1977 * sifaddr - Config the interface IP addresses and netmask.
1980 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1986 memset (&ifr, '\0', sizeof (ifr));
1987 memset (&rt, '\0', sizeof (rt));
1989 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
1990 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
1991 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
1993 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1995 * Set our IP address
1997 SIN_ADDR(ifr.ifr_addr) = our_adr;
1998 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
1999 if (errno != EEXIST) {
2000 if (! ok_error (errno))
2001 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2004 warn("ioctl(SIOCSIFADDR): Address already exists");
2009 * Set the gateway address
2011 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2012 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2013 if (! ok_error (errno))
2014 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2019 * For recent kernels, force the netmask to 255.255.255.255.
2021 if (kernel_version >= KVERSION(2,1,16))
2023 if (net_mask != 0) {
2024 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2025 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2026 if (! ok_error (errno))
2027 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2032 * Add the device route
2034 if (kernel_version < KVERSION(2,1,16)) {
2035 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2036 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2039 SIN_ADDR(rt.rt_gateway) = 0L;
2040 SIN_ADDR(rt.rt_dst) = his_adr;
2041 rt.rt_flags = RTF_UP | RTF_HOST;
2043 if (kernel_version > KVERSION(2,1,0)) {
2044 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2045 SIN_ADDR(rt.rt_genmask) = -1L;
2048 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2049 if (! ok_error (errno))
2050 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2055 /* set ip_dynaddr in demand mode if address changes */
2056 if (demand && tune_kernel && !dynaddr_set
2057 && our_old_addr && our_old_addr != our_adr) {
2058 /* set ip_dynaddr if possible */
2062 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2063 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2064 if (write(fd, "1", 1) != 1)
2065 error("Couldn't enable dynamic IP addressing: %m");
2068 dynaddr_set = 1; /* only 1 attempt */
2075 /********************************************************************
2077 * cifaddr - Clear the interface IP addresses, and delete routes
2078 * through the interface if possible.
2081 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2085 if (kernel_version < KVERSION(2,1,16)) {
2087 * Delete the route through the device
2090 memset (&rt, '\0', sizeof (rt));
2092 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2093 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2096 SIN_ADDR(rt.rt_gateway) = 0;
2097 SIN_ADDR(rt.rt_dst) = his_adr;
2098 rt.rt_flags = RTF_UP | RTF_HOST;
2100 if (kernel_version > KVERSION(2,1,0)) {
2101 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2102 SIN_ADDR(rt.rt_genmask) = -1L;
2105 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2106 if (still_ppp() && ! ok_error (errno))
2107 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2112 /* This way it is possible to have an IPX-only or IPv6-only interface */
2113 memset(&ifr, 0, sizeof(ifr));
2114 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2115 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2117 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2118 if (! ok_error (errno)) {
2119 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2124 our_old_addr = our_adr;
2130 /********************************************************************
2132 * sif6addr - Config the interface with an IPv6 link-local address
2134 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2136 struct in6_ifreq ifr6;
2138 struct in6_rtmsg rt6;
2140 memset(&ifr, 0, sizeof (ifr));
2141 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2142 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2143 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2147 /* Local interface */
2148 memset(&ifr6, 0, sizeof(ifr6));
2149 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2150 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2151 ifr6.ifr6_prefixlen = 10;
2153 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2154 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2158 /* Route to remote host */
2159 memset(&rt6, 0, sizeof(rt6));
2160 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2161 rt6.rtmsg_flags = RTF_UP;
2162 rt6.rtmsg_dst_len = 10;
2163 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2164 rt6.rtmsg_metric = 1;
2166 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2167 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2175 /********************************************************************
2177 * cif6addr - Remove IPv6 address from interface
2179 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2182 struct in6_ifreq ifr6;
2184 memset(&ifr, 0, sizeof(ifr));
2185 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2186 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2187 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2191 memset(&ifr6, 0, sizeof(ifr6));
2192 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2193 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2194 ifr6.ifr6_prefixlen = 10;
2196 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2197 if (errno != EADDRNOTAVAIL) {
2198 if (! ok_error (errno))
2199 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2202 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2211 * get_pty - get a pty master/slave pair and chown the slave side
2212 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2215 get_pty(master_fdp, slave_fdp, slave_name, uid)
2221 int i, mfd, sfd = -1;
2223 struct termios tios;
2227 * Try the unix98 way first.
2229 mfd = open("/dev/ptmx", O_RDWR);
2232 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2233 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2234 chmod(pty_name, S_IRUSR | S_IWUSR);
2237 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2238 warn("Couldn't unlock pty slave %s: %m", pty_name);
2240 if ((sfd = open(pty_name, O_RDWR)) < 0)
2241 warn("Couldn't open pty slave %s: %m", pty_name);
2244 #endif /* TIOCGPTN */
2247 /* the old way - scan through the pty name space */
2248 for (i = 0; i < 64; ++i) {
2249 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2250 'p' + i / 16, i % 16);
2251 mfd = open(pty_name, O_RDWR, 0);
2254 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2256 fchown(sfd, uid, -1);
2257 fchmod(sfd, S_IRUSR | S_IWUSR);
2268 strlcpy(slave_name, pty_name, 16);
2271 if (tcgetattr(sfd, &tios) == 0) {
2272 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2273 tios.c_cflag |= CS8 | CREAD;
2274 tios.c_iflag = IGNPAR | CLOCAL;
2277 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2278 warn("couldn't set attributes on pty: %m");
2280 warn("couldn't get attributes on pty: %m");
2285 /********************************************************************
2287 * open_loopback - open the device we use for getting packets
2288 * in demand mode. Under Linux, we use a pty master/slave pair.
2291 open_ppp_loopback(void)
2296 if (new_style_driver) {
2297 /* allocate ourselves a ppp unit */
2299 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
2300 fatal("Couldn't create PPP unit: %m");
2301 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2302 set_kdebugflag(kdebugflag);
2307 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2308 fatal("No free pty for loopback");
2309 SYSDEBUG(("using %s for loopback", loop_name));
2311 set_ppp_fd(slave_fd);
2313 flags = fcntl(master_fd, F_GETFL);
2315 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2316 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2318 flags = fcntl(ppp_fd, F_GETFL);
2320 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2321 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2323 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2324 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2326 * Find out which interface we were given.
2328 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2329 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2331 * Enable debug in the driver if requested.
2333 set_kdebugflag (kdebugflag);
2338 /********************************************************************
2340 * restore_loop - reattach the ppp unit to the loopback.
2342 * The kernel ppp driver automatically reattaches the ppp unit to
2343 * the loopback if the serial port is set to a line discipline other
2344 * than ppp, or if it detects a modem hangup. The former will happen
2345 * in disestablish_ppp if the latter hasn't already happened, so we
2346 * shouldn't need to do anything.
2348 * Just to be sure, set the real serial port to the normal discipline.
2355 if (new_style_driver) {
2356 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2359 if (ppp_fd != slave_fd) {
2360 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2361 set_ppp_fd(slave_fd);
2365 /********************************************************************
2367 * sifnpmode - Set the mode for handling packets for a given NP.
2371 sifnpmode(u, proto, mode)
2378 npi.protocol = proto;
2380 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2381 if (! ok_error (errno))
2382 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2383 proto, mode, errno);
2390 /********************************************************************
2392 * sipxfaddr - Config the interface IPX networknumber
2395 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2402 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2404 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2406 if (! ok_error (errno))
2407 dbglog("socket(AF_IPX): %m (%d)", errno);
2411 memset (&ifr, '\0', sizeof (ifr));
2412 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2414 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2415 sipx->sipx_family = AF_IPX;
2416 sipx->sipx_port = 0;
2417 sipx->sipx_network = htonl (network);
2418 sipx->sipx_type = IPX_FRAME_ETHERII;
2419 sipx->sipx_action = IPX_CRTITF;
2421 * Set the IPX device
2423 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2425 if (errno != EEXIST) {
2426 if (! ok_error (errno))
2427 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2430 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2439 /********************************************************************
2441 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2442 * are removed and the device is no longer able to pass IPX
2446 int cipxfaddr (int unit)
2453 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2455 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2457 if (! ok_error (errno))
2458 dbglog("socket(AF_IPX): %m (%d)", errno);
2462 memset (&ifr, '\0', sizeof (ifr));
2463 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2465 sipx->sipx_type = IPX_FRAME_ETHERII;
2466 sipx->sipx_action = IPX_DLTITF;
2467 sipx->sipx_family = AF_IPX;
2469 * Set the IPX device
2471 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2472 if (! ok_error (errno))
2473 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2483 * Use the hostname as part of the random number seed.
2492 for (p = hostname; *p != 0; ++p)
2497 /********************************************************************
2499 * sys_check_options - check the options that the user specified
2503 sys_check_options(void)
2507 * Disable the IPX protocol if the support is not present in the kernel.
2511 if (ipxcp_protent.enabled_flag) {
2512 struct stat stat_buf;
2513 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2514 || lstat(path, &stat_buf) < 0) {
2515 error("IPX support is not present in the kernel\n");
2516 ipxcp_protent.enabled_flag = 0;
2520 if (demand && driver_is_old) {
2521 option_error("demand dialling is not supported by kernel driver "
2522 "version %d.%d.%d", driver_version, driver_modification,