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) */
127 static int chindex; /* channel index (new style driver) */
129 static fd_set in_fds; /* set of fds that wait_input waits for */
130 static int max_in_fd; /* highest fd set in in_fds */
132 static int has_proxy_arp = 0;
133 static int driver_version = 0;
134 static int driver_modification = 0;
135 static int driver_patch = 0;
136 static int driver_is_old = 0;
137 static int restore_term = 0; /* 1 => we've munged the terminal */
138 static struct termios inittermios; /* Initial TTY termios */
140 static int new_style_driver = 0;
142 static char loop_name[20];
143 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
145 static int if_is_up; /* Interface has been marked up */
146 static u_int32_t default_route_gateway; /* Gateway for default route added */
147 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
148 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
149 static u_int32_t our_old_addr; /* for detecting address changes */
150 static int dynaddr_set; /* 1 if ip_dynaddr set */
151 static int looped; /* 1 if using loop */
152 static int link_mtu; /* mtu for the link (not bundle) */
154 static struct utsname utsname; /* for the kernel version */
155 static int kernel_version;
156 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
160 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
161 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
162 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
164 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
166 /* Prototypes for procedures local to this file. */
167 static int get_flags (int fd);
168 static void set_flags (int fd, int flags);
169 static int translate_speed (int bps);
170 static int baud_rate_of (int speed);
171 static void close_route_table (void);
172 static int open_route_table (void);
173 static int read_route_table (struct rtentry *rt);
174 static int defaultroute_exists (struct rtentry *rt);
175 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
176 char *name, int namelen);
177 static void decode_version (char *buf, int *version, int *mod, int *patch);
178 static int set_kdebugflag(int level);
179 static int ppp_registered(void);
180 static int make_ppp_unit(void);
182 extern u_char inpacket_buf[]; /* borrowed from main.c */
185 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
189 #define SET_SA_FAMILY(addr, family) \
190 memset ((char *) &(addr), '\0', sizeof(addr)); \
191 addr.sa_family = (family);
194 * Determine if the PPP connection should still be present.
199 /* new_fd is the fd of a tty */
200 static void set_ppp_fd (int new_fd)
202 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
204 if (!new_style_driver)
208 static int still_ppp(void)
210 if (new_style_driver)
211 return !hungup && ppp_fd >= 0;
212 if (!hungup || ppp_fd == slave_fd)
215 set_ppp_fd(slave_fd);
221 /********************************************************************
223 * Functions to read and set the flags value in the device driver
226 static int get_flags (int fd)
230 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
231 if ( ok_error (errno) )
234 fatal("ioctl(PPPIOCGFLAGS): %m");
237 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
241 /********************************************************************/
243 static void set_flags (int fd, int flags)
245 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
247 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
248 if (! ok_error (errno) )
249 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
253 /********************************************************************
255 * sys_init - System-dependent initialization.
262 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
263 setlogmask(LOG_UPTO(LOG_INFO));
265 setlogmask(LOG_UPTO(LOG_DEBUG));
267 if (new_style_driver) {
268 ppp_dev_fd = open("/dev/ppp", O_RDWR);
270 fatal("Couldn't open /dev/ppp: %m");
271 flags = fcntl(ppp_dev_fd, F_GETFL);
273 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
274 warn("Couldn't set /dev/ppp to nonblock: %m");
277 /* Get an internet socket for doing socket ioctls. */
278 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
280 fatal("Couldn't create IP socket: %m(%d)", errno);
283 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
285 sock6_fd = -errno; /* save errno for later */
292 /********************************************************************
294 * sys_cleanup - restore any system state we modified before exiting:
295 * mark the interface down, delete default route and/or proxy arp entry.
296 * This shouldn't call die() because it's called from die().
299 void sys_cleanup(void)
302 * Take down the device
309 * Delete any routes through the device.
311 if (default_route_gateway != 0)
312 cifdefaultroute(0, 0, default_route_gateway);
315 cifproxyarp(0, proxy_arp_addr);
318 /********************************************************************
320 * sys_close - Clean up in a child process before execing.
325 if (new_style_driver)
336 /********************************************************************
338 * set_kdebugflag - Define the debugging level for the kernel
341 static int set_kdebugflag (int requested_level)
343 if (new_style_driver && ifunit < 0)
345 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
346 if ( ! ok_error (errno) )
347 error("ioctl(PPPIOCSDEBUG): %m");
350 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
355 /********************************************************************
357 * establish_ppp - Turn the serial port into a ppp interface.
360 int establish_ppp (int tty_fd)
366 * Ensure that the tty device is in exclusive mode.
368 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
369 if ( ! ok_error ( errno ))
370 warn("Couldn't make tty exclusive: %m");
373 * Demand mode - prime the old ppp device to relinquish the unit.
375 if (!new_style_driver && looped
376 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
377 error("ioctl(transfer ppp unit): %m");
381 * Set the current tty to the PPP discpline
385 #define N_SYNC_PPP 14
387 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
388 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
389 if ( ! ok_error (errno) ) {
390 error("Couldn't set tty to PPP discipline: %m");
395 if (new_style_driver) {
396 /* Open another instance of /dev/ppp and connect the channel to it */
399 if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
400 error("Couldn't get channel number: %m");
403 dbglog("using channel %d", chindex);
404 fd = open("/dev/ppp", O_RDWR);
406 error("Couldn't reopen /dev/ppp: %m");
409 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
410 error("Couldn't attach to channel %d: %m", chindex);
413 flags = fcntl(fd, F_GETFL);
414 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
415 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
420 if (!looped && !multilink) {
422 * Create a new PPP unit.
424 if (make_ppp_unit() < 0)
429 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
433 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
434 error("Couldn't attach to PPP unit %d: %m", ifunit);
441 * Old-style driver: find out which interface we were given.
444 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
445 if (ok_error (errno))
447 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
449 /* Check that we got the same unit again. */
450 if (looped && x != ifunit)
451 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
455 * Fetch the initial file flags and reset blocking mode on the file.
457 initfdflags = fcntl(tty_fd, F_GETFL);
458 if (initfdflags == -1 ||
459 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
460 if ( ! ok_error (errno))
461 warn("Couldn't set device to non-blocking mode: %m");
468 * Enable debug in the driver if requested.
471 set_kdebugflag (kdebugflag);
473 set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
474 SC_RCV_EVNP | SC_RCV_ODDP));
476 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
477 driver_version, driver_modification, driver_patch));
484 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
485 warn("Couldn't reset tty to normal line discipline: %m");
489 /********************************************************************
491 * disestablish_ppp - Restore the serial port to normal operation.
492 * This shouldn't call die() because it's called from die().
495 void disestablish_ppp(int tty_fd)
499 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
501 if (tcflush(tty_fd, TCIOFLUSH) < 0)
502 warn("tcflush failed: %m");
504 * Restore the previous line discipline
506 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
507 if ( ! ok_error (errno))
508 error("ioctl(TIOCSETD, N_TTY): %m");
511 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
512 if ( ! ok_error (errno))
513 warn("ioctl(TIOCNXCL): %m(%d)", errno);
516 /* Reset non-blocking mode on fd. */
517 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
518 if ( ! ok_error (errno))
519 warn("Couldn't restore device fd flags: %m");
524 if (new_style_driver) {
527 if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
528 error("Couldn't release PPP unit: %m");
530 remove_fd(ppp_dev_fd);
535 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
536 * Assumes new_style_driver.
538 static int make_ppp_unit()
543 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
544 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
545 warn("Couldn't allocate PPP unit %d as it is already in use");
547 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
550 error("Couldn't create new ppp unit: %m");
555 * cfg_bundle - configure the existing bundle.
556 * Used in demand mode.
558 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
563 if (!new_style_driver)
566 /* set the mrru, mtu and flags */
567 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
568 error("Couldn't set MRRU: %m");
569 flags = get_flags(ppp_dev_fd);
570 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
571 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0);
573 if (mtru > 0 && mtru != link_mtu) {
574 memset(&ifr, 0, sizeof(ifr));
575 slprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ppp%d", ifunit);
577 if (ioctl(sock_fd, SIOCSIFMTU, &ifr) < 0)
578 error("Couldn't set interface MTU: %m");
579 flags |= SC_MULTILINK;
582 set_flags(ppp_dev_fd, flags);
584 /* connect up the channel */
585 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
586 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
591 * make_new_bundle - create a new PPP unit (i.e. a bundle)
592 * and connect our channel to it. This should only get called
593 * if `multilink' was set at the time establish_ppp was called.
594 * In demand mode this uses our existing bundle instead of making
597 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
599 if (!new_style_driver)
602 /* make us a ppp unit */
603 if (make_ppp_unit() < 0)
606 /* set the mrru, mtu and flags */
607 cfg_bundle(mrru, mtru, rssn, tssn);
611 * bundle_attach - attach our link to a given PPP unit.
612 * We assume the unit is controlled by another pppd.
614 int bundle_attach(int ifnum)
616 if (!new_style_driver)
619 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
621 return 0; /* doesn't still exist */
622 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
624 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
625 fatal("Couldn't connect to interface unit %d: %m", ifnum);
626 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
632 /********************************************************************
634 * clean_check - Fetch the flags for the device and generate
635 * appropriate error messages.
637 void clean_check(void)
643 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
645 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
647 s = "all had bit 7 set to 1";
651 s = "all had bit 7 set to 0";
655 s = "all had odd parity";
659 s = "all had even parity";
664 warn("Receive serial link is not 8-bit clean:");
665 warn("Problem: %s", s);
673 * List of valid speeds.
677 int speed_int, speed_val;
754 /********************************************************************
756 * Translate from bits/second to a speed_t.
759 static int translate_speed (int bps)
761 struct speed *speedp;
764 for (speedp = speeds; speedp->speed_int; speedp++) {
765 if (bps == speedp->speed_int)
766 return speedp->speed_val;
768 warn("speed %d not supported", bps);
773 /********************************************************************
775 * Translate from a speed_t to bits/second.
778 static int baud_rate_of (int speed)
780 struct speed *speedp;
783 for (speedp = speeds; speedp->speed_int; speedp++) {
784 if (speed == speedp->speed_val)
785 return speedp->speed_int;
791 /********************************************************************
793 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
794 * at the requested speed, etc. If `local' is true, set CLOCAL
795 * regardless of whether the modem option was specified.
798 void set_up_tty(int tty_fd, int local)
804 if (tcgetattr(tty_fd, &tios) < 0) {
805 if (!ok_error(errno))
806 fatal("tcgetattr: %m(%d)", errno);
813 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
814 tios.c_cflag |= CS8 | CREAD | HUPCL;
816 tios.c_iflag = IGNBRK | IGNPAR;
820 tios.c_cc[VTIME] = 0;
823 tios.c_cflag ^= (CLOCAL | HUPCL);
827 tios.c_cflag |= CRTSCTS;
831 tios.c_iflag |= IXON | IXOFF;
832 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
833 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
837 tios.c_cflag &= ~CRTSCTS;
844 speed = translate_speed(inspeed);
846 cfsetospeed (&tios, speed);
847 cfsetispeed (&tios, speed);
850 * We can't proceed if the serial port speed is B0,
851 * since that implies that the serial port is disabled.
854 speed = cfgetospeed(&tios);
856 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
859 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
860 if (!ok_error(errno))
861 fatal("tcsetattr: %m");
863 baud_rate = baud_rate_of(speed);
867 /********************************************************************
869 * setdtr - control the DTR line on the serial port.
870 * This is called from die(), so it shouldn't call die().
873 void setdtr (int tty_fd, int on)
875 int modembits = TIOCM_DTR;
877 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
880 /********************************************************************
882 * restore_tty - restore the terminal to the saved settings.
885 void restore_tty (int tty_fd)
890 * Turn off echoing, because otherwise we can get into
891 * a loop with the tty and the modem echoing to each other.
892 * We presume we are the sole user of this tty device, so
893 * when we close it, it will revert to its defaults anyway.
896 inittermios.c_lflag &= ~(ECHO | ECHONL);
898 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
899 if (! ok_error (errno))
900 warn("tcsetattr: %m");
905 /********************************************************************
907 * output - Output PPP packet.
910 void output (int unit, unsigned char *p, int len)
916 dbglog("sent %P", p, len);
918 if (len < PPP_HDRLEN)
920 if (new_style_driver) {
923 proto = (p[0] << 8) + p[1];
924 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
927 if (write(fd, p, len) < 0) {
928 if (errno == EWOULDBLOCK || errno == ENOBUFS
929 || errno == ENXIO || errno == EIO || errno == EINTR)
930 warn("write: warning: %m (%d)", errno);
932 error("write: %m (%d)", errno);
936 /********************************************************************
938 * wait_input - wait until there is data available,
939 * for the length of time specified by *timo (indefinite
943 void wait_input(struct timeval *timo)
950 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
951 if (n < 0 && errno != EINTR)
952 fatal("select: %m(%d)", errno);
956 * add_fd - add an fd to the set that wait_input waits for.
966 * remove_fd - remove an fd from the set that wait_input waits for.
968 void remove_fd(int fd)
974 /********************************************************************
976 * read_packet - get a PPP packet from the serial device.
979 int read_packet (unsigned char *buf)
983 len = PPP_MRU + PPP_HDRLEN;
984 if (new_style_driver) {
985 *buf++ = PPP_ALLSTATIONS;
991 nr = read(ppp_fd, buf, len);
992 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
995 if (nr < 0 && new_style_driver && ifunit >= 0) {
996 /* N.B. we read ppp_fd first since LCP packets come in there. */
997 nr = read(ppp_dev_fd, buf, len);
998 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
999 error("read /dev/ppp: %m");
1001 return (new_style_driver && nr > 0)? nr+2: nr;
1004 /********************************************************************
1006 * get_loop_output - get outgoing packets from the ppp device,
1007 * and detect when we want to bring the real link up.
1008 * Return value is 1 if we need to bring up the link, 0 otherwise.
1011 get_loop_output(void)
1016 if (new_style_driver) {
1017 while ((n = read_packet(inpacket_buf)) > 0)
1018 if (loop_frame(inpacket_buf, n))
1023 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1024 if (loop_chars(inbuf, n))
1028 fatal("eof on loopback");
1030 if (errno != EWOULDBLOCK)
1031 fatal("read from loopback: %m(%d)", errno);
1036 /********************************************************************
1038 * ppp_send_config - configure the transmit characteristics of
1039 * the ppp interface.
1042 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1047 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
1049 * Set the MTU and other parameters for the ppp device
1051 memset (&ifr, '\0', sizeof (ifr));
1052 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1055 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1056 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
1061 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1062 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1063 if (!ok_error(errno))
1064 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1068 x = get_flags(ppp_fd);
1069 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1070 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1071 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1072 set_flags(ppp_fd, x);
1075 /********************************************************************
1077 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1080 void ppp_set_xaccm (int unit, ext_accm accm)
1082 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1083 accm[0], accm[1], accm[2], accm[3]));
1087 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1088 if ( ! ok_error (errno))
1089 warn("ioctl(set extended ACCM): %m(%d)", errno);
1093 /********************************************************************
1095 * ppp_recv_config - configure the receive-side characteristics of
1096 * the ppp interface.
1099 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1101 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1103 * If we were called because the link has gone down then there is nothing
1104 * which may be done. Just return without incident.
1109 * Set the receiver parameters
1111 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1112 if ( ! ok_error (errno))
1113 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1115 if (new_style_driver && ifunit >= 0
1116 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1117 error("Couldn't set MRU in generic PPP layer: %m");
1119 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1120 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1121 if (!ok_error(errno))
1122 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1126 /********************************************************************
1128 * ccp_test - ask kernel whether a given compression method
1129 * is acceptable for use.
1132 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1134 struct ppp_option_data data;
1136 memset (&data, '\0', sizeof (data));
1138 data.length = opt_len;
1139 data.transmit = for_transmit;
1141 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1144 return (errno == ENOBUFS)? 0: -1;
1147 /********************************************************************
1149 * ccp_flags_set - inform kernel about the current state of CCP.
1152 void ccp_flags_set (int unit, int isopen, int isup)
1155 int x = get_flags(ppp_dev_fd);
1156 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1157 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1158 set_flags (ppp_dev_fd, x);
1162 /********************************************************************
1164 * get_idle_time - return how long the link has been idle.
1167 get_idle_time(u, ip)
1169 struct ppp_idle *ip;
1171 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1174 /********************************************************************
1176 * get_ppp_stats - return statistics for the link.
1179 get_ppp_stats(u, stats)
1181 struct pppd_stats *stats;
1183 struct ifpppstatsreq req;
1185 memset (&req, 0, sizeof (req));
1187 req.stats_ptr = (caddr_t) &req.stats;
1188 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1189 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1190 error("Couldn't get PPP statistics: %m");
1193 stats->bytes_in = req.stats.p.ppp_ibytes;
1194 stats->bytes_out = req.stats.p.ppp_obytes;
1198 /********************************************************************
1200 * ccp_fatal_error - returns 1 if decompression was disabled as a
1201 * result of an error detected after decompression of a packet,
1202 * 0 otherwise. This is necessary because of patent nonsense.
1205 int ccp_fatal_error (int unit)
1207 int x = get_flags(ppp_dev_fd);
1209 return x & SC_DC_FERROR;
1212 /********************************************************************
1214 * path_to_procfs - find the path to the proc file system mount point
1216 static char proc_path[MAXPATHLEN];
1217 static int proc_path_len;
1219 static char *path_to_procfs(const char *tail)
1221 struct mntent *mntent;
1224 if (proc_path_len == 0) {
1225 /* Default the mount location of /proc */
1226 strlcpy (proc_path, "/proc", sizeof(proc_path));
1228 fp = fopen(MOUNTED, "r");
1230 while ((mntent = getmntent(fp)) != NULL) {
1231 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1233 if (strcmp(mntent->mnt_type, "proc") == 0) {
1234 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1235 proc_path_len = strlen(proc_path);
1243 strlcpy(proc_path + proc_path_len, tail,
1244 sizeof(proc_path) - proc_path_len);
1249 * /proc/net/route parsing stuff.
1251 #define ROUTE_MAX_COLS 12
1252 FILE *route_fd = (FILE *) 0;
1253 static char route_buffer[512];
1254 static int route_dev_col, route_dest_col, route_gw_col;
1255 static int route_flags_col, route_mask_col;
1256 static int route_num_cols;
1258 static int open_route_table (void);
1259 static void close_route_table (void);
1260 static int read_route_table (struct rtentry *rt);
1262 /********************************************************************
1264 * close_route_table - close the interface to the route table
1267 static void close_route_table (void)
1269 if (route_fd != (FILE *) 0) {
1271 route_fd = (FILE *) 0;
1275 /********************************************************************
1277 * open_route_table - open the interface to the route table
1279 static char route_delims[] = " \t\n";
1281 static int open_route_table (void)
1285 close_route_table();
1287 path = path_to_procfs("/net/route");
1288 route_fd = fopen (path, "r");
1289 if (route_fd == NULL) {
1290 error("can't open routing table %s: %m", path);
1294 route_dev_col = 0; /* default to usual columns */
1297 route_flags_col = 3;
1301 /* parse header line */
1302 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1303 char *p = route_buffer, *q;
1305 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1307 if ((q = strtok(p, route_delims)) == 0)
1309 if (strcasecmp(q, "iface") == 0)
1310 route_dev_col = col;
1311 else if (strcasecmp(q, "destination") == 0)
1312 route_dest_col = col;
1313 else if (strcasecmp(q, "gateway") == 0)
1315 else if (strcasecmp(q, "flags") == 0)
1316 route_flags_col = col;
1317 else if (strcasecmp(q, "mask") == 0)
1318 route_mask_col = col;
1321 if (used && col >= route_num_cols)
1322 route_num_cols = col + 1;
1330 /********************************************************************
1332 * read_route_table - read the next entry from the route table
1335 static int read_route_table(struct rtentry *rt)
1337 char *cols[ROUTE_MAX_COLS], *p;
1340 memset (rt, '\0', sizeof (struct rtentry));
1342 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1346 for (col = 0; col < route_num_cols; ++col) {
1347 cols[col] = strtok(p, route_delims);
1348 if (cols[col] == NULL)
1349 return 0; /* didn't get enough columns */
1353 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1354 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1355 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1357 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1358 rt->rt_dev = cols[route_dev_col];
1363 /********************************************************************
1365 * defaultroute_exists - determine if there is a default route
1368 static int defaultroute_exists (struct rtentry *rt)
1372 if (!open_route_table())
1375 while (read_route_table(rt) != 0) {
1376 if ((rt->rt_flags & RTF_UP) == 0)
1379 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1381 if (SIN_ADDR(rt->rt_dst) == 0L) {
1387 close_route_table();
1392 * have_route_to - determine if the system has any route to
1393 * a given IP address. `addr' is in network byte order.
1394 * Return value is 1 if yes, 0 if no, -1 if don't know.
1395 * For demand mode to work properly, we have to ignore routes
1396 * through our own interface.
1398 int have_route_to(u_int32_t addr)
1403 if (!open_route_table())
1404 return -1; /* don't know */
1406 while (read_route_table(&rt)) {
1407 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1409 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1415 close_route_table();
1419 /********************************************************************
1421 * sifdefaultroute - assign a default route through the address given.
1424 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1428 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1429 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1431 if (old_gateway != gateway)
1432 error("not replacing existing default route to %s [%I]",
1433 rt.rt_dev, old_gateway);
1437 memset (&rt, '\0', sizeof (rt));
1438 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1439 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1441 if (kernel_version > KVERSION(2,1,0)) {
1442 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1443 SIN_ADDR(rt.rt_genmask) = 0L;
1446 SIN_ADDR(rt.rt_gateway) = gateway;
1448 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1449 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1450 if ( ! ok_error ( errno ))
1451 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1455 default_route_gateway = gateway;
1459 /********************************************************************
1461 * cifdefaultroute - delete a default route through the address given.
1464 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1468 default_route_gateway = 0;
1470 memset (&rt, '\0', sizeof (rt));
1471 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1472 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1474 if (kernel_version > KVERSION(2,1,0)) {
1475 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1476 SIN_ADDR(rt.rt_genmask) = 0L;
1479 SIN_ADDR(rt.rt_gateway) = gateway;
1481 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1482 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1484 if ( ! ok_error ( errno ))
1485 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1493 /********************************************************************
1495 * sifproxyarp - Make a proxy ARP entry for the peer.
1498 int sifproxyarp (int unit, u_int32_t his_adr)
1500 struct arpreq arpreq;
1503 if (has_proxy_arp == 0) {
1504 memset (&arpreq, '\0', sizeof(arpreq));
1506 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1507 SIN_ADDR(arpreq.arp_pa) = his_adr;
1508 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1510 * Get the hardware address of an interface on the same subnet
1511 * as our local address.
1513 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1514 sizeof(proxy_arp_dev))) {
1515 error("Cannot determine ethernet address for proxy ARP");
1518 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1520 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1521 if ( ! ok_error ( errno ))
1522 error("ioctl(SIOCSARP): %m(%d)", errno);
1525 proxy_arp_addr = his_adr;
1529 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1530 if (forw_path != 0) {
1531 int fd = open(forw_path, O_WRONLY);
1533 if (write(fd, "1", 1) != 1)
1534 error("Couldn't enable IP forwarding: %m");
1544 /********************************************************************
1546 * cifproxyarp - Delete the proxy ARP entry for the peer.
1549 int cifproxyarp (int unit, u_int32_t his_adr)
1551 struct arpreq arpreq;
1553 if (has_proxy_arp) {
1555 memset (&arpreq, '\0', sizeof(arpreq));
1556 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1557 SIN_ADDR(arpreq.arp_pa) = his_adr;
1558 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1559 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1561 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1562 if ( ! ok_error ( errno ))
1563 warn("ioctl(SIOCDARP): %m(%d)", errno);
1570 /********************************************************************
1572 * get_ether_addr - get the hardware address of an interface on the
1573 * the same subnet as ipaddr.
1576 static int get_ether_addr (u_int32_t ipaddr,
1577 struct sockaddr *hwaddr,
1578 char *name, int namelen)
1580 struct ifreq *ifr, *ifend;
1581 u_int32_t ina, mask;
1585 struct ifreq ifs[MAX_IFS];
1587 ifc.ifc_len = sizeof(ifs);
1589 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1590 if ( ! ok_error ( errno ))
1591 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1595 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1596 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1598 * Scan through looking for an interface with an Internet
1599 * address on the same subnet as `ipaddr'.
1601 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1602 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1603 if (ifr->ifr_addr.sa_family == AF_INET) {
1604 ina = SIN_ADDR(ifr->ifr_addr);
1605 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1606 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1609 * Check that the interface is up, and not point-to-point
1612 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1615 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1618 * Get its netmask and check that it's on the right subnet.
1620 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1623 mask = SIN_ADDR(ifreq.ifr_addr);
1624 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1625 ip_ntoa(ina), ntohl(mask)));
1627 if (((ipaddr ^ ina) & mask) != 0)
1636 strlcpy(name, ifreq.ifr_name, namelen);
1638 /* trim off the :1 in eth0:1 */
1639 aliasp = strchr(name, ':');
1643 info("found interface %s for proxy arp", name);
1645 * Now get the hardware address.
1647 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1648 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1649 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1655 sizeof (struct sockaddr));
1657 SYSDEBUG ((LOG_DEBUG,
1658 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1659 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1660 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1661 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1662 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1663 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1664 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1665 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1666 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1671 * get_if_hwaddr - get the hardware address for the specified
1672 * network interface device.
1675 get_if_hwaddr(u_char *addr, char *name)
1680 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1683 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1684 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1685 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1688 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1693 * get_first_ethernet - return the name of the first ethernet-style
1694 * interface on this system.
1697 get_first_ethernet()
1702 /********************************************************************
1704 * Return user specified netmask, modified by any mask we might determine
1705 * for address `addr' (in network byte order).
1706 * Here we scan through the system's list of interfaces, looking for
1707 * any non-point-to-point interfaces which might appear to be on the same
1708 * network as `addr'. If we find any, we OR in their netmask to the
1709 * user-specified netmask.
1712 u_int32_t GetMask (u_int32_t addr)
1714 u_int32_t mask, nmask, ina;
1715 struct ifreq *ifr, *ifend, ifreq;
1717 struct ifreq ifs[MAX_IFS];
1721 if (IN_CLASSA(addr)) /* determine network mask for address class */
1722 nmask = IN_CLASSA_NET;
1723 else if (IN_CLASSB(addr))
1724 nmask = IN_CLASSB_NET;
1726 nmask = IN_CLASSC_NET;
1728 /* class D nets are disallowed by bad_ip_adrs */
1729 mask = netmask | htonl(nmask);
1731 * Scan through the system's network interfaces.
1733 ifc.ifc_len = sizeof(ifs);
1735 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1736 if ( ! ok_error ( errno ))
1737 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1741 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1742 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1744 * Check the interface's internet address.
1746 if (ifr->ifr_addr.sa_family != AF_INET)
1748 ina = SIN_ADDR(ifr->ifr_addr);
1749 if (((ntohl(ina) ^ addr) & nmask) != 0)
1752 * Check that the interface is up, and not point-to-point nor loopback.
1754 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1755 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1758 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1761 * Get its netmask and OR it into our mask.
1763 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1765 mask |= SIN_ADDR(ifreq.ifr_addr);
1771 /********************************************************************
1773 * Internal routine to decode the version.modification.patch level
1776 static void decode_version (char *buf, int *version,
1777 int *modification, int *patch)
1779 *version = (int) strtoul (buf, &buf, 10);
1785 *modification = (int) strtoul (buf, &buf, 10);
1788 *patch = (int) strtoul (buf, &buf, 10);
1799 /********************************************************************
1801 * Procedure to determine if the PPP line discipline is registered.
1805 ppp_registered(void)
1813 * We used to open the serial device and set it to the ppp line
1814 * discipline here, in order to create a ppp unit. But that is
1815 * not a good idea - the user might have specified a device that
1816 * they can't open (permission, or maybe it doesn't really exist).
1817 * So we grab a pty master/slave pair and use that.
1819 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1820 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1825 * Try to put the device into the PPP discipline.
1827 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1828 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1837 /********************************************************************
1839 * ppp_available - check whether the system has any ppp interfaces
1840 * (in fact we check whether we can do an ioctl on ppp0).
1843 int ppp_available(void)
1848 int my_version, my_modification, my_patch;
1849 int osmaj, osmin, ospatch;
1852 "This system lacks kernel support for PPP. This could be because\n"
1853 "the PPP kernel module could not be loaded, or because PPP was not\n"
1854 "included in the kernel configuration. If PPP was included as a\n"
1855 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1856 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1857 "See README.linux file in the ppp distribution for more details.\n";
1859 /* get the kernel version now, since we are called before sys_init */
1861 osmaj = osmin = ospatch = 0;
1862 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1863 kernel_version = KVERSION(osmaj, osmin, ospatch);
1865 fd = open("/dev/ppp", O_RDWR);
1867 if (fd < 0 && errno == ENOENT) {
1868 /* try making it and see if that helps. */
1869 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1870 makedev(108, 0)) >= 0) {
1871 fd = open("/dev/ppp", O_RDWR);
1873 info("Created /dev/ppp device node");
1875 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1876 } else if (errno == EEXIST) {
1877 fd = open("/dev/ppp", O_RDWR);
1882 new_style_driver = 1;
1884 /* XXX should get from driver */
1886 driver_modification = 4;
1891 if (kernel_version >= KVERSION(2,3,13))
1895 * Open a socket for doing the ioctl operations.
1897 s = socket(AF_INET, SOCK_DGRAM, 0);
1901 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1902 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1904 * If the device did not exist then attempt to create one by putting the
1905 * current tty into the PPP discipline. If this works then obtain the
1906 * flags for the device again.
1909 if (ppp_registered()) {
1910 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1911 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1915 * Ensure that the hardware address is for PPP and not something else
1918 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1920 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1924 * This is the PPP device. Validate the version of the driver at this
1925 * point to ensure that this program will work with the driver.
1928 char abBuffer [1024];
1930 ifr.ifr_data = abBuffer;
1931 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1933 error("Couldn't read driver version: %m");
1935 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1938 decode_version(abBuffer,
1940 &driver_modification,
1943 * Validate the version of the driver against the version that we used.
1945 decode_version(VERSION,
1950 /* The version numbers must match */
1951 if (driver_version != my_version)
1954 /* The modification levels must be legal */
1955 if (driver_modification < 3) {
1956 if (driver_modification >= 2) {
1957 /* we can cope with 2.2.0 and above */
1966 slprintf(route_buffer, sizeof(route_buffer),
1967 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1968 driver_version, driver_modification, driver_patch);
1970 no_ppp_msg = route_buffer;
1977 /********************************************************************
1979 * Update the wtmp file with the appropriate user name and tty device.
1982 void logwtmp (const char *line, const char *name, const char *host)
1984 struct utmp ut, *utp;
1985 pid_t mypid = getpid();
1991 * Update the signon database for users.
1992 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1994 utmpname(_PATH_UTMP);
1996 while ((utp = getutent()) && (utp->ut_pid != mypid))
1999 /* Is this call really necessary? There is another one after the 'put' */
2003 memcpy(&ut, utp, sizeof(ut));
2005 /* some gettys/telnetds don't initialize utmp... */
2006 memset(&ut, 0, sizeof(ut));
2008 if (ut.ut_id[0] == 0)
2009 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2011 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2012 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2016 ut.ut_type = USER_PROCESS;
2019 /* Insert the host name if one is supplied */
2021 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2023 /* Insert the IP address of the remote system if IP is enabled */
2024 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2025 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2026 sizeof(ut.ut_addr));
2028 /* CL: Makes sure that the logout works */
2029 if (*host == 0 && *name==0)
2035 * Update the wtmp file.
2038 updwtmp(_PATH_WTMP, &ut);
2040 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2042 flock(wtmp, LOCK_EX);
2044 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2045 warn("error writing %s: %m", _PATH_WTMP);
2047 flock(wtmp, LOCK_UN);
2055 /********************************************************************
2057 * sifvjcomp - config tcp header compression
2060 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2062 u_int x = get_flags(ppp_dev_fd);
2065 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2066 if (! ok_error (errno))
2067 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2072 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2073 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2074 set_flags (ppp_dev_fd, x);
2079 /********************************************************************
2081 * sifup - Config the interface up and enable IP packets to pass.
2088 memset (&ifr, '\0', sizeof (ifr));
2089 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2090 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2091 if (! ok_error (errno))
2092 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2096 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2097 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2098 if (! ok_error (errno))
2099 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2107 /********************************************************************
2109 * sifdown - Disable the indicated protocol and config the interface
2110 * down if there are no remaining protocols.
2117 if (if_is_up && --if_is_up > 0)
2120 memset (&ifr, '\0', sizeof (ifr));
2121 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2122 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2123 if (! ok_error (errno))
2124 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2128 ifr.ifr_flags &= ~IFF_UP;
2129 ifr.ifr_flags |= IFF_POINTOPOINT;
2130 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2131 if (! ok_error (errno))
2132 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2138 /********************************************************************
2140 * sifaddr - Config the interface IP addresses and netmask.
2143 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2149 memset (&ifr, '\0', sizeof (ifr));
2150 memset (&rt, '\0', sizeof (rt));
2152 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2153 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2154 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2156 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2158 * Set our IP address
2160 SIN_ADDR(ifr.ifr_addr) = our_adr;
2161 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2162 if (errno != EEXIST) {
2163 if (! ok_error (errno))
2164 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2167 warn("ioctl(SIOCSIFADDR): Address already exists");
2172 * Set the gateway address
2174 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2175 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2176 if (! ok_error (errno))
2177 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2182 * For recent kernels, force the netmask to 255.255.255.255.
2184 if (kernel_version >= KVERSION(2,1,16))
2186 if (net_mask != 0) {
2187 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2188 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2189 if (! ok_error (errno))
2190 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2195 * Add the device route
2197 if (kernel_version < KVERSION(2,1,16)) {
2198 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2199 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2202 SIN_ADDR(rt.rt_gateway) = 0L;
2203 SIN_ADDR(rt.rt_dst) = his_adr;
2204 rt.rt_flags = RTF_UP | RTF_HOST;
2206 if (kernel_version > KVERSION(2,1,0)) {
2207 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2208 SIN_ADDR(rt.rt_genmask) = -1L;
2211 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2212 if (! ok_error (errno))
2213 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2218 /* set ip_dynaddr in demand mode if address changes */
2219 if (demand && tune_kernel && !dynaddr_set
2220 && our_old_addr && our_old_addr != our_adr) {
2221 /* set ip_dynaddr if possible */
2225 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2226 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2227 if (write(fd, "1", 1) != 1)
2228 error("Couldn't enable dynamic IP addressing: %m");
2231 dynaddr_set = 1; /* only 1 attempt */
2238 /********************************************************************
2240 * cifaddr - Clear the interface IP addresses, and delete routes
2241 * through the interface if possible.
2244 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2248 if (kernel_version < KVERSION(2,1,16)) {
2250 * Delete the route through the device
2253 memset (&rt, '\0', sizeof (rt));
2255 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2256 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2259 SIN_ADDR(rt.rt_gateway) = 0;
2260 SIN_ADDR(rt.rt_dst) = his_adr;
2261 rt.rt_flags = RTF_UP | RTF_HOST;
2263 if (kernel_version > KVERSION(2,1,0)) {
2264 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2265 SIN_ADDR(rt.rt_genmask) = -1L;
2268 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2269 if (still_ppp() && ! ok_error (errno))
2270 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2275 /* This way it is possible to have an IPX-only or IPv6-only interface */
2276 memset(&ifr, 0, sizeof(ifr));
2277 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2278 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2280 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2281 if (! ok_error (errno)) {
2282 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2287 our_old_addr = our_adr;
2293 /********************************************************************
2295 * sif6addr - Config the interface with an IPv6 link-local address
2297 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2299 struct in6_ifreq ifr6;
2301 struct in6_rtmsg rt6;
2305 error("IPv6 socket creation failed: %m");
2308 memset(&ifr, 0, sizeof (ifr));
2309 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2310 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2311 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2315 /* Local interface */
2316 memset(&ifr6, 0, sizeof(ifr6));
2317 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2318 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2319 ifr6.ifr6_prefixlen = 10;
2321 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2322 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2326 /* Route to remote host */
2327 memset(&rt6, 0, sizeof(rt6));
2328 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2329 rt6.rtmsg_flags = RTF_UP;
2330 rt6.rtmsg_dst_len = 10;
2331 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2332 rt6.rtmsg_metric = 1;
2334 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2335 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2343 /********************************************************************
2345 * cif6addr - Remove IPv6 address from interface
2347 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2350 struct in6_ifreq ifr6;
2354 error("IPv6 socket creation failed: %m");
2357 memset(&ifr, 0, sizeof(ifr));
2358 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2359 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2360 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2364 memset(&ifr6, 0, sizeof(ifr6));
2365 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2366 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2367 ifr6.ifr6_prefixlen = 10;
2369 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2370 if (errno != EADDRNOTAVAIL) {
2371 if (! ok_error (errno))
2372 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2375 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2384 * get_pty - get a pty master/slave pair and chown the slave side
2385 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2388 get_pty(master_fdp, slave_fdp, slave_name, uid)
2394 int i, mfd, sfd = -1;
2396 struct termios tios;
2400 * Try the unix98 way first.
2402 mfd = open("/dev/ptmx", O_RDWR);
2405 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2406 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2407 chmod(pty_name, S_IRUSR | S_IWUSR);
2410 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2411 warn("Couldn't unlock pty slave %s: %m", pty_name);
2413 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2414 warn("Couldn't open pty slave %s: %m", pty_name);
2417 #endif /* TIOCGPTN */
2420 /* the old way - scan through the pty name space */
2421 for (i = 0; i < 64; ++i) {
2422 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2423 'p' + i / 16, i % 16);
2424 mfd = open(pty_name, O_RDWR, 0);
2427 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2429 fchown(sfd, uid, -1);
2430 fchmod(sfd, S_IRUSR | S_IWUSR);
2441 strlcpy(slave_name, pty_name, 16);
2444 if (tcgetattr(sfd, &tios) == 0) {
2445 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2446 tios.c_cflag |= CS8 | CREAD;
2447 tios.c_iflag = IGNPAR | CLOCAL;
2450 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2451 warn("couldn't set attributes on pty: %m");
2453 warn("couldn't get attributes on pty: %m");
2458 /********************************************************************
2460 * open_loopback - open the device we use for getting packets
2461 * in demand mode. Under Linux, we use a pty master/slave pair.
2464 open_ppp_loopback(void)
2469 if (new_style_driver) {
2470 /* allocate ourselves a ppp unit */
2471 if (make_ppp_unit() < 0)
2473 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2474 set_kdebugflag(kdebugflag);
2479 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2480 fatal("No free pty for loopback");
2481 SYSDEBUG(("using %s for loopback", loop_name));
2483 set_ppp_fd(slave_fd);
2485 flags = fcntl(master_fd, F_GETFL);
2487 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2488 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2490 flags = fcntl(ppp_fd, F_GETFL);
2492 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2493 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2495 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2496 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2498 * Find out which interface we were given.
2500 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2501 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2503 * Enable debug in the driver if requested.
2505 set_kdebugflag (kdebugflag);
2510 /********************************************************************
2512 * restore_loop - reattach the ppp unit to the loopback.
2514 * The kernel ppp driver automatically reattaches the ppp unit to
2515 * the loopback if the serial port is set to a line discipline other
2516 * than ppp, or if it detects a modem hangup. The former will happen
2517 * in disestablish_ppp if the latter hasn't already happened, so we
2518 * shouldn't need to do anything.
2520 * Just to be sure, set the real serial port to the normal discipline.
2527 if (new_style_driver) {
2528 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2531 if (ppp_fd != slave_fd) {
2532 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2533 set_ppp_fd(slave_fd);
2537 /********************************************************************
2539 * sifnpmode - Set the mode for handling packets for a given NP.
2543 sifnpmode(u, proto, mode)
2550 npi.protocol = proto;
2552 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2553 if (! ok_error (errno))
2554 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2555 proto, mode, errno);
2562 /********************************************************************
2564 * sipxfaddr - Config the interface IPX networknumber
2567 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2574 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2576 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2578 if (! ok_error (errno))
2579 dbglog("socket(AF_IPX): %m (%d)", errno);
2583 memset (&ifr, '\0', sizeof (ifr));
2584 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2586 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2587 sipx->sipx_family = AF_IPX;
2588 sipx->sipx_port = 0;
2589 sipx->sipx_network = htonl (network);
2590 sipx->sipx_type = IPX_FRAME_ETHERII;
2591 sipx->sipx_action = IPX_CRTITF;
2593 * Set the IPX device
2595 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2597 if (errno != EEXIST) {
2598 if (! ok_error (errno))
2599 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2602 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2611 /********************************************************************
2613 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2614 * are removed and the device is no longer able to pass IPX
2618 int cipxfaddr (int unit)
2625 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2627 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2629 if (! ok_error (errno))
2630 dbglog("socket(AF_IPX): %m (%d)", errno);
2634 memset (&ifr, '\0', sizeof (ifr));
2635 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2637 sipx->sipx_type = IPX_FRAME_ETHERII;
2638 sipx->sipx_action = IPX_DLTITF;
2639 sipx->sipx_family = AF_IPX;
2641 * Set the IPX device
2643 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2644 if (! ok_error (errno))
2645 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2655 * Use the hostname as part of the random number seed.
2664 for (p = hostname; *p != 0; ++p)
2669 /********************************************************************
2671 * sys_check_options - check the options that the user specified
2675 sys_check_options(void)
2679 * Disable the IPX protocol if the support is not present in the kernel.
2683 if (ipxcp_protent.enabled_flag) {
2684 struct stat stat_buf;
2685 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2686 || lstat(path, &stat_buf) < 0) {
2687 error("IPX support is not present in the kernel\n");
2688 ipxcp_protent.enabled_flag = 0;
2692 if (demand && driver_is_old) {
2693 option_error("demand dialling is not supported by kernel driver "
2694 "version %d.%d.%d", driver_version, driver_modification,
2698 if (multilink && !new_style_driver) {
2699 warn("Warning: multilink is not supported by the kernel driver");