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 fatal("Couldn't create IPv6 socket: %m(%d)", errno);
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");
419 if (!looped && !multilink) {
421 * Create a new PPP unit.
423 if (make_ppp_unit() < 0)
428 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
432 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
433 error("Couldn't attach to PPP unit %d: %m", ifunit);
440 * Old-style driver: find out which interface we were given.
443 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
444 if ( ! ok_error (errno))
445 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
447 /* Check that we got the same unit again. */
448 if (looped && x != ifunit)
449 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
453 * Fetch the initial file flags and reset blocking mode on the file.
455 initfdflags = fcntl(tty_fd, F_GETFL);
456 if (initfdflags == -1 ||
457 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
458 if ( ! ok_error (errno))
459 warn("Couldn't set device to non-blocking mode: %m");
466 * Enable debug in the driver if requested.
469 set_kdebugflag (kdebugflag);
471 set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
472 SC_RCV_EVNP | SC_RCV_ODDP));
474 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
475 driver_version, driver_modification, driver_patch));
482 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
483 warn("Couldn't reset tty to normal line discipline: %m");
487 /********************************************************************
489 * disestablish_ppp - Restore the serial port to normal operation.
490 * This shouldn't call die() because it's called from die().
493 void disestablish_ppp(int tty_fd)
497 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
499 if (tcflush(tty_fd, TCIOFLUSH) < 0)
500 warn("tcflush failed: %m");
502 * Restore the previous line discipline
504 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
505 if ( ! ok_error (errno))
506 error("ioctl(TIOCSETD, N_TTY): %m");
509 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
510 if ( ! ok_error (errno))
511 warn("ioctl(TIOCNXCL): %m(%d)", errno);
514 /* Reset non-blocking mode on fd. */
515 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
516 if ( ! ok_error (errno))
517 warn("Couldn't restore device fd flags: %m");
522 if (new_style_driver) {
525 if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
526 error("Couldn't release PPP unit: %m");
528 remove_fd(ppp_dev_fd);
533 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
534 * Assumes new_style_driver.
536 static int make_ppp_unit()
541 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
542 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
543 warn("Couldn't allocate PPP unit %d as it is already in use");
545 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
548 error("Couldn't create new ppp unit: %m");
553 * make_new_bundle - create a new PPP unit (i.e. a bundle)
554 * and connect our channel to it. This should only get called
555 * if `multilink' was set at the time establish_ppp was called.
557 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
562 if (looped || !new_style_driver)
564 dbglog("make_new_bundle(%d,%d,%d,%d)", mrru, mtru, rssn, tssn);
566 /* make us a ppp unit */
567 if (make_ppp_unit() < 0)
570 /* set the mrru, mtu and flags */
571 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
572 error("Couldn't set MRRU: %m");
573 flags = get_flags(ppp_dev_fd);
574 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
575 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0);
577 if (mtru > 0 && mtru != link_mtu) {
578 memset(&ifr, 0, sizeof(ifr));
579 slprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ppp%d", ifunit);
581 if (ioctl(sock_fd, SIOCSIFMTU, &ifr) < 0)
582 error("Couldn't set interface MTU: %m");
583 flags |= SC_MULTILINK;
586 set_flags(ppp_dev_fd, flags);
588 /* connect up the channel */
589 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
590 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
595 * bundle_attach - attach our link to a given PPP unit.
597 int bundle_attach(int ifnum)
599 if (!new_style_driver)
602 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
604 return 0; /* doesn't still exist */
605 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
607 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
608 fatal("Couldn't connect to interface unit %d: %m", ifnum);
609 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
612 dbglog("bundle_attach succeeded");
616 /********************************************************************
618 * clean_check - Fetch the flags for the device and generate
619 * appropriate error messages.
621 void clean_check(void)
627 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
629 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
631 s = "all had bit 7 set to 1";
635 s = "all had bit 7 set to 0";
639 s = "all had odd parity";
643 s = "all had even parity";
648 warn("Receive serial link is not 8-bit clean:");
649 warn("Problem: %s", s);
657 * List of valid speeds.
661 int speed_int, speed_val;
738 /********************************************************************
740 * Translate from bits/second to a speed_t.
743 static int translate_speed (int bps)
745 struct speed *speedp;
748 for (speedp = speeds; speedp->speed_int; speedp++) {
749 if (bps == speedp->speed_int)
750 return speedp->speed_val;
752 warn("speed %d not supported", bps);
757 /********************************************************************
759 * Translate from a speed_t to bits/second.
762 static int baud_rate_of (int speed)
764 struct speed *speedp;
767 for (speedp = speeds; speedp->speed_int; speedp++) {
768 if (speed == speedp->speed_val)
769 return speedp->speed_int;
775 /********************************************************************
777 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
778 * at the requested speed, etc. If `local' is true, set CLOCAL
779 * regardless of whether the modem option was specified.
782 void set_up_tty(int tty_fd, int local)
788 if (tcgetattr(tty_fd, &tios) < 0) {
789 if (!ok_error(errno))
790 fatal("tcgetattr: %m(%d)", errno);
797 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
798 tios.c_cflag |= CS8 | CREAD | HUPCL;
800 tios.c_iflag = IGNBRK | IGNPAR;
804 tios.c_cc[VTIME] = 0;
807 tios.c_cflag ^= (CLOCAL | HUPCL);
811 tios.c_cflag |= CRTSCTS;
815 tios.c_iflag |= IXON | IXOFF;
816 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
817 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
821 tios.c_cflag &= ~CRTSCTS;
828 speed = translate_speed(inspeed);
830 cfsetospeed (&tios, speed);
831 cfsetispeed (&tios, speed);
834 * We can't proceed if the serial port speed is B0,
835 * since that implies that the serial port is disabled.
838 speed = cfgetospeed(&tios);
840 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
843 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
844 if (!ok_error(errno))
845 fatal("tcsetattr: %m");
847 baud_rate = baud_rate_of(speed);
851 /********************************************************************
853 * setdtr - control the DTR line on the serial port.
854 * This is called from die(), so it shouldn't call die().
857 void setdtr (int tty_fd, int on)
859 int modembits = TIOCM_DTR;
861 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
864 /********************************************************************
866 * restore_tty - restore the terminal to the saved settings.
869 void restore_tty (int tty_fd)
874 * Turn off echoing, because otherwise we can get into
875 * a loop with the tty and the modem echoing to each other.
876 * We presume we are the sole user of this tty device, so
877 * when we close it, it will revert to its defaults anyway.
880 inittermios.c_lflag &= ~(ECHO | ECHONL);
882 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
883 if (! ok_error (errno))
884 warn("tcsetattr: %m");
889 /********************************************************************
891 * output - Output PPP packet.
894 void output (int unit, unsigned char *p, int len)
900 dbglog("sent %P", p, len);
902 if (len < PPP_HDRLEN)
904 if (new_style_driver) {
907 proto = (p[0] << 8) + p[1];
908 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
911 if (write(fd, p, len) < 0) {
912 if (errno == EWOULDBLOCK || errno == ENOBUFS
913 || errno == ENXIO || errno == EIO || errno == EINTR)
914 warn("write: warning: %m (%d)", errno);
916 error("write: %m (%d)", errno);
920 /********************************************************************
922 * wait_input - wait until there is data available,
923 * for the length of time specified by *timo (indefinite
927 void wait_input(struct timeval *timo)
934 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
935 if (n < 0 && errno != EINTR)
936 fatal("select: %m(%d)", errno);
940 * add_fd - add an fd to the set that wait_input waits for.
950 * remove_fd - remove an fd from the set that wait_input waits for.
952 void remove_fd(int fd)
958 /********************************************************************
960 * read_packet - get a PPP packet from the serial device.
963 int read_packet (unsigned char *buf)
967 len = PPP_MRU + PPP_HDRLEN;
968 if (new_style_driver) {
969 *buf++ = PPP_ALLSTATIONS;
975 nr = read(ppp_fd, buf, len);
976 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
979 if (nr < 0 && new_style_driver && ifunit >= 0) {
980 /* N.B. we read ppp_fd first since LCP packets come in there. */
981 nr = read(ppp_dev_fd, buf, len);
982 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
983 error("read /dev/ppp: %m");
985 return (new_style_driver && nr > 0)? nr+2: nr;
988 /********************************************************************
990 * get_loop_output - get outgoing packets from the ppp device,
991 * and detect when we want to bring the real link up.
992 * Return value is 1 if we need to bring up the link, 0 otherwise.
995 get_loop_output(void)
1000 if (new_style_driver) {
1001 while ((n = read_packet(inpacket_buf)) > 0)
1002 if (loop_frame(inpacket_buf, n))
1007 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1008 if (loop_chars(inbuf, n))
1012 fatal("eof on loopback");
1014 if (errno != EWOULDBLOCK)
1015 fatal("read from loopback: %m(%d)", errno);
1020 /********************************************************************
1022 * ppp_send_config - configure the transmit characteristics of
1023 * the ppp interface.
1026 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1031 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
1033 * Set the MTU and other parameters for the ppp device
1035 memset (&ifr, '\0', sizeof (ifr));
1036 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1039 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1040 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
1045 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1046 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1047 if (!ok_error(errno))
1048 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1052 x = get_flags(ppp_fd);
1053 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1054 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1055 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1056 set_flags(ppp_fd, x);
1059 /********************************************************************
1061 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1064 void ppp_set_xaccm (int unit, ext_accm accm)
1066 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1067 accm[0], accm[1], accm[2], accm[3]));
1071 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1072 if ( ! ok_error (errno))
1073 warn("ioctl(set extended ACCM): %m(%d)", errno);
1077 /********************************************************************
1079 * ppp_recv_config - configure the receive-side characteristics of
1080 * the ppp interface.
1083 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1085 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1087 * If we were called because the link has gone down then there is nothing
1088 * which may be done. Just return without incident.
1093 * Set the receiver parameters
1095 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1096 if ( ! ok_error (errno))
1097 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1099 if (new_style_driver && ifunit >= 0
1100 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1101 error("Couldn't set MRU in generic PPP layer: %m");
1103 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1104 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1105 if (!ok_error(errno))
1106 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1110 /********************************************************************
1112 * ccp_test - ask kernel whether a given compression method
1113 * is acceptable for use.
1116 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1118 struct ppp_option_data data;
1120 memset (&data, '\0', sizeof (data));
1122 data.length = opt_len;
1123 data.transmit = for_transmit;
1125 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1128 return (errno == ENOBUFS)? 0: -1;
1131 /********************************************************************
1133 * ccp_flags_set - inform kernel about the current state of CCP.
1136 void ccp_flags_set (int unit, int isopen, int isup)
1139 int x = get_flags(ppp_dev_fd);
1140 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1141 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1142 set_flags (ppp_dev_fd, x);
1146 /********************************************************************
1148 * get_idle_time - return how long the link has been idle.
1151 get_idle_time(u, ip)
1153 struct ppp_idle *ip;
1155 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1158 /********************************************************************
1160 * get_ppp_stats - return statistics for the link.
1163 get_ppp_stats(u, stats)
1165 struct pppd_stats *stats;
1167 struct ifpppstatsreq req;
1169 memset (&req, 0, sizeof (req));
1171 req.stats_ptr = (caddr_t) &req.stats;
1172 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1173 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1174 error("Couldn't get PPP statistics: %m");
1177 stats->bytes_in = req.stats.p.ppp_ibytes;
1178 stats->bytes_out = req.stats.p.ppp_obytes;
1182 /********************************************************************
1184 * ccp_fatal_error - returns 1 if decompression was disabled as a
1185 * result of an error detected after decompression of a packet,
1186 * 0 otherwise. This is necessary because of patent nonsense.
1189 int ccp_fatal_error (int unit)
1191 int x = get_flags(ppp_dev_fd);
1193 return x & SC_DC_FERROR;
1196 /********************************************************************
1198 * path_to_procfs - find the path to the proc file system mount point
1200 static char proc_path[MAXPATHLEN];
1201 static int proc_path_len;
1203 static char *path_to_procfs(const char *tail)
1205 struct mntent *mntent;
1208 if (proc_path_len == 0) {
1209 /* Default the mount location of /proc */
1210 strlcpy (proc_path, "/proc", sizeof(proc_path));
1212 fp = fopen(MOUNTED, "r");
1214 while ((mntent = getmntent(fp)) != NULL) {
1215 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1217 if (strcmp(mntent->mnt_type, "proc") == 0) {
1218 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1219 proc_path_len = strlen(proc_path);
1227 strlcpy(proc_path + proc_path_len, tail,
1228 sizeof(proc_path) - proc_path_len);
1233 * /proc/net/route parsing stuff.
1235 #define ROUTE_MAX_COLS 12
1236 FILE *route_fd = (FILE *) 0;
1237 static char route_buffer[512];
1238 static int route_dev_col, route_dest_col, route_gw_col;
1239 static int route_flags_col, route_mask_col;
1240 static int route_num_cols;
1242 static int open_route_table (void);
1243 static void close_route_table (void);
1244 static int read_route_table (struct rtentry *rt);
1246 /********************************************************************
1248 * close_route_table - close the interface to the route table
1251 static void close_route_table (void)
1253 if (route_fd != (FILE *) 0) {
1255 route_fd = (FILE *) 0;
1259 /********************************************************************
1261 * open_route_table - open the interface to the route table
1263 static char route_delims[] = " \t\n";
1265 static int open_route_table (void)
1269 close_route_table();
1271 path = path_to_procfs("/net/route");
1272 route_fd = fopen (path, "r");
1273 if (route_fd == NULL) {
1274 error("can't open routing table %s: %m", path);
1278 route_dev_col = 0; /* default to usual columns */
1281 route_flags_col = 3;
1285 /* parse header line */
1286 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1287 char *p = route_buffer, *q;
1289 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1291 if ((q = strtok(p, route_delims)) == 0)
1293 if (strcasecmp(q, "iface") == 0)
1294 route_dev_col = col;
1295 else if (strcasecmp(q, "destination") == 0)
1296 route_dest_col = col;
1297 else if (strcasecmp(q, "gateway") == 0)
1299 else if (strcasecmp(q, "flags") == 0)
1300 route_flags_col = col;
1301 else if (strcasecmp(q, "mask") == 0)
1302 route_mask_col = col;
1305 if (used && col >= route_num_cols)
1306 route_num_cols = col + 1;
1314 /********************************************************************
1316 * read_route_table - read the next entry from the route table
1319 static int read_route_table(struct rtentry *rt)
1321 char *cols[ROUTE_MAX_COLS], *p;
1324 memset (rt, '\0', sizeof (struct rtentry));
1326 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1330 for (col = 0; col < route_num_cols; ++col) {
1331 cols[col] = strtok(p, route_delims);
1332 if (cols[col] == NULL)
1333 return 0; /* didn't get enough columns */
1337 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1338 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1339 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1341 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1342 rt->rt_dev = cols[route_dev_col];
1347 /********************************************************************
1349 * defaultroute_exists - determine if there is a default route
1352 static int defaultroute_exists (struct rtentry *rt)
1356 if (!open_route_table())
1359 while (read_route_table(rt) != 0) {
1360 if ((rt->rt_flags & RTF_UP) == 0)
1363 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1365 if (SIN_ADDR(rt->rt_dst) == 0L) {
1371 close_route_table();
1376 * have_route_to - determine if the system has any route to
1377 * a given IP address. `addr' is in network byte order.
1378 * Return value is 1 if yes, 0 if no, -1 if don't know.
1379 * For demand mode to work properly, we have to ignore routes
1380 * through our own interface.
1382 int have_route_to(u_int32_t addr)
1387 if (!open_route_table())
1388 return -1; /* don't know */
1390 while (read_route_table(&rt)) {
1391 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1393 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1399 close_route_table();
1403 /********************************************************************
1405 * sifdefaultroute - assign a default route through the address given.
1408 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1412 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1413 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1415 if (old_gateway != gateway)
1416 error("not replacing existing default route to %s [%I]",
1417 rt.rt_dev, old_gateway);
1421 memset (&rt, '\0', sizeof (rt));
1422 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1423 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1425 if (kernel_version > KVERSION(2,1,0)) {
1426 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1427 SIN_ADDR(rt.rt_genmask) = 0L;
1430 SIN_ADDR(rt.rt_gateway) = gateway;
1432 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1433 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1434 if ( ! ok_error ( errno ))
1435 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1439 default_route_gateway = gateway;
1443 /********************************************************************
1445 * cifdefaultroute - delete a default route through the address given.
1448 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1452 default_route_gateway = 0;
1454 memset (&rt, '\0', sizeof (rt));
1455 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1456 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1458 if (kernel_version > KVERSION(2,1,0)) {
1459 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1460 SIN_ADDR(rt.rt_genmask) = 0L;
1463 SIN_ADDR(rt.rt_gateway) = gateway;
1465 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1466 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1468 if ( ! ok_error ( errno ))
1469 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1477 /********************************************************************
1479 * sifproxyarp - Make a proxy ARP entry for the peer.
1482 int sifproxyarp (int unit, u_int32_t his_adr)
1484 struct arpreq arpreq;
1487 if (has_proxy_arp == 0) {
1488 memset (&arpreq, '\0', sizeof(arpreq));
1490 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1491 SIN_ADDR(arpreq.arp_pa) = his_adr;
1492 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1494 * Get the hardware address of an interface on the same subnet
1495 * as our local address.
1497 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1498 sizeof(proxy_arp_dev))) {
1499 error("Cannot determine ethernet address for proxy ARP");
1502 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1504 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1505 if ( ! ok_error ( errno ))
1506 error("ioctl(SIOCSARP): %m(%d)", errno);
1509 proxy_arp_addr = his_adr;
1513 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1514 if (forw_path != 0) {
1515 int fd = open(forw_path, O_WRONLY);
1517 if (write(fd, "1", 1) != 1)
1518 error("Couldn't enable IP forwarding: %m");
1528 /********************************************************************
1530 * cifproxyarp - Delete the proxy ARP entry for the peer.
1533 int cifproxyarp (int unit, u_int32_t his_adr)
1535 struct arpreq arpreq;
1537 if (has_proxy_arp) {
1539 memset (&arpreq, '\0', sizeof(arpreq));
1540 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1541 SIN_ADDR(arpreq.arp_pa) = his_adr;
1542 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1543 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1545 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1546 if ( ! ok_error ( errno ))
1547 warn("ioctl(SIOCDARP): %m(%d)", errno);
1554 /********************************************************************
1556 * get_ether_addr - get the hardware address of an interface on the
1557 * the same subnet as ipaddr.
1560 static int get_ether_addr (u_int32_t ipaddr,
1561 struct sockaddr *hwaddr,
1562 char *name, int namelen)
1564 struct ifreq *ifr, *ifend;
1565 u_int32_t ina, mask;
1569 struct ifreq ifs[MAX_IFS];
1571 ifc.ifc_len = sizeof(ifs);
1573 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1574 if ( ! ok_error ( errno ))
1575 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1579 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1580 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1582 * Scan through looking for an interface with an Internet
1583 * address on the same subnet as `ipaddr'.
1585 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1586 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1587 if (ifr->ifr_addr.sa_family == AF_INET) {
1588 ina = SIN_ADDR(ifr->ifr_addr);
1589 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1590 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1593 * Check that the interface is up, and not point-to-point
1596 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1599 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1602 * Get its netmask and check that it's on the right subnet.
1604 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1607 mask = SIN_ADDR(ifreq.ifr_addr);
1608 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1609 ip_ntoa(ina), ntohl(mask)));
1611 if (((ipaddr ^ ina) & mask) != 0)
1620 strlcpy(name, ifreq.ifr_name, namelen);
1622 /* trim off the :1 in eth0:1 */
1623 aliasp = strchr(name, ':');
1627 info("found interface %s for proxy arp", name);
1629 * Now get the hardware address.
1631 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1632 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1633 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1639 sizeof (struct sockaddr));
1641 SYSDEBUG ((LOG_DEBUG,
1642 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1643 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1644 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1645 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1646 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1647 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1648 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1649 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1650 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1655 * get_if_hwaddr - get the hardware address for the specified
1656 * network interface device.
1659 get_if_hwaddr(u_char *addr, char *name)
1664 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1667 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1668 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1669 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1672 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1677 * get_first_ethernet - return the name of the first ethernet-style
1678 * interface on this system.
1681 get_first_ethernet()
1686 /********************************************************************
1688 * Return user specified netmask, modified by any mask we might determine
1689 * for address `addr' (in network byte order).
1690 * Here we scan through the system's list of interfaces, looking for
1691 * any non-point-to-point interfaces which might appear to be on the same
1692 * network as `addr'. If we find any, we OR in their netmask to the
1693 * user-specified netmask.
1696 u_int32_t GetMask (u_int32_t addr)
1698 u_int32_t mask, nmask, ina;
1699 struct ifreq *ifr, *ifend, ifreq;
1701 struct ifreq ifs[MAX_IFS];
1705 if (IN_CLASSA(addr)) /* determine network mask for address class */
1706 nmask = IN_CLASSA_NET;
1707 else if (IN_CLASSB(addr))
1708 nmask = IN_CLASSB_NET;
1710 nmask = IN_CLASSC_NET;
1712 /* class D nets are disallowed by bad_ip_adrs */
1713 mask = netmask | htonl(nmask);
1715 * Scan through the system's network interfaces.
1717 ifc.ifc_len = sizeof(ifs);
1719 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1720 if ( ! ok_error ( errno ))
1721 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1725 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1726 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1728 * Check the interface's internet address.
1730 if (ifr->ifr_addr.sa_family != AF_INET)
1732 ina = SIN_ADDR(ifr->ifr_addr);
1733 if (((ntohl(ina) ^ addr) & nmask) != 0)
1736 * Check that the interface is up, and not point-to-point nor loopback.
1738 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1739 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1742 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1745 * Get its netmask and OR it into our mask.
1747 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1749 mask |= SIN_ADDR(ifreq.ifr_addr);
1755 /********************************************************************
1757 * Internal routine to decode the version.modification.patch level
1760 static void decode_version (char *buf, int *version,
1761 int *modification, int *patch)
1763 *version = (int) strtoul (buf, &buf, 10);
1769 *modification = (int) strtoul (buf, &buf, 10);
1772 *patch = (int) strtoul (buf, &buf, 10);
1783 /********************************************************************
1785 * Procedure to determine if the PPP line discipline is registered.
1789 ppp_registered(void)
1797 * We used to open the serial device and set it to the ppp line
1798 * discipline here, in order to create a ppp unit. But that is
1799 * not a good idea - the user might have specified a device that
1800 * they can't open (permission, or maybe it doesn't really exist).
1801 * So we grab a pty master/slave pair and use that.
1803 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1804 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1809 * Try to put the device into the PPP discipline.
1811 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1812 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1821 /********************************************************************
1823 * ppp_available - check whether the system has any ppp interfaces
1824 * (in fact we check whether we can do an ioctl on ppp0).
1827 int ppp_available(void)
1832 int my_version, my_modification, my_patch;
1833 int osmaj, osmin, ospatch;
1836 "This system lacks kernel support for PPP. This could be because\n"
1837 "the PPP kernel module could not be loaded, or because PPP was not\n"
1838 "included in the kernel configuration. If PPP was included as a\n"
1839 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1840 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1841 "See README.linux file in the ppp distribution for more details.\n";
1843 /* get the kernel version now, since we are called before sys_init */
1845 osmaj = osmin = ospatch = 0;
1846 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1847 kernel_version = KVERSION(osmaj, osmin, ospatch);
1849 if (kernel_version >= KVERSION(2,3,13)) {
1850 fd = open("/dev/ppp", O_RDWR);
1852 if (fd < 0 && errno == ENOENT) {
1853 /* try making it and see if that helps. */
1854 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1855 makedev(108, 0)) >= 0) {
1856 fd = open("/dev/ppp", O_RDWR);
1858 info("Created /dev/ppp device node");
1860 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1861 } else if (errno == EEXIST) {
1862 fd = open("/dev/ppp", O_RDWR);
1867 new_style_driver = 1;
1869 /* XXX should get from driver */
1871 driver_modification = 4;
1880 * Open a socket for doing the ioctl operations.
1882 s = socket(AF_INET, SOCK_DGRAM, 0);
1886 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1887 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1889 * If the device did not exist then attempt to create one by putting the
1890 * current tty into the PPP discipline. If this works then obtain the
1891 * flags for the device again.
1894 if (ppp_registered()) {
1895 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1896 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1900 * Ensure that the hardware address is for PPP and not something else
1903 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1905 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1909 * This is the PPP device. Validate the version of the driver at this
1910 * point to ensure that this program will work with the driver.
1913 char abBuffer [1024];
1915 ifr.ifr_data = abBuffer;
1916 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1918 error("Couldn't read driver version: %m");
1920 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1923 decode_version(abBuffer,
1925 &driver_modification,
1928 * Validate the version of the driver against the version that we used.
1930 decode_version(VERSION,
1935 /* The version numbers must match */
1936 if (driver_version != my_version)
1939 /* The modification levels must be legal */
1940 if (driver_modification < 3) {
1941 if (driver_modification >= 2) {
1942 /* we can cope with 2.2.0 and above */
1951 slprintf(route_buffer, sizeof(route_buffer),
1952 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1953 driver_version, driver_modification, driver_patch);
1955 no_ppp_msg = route_buffer;
1962 /********************************************************************
1964 * Update the wtmp file with the appropriate user name and tty device.
1967 void logwtmp (const char *line, const char *name, const char *host)
1969 struct utmp ut, *utp;
1970 pid_t mypid = getpid();
1976 * Update the signon database for users.
1977 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1979 utmpname(_PATH_UTMP);
1981 while ((utp = getutent()) && (utp->ut_pid != mypid))
1984 /* Is this call really necessary? There is another one after the 'put' */
1988 memcpy(&ut, utp, sizeof(ut));
1990 /* some gettys/telnetds don't initialize utmp... */
1991 memset(&ut, 0, sizeof(ut));
1993 if (ut.ut_id[0] == 0)
1994 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1996 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1997 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2001 ut.ut_type = USER_PROCESS;
2004 /* Insert the host name if one is supplied */
2006 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2008 /* Insert the IP address of the remote system if IP is enabled */
2009 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2010 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2011 sizeof(ut.ut_addr));
2013 /* CL: Makes sure that the logout works */
2014 if (*host == 0 && *name==0)
2020 * Update the wtmp file.
2023 updwtmp(_PATH_WTMP, &ut);
2025 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2027 flock(wtmp, LOCK_EX);
2029 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2030 warn("error writing %s: %m", _PATH_WTMP);
2032 flock(wtmp, LOCK_UN);
2040 /********************************************************************
2042 * sifvjcomp - config tcp header compression
2045 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2047 u_int x = get_flags(ppp_dev_fd);
2050 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2051 if (! ok_error (errno))
2052 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2057 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2058 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2059 set_flags (ppp_dev_fd, x);
2064 /********************************************************************
2066 * sifup - Config the interface up and enable IP packets to pass.
2073 memset (&ifr, '\0', sizeof (ifr));
2074 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2075 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2076 if (! ok_error (errno))
2077 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2081 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2082 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2083 if (! ok_error (errno))
2084 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2092 /********************************************************************
2094 * sifdown - Disable the indicated protocol and config the interface
2095 * down if there are no remaining protocols.
2102 if (if_is_up && --if_is_up > 0)
2105 memset (&ifr, '\0', sizeof (ifr));
2106 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2107 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2108 if (! ok_error (errno))
2109 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2113 ifr.ifr_flags &= ~IFF_UP;
2114 ifr.ifr_flags |= IFF_POINTOPOINT;
2115 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2116 if (! ok_error (errno))
2117 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2123 /********************************************************************
2125 * sifaddr - Config the interface IP addresses and netmask.
2128 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2134 memset (&ifr, '\0', sizeof (ifr));
2135 memset (&rt, '\0', sizeof (rt));
2137 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2138 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2139 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2141 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2143 * Set our IP address
2145 SIN_ADDR(ifr.ifr_addr) = our_adr;
2146 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2147 if (errno != EEXIST) {
2148 if (! ok_error (errno))
2149 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2152 warn("ioctl(SIOCSIFADDR): Address already exists");
2157 * Set the gateway address
2159 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2160 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2161 if (! ok_error (errno))
2162 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2167 * For recent kernels, force the netmask to 255.255.255.255.
2169 if (kernel_version >= KVERSION(2,1,16))
2171 if (net_mask != 0) {
2172 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2173 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2174 if (! ok_error (errno))
2175 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2180 * Add the device route
2182 if (kernel_version < KVERSION(2,1,16)) {
2183 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2184 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2187 SIN_ADDR(rt.rt_gateway) = 0L;
2188 SIN_ADDR(rt.rt_dst) = his_adr;
2189 rt.rt_flags = RTF_UP | RTF_HOST;
2191 if (kernel_version > KVERSION(2,1,0)) {
2192 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2193 SIN_ADDR(rt.rt_genmask) = -1L;
2196 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2197 if (! ok_error (errno))
2198 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2203 /* set ip_dynaddr in demand mode if address changes */
2204 if (demand && tune_kernel && !dynaddr_set
2205 && our_old_addr && our_old_addr != our_adr) {
2206 /* set ip_dynaddr if possible */
2210 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2211 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2212 if (write(fd, "1", 1) != 1)
2213 error("Couldn't enable dynamic IP addressing: %m");
2216 dynaddr_set = 1; /* only 1 attempt */
2223 /********************************************************************
2225 * cifaddr - Clear the interface IP addresses, and delete routes
2226 * through the interface if possible.
2229 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2233 if (kernel_version < KVERSION(2,1,16)) {
2235 * Delete the route through the device
2238 memset (&rt, '\0', sizeof (rt));
2240 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2241 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2244 SIN_ADDR(rt.rt_gateway) = 0;
2245 SIN_ADDR(rt.rt_dst) = his_adr;
2246 rt.rt_flags = RTF_UP | RTF_HOST;
2248 if (kernel_version > KVERSION(2,1,0)) {
2249 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2250 SIN_ADDR(rt.rt_genmask) = -1L;
2253 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2254 if (still_ppp() && ! ok_error (errno))
2255 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2260 /* This way it is possible to have an IPX-only or IPv6-only interface */
2261 memset(&ifr, 0, sizeof(ifr));
2262 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2263 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2265 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2266 if (! ok_error (errno)) {
2267 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2272 our_old_addr = our_adr;
2278 /********************************************************************
2280 * sif6addr - Config the interface with an IPv6 link-local address
2282 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2284 struct in6_ifreq ifr6;
2286 struct in6_rtmsg rt6;
2288 memset(&ifr, 0, sizeof (ifr));
2289 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2290 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2291 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2295 /* Local interface */
2296 memset(&ifr6, 0, sizeof(ifr6));
2297 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2298 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2299 ifr6.ifr6_prefixlen = 10;
2301 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2302 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2306 /* Route to remote host */
2307 memset(&rt6, 0, sizeof(rt6));
2308 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2309 rt6.rtmsg_flags = RTF_UP;
2310 rt6.rtmsg_dst_len = 10;
2311 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2312 rt6.rtmsg_metric = 1;
2314 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2315 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2323 /********************************************************************
2325 * cif6addr - Remove IPv6 address from interface
2327 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2330 struct in6_ifreq ifr6;
2332 memset(&ifr, 0, sizeof(ifr));
2333 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2334 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2335 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2339 memset(&ifr6, 0, sizeof(ifr6));
2340 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2341 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2342 ifr6.ifr6_prefixlen = 10;
2344 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2345 if (errno != EADDRNOTAVAIL) {
2346 if (! ok_error (errno))
2347 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2350 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2359 * get_pty - get a pty master/slave pair and chown the slave side
2360 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2363 get_pty(master_fdp, slave_fdp, slave_name, uid)
2369 int i, mfd, sfd = -1;
2371 struct termios tios;
2375 * Try the unix98 way first.
2377 mfd = open("/dev/ptmx", O_RDWR);
2380 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2381 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2382 chmod(pty_name, S_IRUSR | S_IWUSR);
2385 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2386 warn("Couldn't unlock pty slave %s: %m", pty_name);
2388 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2389 warn("Couldn't open pty slave %s: %m", pty_name);
2392 #endif /* TIOCGPTN */
2395 /* the old way - scan through the pty name space */
2396 for (i = 0; i < 64; ++i) {
2397 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2398 'p' + i / 16, i % 16);
2399 mfd = open(pty_name, O_RDWR, 0);
2402 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2404 fchown(sfd, uid, -1);
2405 fchmod(sfd, S_IRUSR | S_IWUSR);
2416 strlcpy(slave_name, pty_name, 16);
2419 if (tcgetattr(sfd, &tios) == 0) {
2420 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2421 tios.c_cflag |= CS8 | CREAD;
2422 tios.c_iflag = IGNPAR | CLOCAL;
2425 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2426 warn("couldn't set attributes on pty: %m");
2428 warn("couldn't get attributes on pty: %m");
2433 /********************************************************************
2435 * open_loopback - open the device we use for getting packets
2436 * in demand mode. Under Linux, we use a pty master/slave pair.
2439 open_ppp_loopback(void)
2444 if (new_style_driver) {
2445 /* allocate ourselves a ppp unit */
2446 if (make_ppp_unit() < 0)
2448 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2449 set_kdebugflag(kdebugflag);
2454 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2455 fatal("No free pty for loopback");
2456 SYSDEBUG(("using %s for loopback", loop_name));
2458 set_ppp_fd(slave_fd);
2460 flags = fcntl(master_fd, F_GETFL);
2462 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2463 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2465 flags = fcntl(ppp_fd, F_GETFL);
2467 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2468 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2470 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2471 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2473 * Find out which interface we were given.
2475 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2476 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2478 * Enable debug in the driver if requested.
2480 set_kdebugflag (kdebugflag);
2485 /********************************************************************
2487 * restore_loop - reattach the ppp unit to the loopback.
2489 * The kernel ppp driver automatically reattaches the ppp unit to
2490 * the loopback if the serial port is set to a line discipline other
2491 * than ppp, or if it detects a modem hangup. The former will happen
2492 * in disestablish_ppp if the latter hasn't already happened, so we
2493 * shouldn't need to do anything.
2495 * Just to be sure, set the real serial port to the normal discipline.
2502 if (new_style_driver) {
2503 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2506 if (ppp_fd != slave_fd) {
2507 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2508 set_ppp_fd(slave_fd);
2512 /********************************************************************
2514 * sifnpmode - Set the mode for handling packets for a given NP.
2518 sifnpmode(u, proto, mode)
2525 npi.protocol = proto;
2527 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2528 if (! ok_error (errno))
2529 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2530 proto, mode, errno);
2537 /********************************************************************
2539 * sipxfaddr - Config the interface IPX networknumber
2542 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2549 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2551 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2553 if (! ok_error (errno))
2554 dbglog("socket(AF_IPX): %m (%d)", errno);
2558 memset (&ifr, '\0', sizeof (ifr));
2559 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2561 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2562 sipx->sipx_family = AF_IPX;
2563 sipx->sipx_port = 0;
2564 sipx->sipx_network = htonl (network);
2565 sipx->sipx_type = IPX_FRAME_ETHERII;
2566 sipx->sipx_action = IPX_CRTITF;
2568 * Set the IPX device
2570 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2572 if (errno != EEXIST) {
2573 if (! ok_error (errno))
2574 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2577 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2586 /********************************************************************
2588 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2589 * are removed and the device is no longer able to pass IPX
2593 int cipxfaddr (int unit)
2600 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2602 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2604 if (! ok_error (errno))
2605 dbglog("socket(AF_IPX): %m (%d)", errno);
2609 memset (&ifr, '\0', sizeof (ifr));
2610 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2612 sipx->sipx_type = IPX_FRAME_ETHERII;
2613 sipx->sipx_action = IPX_DLTITF;
2614 sipx->sipx_family = AF_IPX;
2616 * Set the IPX device
2618 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2619 if (! ok_error (errno))
2620 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2630 * Use the hostname as part of the random number seed.
2639 for (p = hostname; *p != 0; ++p)
2644 /********************************************************************
2646 * sys_check_options - check the options that the user specified
2650 sys_check_options(void)
2654 * Disable the IPX protocol if the support is not present in the kernel.
2658 if (ipxcp_protent.enabled_flag) {
2659 struct stat stat_buf;
2660 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2661 || lstat(path, &stat_buf) < 0) {
2662 error("IPX support is not present in the kernel\n");
2663 ipxcp_protent.enabled_flag = 0;
2667 if (demand && driver_is_old) {
2668 option_error("demand dialling is not supported by kernel driver "
2669 "version %d.%d.%d", driver_version, driver_modification,
2673 if (multilink && !new_style_driver) {
2674 option_error("multilink is not supported by the kernel driver");