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");
418 if (!looped && !multilink) {
420 * Create a new PPP unit.
422 if (make_ppp_unit() < 0)
427 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
431 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
432 error("Couldn't attach to PPP unit %d: %m", ifunit);
439 * Old-style driver: find out which interface we were given.
442 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
443 if ( ! ok_error (errno))
444 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
446 /* Check that we got the same unit again. */
447 if (looped && x != ifunit)
448 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
452 * Fetch the initial file flags and reset blocking mode on the file.
454 initfdflags = fcntl(tty_fd, F_GETFL);
455 if (initfdflags == -1 ||
456 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
457 if ( ! ok_error (errno))
458 warn("Couldn't set device to non-blocking mode: %m");
465 * Enable debug in the driver if requested.
468 set_kdebugflag (kdebugflag);
470 set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
471 SC_RCV_EVNP | SC_RCV_ODDP));
473 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
474 driver_version, driver_modification, driver_patch));
481 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
482 warn("Couldn't reset tty to normal line discipline: %m");
486 /********************************************************************
488 * disestablish_ppp - Restore the serial port to normal operation.
489 * This shouldn't call die() because it's called from die().
492 void disestablish_ppp(int tty_fd)
496 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
498 if (tcflush(tty_fd, TCIOFLUSH) < 0)
499 warn("tcflush failed: %m");
501 * Restore the previous line discipline
503 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
504 if ( ! ok_error (errno))
505 error("ioctl(TIOCSETD, N_TTY): %m");
508 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
509 if ( ! ok_error (errno))
510 warn("ioctl(TIOCNXCL): %m(%d)", errno);
513 /* Reset non-blocking mode on fd. */
514 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
515 if ( ! ok_error (errno))
516 warn("Couldn't restore device fd flags: %m");
521 if (new_style_driver) {
524 if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
525 error("Couldn't release PPP unit: %m");
527 remove_fd(ppp_dev_fd);
532 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
533 * Assumes new_style_driver.
535 static int make_ppp_unit()
540 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
541 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
542 warn("Couldn't allocate PPP unit %d as it is already in use");
544 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
547 error("Couldn't create new ppp unit: %m");
552 * cfg_bundle - configure the existing bundle.
553 * Used in demand mode.
555 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
560 if (!new_style_driver)
563 /* set the mrru, mtu and flags */
564 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
565 error("Couldn't set MRRU: %m");
566 flags = get_flags(ppp_dev_fd);
567 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
568 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0);
570 if (mtru > 0 && mtru != link_mtu) {
571 memset(&ifr, 0, sizeof(ifr));
572 slprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ppp%d", ifunit);
574 if (ioctl(sock_fd, SIOCSIFMTU, &ifr) < 0)
575 error("Couldn't set interface MTU: %m");
576 flags |= SC_MULTILINK;
579 set_flags(ppp_dev_fd, flags);
581 /* connect up the channel */
582 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
583 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
588 * make_new_bundle - create a new PPP unit (i.e. a bundle)
589 * and connect our channel to it. This should only get called
590 * if `multilink' was set at the time establish_ppp was called.
591 * In demand mode this uses our existing bundle instead of making
594 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
596 if (!new_style_driver)
599 /* make us a ppp unit */
600 if (make_ppp_unit() < 0)
603 /* set the mrru, mtu and flags */
604 cfg_bundle(mrru, mtru, rssn, tssn);
608 * bundle_attach - attach our link to a given PPP unit.
609 * We assume the unit is controlled by another pppd.
611 int bundle_attach(int ifnum)
613 if (!new_style_driver)
616 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
618 return 0; /* doesn't still exist */
619 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
621 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
622 fatal("Couldn't connect to interface unit %d: %m", ifnum);
623 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
629 /********************************************************************
631 * clean_check - Fetch the flags for the device and generate
632 * appropriate error messages.
634 void clean_check(void)
640 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
642 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
644 s = "all had bit 7 set to 1";
648 s = "all had bit 7 set to 0";
652 s = "all had odd parity";
656 s = "all had even parity";
661 warn("Receive serial link is not 8-bit clean:");
662 warn("Problem: %s", s);
670 * List of valid speeds.
674 int speed_int, speed_val;
751 /********************************************************************
753 * Translate from bits/second to a speed_t.
756 static int translate_speed (int bps)
758 struct speed *speedp;
761 for (speedp = speeds; speedp->speed_int; speedp++) {
762 if (bps == speedp->speed_int)
763 return speedp->speed_val;
765 warn("speed %d not supported", bps);
770 /********************************************************************
772 * Translate from a speed_t to bits/second.
775 static int baud_rate_of (int speed)
777 struct speed *speedp;
780 for (speedp = speeds; speedp->speed_int; speedp++) {
781 if (speed == speedp->speed_val)
782 return speedp->speed_int;
788 /********************************************************************
790 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
791 * at the requested speed, etc. If `local' is true, set CLOCAL
792 * regardless of whether the modem option was specified.
795 void set_up_tty(int tty_fd, int local)
801 if (tcgetattr(tty_fd, &tios) < 0) {
802 if (!ok_error(errno))
803 fatal("tcgetattr: %m(%d)", errno);
810 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
811 tios.c_cflag |= CS8 | CREAD | HUPCL;
813 tios.c_iflag = IGNBRK | IGNPAR;
817 tios.c_cc[VTIME] = 0;
820 tios.c_cflag ^= (CLOCAL | HUPCL);
824 tios.c_cflag |= CRTSCTS;
828 tios.c_iflag |= IXON | IXOFF;
829 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
830 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
834 tios.c_cflag &= ~CRTSCTS;
841 speed = translate_speed(inspeed);
843 cfsetospeed (&tios, speed);
844 cfsetispeed (&tios, speed);
847 * We can't proceed if the serial port speed is B0,
848 * since that implies that the serial port is disabled.
851 speed = cfgetospeed(&tios);
853 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
856 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
857 if (!ok_error(errno))
858 fatal("tcsetattr: %m");
860 baud_rate = baud_rate_of(speed);
864 /********************************************************************
866 * setdtr - control the DTR line on the serial port.
867 * This is called from die(), so it shouldn't call die().
870 void setdtr (int tty_fd, int on)
872 int modembits = TIOCM_DTR;
874 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
877 /********************************************************************
879 * restore_tty - restore the terminal to the saved settings.
882 void restore_tty (int tty_fd)
887 * Turn off echoing, because otherwise we can get into
888 * a loop with the tty and the modem echoing to each other.
889 * We presume we are the sole user of this tty device, so
890 * when we close it, it will revert to its defaults anyway.
893 inittermios.c_lflag &= ~(ECHO | ECHONL);
895 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
896 if (! ok_error (errno))
897 warn("tcsetattr: %m");
902 /********************************************************************
904 * output - Output PPP packet.
907 void output (int unit, unsigned char *p, int len)
913 dbglog("sent %P", p, len);
915 if (len < PPP_HDRLEN)
917 if (new_style_driver) {
920 proto = (p[0] << 8) + p[1];
921 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
924 if (write(fd, p, len) < 0) {
925 if (errno == EWOULDBLOCK || errno == ENOBUFS
926 || errno == ENXIO || errno == EIO || errno == EINTR)
927 warn("write: warning: %m (%d)", errno);
929 error("write: %m (%d)", errno);
933 /********************************************************************
935 * wait_input - wait until there is data available,
936 * for the length of time specified by *timo (indefinite
940 void wait_input(struct timeval *timo)
947 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
948 if (n < 0 && errno != EINTR)
949 fatal("select: %m(%d)", errno);
953 * add_fd - add an fd to the set that wait_input waits for.
963 * remove_fd - remove an fd from the set that wait_input waits for.
965 void remove_fd(int fd)
971 /********************************************************************
973 * read_packet - get a PPP packet from the serial device.
976 int read_packet (unsigned char *buf)
980 len = PPP_MRU + PPP_HDRLEN;
981 if (new_style_driver) {
982 *buf++ = PPP_ALLSTATIONS;
988 nr = read(ppp_fd, buf, len);
989 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
992 if (nr < 0 && new_style_driver && ifunit >= 0) {
993 /* N.B. we read ppp_fd first since LCP packets come in there. */
994 nr = read(ppp_dev_fd, buf, len);
995 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
996 error("read /dev/ppp: %m");
998 return (new_style_driver && nr > 0)? nr+2: nr;
1001 /********************************************************************
1003 * get_loop_output - get outgoing packets from the ppp device,
1004 * and detect when we want to bring the real link up.
1005 * Return value is 1 if we need to bring up the link, 0 otherwise.
1008 get_loop_output(void)
1013 if (new_style_driver) {
1014 while ((n = read_packet(inpacket_buf)) > 0)
1015 if (loop_frame(inpacket_buf, n))
1020 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1021 if (loop_chars(inbuf, n))
1025 fatal("eof on loopback");
1027 if (errno != EWOULDBLOCK)
1028 fatal("read from loopback: %m(%d)", errno);
1033 /********************************************************************
1035 * ppp_send_config - configure the transmit characteristics of
1036 * the ppp interface.
1039 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1044 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
1046 * Set the MTU and other parameters for the ppp device
1048 memset (&ifr, '\0', sizeof (ifr));
1049 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1052 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1053 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
1058 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1059 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1060 if (!ok_error(errno))
1061 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1065 x = get_flags(ppp_fd);
1066 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1067 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1068 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1069 set_flags(ppp_fd, x);
1072 /********************************************************************
1074 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1077 void ppp_set_xaccm (int unit, ext_accm accm)
1079 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1080 accm[0], accm[1], accm[2], accm[3]));
1084 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1085 if ( ! ok_error (errno))
1086 warn("ioctl(set extended ACCM): %m(%d)", errno);
1090 /********************************************************************
1092 * ppp_recv_config - configure the receive-side characteristics of
1093 * the ppp interface.
1096 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1098 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1100 * If we were called because the link has gone down then there is nothing
1101 * which may be done. Just return without incident.
1106 * Set the receiver parameters
1108 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1109 if ( ! ok_error (errno))
1110 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1112 if (new_style_driver && ifunit >= 0
1113 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1114 error("Couldn't set MRU in generic PPP layer: %m");
1116 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1117 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1118 if (!ok_error(errno))
1119 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1123 /********************************************************************
1125 * ccp_test - ask kernel whether a given compression method
1126 * is acceptable for use.
1129 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1131 struct ppp_option_data data;
1133 memset (&data, '\0', sizeof (data));
1135 data.length = opt_len;
1136 data.transmit = for_transmit;
1138 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1141 return (errno == ENOBUFS)? 0: -1;
1144 /********************************************************************
1146 * ccp_flags_set - inform kernel about the current state of CCP.
1149 void ccp_flags_set (int unit, int isopen, int isup)
1152 int x = get_flags(ppp_dev_fd);
1153 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1154 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1155 set_flags (ppp_dev_fd, x);
1159 /********************************************************************
1161 * get_idle_time - return how long the link has been idle.
1164 get_idle_time(u, ip)
1166 struct ppp_idle *ip;
1168 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1171 /********************************************************************
1173 * get_ppp_stats - return statistics for the link.
1176 get_ppp_stats(u, stats)
1178 struct pppd_stats *stats;
1180 struct ifpppstatsreq req;
1182 memset (&req, 0, sizeof (req));
1184 req.stats_ptr = (caddr_t) &req.stats;
1185 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1186 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1187 error("Couldn't get PPP statistics: %m");
1190 stats->bytes_in = req.stats.p.ppp_ibytes;
1191 stats->bytes_out = req.stats.p.ppp_obytes;
1195 /********************************************************************
1197 * ccp_fatal_error - returns 1 if decompression was disabled as a
1198 * result of an error detected after decompression of a packet,
1199 * 0 otherwise. This is necessary because of patent nonsense.
1202 int ccp_fatal_error (int unit)
1204 int x = get_flags(ppp_dev_fd);
1206 return x & SC_DC_FERROR;
1209 /********************************************************************
1211 * path_to_procfs - find the path to the proc file system mount point
1213 static char proc_path[MAXPATHLEN];
1214 static int proc_path_len;
1216 static char *path_to_procfs(const char *tail)
1218 struct mntent *mntent;
1221 if (proc_path_len == 0) {
1222 /* Default the mount location of /proc */
1223 strlcpy (proc_path, "/proc", sizeof(proc_path));
1225 fp = fopen(MOUNTED, "r");
1227 while ((mntent = getmntent(fp)) != NULL) {
1228 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1230 if (strcmp(mntent->mnt_type, "proc") == 0) {
1231 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1232 proc_path_len = strlen(proc_path);
1240 strlcpy(proc_path + proc_path_len, tail,
1241 sizeof(proc_path) - proc_path_len);
1246 * /proc/net/route parsing stuff.
1248 #define ROUTE_MAX_COLS 12
1249 FILE *route_fd = (FILE *) 0;
1250 static char route_buffer[512];
1251 static int route_dev_col, route_dest_col, route_gw_col;
1252 static int route_flags_col, route_mask_col;
1253 static int route_num_cols;
1255 static int open_route_table (void);
1256 static void close_route_table (void);
1257 static int read_route_table (struct rtentry *rt);
1259 /********************************************************************
1261 * close_route_table - close the interface to the route table
1264 static void close_route_table (void)
1266 if (route_fd != (FILE *) 0) {
1268 route_fd = (FILE *) 0;
1272 /********************************************************************
1274 * open_route_table - open the interface to the route table
1276 static char route_delims[] = " \t\n";
1278 static int open_route_table (void)
1282 close_route_table();
1284 path = path_to_procfs("/net/route");
1285 route_fd = fopen (path, "r");
1286 if (route_fd == NULL) {
1287 error("can't open routing table %s: %m", path);
1291 route_dev_col = 0; /* default to usual columns */
1294 route_flags_col = 3;
1298 /* parse header line */
1299 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1300 char *p = route_buffer, *q;
1302 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1304 if ((q = strtok(p, route_delims)) == 0)
1306 if (strcasecmp(q, "iface") == 0)
1307 route_dev_col = col;
1308 else if (strcasecmp(q, "destination") == 0)
1309 route_dest_col = col;
1310 else if (strcasecmp(q, "gateway") == 0)
1312 else if (strcasecmp(q, "flags") == 0)
1313 route_flags_col = col;
1314 else if (strcasecmp(q, "mask") == 0)
1315 route_mask_col = col;
1318 if (used && col >= route_num_cols)
1319 route_num_cols = col + 1;
1327 /********************************************************************
1329 * read_route_table - read the next entry from the route table
1332 static int read_route_table(struct rtentry *rt)
1334 char *cols[ROUTE_MAX_COLS], *p;
1337 memset (rt, '\0', sizeof (struct rtentry));
1339 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1343 for (col = 0; col < route_num_cols; ++col) {
1344 cols[col] = strtok(p, route_delims);
1345 if (cols[col] == NULL)
1346 return 0; /* didn't get enough columns */
1350 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1351 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1352 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1354 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1355 rt->rt_dev = cols[route_dev_col];
1360 /********************************************************************
1362 * defaultroute_exists - determine if there is a default route
1365 static int defaultroute_exists (struct rtentry *rt)
1369 if (!open_route_table())
1372 while (read_route_table(rt) != 0) {
1373 if ((rt->rt_flags & RTF_UP) == 0)
1376 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1378 if (SIN_ADDR(rt->rt_dst) == 0L) {
1384 close_route_table();
1389 * have_route_to - determine if the system has any route to
1390 * a given IP address. `addr' is in network byte order.
1391 * Return value is 1 if yes, 0 if no, -1 if don't know.
1392 * For demand mode to work properly, we have to ignore routes
1393 * through our own interface.
1395 int have_route_to(u_int32_t addr)
1400 if (!open_route_table())
1401 return -1; /* don't know */
1403 while (read_route_table(&rt)) {
1404 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1406 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1412 close_route_table();
1416 /********************************************************************
1418 * sifdefaultroute - assign a default route through the address given.
1421 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1425 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1426 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1428 if (old_gateway != gateway)
1429 error("not replacing existing default route to %s [%I]",
1430 rt.rt_dev, old_gateway);
1434 memset (&rt, '\0', sizeof (rt));
1435 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1436 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1438 if (kernel_version > KVERSION(2,1,0)) {
1439 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1440 SIN_ADDR(rt.rt_genmask) = 0L;
1443 SIN_ADDR(rt.rt_gateway) = gateway;
1445 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1446 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1447 if ( ! ok_error ( errno ))
1448 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1452 default_route_gateway = gateway;
1456 /********************************************************************
1458 * cifdefaultroute - delete a default route through the address given.
1461 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1465 default_route_gateway = 0;
1467 memset (&rt, '\0', sizeof (rt));
1468 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1469 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1471 if (kernel_version > KVERSION(2,1,0)) {
1472 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1473 SIN_ADDR(rt.rt_genmask) = 0L;
1476 SIN_ADDR(rt.rt_gateway) = gateway;
1478 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1479 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1481 if ( ! ok_error ( errno ))
1482 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1490 /********************************************************************
1492 * sifproxyarp - Make a proxy ARP entry for the peer.
1495 int sifproxyarp (int unit, u_int32_t his_adr)
1497 struct arpreq arpreq;
1500 if (has_proxy_arp == 0) {
1501 memset (&arpreq, '\0', sizeof(arpreq));
1503 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1504 SIN_ADDR(arpreq.arp_pa) = his_adr;
1505 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1507 * Get the hardware address of an interface on the same subnet
1508 * as our local address.
1510 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1511 sizeof(proxy_arp_dev))) {
1512 error("Cannot determine ethernet address for proxy ARP");
1515 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1517 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1518 if ( ! ok_error ( errno ))
1519 error("ioctl(SIOCSARP): %m(%d)", errno);
1522 proxy_arp_addr = his_adr;
1526 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1527 if (forw_path != 0) {
1528 int fd = open(forw_path, O_WRONLY);
1530 if (write(fd, "1", 1) != 1)
1531 error("Couldn't enable IP forwarding: %m");
1541 /********************************************************************
1543 * cifproxyarp - Delete the proxy ARP entry for the peer.
1546 int cifproxyarp (int unit, u_int32_t his_adr)
1548 struct arpreq arpreq;
1550 if (has_proxy_arp) {
1552 memset (&arpreq, '\0', sizeof(arpreq));
1553 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1554 SIN_ADDR(arpreq.arp_pa) = his_adr;
1555 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1556 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1558 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1559 if ( ! ok_error ( errno ))
1560 warn("ioctl(SIOCDARP): %m(%d)", errno);
1567 /********************************************************************
1569 * get_ether_addr - get the hardware address of an interface on the
1570 * the same subnet as ipaddr.
1573 static int get_ether_addr (u_int32_t ipaddr,
1574 struct sockaddr *hwaddr,
1575 char *name, int namelen)
1577 struct ifreq *ifr, *ifend;
1578 u_int32_t ina, mask;
1582 struct ifreq ifs[MAX_IFS];
1584 ifc.ifc_len = sizeof(ifs);
1586 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1587 if ( ! ok_error ( errno ))
1588 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1592 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1593 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1595 * Scan through looking for an interface with an Internet
1596 * address on the same subnet as `ipaddr'.
1598 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1599 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1600 if (ifr->ifr_addr.sa_family == AF_INET) {
1601 ina = SIN_ADDR(ifr->ifr_addr);
1602 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1603 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1606 * Check that the interface is up, and not point-to-point
1609 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1612 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1615 * Get its netmask and check that it's on the right subnet.
1617 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1620 mask = SIN_ADDR(ifreq.ifr_addr);
1621 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1622 ip_ntoa(ina), ntohl(mask)));
1624 if (((ipaddr ^ ina) & mask) != 0)
1633 strlcpy(name, ifreq.ifr_name, namelen);
1635 /* trim off the :1 in eth0:1 */
1636 aliasp = strchr(name, ':');
1640 info("found interface %s for proxy arp", name);
1642 * Now get the hardware address.
1644 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1645 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1646 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1652 sizeof (struct sockaddr));
1654 SYSDEBUG ((LOG_DEBUG,
1655 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1656 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1657 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1658 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1659 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1660 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1661 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1662 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1663 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1668 * get_if_hwaddr - get the hardware address for the specified
1669 * network interface device.
1672 get_if_hwaddr(u_char *addr, char *name)
1677 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1680 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1681 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1682 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1685 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1690 * get_first_ethernet - return the name of the first ethernet-style
1691 * interface on this system.
1694 get_first_ethernet()
1699 /********************************************************************
1701 * Return user specified netmask, modified by any mask we might determine
1702 * for address `addr' (in network byte order).
1703 * Here we scan through the system's list of interfaces, looking for
1704 * any non-point-to-point interfaces which might appear to be on the same
1705 * network as `addr'. If we find any, we OR in their netmask to the
1706 * user-specified netmask.
1709 u_int32_t GetMask (u_int32_t addr)
1711 u_int32_t mask, nmask, ina;
1712 struct ifreq *ifr, *ifend, ifreq;
1714 struct ifreq ifs[MAX_IFS];
1718 if (IN_CLASSA(addr)) /* determine network mask for address class */
1719 nmask = IN_CLASSA_NET;
1720 else if (IN_CLASSB(addr))
1721 nmask = IN_CLASSB_NET;
1723 nmask = IN_CLASSC_NET;
1725 /* class D nets are disallowed by bad_ip_adrs */
1726 mask = netmask | htonl(nmask);
1728 * Scan through the system's network interfaces.
1730 ifc.ifc_len = sizeof(ifs);
1732 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1733 if ( ! ok_error ( errno ))
1734 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1738 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1739 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1741 * Check the interface's internet address.
1743 if (ifr->ifr_addr.sa_family != AF_INET)
1745 ina = SIN_ADDR(ifr->ifr_addr);
1746 if (((ntohl(ina) ^ addr) & nmask) != 0)
1749 * Check that the interface is up, and not point-to-point nor loopback.
1751 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1752 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1755 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1758 * Get its netmask and OR it into our mask.
1760 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1762 mask |= SIN_ADDR(ifreq.ifr_addr);
1768 /********************************************************************
1770 * Internal routine to decode the version.modification.patch level
1773 static void decode_version (char *buf, int *version,
1774 int *modification, int *patch)
1776 *version = (int) strtoul (buf, &buf, 10);
1782 *modification = (int) strtoul (buf, &buf, 10);
1785 *patch = (int) strtoul (buf, &buf, 10);
1796 /********************************************************************
1798 * Procedure to determine if the PPP line discipline is registered.
1802 ppp_registered(void)
1810 * We used to open the serial device and set it to the ppp line
1811 * discipline here, in order to create a ppp unit. But that is
1812 * not a good idea - the user might have specified a device that
1813 * they can't open (permission, or maybe it doesn't really exist).
1814 * So we grab a pty master/slave pair and use that.
1816 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1817 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1822 * Try to put the device into the PPP discipline.
1824 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1825 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1834 /********************************************************************
1836 * ppp_available - check whether the system has any ppp interfaces
1837 * (in fact we check whether we can do an ioctl on ppp0).
1840 int ppp_available(void)
1845 int my_version, my_modification, my_patch;
1846 int osmaj, osmin, ospatch;
1849 "This system lacks kernel support for PPP. This could be because\n"
1850 "the PPP kernel module could not be loaded, or because PPP was not\n"
1851 "included in the kernel configuration. If PPP was included as a\n"
1852 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1853 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1854 "See README.linux file in the ppp distribution for more details.\n";
1856 /* get the kernel version now, since we are called before sys_init */
1858 osmaj = osmin = ospatch = 0;
1859 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1860 kernel_version = KVERSION(osmaj, osmin, ospatch);
1862 fd = open("/dev/ppp", O_RDWR);
1864 if (fd < 0 && errno == ENOENT) {
1865 /* try making it and see if that helps. */
1866 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1867 makedev(108, 0)) >= 0) {
1868 fd = open("/dev/ppp", O_RDWR);
1870 info("Created /dev/ppp device node");
1872 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1873 } else if (errno == EEXIST) {
1874 fd = open("/dev/ppp", O_RDWR);
1879 new_style_driver = 1;
1881 /* XXX should get from driver */
1883 driver_modification = 4;
1888 if (kernel_version >= KVERSION(2,3,13))
1892 * Open a socket for doing the ioctl operations.
1894 s = socket(AF_INET, SOCK_DGRAM, 0);
1898 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1899 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1901 * If the device did not exist then attempt to create one by putting the
1902 * current tty into the PPP discipline. If this works then obtain the
1903 * flags for the device again.
1906 if (ppp_registered()) {
1907 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1908 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1912 * Ensure that the hardware address is for PPP and not something else
1915 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1917 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1921 * This is the PPP device. Validate the version of the driver at this
1922 * point to ensure that this program will work with the driver.
1925 char abBuffer [1024];
1927 ifr.ifr_data = abBuffer;
1928 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1930 error("Couldn't read driver version: %m");
1932 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1935 decode_version(abBuffer,
1937 &driver_modification,
1940 * Validate the version of the driver against the version that we used.
1942 decode_version(VERSION,
1947 /* The version numbers must match */
1948 if (driver_version != my_version)
1951 /* The modification levels must be legal */
1952 if (driver_modification < 3) {
1953 if (driver_modification >= 2) {
1954 /* we can cope with 2.2.0 and above */
1963 slprintf(route_buffer, sizeof(route_buffer),
1964 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1965 driver_version, driver_modification, driver_patch);
1967 no_ppp_msg = route_buffer;
1974 /********************************************************************
1976 * Update the wtmp file with the appropriate user name and tty device.
1979 void logwtmp (const char *line, const char *name, const char *host)
1981 struct utmp ut, *utp;
1982 pid_t mypid = getpid();
1988 * Update the signon database for users.
1989 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1991 utmpname(_PATH_UTMP);
1993 while ((utp = getutent()) && (utp->ut_pid != mypid))
1996 /* Is this call really necessary? There is another one after the 'put' */
2000 memcpy(&ut, utp, sizeof(ut));
2002 /* some gettys/telnetds don't initialize utmp... */
2003 memset(&ut, 0, sizeof(ut));
2005 if (ut.ut_id[0] == 0)
2006 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2008 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2009 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2013 ut.ut_type = USER_PROCESS;
2016 /* Insert the host name if one is supplied */
2018 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2020 /* Insert the IP address of the remote system if IP is enabled */
2021 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2022 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2023 sizeof(ut.ut_addr));
2025 /* CL: Makes sure that the logout works */
2026 if (*host == 0 && *name==0)
2032 * Update the wtmp file.
2035 updwtmp(_PATH_WTMP, &ut);
2037 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2039 flock(wtmp, LOCK_EX);
2041 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2042 warn("error writing %s: %m", _PATH_WTMP);
2044 flock(wtmp, LOCK_UN);
2052 /********************************************************************
2054 * sifvjcomp - config tcp header compression
2057 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2059 u_int x = get_flags(ppp_dev_fd);
2062 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2063 if (! ok_error (errno))
2064 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2069 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2070 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2071 set_flags (ppp_dev_fd, x);
2076 /********************************************************************
2078 * sifup - Config the interface up and enable IP packets to pass.
2085 memset (&ifr, '\0', sizeof (ifr));
2086 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2087 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2088 if (! ok_error (errno))
2089 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2093 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2094 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2095 if (! ok_error (errno))
2096 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2104 /********************************************************************
2106 * sifdown - Disable the indicated protocol and config the interface
2107 * down if there are no remaining protocols.
2114 if (if_is_up && --if_is_up > 0)
2117 memset (&ifr, '\0', sizeof (ifr));
2118 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2119 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2120 if (! ok_error (errno))
2121 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2125 ifr.ifr_flags &= ~IFF_UP;
2126 ifr.ifr_flags |= IFF_POINTOPOINT;
2127 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2128 if (! ok_error (errno))
2129 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2135 /********************************************************************
2137 * sifaddr - Config the interface IP addresses and netmask.
2140 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2146 memset (&ifr, '\0', sizeof (ifr));
2147 memset (&rt, '\0', sizeof (rt));
2149 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2150 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2151 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2153 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2155 * Set our IP address
2157 SIN_ADDR(ifr.ifr_addr) = our_adr;
2158 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2159 if (errno != EEXIST) {
2160 if (! ok_error (errno))
2161 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2164 warn("ioctl(SIOCSIFADDR): Address already exists");
2169 * Set the gateway address
2171 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2172 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2173 if (! ok_error (errno))
2174 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2179 * For recent kernels, force the netmask to 255.255.255.255.
2181 if (kernel_version >= KVERSION(2,1,16))
2183 if (net_mask != 0) {
2184 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2185 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2186 if (! ok_error (errno))
2187 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2192 * Add the device route
2194 if (kernel_version < KVERSION(2,1,16)) {
2195 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2196 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2199 SIN_ADDR(rt.rt_gateway) = 0L;
2200 SIN_ADDR(rt.rt_dst) = his_adr;
2201 rt.rt_flags = RTF_UP | RTF_HOST;
2203 if (kernel_version > KVERSION(2,1,0)) {
2204 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2205 SIN_ADDR(rt.rt_genmask) = -1L;
2208 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2209 if (! ok_error (errno))
2210 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2215 /* set ip_dynaddr in demand mode if address changes */
2216 if (demand && tune_kernel && !dynaddr_set
2217 && our_old_addr && our_old_addr != our_adr) {
2218 /* set ip_dynaddr if possible */
2222 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2223 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2224 if (write(fd, "1", 1) != 1)
2225 error("Couldn't enable dynamic IP addressing: %m");
2228 dynaddr_set = 1; /* only 1 attempt */
2235 /********************************************************************
2237 * cifaddr - Clear the interface IP addresses, and delete routes
2238 * through the interface if possible.
2241 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2245 if (kernel_version < KVERSION(2,1,16)) {
2247 * Delete the route through the device
2250 memset (&rt, '\0', sizeof (rt));
2252 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2253 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2256 SIN_ADDR(rt.rt_gateway) = 0;
2257 SIN_ADDR(rt.rt_dst) = his_adr;
2258 rt.rt_flags = RTF_UP | RTF_HOST;
2260 if (kernel_version > KVERSION(2,1,0)) {
2261 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2262 SIN_ADDR(rt.rt_genmask) = -1L;
2265 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2266 if (still_ppp() && ! ok_error (errno))
2267 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2272 /* This way it is possible to have an IPX-only or IPv6-only interface */
2273 memset(&ifr, 0, sizeof(ifr));
2274 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2275 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2277 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2278 if (! ok_error (errno)) {
2279 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2284 our_old_addr = our_adr;
2290 /********************************************************************
2292 * sif6addr - Config the interface with an IPv6 link-local address
2294 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2296 struct in6_ifreq ifr6;
2298 struct in6_rtmsg rt6;
2300 memset(&ifr, 0, sizeof (ifr));
2301 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2302 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2303 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2307 /* Local interface */
2308 memset(&ifr6, 0, sizeof(ifr6));
2309 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2310 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2311 ifr6.ifr6_prefixlen = 10;
2313 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2314 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2318 /* Route to remote host */
2319 memset(&rt6, 0, sizeof(rt6));
2320 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2321 rt6.rtmsg_flags = RTF_UP;
2322 rt6.rtmsg_dst_len = 10;
2323 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2324 rt6.rtmsg_metric = 1;
2326 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2327 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2335 /********************************************************************
2337 * cif6addr - Remove IPv6 address from interface
2339 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2342 struct in6_ifreq ifr6;
2344 memset(&ifr, 0, sizeof(ifr));
2345 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2346 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2347 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2351 memset(&ifr6, 0, sizeof(ifr6));
2352 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2353 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2354 ifr6.ifr6_prefixlen = 10;
2356 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2357 if (errno != EADDRNOTAVAIL) {
2358 if (! ok_error (errno))
2359 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2362 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2371 * get_pty - get a pty master/slave pair and chown the slave side
2372 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2375 get_pty(master_fdp, slave_fdp, slave_name, uid)
2381 int i, mfd, sfd = -1;
2383 struct termios tios;
2387 * Try the unix98 way first.
2389 mfd = open("/dev/ptmx", O_RDWR);
2392 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2393 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2394 chmod(pty_name, S_IRUSR | S_IWUSR);
2397 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2398 warn("Couldn't unlock pty slave %s: %m", pty_name);
2400 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2401 warn("Couldn't open pty slave %s: %m", pty_name);
2404 #endif /* TIOCGPTN */
2407 /* the old way - scan through the pty name space */
2408 for (i = 0; i < 64; ++i) {
2409 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2410 'p' + i / 16, i % 16);
2411 mfd = open(pty_name, O_RDWR, 0);
2414 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2416 fchown(sfd, uid, -1);
2417 fchmod(sfd, S_IRUSR | S_IWUSR);
2428 strlcpy(slave_name, pty_name, 16);
2431 if (tcgetattr(sfd, &tios) == 0) {
2432 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2433 tios.c_cflag |= CS8 | CREAD;
2434 tios.c_iflag = IGNPAR | CLOCAL;
2437 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2438 warn("couldn't set attributes on pty: %m");
2440 warn("couldn't get attributes on pty: %m");
2445 /********************************************************************
2447 * open_loopback - open the device we use for getting packets
2448 * in demand mode. Under Linux, we use a pty master/slave pair.
2451 open_ppp_loopback(void)
2456 if (new_style_driver) {
2457 /* allocate ourselves a ppp unit */
2458 if (make_ppp_unit() < 0)
2460 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2461 set_kdebugflag(kdebugflag);
2466 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2467 fatal("No free pty for loopback");
2468 SYSDEBUG(("using %s for loopback", loop_name));
2470 set_ppp_fd(slave_fd);
2472 flags = fcntl(master_fd, F_GETFL);
2474 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2475 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2477 flags = fcntl(ppp_fd, F_GETFL);
2479 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2480 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2482 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2483 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2485 * Find out which interface we were given.
2487 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2488 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2490 * Enable debug in the driver if requested.
2492 set_kdebugflag (kdebugflag);
2497 /********************************************************************
2499 * restore_loop - reattach the ppp unit to the loopback.
2501 * The kernel ppp driver automatically reattaches the ppp unit to
2502 * the loopback if the serial port is set to a line discipline other
2503 * than ppp, or if it detects a modem hangup. The former will happen
2504 * in disestablish_ppp if the latter hasn't already happened, so we
2505 * shouldn't need to do anything.
2507 * Just to be sure, set the real serial port to the normal discipline.
2514 if (new_style_driver) {
2515 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2518 if (ppp_fd != slave_fd) {
2519 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2520 set_ppp_fd(slave_fd);
2524 /********************************************************************
2526 * sifnpmode - Set the mode for handling packets for a given NP.
2530 sifnpmode(u, proto, mode)
2537 npi.protocol = proto;
2539 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2540 if (! ok_error (errno))
2541 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2542 proto, mode, errno);
2549 /********************************************************************
2551 * sipxfaddr - Config the interface IPX networknumber
2554 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2561 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2563 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2565 if (! ok_error (errno))
2566 dbglog("socket(AF_IPX): %m (%d)", errno);
2570 memset (&ifr, '\0', sizeof (ifr));
2571 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2573 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2574 sipx->sipx_family = AF_IPX;
2575 sipx->sipx_port = 0;
2576 sipx->sipx_network = htonl (network);
2577 sipx->sipx_type = IPX_FRAME_ETHERII;
2578 sipx->sipx_action = IPX_CRTITF;
2580 * Set the IPX device
2582 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2584 if (errno != EEXIST) {
2585 if (! ok_error (errno))
2586 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2589 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2598 /********************************************************************
2600 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2601 * are removed and the device is no longer able to pass IPX
2605 int cipxfaddr (int unit)
2612 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2614 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2616 if (! ok_error (errno))
2617 dbglog("socket(AF_IPX): %m (%d)", errno);
2621 memset (&ifr, '\0', sizeof (ifr));
2622 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2624 sipx->sipx_type = IPX_FRAME_ETHERII;
2625 sipx->sipx_action = IPX_DLTITF;
2626 sipx->sipx_family = AF_IPX;
2628 * Set the IPX device
2630 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2631 if (! ok_error (errno))
2632 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2642 * Use the hostname as part of the random number seed.
2651 for (p = hostname; *p != 0; ++p)
2656 /********************************************************************
2658 * sys_check_options - check the options that the user specified
2662 sys_check_options(void)
2666 * Disable the IPX protocol if the support is not present in the kernel.
2670 if (ipxcp_protent.enabled_flag) {
2671 struct stat stat_buf;
2672 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2673 || lstat(path, &stat_buf) < 0) {
2674 error("IPX support is not present in the kernel\n");
2675 ipxcp_protent.enabled_flag = 0;
2679 if (demand && driver_is_old) {
2680 option_error("demand dialling is not supported by kernel driver "
2681 "version %d.%d.%d", driver_version, driver_modification,
2685 if (multilink && !new_style_driver) {
2686 warn("Warning: multilink is not supported by the kernel driver");