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.
260 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
261 setlogmask(LOG_UPTO(LOG_INFO));
263 setlogmask(LOG_UPTO(LOG_DEBUG));
265 if (new_style_driver) {
266 ppp_dev_fd = open("/dev/ppp", O_RDWR);
268 fatal("Couldn't open /dev/ppp: %m");
269 flags = fcntl(ppp_dev_fd, F_GETFL);
271 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
272 warn("Couldn't set /dev/ppp to nonblock: %m");
275 /* Get an internet socket for doing socket ioctls. */
276 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
278 fatal("Couldn't create IP socket: %m(%d)", errno);
281 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
283 fatal("Couldn't create IPv6 socket: %m(%d)", errno);
290 /********************************************************************
292 * sys_cleanup - restore any system state we modified before exiting:
293 * mark the interface down, delete default route and/or proxy arp entry.
294 * This shouldn't call die() because it's called from die().
297 void sys_cleanup(void)
300 * Take down the device
307 * Delete any routes through the device.
309 if (default_route_gateway != 0)
310 cifdefaultroute(0, 0, default_route_gateway);
313 cifproxyarp(0, proxy_arp_addr);
316 /********************************************************************
318 * sys_close - Clean up in a child process before execing.
323 if (new_style_driver)
334 /********************************************************************
336 * set_kdebugflag - Define the debugging level for the kernel
339 static int set_kdebugflag (int requested_level)
341 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
342 if ( ! ok_error (errno) )
343 error("ioctl(PPPIOCSDEBUG): %m");
346 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
351 /********************************************************************
353 * establish_ppp - Turn the serial port into a ppp interface.
356 int establish_ppp (int tty_fd)
361 * The current PPP device will be the tty file.
365 * Ensure that the tty device is in exclusive mode.
367 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
368 if ( ! ok_error ( errno ))
369 warn("ioctl(TIOCEXCL): %m");
372 * Demand mode - prime the old ppp device to relinquish the unit.
374 if (!new_style_driver && looped
375 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
376 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
378 * Set the current tty to the PPP discpline
382 #define N_SYNC_PPP 14
384 if (new_style_driver)
385 ppp_disc = sync_serial ? N_SYNC_PPP:N_PPP;
387 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
388 if ( ! ok_error (errno) )
389 fatal("ioctl(TIOCSETD): %m(%d)", errno);
392 * Find out which interface we were given.
394 if (new_style_driver) {
396 /* allocate ourselves a ppp unit */
398 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
399 fatal("Couldn't create new ppp unit: %m");
400 set_kdebugflag(kdebugflag);
402 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
404 if (ioctl(tty_fd, PPPIOCATTACH, &ifunit) < 0) {
407 fatal("Couldn't attach tty to PPP unit %d: %m", ifunit);
410 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
411 if ( ! ok_error (errno))
412 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
414 /* Check that we got the same unit again. */
415 if (looped && x != ifunit)
416 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
421 * Enable debug in the driver if requested.
424 set_kdebugflag (kdebugflag);
427 set_flags(tty_fd, get_flags(tty_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
428 SC_RCV_EVNP | SC_RCV_ODDP));
430 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
431 driver_version, driver_modification, driver_patch));
434 * Fetch the initial file flags and reset blocking mode on the file.
436 initfdflags = fcntl(tty_fd, F_GETFL);
437 if (initfdflags == -1 ||
438 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
439 if ( ! ok_error (errno))
440 warn("Couldn't set device to non-blocking mode: %m");
446 /********************************************************************
448 * disestablish_ppp - Restore the serial port to normal operation.
449 * This shouldn't call die() because it's called from die().
452 void disestablish_ppp(int tty_fd)
456 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
458 if (tcflush(tty_fd, TCIOFLUSH) < 0)
459 warn("tcflush failed: %m");
461 * Restore the previous line discipline
463 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
464 if ( ! ok_error (errno))
465 error("ioctl(TIOCSETD, N_TTY): %m");
468 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
469 if ( ! ok_error (errno))
470 warn("ioctl(TIOCNXCL): %m(%d)", errno);
473 /* Reset non-blocking mode on fd. */
474 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
475 if ( ! ok_error (errno))
476 warn("Couldn't restore device fd flags: %m");
480 if (new_style_driver && !looped) {
481 if (ioctl(ppp_dev_fd, PPPIOCDETACH) < 0) {
482 if (errno == ENOTTY) {
483 /* first version of new driver didn't have PPPIOCDETACH */
487 ppp_dev_fd = open("/dev/ppp", O_RDWR);
489 fatal("Couldn't reopen /dev/ppp: %m");
490 flags = fcntl(ppp_dev_fd, F_GETFL);
492 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
493 warn("Couldn't set /dev/ppp to nonblock: %m");
495 error("Couldn't release PPP unit: %m");
501 /********************************************************************
503 * clean_check - Fetch the flags for the device and generate
504 * appropriate error messages.
506 void clean_check(void)
512 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
514 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
516 s = "all had bit 7 set to 1";
520 s = "all had bit 7 set to 0";
524 s = "all had odd parity";
528 s = "all had even parity";
533 warn("Receive serial link is not 8-bit clean:");
534 warn("Problem: %s", s);
542 * List of valid speeds.
546 int speed_int, speed_val;
623 /********************************************************************
625 * Translate from bits/second to a speed_t.
628 static int translate_speed (int bps)
630 struct speed *speedp;
633 for (speedp = speeds; speedp->speed_int; speedp++) {
634 if (bps == speedp->speed_int)
635 return speedp->speed_val;
637 warn("speed %d not supported", bps);
642 /********************************************************************
644 * Translate from a speed_t to bits/second.
647 static int baud_rate_of (int speed)
649 struct speed *speedp;
652 for (speedp = speeds; speedp->speed_int; speedp++) {
653 if (speed == speedp->speed_val)
654 return speedp->speed_int;
660 /********************************************************************
662 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
663 * at the requested speed, etc. If `local' is true, set CLOCAL
664 * regardless of whether the modem option was specified.
667 void set_up_tty(int tty_fd, int local)
673 if (tcgetattr(tty_fd, &tios) < 0) {
674 if (!ok_error(errno))
675 fatal("tcgetattr: %m(%d)", errno);
682 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
683 tios.c_cflag |= CS8 | CREAD | HUPCL;
685 tios.c_iflag = IGNBRK | IGNPAR;
689 tios.c_cc[VTIME] = 0;
692 tios.c_cflag ^= (CLOCAL | HUPCL);
696 tios.c_cflag |= CRTSCTS;
700 tios.c_iflag |= IXON | IXOFF;
701 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
702 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
706 tios.c_cflag &= ~CRTSCTS;
713 speed = translate_speed(inspeed);
715 cfsetospeed (&tios, speed);
716 cfsetispeed (&tios, speed);
719 * We can't proceed if the serial port speed is B0,
720 * since that implies that the serial port is disabled.
723 speed = cfgetospeed(&tios);
725 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
728 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
729 if (!ok_error(errno))
730 fatal("tcsetattr: %m");
732 baud_rate = baud_rate_of(speed);
736 /********************************************************************
738 * setdtr - control the DTR line on the serial port.
739 * This is called from die(), so it shouldn't call die().
742 void setdtr (int tty_fd, int on)
744 int modembits = TIOCM_DTR;
746 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
749 /********************************************************************
751 * restore_tty - restore the terminal to the saved settings.
754 void restore_tty (int tty_fd)
759 * Turn off echoing, because otherwise we can get into
760 * a loop with the tty and the modem echoing to each other.
761 * We presume we are the sole user of this tty device, so
762 * when we close it, it will revert to its defaults anyway.
765 inittermios.c_lflag &= ~(ECHO | ECHONL);
767 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
768 if (! ok_error (errno))
769 warn("tcsetattr: %m");
774 /********************************************************************
776 * output - Output PPP packet.
779 void output (int unit, unsigned char *p, int len)
782 dbglog("sent %P", p, len);
784 if (len < PPP_HDRLEN)
786 if (new_style_driver) {
790 if (write(ppp_dev_fd, p, len) < 0) {
791 if (errno == EWOULDBLOCK || errno == ENOBUFS
792 || errno == ENXIO || errno == EIO || errno == EINTR)
793 warn("write: warning: %m (%d)", errno);
795 error("write: %m (%d)", errno);
799 /********************************************************************
801 * wait_input - wait until there is data available,
802 * for the length of time specified by *timo (indefinite
806 void wait_input(struct timeval *timo)
812 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
813 if (n < 0 && errno != EINTR)
814 fatal("select: %m(%d)", errno);
818 * add_fd - add an fd to the set that wait_input waits for.
828 * remove_fd - remove an fd from the set that wait_input waits for.
830 void remove_fd(int fd)
836 /********************************************************************
838 * read_packet - get a PPP packet from the serial device.
841 int read_packet (unsigned char *buf)
845 len = PPP_MRU + PPP_HDRLEN;
846 if (new_style_driver) {
847 *buf++ = PPP_ALLSTATIONS;
851 len = read(ppp_dev_fd, buf, len);
853 if (errno == EWOULDBLOCK || errno == EIO)
855 fatal("read: %m(%d)", errno);
857 return new_style_driver? len+2: len;
860 /********************************************************************
862 * get_loop_output - get outgoing packets from the ppp device,
863 * and detect when we want to bring the real link up.
864 * Return value is 1 if we need to bring up the link, 0 otherwise.
867 get_loop_output(void)
872 if (new_style_driver) {
873 while ((n = read_packet(inpacket_buf)) > 0)
874 if (loop_frame(inpacket_buf, n))
879 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
880 if (loop_chars(inbuf, n))
884 fatal("eof on loopback");
886 if (errno != EWOULDBLOCK)
887 fatal("read from loopback: %m(%d)", errno);
892 /********************************************************************
894 * ppp_send_config - configure the transmit characteristics of
898 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
903 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
905 * Set the MTU and other parameters for the ppp device
907 memset (&ifr, '\0', sizeof (ifr));
908 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
911 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
912 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
916 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
917 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
918 if (!ok_error(errno))
919 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
923 x = get_flags(ppp_fd);
924 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
925 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
926 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
927 set_flags(ppp_fd, x);
930 /********************************************************************
932 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
935 void ppp_set_xaccm (int unit, ext_accm accm)
937 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
938 accm[0], accm[1], accm[2], accm[3]));
942 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
943 if ( ! ok_error (errno))
944 warn("ioctl(set extended ACCM): %m(%d)", errno);
948 /********************************************************************
950 * ppp_recv_config - configure the receive-side characteristics of
954 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
956 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
958 * If we were called because the link has gone down then there is nothing
959 * which may be done. Just return without incident.
964 * Set the receiver parameters
966 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
967 if ( ! ok_error (errno))
968 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
970 if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
971 error("Couldn't set MRU in generic PPP layer: %m");
973 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
974 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
975 if (!ok_error(errno))
976 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
980 /********************************************************************
982 * ccp_test - ask kernel whether a given compression method
983 * is acceptable for use.
986 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
988 struct ppp_option_data data;
990 memset (&data, '\0', sizeof (data));
992 data.length = opt_len;
993 data.transmit = for_transmit;
995 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
998 return (errno == ENOBUFS)? 0: -1;
1001 /********************************************************************
1003 * ccp_flags_set - inform kernel about the current state of CCP.
1006 void ccp_flags_set (int unit, int isopen, int isup)
1009 int x = get_flags(ppp_dev_fd);
1010 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1011 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1012 set_flags (ppp_dev_fd, x);
1016 /********************************************************************
1018 * get_idle_time - return how long the link has been idle.
1021 get_idle_time(u, ip)
1023 struct ppp_idle *ip;
1025 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1028 /********************************************************************
1030 * get_ppp_stats - return statistics for the link.
1033 get_ppp_stats(u, stats)
1035 struct pppd_stats *stats;
1037 struct ifpppstatsreq req;
1039 memset (&req, 0, sizeof (req));
1041 req.stats_ptr = (caddr_t) &req.stats;
1042 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1043 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1044 error("Couldn't get PPP statistics: %m");
1047 stats->bytes_in = req.stats.p.ppp_ibytes;
1048 stats->bytes_out = req.stats.p.ppp_obytes;
1052 /********************************************************************
1054 * ccp_fatal_error - returns 1 if decompression was disabled as a
1055 * result of an error detected after decompression of a packet,
1056 * 0 otherwise. This is necessary because of patent nonsense.
1059 int ccp_fatal_error (int unit)
1061 int x = get_flags(ppp_dev_fd);
1063 return x & SC_DC_FERROR;
1066 /********************************************************************
1068 * path_to_procfs - find the path to the proc file system mount point
1070 static char proc_path[MAXPATHLEN];
1071 static int proc_path_len;
1073 static char *path_to_procfs(const char *tail)
1075 struct mntent *mntent;
1078 if (proc_path_len == 0) {
1079 fp = fopen(MOUNTED, "r");
1081 /* Default the mount location of /proc */
1082 strlcpy (proc_path, "/proc", sizeof(proc_path));
1086 while ((mntent = getmntent(fp)) != NULL) {
1087 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1089 if (strcmp(mntent->mnt_type, "proc") == 0)
1096 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1097 proc_path_len = strlen(proc_path);
1102 if (proc_path_len < 0)
1105 strlcpy(proc_path + proc_path_len, tail,
1106 sizeof(proc_path) - proc_path_len);
1111 * path_to_route - determine the path to the proc file system data
1113 #define ROUTE_MAX_COLS 12
1114 FILE *route_fd = (FILE *) 0;
1115 static char route_buffer[512];
1116 static int route_dev_col, route_dest_col, route_gw_col;
1117 static int route_flags_col, route_mask_col;
1118 static int route_num_cols;
1120 static char *path_to_route (void);
1121 static int open_route_table (void);
1122 static void close_route_table (void);
1123 static int read_route_table (struct rtentry *rt);
1125 /********************************************************************
1127 * path_to_route - find the path to the route tables in the proc file system
1130 static char *path_to_route (void)
1134 path = path_to_procfs("/net/route");
1136 error("proc file system not mounted");
1140 /********************************************************************
1142 * close_route_table - close the interface to the route table
1145 static void close_route_table (void)
1147 if (route_fd != (FILE *) 0) {
1149 route_fd = (FILE *) 0;
1153 /********************************************************************
1155 * open_route_table - open the interface to the route table
1157 static char route_delims[] = " \t\n";
1159 static int open_route_table (void)
1163 close_route_table();
1165 path = path_to_route();
1169 route_fd = fopen (path, "r");
1170 if (route_fd == NULL) {
1171 error("can't open %s: %m (%d)", path, errno);
1175 route_dev_col = 0; /* default to usual columns */
1178 route_flags_col = 3;
1182 /* parse header line */
1183 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1184 char *p = route_buffer, *q;
1186 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1188 if ((q = strtok(p, route_delims)) == 0)
1190 if (strcasecmp(q, "iface") == 0)
1191 route_dev_col = col;
1192 else if (strcasecmp(q, "destination") == 0)
1193 route_dest_col = col;
1194 else if (strcasecmp(q, "gateway") == 0)
1196 else if (strcasecmp(q, "flags") == 0)
1197 route_flags_col = col;
1198 else if (strcasecmp(q, "mask") == 0)
1199 route_mask_col = col;
1202 if (used && col >= route_num_cols)
1203 route_num_cols = col + 1;
1211 /********************************************************************
1213 * read_route_table - read the next entry from the route table
1216 static int read_route_table(struct rtentry *rt)
1218 char *cols[ROUTE_MAX_COLS], *p;
1221 memset (rt, '\0', sizeof (struct rtentry));
1223 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1227 for (col = 0; col < route_num_cols; ++col) {
1228 cols[col] = strtok(p, route_delims);
1229 if (cols[col] == NULL)
1230 return 0; /* didn't get enough columns */
1234 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1235 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1236 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1238 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1239 rt->rt_dev = cols[route_dev_col];
1244 /********************************************************************
1246 * defaultroute_exists - determine if there is a default route
1249 static int defaultroute_exists (struct rtentry *rt)
1253 if (!open_route_table())
1256 while (read_route_table(rt) != 0) {
1257 if ((rt->rt_flags & RTF_UP) == 0)
1260 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1262 if (SIN_ADDR(rt->rt_dst) == 0L) {
1268 close_route_table();
1273 * have_route_to - determine if the system has any route to
1274 * a given IP address. `addr' is in network byte order.
1275 * Return value is 1 if yes, 0 if no, -1 if don't know.
1276 * For demand mode to work properly, we have to ignore routes
1277 * through our own interface.
1279 int have_route_to(u_int32_t addr)
1284 if (!open_route_table())
1285 return -1; /* don't know */
1287 while (read_route_table(&rt)) {
1288 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1290 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1296 close_route_table();
1300 /********************************************************************
1302 * sifdefaultroute - assign a default route through the address given.
1305 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1309 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1310 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1312 if (old_gateway != gateway)
1313 error("not replacing existing default route to %s [%I]",
1314 rt.rt_dev, old_gateway);
1318 memset (&rt, '\0', sizeof (rt));
1319 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1320 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1322 if (kernel_version > KVERSION(2,1,0)) {
1323 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1324 SIN_ADDR(rt.rt_genmask) = 0L;
1327 SIN_ADDR(rt.rt_gateway) = gateway;
1329 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1330 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1331 if ( ! ok_error ( errno ))
1332 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1336 default_route_gateway = gateway;
1340 /********************************************************************
1342 * cifdefaultroute - delete a default route through the address given.
1345 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1349 default_route_gateway = 0;
1351 memset (&rt, '\0', sizeof (rt));
1352 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1353 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1355 if (kernel_version > KVERSION(2,1,0)) {
1356 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1357 SIN_ADDR(rt.rt_genmask) = 0L;
1360 SIN_ADDR(rt.rt_gateway) = gateway;
1362 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1363 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1365 if ( ! ok_error ( errno ))
1366 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1374 /********************************************************************
1376 * sifproxyarp - Make a proxy ARP entry for the peer.
1379 int sifproxyarp (int unit, u_int32_t his_adr)
1381 struct arpreq arpreq;
1384 if (has_proxy_arp == 0) {
1385 memset (&arpreq, '\0', sizeof(arpreq));
1387 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1388 SIN_ADDR(arpreq.arp_pa) = his_adr;
1389 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1391 * Get the hardware address of an interface on the same subnet
1392 * as our local address.
1394 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1395 sizeof(proxy_arp_dev))) {
1396 error("Cannot determine ethernet address for proxy ARP");
1399 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1401 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1402 if ( ! ok_error ( errno ))
1403 error("ioctl(SIOCSARP): %m(%d)", errno);
1406 proxy_arp_addr = his_adr;
1410 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1411 if (forw_path != 0) {
1412 int fd = open(forw_path, O_WRONLY);
1414 if (write(fd, "1", 1) != 1)
1415 error("Couldn't enable IP forwarding: %m");
1425 /********************************************************************
1427 * cifproxyarp - Delete the proxy ARP entry for the peer.
1430 int cifproxyarp (int unit, u_int32_t his_adr)
1432 struct arpreq arpreq;
1434 if (has_proxy_arp) {
1436 memset (&arpreq, '\0', sizeof(arpreq));
1437 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1438 SIN_ADDR(arpreq.arp_pa) = his_adr;
1439 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1440 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1442 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1443 if ( ! ok_error ( errno ))
1444 warn("ioctl(SIOCDARP): %m(%d)", errno);
1451 /********************************************************************
1453 * get_ether_addr - get the hardware address of an interface on the
1454 * the same subnet as ipaddr.
1457 static int get_ether_addr (u_int32_t ipaddr,
1458 struct sockaddr *hwaddr,
1459 char *name, int namelen)
1461 struct ifreq *ifr, *ifend;
1462 u_int32_t ina, mask;
1466 struct ifreq ifs[MAX_IFS];
1468 ifc.ifc_len = sizeof(ifs);
1470 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1471 if ( ! ok_error ( errno ))
1472 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1476 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1477 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1479 * Scan through looking for an interface with an Internet
1480 * address on the same subnet as `ipaddr'.
1482 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1483 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1484 if (ifr->ifr_addr.sa_family == AF_INET) {
1485 ina = SIN_ADDR(ifr->ifr_addr);
1486 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1487 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1490 * Check that the interface is up, and not point-to-point
1493 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1496 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1499 * Get its netmask and check that it's on the right subnet.
1501 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1504 mask = SIN_ADDR(ifreq.ifr_addr);
1505 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1506 ip_ntoa(ina), ntohl(mask)));
1508 if (((ipaddr ^ ina) & mask) != 0)
1517 strlcpy(name, ifreq.ifr_name, namelen);
1519 /* trim off the :1 in eth0:1 */
1520 aliasp = strchr(name, ':');
1524 info("found interface %s for proxy arp", name);
1526 * Now get the hardware address.
1528 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1529 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1530 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1536 sizeof (struct sockaddr));
1538 SYSDEBUG ((LOG_DEBUG,
1539 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1540 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1541 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1542 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1543 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1544 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1545 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1546 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1547 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1551 /********************************************************************
1553 * Return user specified netmask, modified by any mask we might determine
1554 * for address `addr' (in network byte order).
1555 * Here we scan through the system's list of interfaces, looking for
1556 * any non-point-to-point interfaces which might appear to be on the same
1557 * network as `addr'. If we find any, we OR in their netmask to the
1558 * user-specified netmask.
1561 u_int32_t GetMask (u_int32_t addr)
1563 u_int32_t mask, nmask, ina;
1564 struct ifreq *ifr, *ifend, ifreq;
1566 struct ifreq ifs[MAX_IFS];
1570 if (IN_CLASSA(addr)) /* determine network mask for address class */
1571 nmask = IN_CLASSA_NET;
1572 else if (IN_CLASSB(addr))
1573 nmask = IN_CLASSB_NET;
1575 nmask = IN_CLASSC_NET;
1577 /* class D nets are disallowed by bad_ip_adrs */
1578 mask = netmask | htonl(nmask);
1580 * Scan through the system's network interfaces.
1582 ifc.ifc_len = sizeof(ifs);
1584 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1585 if ( ! ok_error ( errno ))
1586 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1590 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1591 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1593 * Check the interface's internet address.
1595 if (ifr->ifr_addr.sa_family != AF_INET)
1597 ina = SIN_ADDR(ifr->ifr_addr);
1598 if (((ntohl(ina) ^ addr) & nmask) != 0)
1601 * Check that the interface is up, and not point-to-point nor loopback.
1603 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1604 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1607 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1610 * Get its netmask and OR it into our mask.
1612 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1614 mask |= SIN_ADDR(ifreq.ifr_addr);
1620 /********************************************************************
1622 * Internal routine to decode the version.modification.patch level
1625 static void decode_version (char *buf, int *version,
1626 int *modification, int *patch)
1628 *version = (int) strtoul (buf, &buf, 10);
1634 *modification = (int) strtoul (buf, &buf, 10);
1637 *patch = (int) strtoul (buf, &buf, 10);
1648 /********************************************************************
1650 * Procedure to determine if the PPP line discipline is registered.
1654 ppp_registered(void)
1662 * We used to open the serial device and set it to the ppp line
1663 * discipline here, in order to create a ppp unit. But that is
1664 * not a good idea - the user might have specified a device that
1665 * they can't open (permission, or maybe it doesn't really exist).
1666 * So we grab a pty master/slave pair and use that.
1668 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1669 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1674 * Try to put the device into the PPP discipline.
1676 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1677 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1686 /********************************************************************
1688 * ppp_available - check whether the system has any ppp interfaces
1689 * (in fact we check whether we can do an ioctl on ppp0).
1692 int ppp_available(void)
1697 int my_version, my_modification, my_patch;
1698 int osmaj, osmin, ospatch;
1701 "This system lacks kernel support for PPP. This could be because\n"
1702 "the PPP kernel module could not be loaded, or because PPP was not\n"
1703 "included in the kernel configuration. If PPP was included as a\n"
1704 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1705 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1706 "See README.linux file in the ppp distribution for more details.\n";
1708 /* get the kernel version now, since we are called before sys_init */
1710 osmaj = osmin = ospatch = 0;
1711 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1712 kernel_version = KVERSION(osmaj, osmin, ospatch);
1714 if (kernel_version >= KVERSION(2,3,13)) {
1715 fd = open("/dev/ppp", O_RDWR);
1716 if (fd < 0 && errno == ENOENT) {
1717 /* try making it and see if that helps. */
1718 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1719 makedev(108, 0)) >= 0) {
1720 fd = open("/dev/ppp", O_RDWR);
1722 info("Created /dev/ppp device node");
1724 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1725 } else if (errno == EEXIST) {
1726 fd = open("/dev/ppp", O_RDWR);
1730 new_style_driver = 1;
1732 /* XXX should get from driver */
1734 driver_modification = 4;
1742 * Open a socket for doing the ioctl operations.
1744 s = socket(AF_INET, SOCK_DGRAM, 0);
1748 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1749 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1751 * If the device did not exist then attempt to create one by putting the
1752 * current tty into the PPP discipline. If this works then obtain the
1753 * flags for the device again.
1756 if (ppp_registered()) {
1757 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1758 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1762 * Ensure that the hardware address is for PPP and not something else
1765 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1767 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1771 * This is the PPP device. Validate the version of the driver at this
1772 * point to ensure that this program will work with the driver.
1775 char abBuffer [1024];
1777 ifr.ifr_data = abBuffer;
1778 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1780 error("Couldn't read driver version: %m");
1782 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1785 decode_version(abBuffer,
1787 &driver_modification,
1790 * Validate the version of the driver against the version that we used.
1792 decode_version(VERSION,
1797 /* The version numbers must match */
1798 if (driver_version != my_version)
1801 /* The modification levels must be legal */
1802 if (driver_modification < 3) {
1803 if (driver_modification >= 2) {
1804 /* we can cope with 2.2.0 and above */
1813 slprintf(route_buffer, sizeof(route_buffer),
1814 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1815 driver_version, driver_modification, driver_patch);
1817 no_ppp_msg = route_buffer;
1824 /********************************************************************
1826 * Update the wtmp file with the appropriate user name and tty device.
1829 void logwtmp (const char *line, const char *name, const char *host)
1831 struct utmp ut, *utp;
1832 pid_t mypid = getpid();
1838 * Update the signon database for users.
1839 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1841 utmpname(_PATH_UTMP);
1843 while ((utp = getutent()) && (utp->ut_pid != mypid))
1846 /* Is this call really necessary? There is another one after the 'put' */
1850 memcpy(&ut, utp, sizeof(ut));
1852 /* some gettys/telnetds don't initialize utmp... */
1853 memset(&ut, 0, sizeof(ut));
1855 if (ut.ut_id[0] == 0)
1856 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1858 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1859 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1863 ut.ut_type = USER_PROCESS;
1866 /* Insert the host name if one is supplied */
1868 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1870 /* Insert the IP address of the remote system if IP is enabled */
1871 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1872 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1873 sizeof(ut.ut_addr));
1875 /* CL: Makes sure that the logout works */
1876 if (*host == 0 && *name==0)
1882 * Update the wtmp file.
1885 updwtmp(_PATH_WTMP, &ut);
1887 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1889 flock(wtmp, LOCK_EX);
1891 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1892 warn("error writing %s: %m", _PATH_WTMP);
1894 flock(wtmp, LOCK_UN);
1902 /********************************************************************
1904 * sifvjcomp - config tcp header compression
1907 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1909 u_int x = get_flags(ppp_dev_fd);
1912 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1913 if (! ok_error (errno))
1914 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1919 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1920 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1921 set_flags (ppp_dev_fd, x);
1926 /********************************************************************
1928 * sifup - Config the interface up and enable IP packets to pass.
1935 memset (&ifr, '\0', sizeof (ifr));
1936 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1937 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1938 if (! ok_error (errno))
1939 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1943 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1944 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1945 if (! ok_error (errno))
1946 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1954 /********************************************************************
1956 * sifdown - Disable the indicated protocol and config the interface
1957 * down if there are no remaining protocols.
1964 if (if_is_up && --if_is_up > 0)
1967 memset (&ifr, '\0', sizeof (ifr));
1968 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1969 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1970 if (! ok_error (errno))
1971 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1975 ifr.ifr_flags &= ~IFF_UP;
1976 ifr.ifr_flags |= IFF_POINTOPOINT;
1977 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1978 if (! ok_error (errno))
1979 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1985 /********************************************************************
1987 * sifaddr - Config the interface IP addresses and netmask.
1990 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1996 memset (&ifr, '\0', sizeof (ifr));
1997 memset (&rt, '\0', sizeof (rt));
1999 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2000 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2001 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2003 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2005 * Set our IP address
2007 SIN_ADDR(ifr.ifr_addr) = our_adr;
2008 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2009 if (errno != EEXIST) {
2010 if (! ok_error (errno))
2011 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2014 warn("ioctl(SIOCSIFADDR): Address already exists");
2019 * Set the gateway address
2021 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2022 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2023 if (! ok_error (errno))
2024 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2029 * For recent kernels, force the netmask to 255.255.255.255.
2031 if (kernel_version >= KVERSION(2,1,16))
2033 if (net_mask != 0) {
2034 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2035 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2036 if (! ok_error (errno))
2037 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2042 * Add the device route
2044 if (kernel_version < KVERSION(2,1,16)) {
2045 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2046 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2049 SIN_ADDR(rt.rt_gateway) = 0L;
2050 SIN_ADDR(rt.rt_dst) = his_adr;
2051 rt.rt_flags = RTF_UP | RTF_HOST;
2053 if (kernel_version > KVERSION(2,1,0)) {
2054 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2055 SIN_ADDR(rt.rt_genmask) = -1L;
2058 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2059 if (! ok_error (errno))
2060 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2065 /* set ip_dynaddr in demand mode if address changes */
2066 if (demand && tune_kernel && !dynaddr_set
2067 && our_old_addr && our_old_addr != our_adr) {
2068 /* set ip_dynaddr if possible */
2072 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2073 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2074 if (write(fd, "1", 1) != 1)
2075 error("Couldn't enable dynamic IP addressing: %m");
2078 dynaddr_set = 1; /* only 1 attempt */
2085 /********************************************************************
2087 * cifaddr - Clear the interface IP addresses, and delete routes
2088 * through the interface if possible.
2091 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2095 if (kernel_version < KVERSION(2,1,16)) {
2097 * Delete the route through the device
2100 memset (&rt, '\0', sizeof (rt));
2102 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2103 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2106 SIN_ADDR(rt.rt_gateway) = 0;
2107 SIN_ADDR(rt.rt_dst) = his_adr;
2108 rt.rt_flags = RTF_UP | RTF_HOST;
2110 if (kernel_version > KVERSION(2,1,0)) {
2111 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2112 SIN_ADDR(rt.rt_genmask) = -1L;
2115 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2116 if (still_ppp() && ! ok_error (errno))
2117 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2122 /* This way it is possible to have an IPX-only or IPv6-only interface */
2123 memset(&ifr, 0, sizeof(ifr));
2124 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2125 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2127 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2128 if (! ok_error (errno)) {
2129 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2134 our_old_addr = our_adr;
2140 /********************************************************************
2142 * sif6addr - Config the interface with an IPv6 link-local address
2144 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2146 struct in6_ifreq ifr6;
2148 struct in6_rtmsg rt6;
2150 memset(&ifr, 0, sizeof (ifr));
2151 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2152 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2153 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2157 /* Local interface */
2158 memset(&ifr6, 0, sizeof(ifr6));
2159 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2160 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2161 ifr6.ifr6_prefixlen = 10;
2163 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2164 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2168 /* Route to remote host */
2169 memset(&rt6, 0, sizeof(rt6));
2170 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2171 rt6.rtmsg_flags = RTF_UP;
2172 rt6.rtmsg_dst_len = 10;
2173 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2174 rt6.rtmsg_metric = 1;
2176 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2177 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2185 /********************************************************************
2187 * cif6addr - Remove IPv6 address from interface
2189 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2192 struct in6_ifreq ifr6;
2194 memset(&ifr, 0, sizeof(ifr));
2195 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2196 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2197 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2201 memset(&ifr6, 0, sizeof(ifr6));
2202 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2203 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2204 ifr6.ifr6_prefixlen = 10;
2206 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2207 if (errno != EADDRNOTAVAIL) {
2208 if (! ok_error (errno))
2209 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2212 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2221 * get_pty - get a pty master/slave pair and chown the slave side
2222 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2225 get_pty(master_fdp, slave_fdp, slave_name, uid)
2231 int i, mfd, sfd = -1;
2233 struct termios tios;
2237 * Try the unix98 way first.
2239 mfd = open("/dev/ptmx", O_RDWR);
2242 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2243 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2244 chmod(pty_name, S_IRUSR | S_IWUSR);
2247 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2248 warn("Couldn't unlock pty slave %s: %m", pty_name);
2250 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2251 warn("Couldn't open pty slave %s: %m", pty_name);
2254 #endif /* TIOCGPTN */
2257 /* the old way - scan through the pty name space */
2258 for (i = 0; i < 64; ++i) {
2259 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2260 'p' + i / 16, i % 16);
2261 mfd = open(pty_name, O_RDWR, 0);
2264 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2266 fchown(sfd, uid, -1);
2267 fchmod(sfd, S_IRUSR | S_IWUSR);
2278 strlcpy(slave_name, pty_name, 16);
2281 if (tcgetattr(sfd, &tios) == 0) {
2282 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2283 tios.c_cflag |= CS8 | CREAD;
2284 tios.c_iflag = IGNPAR | CLOCAL;
2287 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2288 warn("couldn't set attributes on pty: %m");
2290 warn("couldn't get attributes on pty: %m");
2295 /********************************************************************
2297 * open_loopback - open the device we use for getting packets
2298 * in demand mode. Under Linux, we use a pty master/slave pair.
2301 open_ppp_loopback(void)
2306 if (new_style_driver) {
2307 /* allocate ourselves a ppp unit */
2309 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
2310 fatal("Couldn't create PPP unit: %m");
2311 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2312 set_kdebugflag(kdebugflag);
2317 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2318 fatal("No free pty for loopback");
2319 SYSDEBUG(("using %s for loopback", loop_name));
2321 set_ppp_fd(slave_fd);
2323 flags = fcntl(master_fd, F_GETFL);
2325 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2326 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2328 flags = fcntl(ppp_fd, F_GETFL);
2330 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2331 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2333 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2334 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2336 * Find out which interface we were given.
2338 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2339 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2341 * Enable debug in the driver if requested.
2343 set_kdebugflag (kdebugflag);
2348 /********************************************************************
2350 * restore_loop - reattach the ppp unit to the loopback.
2352 * The kernel ppp driver automatically reattaches the ppp unit to
2353 * the loopback if the serial port is set to a line discipline other
2354 * than ppp, or if it detects a modem hangup. The former will happen
2355 * in disestablish_ppp if the latter hasn't already happened, so we
2356 * shouldn't need to do anything.
2358 * Just to be sure, set the real serial port to the normal discipline.
2365 if (new_style_driver) {
2366 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2369 if (ppp_fd != slave_fd) {
2370 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2371 set_ppp_fd(slave_fd);
2375 /********************************************************************
2377 * sifnpmode - Set the mode for handling packets for a given NP.
2381 sifnpmode(u, proto, mode)
2388 npi.protocol = proto;
2390 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2391 if (! ok_error (errno))
2392 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2393 proto, mode, errno);
2400 /********************************************************************
2402 * sipxfaddr - Config the interface IPX networknumber
2405 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2412 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2414 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2416 if (! ok_error (errno))
2417 dbglog("socket(AF_IPX): %m (%d)", errno);
2421 memset (&ifr, '\0', sizeof (ifr));
2422 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2424 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2425 sipx->sipx_family = AF_IPX;
2426 sipx->sipx_port = 0;
2427 sipx->sipx_network = htonl (network);
2428 sipx->sipx_type = IPX_FRAME_ETHERII;
2429 sipx->sipx_action = IPX_CRTITF;
2431 * Set the IPX device
2433 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2435 if (errno != EEXIST) {
2436 if (! ok_error (errno))
2437 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2440 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2449 /********************************************************************
2451 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2452 * are removed and the device is no longer able to pass IPX
2456 int cipxfaddr (int unit)
2463 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2465 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2467 if (! ok_error (errno))
2468 dbglog("socket(AF_IPX): %m (%d)", errno);
2472 memset (&ifr, '\0', sizeof (ifr));
2473 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2475 sipx->sipx_type = IPX_FRAME_ETHERII;
2476 sipx->sipx_action = IPX_DLTITF;
2477 sipx->sipx_family = AF_IPX;
2479 * Set the IPX device
2481 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2482 if (! ok_error (errno))
2483 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2493 * Use the hostname as part of the random number seed.
2502 for (p = hostname; *p != 0; ++p)
2507 /********************************************************************
2509 * sys_check_options - check the options that the user specified
2513 sys_check_options(void)
2517 * Disable the IPX protocol if the support is not present in the kernel.
2521 if (ipxcp_protent.enabled_flag) {
2522 struct stat stat_buf;
2523 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2524 || lstat(path, &stat_buf) < 0) {
2525 error("IPX support is not present in the kernel\n");
2526 ipxcp_protent.enabled_flag = 0;
2530 if (demand && driver_is_old) {
2531 option_error("demand dialling is not supported by kernel driver "
2532 "version %d.%d.%d", driver_version, driver_modification,