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 */
90 #include <linux/filter.h>
91 #endif /* PPP_FILTER */
94 #include <sys/locks.h>
100 * This is in linux/include/net/ipv6.h.
104 struct in6_addr ifr6_addr;
105 __u32 ifr6_prefixlen;
106 unsigned int ifr6_ifindex;
110 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
111 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
112 sin6.s6_addr16[0] = htons(0xfe80); \
113 eui64_copy(eui64, sin6.s6_addr32[2]); \
118 /* We can get an EIO error on an ioctl if the modem has hung up */
119 #define ok_error(num) ((num)==EIO)
121 static int tty_disc = N_TTY; /* The TTY discipline */
122 static int ppp_disc = N_PPP; /* The PPP discpline */
123 static int initfdflags = -1; /* Initial file descriptor flags for fd */
124 static int ppp_fd = -1; /* fd which is set to PPP discipline */
125 static int sock_fd = -1; /* socket for doing interface ioctls */
126 static int slave_fd = -1;
127 static int master_fd = -1;
129 static int sock6_fd = -1;
131 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
132 static int chindex; /* channel index (new style driver) */
134 static fd_set in_fds; /* set of fds that wait_input waits for */
135 static int max_in_fd; /* highest fd set in in_fds */
137 static int has_proxy_arp = 0;
138 static int driver_version = 0;
139 static int driver_modification = 0;
140 static int driver_patch = 0;
141 static int driver_is_old = 0;
142 static int restore_term = 0; /* 1 => we've munged the terminal */
143 static struct termios inittermios; /* Initial TTY termios */
145 static int new_style_driver = 0;
147 static char loop_name[20];
148 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
150 static int if_is_up; /* Interface has been marked up */
151 static u_int32_t default_route_gateway; /* Gateway for default route added */
152 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
153 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
154 static u_int32_t our_old_addr; /* for detecting address changes */
155 static int dynaddr_set; /* 1 if ip_dynaddr set */
156 static int looped; /* 1 if using loop */
157 static int link_mtu; /* mtu for the link (not bundle) */
159 static struct utsname utsname; /* for the kernel version */
160 static int kernel_version;
161 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
165 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
166 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
167 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
169 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
171 /* Prototypes for procedures local to this file. */
172 static int get_flags (int fd);
173 static void set_flags (int fd, int flags);
174 static int translate_speed (int bps);
175 static int baud_rate_of (int speed);
176 static void close_route_table (void);
177 static int open_route_table (void);
178 static int read_route_table (struct rtentry *rt);
179 static int defaultroute_exists (struct rtentry *rt);
180 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
181 char *name, int namelen);
182 static void decode_version (char *buf, int *version, int *mod, int *patch);
183 static int set_kdebugflag(int level);
184 static int ppp_registered(void);
185 static int make_ppp_unit(void);
187 extern u_char inpacket_buf[]; /* borrowed from main.c */
190 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
194 #define SET_SA_FAMILY(addr, family) \
195 memset ((char *) &(addr), '\0', sizeof(addr)); \
196 addr.sa_family = (family);
199 * Determine if the PPP connection should still be present.
204 /* new_fd is the fd of a tty */
205 static void set_ppp_fd (int new_fd)
207 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
209 if (!new_style_driver)
213 static int still_ppp(void)
215 if (new_style_driver)
216 return !hungup && ppp_fd >= 0;
217 if (!hungup || ppp_fd == slave_fd)
220 set_ppp_fd(slave_fd);
226 /********************************************************************
228 * Functions to read and set the flags value in the device driver
231 static int get_flags (int fd)
235 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
236 if ( ok_error (errno) )
239 fatal("ioctl(PPPIOCGFLAGS): %m");
242 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
246 /********************************************************************/
248 static void set_flags (int fd, int flags)
250 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
252 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
253 if (! ok_error (errno) )
254 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
258 /********************************************************************
260 * sys_init - System-dependent initialization.
267 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
268 setlogmask(LOG_UPTO(LOG_INFO));
270 setlogmask(LOG_UPTO(LOG_DEBUG));
272 if (new_style_driver) {
273 ppp_dev_fd = open("/dev/ppp", O_RDWR);
275 fatal("Couldn't open /dev/ppp: %m");
276 flags = fcntl(ppp_dev_fd, F_GETFL);
278 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
279 warn("Couldn't set /dev/ppp to nonblock: %m");
282 /* Get an internet socket for doing socket ioctls. */
283 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
285 fatal("Couldn't create IP socket: %m(%d)", errno);
288 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
290 sock6_fd = -errno; /* save errno for later */
297 /********************************************************************
299 * sys_cleanup - restore any system state we modified before exiting:
300 * mark the interface down, delete default route and/or proxy arp entry.
301 * This shouldn't call die() because it's called from die().
304 void sys_cleanup(void)
307 * Take down the device
314 * Delete any routes through the device.
316 if (default_route_gateway != 0)
317 cifdefaultroute(0, 0, default_route_gateway);
320 cifproxyarp(0, proxy_arp_addr);
323 /********************************************************************
325 * sys_close - Clean up in a child process before execing.
330 if (new_style_driver)
341 /********************************************************************
343 * set_kdebugflag - Define the debugging level for the kernel
346 static int set_kdebugflag (int requested_level)
348 if (new_style_driver && ifunit < 0)
350 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
351 if ( ! ok_error (errno) )
352 error("ioctl(PPPIOCSDEBUG): %m");
355 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
360 /********************************************************************
362 * establish_ppp - Turn the serial port into a ppp interface.
365 int establish_ppp (int tty_fd)
371 * Ensure that the tty device is in exclusive mode.
373 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
374 if ( ! ok_error ( errno ))
375 warn("Couldn't make tty exclusive: %m");
378 * Demand mode - prime the old ppp device to relinquish the unit.
380 if (!new_style_driver && looped
381 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
382 error("ioctl(transfer ppp unit): %m");
386 * Set the current tty to the PPP discpline
390 #define N_SYNC_PPP 14
392 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
393 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
394 if ( ! ok_error (errno) ) {
395 error("Couldn't set tty to PPP discipline: %m");
400 if (new_style_driver) {
401 /* Open another instance of /dev/ppp and connect the channel to it */
404 if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
405 error("Couldn't get channel number: %m");
408 dbglog("using channel %d", chindex);
409 fd = open("/dev/ppp", O_RDWR);
411 error("Couldn't reopen /dev/ppp: %m");
414 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
415 error("Couldn't attach to channel %d: %m", chindex);
418 flags = fcntl(fd, F_GETFL);
419 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
420 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
425 if (!looped && !multilink) {
427 * Create a new PPP unit.
429 if (make_ppp_unit() < 0)
434 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
438 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
439 error("Couldn't attach to PPP unit %d: %m", ifunit);
446 * Old-style driver: find out which interface we were given.
449 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
450 if (ok_error (errno))
452 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
454 /* Check that we got the same unit again. */
455 if (looped && x != ifunit)
456 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
460 * Fetch the initial file flags and reset blocking mode on the file.
462 initfdflags = fcntl(tty_fd, F_GETFL);
463 if (initfdflags == -1 ||
464 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
465 if ( ! ok_error (errno))
466 warn("Couldn't set device to non-blocking mode: %m");
473 * Enable debug in the driver if requested.
476 set_kdebugflag (kdebugflag);
478 set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
479 SC_RCV_EVNP | SC_RCV_ODDP));
481 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
482 driver_version, driver_modification, driver_patch));
489 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
490 warn("Couldn't reset tty to normal line discipline: %m");
494 /********************************************************************
496 * disestablish_ppp - Restore the serial port to normal operation.
497 * This shouldn't call die() because it's called from die().
500 void disestablish_ppp(int tty_fd)
504 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
506 if (tcflush(tty_fd, TCIOFLUSH) < 0)
507 warn("tcflush failed: %m");
509 * Restore the previous line discipline
511 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
512 if ( ! ok_error (errno))
513 error("ioctl(TIOCSETD, N_TTY): %m");
516 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
517 if ( ! ok_error (errno))
518 warn("ioctl(TIOCNXCL): %m(%d)", errno);
521 /* Reset non-blocking mode on fd. */
522 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
523 if ( ! ok_error (errno))
524 warn("Couldn't restore device fd flags: %m");
529 if (new_style_driver) {
532 if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
533 error("Couldn't release PPP unit: %m");
535 remove_fd(ppp_dev_fd);
540 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
541 * Assumes new_style_driver.
543 static int make_ppp_unit()
548 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
549 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
550 warn("Couldn't allocate PPP unit %d as it is already in use");
552 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
555 error("Couldn't create new ppp unit: %m");
560 * cfg_bundle - configure the existing bundle.
561 * Used in demand mode.
563 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
568 if (!new_style_driver)
571 /* set the mrru, mtu and flags */
572 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
573 error("Couldn't set MRRU: %m");
574 flags = get_flags(ppp_dev_fd);
575 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
576 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0);
578 if (mtru > 0 && mtru != link_mtu) {
579 memset(&ifr, 0, sizeof(ifr));
580 slprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ppp%d", ifunit);
582 if (ioctl(sock_fd, SIOCSIFMTU, &ifr) < 0)
583 error("Couldn't set interface MTU: %m");
584 flags |= SC_MULTILINK;
587 set_flags(ppp_dev_fd, flags);
589 /* connect up the channel */
590 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
591 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
596 * make_new_bundle - create a new PPP unit (i.e. a bundle)
597 * and connect our channel to it. This should only get called
598 * if `multilink' was set at the time establish_ppp was called.
599 * In demand mode this uses our existing bundle instead of making
602 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
604 if (!new_style_driver)
607 /* make us a ppp unit */
608 if (make_ppp_unit() < 0)
611 /* set the mrru, mtu and flags */
612 cfg_bundle(mrru, mtru, rssn, tssn);
616 * bundle_attach - attach our link to a given PPP unit.
617 * We assume the unit is controlled by another pppd.
619 int bundle_attach(int ifnum)
621 if (!new_style_driver)
624 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
626 return 0; /* doesn't still exist */
627 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
629 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
630 fatal("Couldn't connect to interface unit %d: %m", ifnum);
631 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
637 /********************************************************************
639 * clean_check - Fetch the flags for the device and generate
640 * appropriate error messages.
642 void clean_check(void)
648 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
650 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
652 s = "all had bit 7 set to 1";
656 s = "all had bit 7 set to 0";
660 s = "all had odd parity";
664 s = "all had even parity";
669 warn("Receive serial link is not 8-bit clean:");
670 warn("Problem: %s", s);
678 * List of valid speeds.
682 int speed_int, speed_val;
765 /********************************************************************
767 * Translate from bits/second to a speed_t.
770 static int translate_speed (int bps)
772 struct speed *speedp;
775 for (speedp = speeds; speedp->speed_int; speedp++) {
776 if (bps == speedp->speed_int)
777 return speedp->speed_val;
779 warn("speed %d not supported", bps);
784 /********************************************************************
786 * Translate from a speed_t to bits/second.
789 static int baud_rate_of (int speed)
791 struct speed *speedp;
794 for (speedp = speeds; speedp->speed_int; speedp++) {
795 if (speed == speedp->speed_val)
796 return speedp->speed_int;
802 /********************************************************************
804 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
805 * at the requested speed, etc. If `local' is true, set CLOCAL
806 * regardless of whether the modem option was specified.
809 void set_up_tty(int tty_fd, int local)
815 if (tcgetattr(tty_fd, &tios) < 0) {
816 if (!ok_error(errno))
817 fatal("tcgetattr: %m(%d)", errno);
824 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
825 tios.c_cflag |= CS8 | CREAD | HUPCL;
827 tios.c_iflag = IGNBRK | IGNPAR;
831 tios.c_cc[VTIME] = 0;
834 tios.c_cflag ^= (CLOCAL | HUPCL);
838 tios.c_cflag |= CRTSCTS;
842 tios.c_iflag |= IXON | IXOFF;
843 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
844 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
848 tios.c_cflag &= ~CRTSCTS;
855 speed = translate_speed(inspeed);
857 cfsetospeed (&tios, speed);
858 cfsetispeed (&tios, speed);
861 * We can't proceed if the serial port speed is B0,
862 * since that implies that the serial port is disabled.
865 speed = cfgetospeed(&tios);
867 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
870 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
871 if (!ok_error(errno))
872 fatal("tcsetattr: %m");
874 baud_rate = baud_rate_of(speed);
878 /********************************************************************
880 * setdtr - control the DTR line on the serial port.
881 * This is called from die(), so it shouldn't call die().
884 void setdtr (int tty_fd, int on)
886 int modembits = TIOCM_DTR;
888 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
891 /********************************************************************
893 * restore_tty - restore the terminal to the saved settings.
896 void restore_tty (int tty_fd)
901 * Turn off echoing, because otherwise we can get into
902 * a loop with the tty and the modem echoing to each other.
903 * We presume we are the sole user of this tty device, so
904 * when we close it, it will revert to its defaults anyway.
907 inittermios.c_lflag &= ~(ECHO | ECHONL);
909 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
910 if (! ok_error (errno))
911 warn("tcsetattr: %m");
916 /********************************************************************
918 * output - Output PPP packet.
921 void output (int unit, unsigned char *p, int len)
927 dbglog("sent %P", p, len);
929 if (len < PPP_HDRLEN)
931 if (new_style_driver) {
934 proto = (p[0] << 8) + p[1];
935 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
938 if (write(fd, p, len) < 0) {
939 if (errno == EWOULDBLOCK || errno == ENOBUFS
940 || errno == ENXIO || errno == EIO || errno == EINTR)
941 warn("write: warning: %m (%d)", errno);
943 error("write: %m (%d)", errno);
947 /********************************************************************
949 * wait_input - wait until there is data available,
950 * for the length of time specified by *timo (indefinite
954 void wait_input(struct timeval *timo)
961 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
962 if (n < 0 && errno != EINTR)
963 fatal("select: %m(%d)", errno);
967 * add_fd - add an fd to the set that wait_input waits for.
977 * remove_fd - remove an fd from the set that wait_input waits for.
979 void remove_fd(int fd)
985 /********************************************************************
987 * read_packet - get a PPP packet from the serial device.
990 int read_packet (unsigned char *buf)
994 len = PPP_MRU + PPP_HDRLEN;
995 if (new_style_driver) {
996 *buf++ = PPP_ALLSTATIONS;
1002 nr = read(ppp_fd, buf, len);
1003 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1006 if (nr < 0 && new_style_driver && ifunit >= 0) {
1007 /* N.B. we read ppp_fd first since LCP packets come in there. */
1008 nr = read(ppp_dev_fd, buf, len);
1009 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1010 error("read /dev/ppp: %m");
1012 return (new_style_driver && nr > 0)? nr+2: nr;
1015 /********************************************************************
1017 * get_loop_output - get outgoing packets from the ppp device,
1018 * and detect when we want to bring the real link up.
1019 * Return value is 1 if we need to bring up the link, 0 otherwise.
1022 get_loop_output(void)
1027 if (new_style_driver) {
1028 while ((n = read_packet(inpacket_buf)) > 0)
1029 if (loop_frame(inpacket_buf, n))
1034 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1035 if (loop_chars(inbuf, n))
1039 fatal("eof on loopback");
1041 if (errno != EWOULDBLOCK)
1042 fatal("read from loopback: %m(%d)", errno);
1047 /********************************************************************
1049 * ppp_send_config - configure the transmit characteristics of
1050 * the ppp interface.
1053 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1058 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
1060 * Set the MTU and other parameters for the ppp device
1062 memset (&ifr, '\0', sizeof (ifr));
1063 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1066 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1067 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
1072 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1073 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1074 if (!ok_error(errno))
1075 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1079 x = get_flags(ppp_fd);
1080 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1081 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1082 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1083 set_flags(ppp_fd, x);
1086 /********************************************************************
1088 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1091 void ppp_set_xaccm (int unit, ext_accm accm)
1093 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1094 accm[0], accm[1], accm[2], accm[3]));
1098 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1099 if ( ! ok_error (errno))
1100 warn("ioctl(set extended ACCM): %m(%d)", errno);
1104 /********************************************************************
1106 * ppp_recv_config - configure the receive-side characteristics of
1107 * the ppp interface.
1110 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1112 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1114 * If we were called because the link has gone down then there is nothing
1115 * which may be done. Just return without incident.
1120 * Set the receiver parameters
1122 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1123 if ( ! ok_error (errno))
1124 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1126 if (new_style_driver && ifunit >= 0
1127 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1128 error("Couldn't set MRU in generic PPP layer: %m");
1130 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1131 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1132 if (!ok_error(errno))
1133 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1137 /********************************************************************
1139 * ccp_test - ask kernel whether a given compression method
1140 * is acceptable for use.
1143 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1145 struct ppp_option_data data;
1147 memset (&data, '\0', sizeof (data));
1149 data.length = opt_len;
1150 data.transmit = for_transmit;
1152 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1155 return (errno == ENOBUFS)? 0: -1;
1158 /********************************************************************
1160 * ccp_flags_set - inform kernel about the current state of CCP.
1163 void ccp_flags_set (int unit, int isopen, int isup)
1166 int x = get_flags(ppp_dev_fd);
1167 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1168 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1169 set_flags (ppp_dev_fd, x);
1175 * set_filters - set the active and pass filters in the kernel driver.
1177 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1179 struct sock_fprog fp;
1181 fp.len = pass->bf_len;
1182 fp.filter = (struct sock_filter *) pass->bf_insns;
1183 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1184 if (errno == ENOTTY)
1185 warn("kernel does not support PPP filtering");
1187 error("Couldn't set pass-filter in kernel: %m");
1190 fp.len = active->bf_len;
1191 fp.filter = (struct sock_filter *) active->bf_insns;
1192 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1193 error("Couldn't set active-filter in kernel: %m");
1198 #endif /* PPP_FILTER */
1200 /********************************************************************
1202 * get_idle_time - return how long the link has been idle.
1205 get_idle_time(u, ip)
1207 struct ppp_idle *ip;
1209 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1212 /********************************************************************
1214 * get_ppp_stats - return statistics for the link.
1217 get_ppp_stats(u, stats)
1219 struct pppd_stats *stats;
1221 struct ifpppstatsreq req;
1223 memset (&req, 0, sizeof (req));
1225 req.stats_ptr = (caddr_t) &req.stats;
1226 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1227 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1228 error("Couldn't get PPP statistics: %m");
1231 stats->bytes_in = req.stats.p.ppp_ibytes;
1232 stats->bytes_out = req.stats.p.ppp_obytes;
1236 /********************************************************************
1238 * ccp_fatal_error - returns 1 if decompression was disabled as a
1239 * result of an error detected after decompression of a packet,
1240 * 0 otherwise. This is necessary because of patent nonsense.
1243 int ccp_fatal_error (int unit)
1245 int x = get_flags(ppp_dev_fd);
1247 return x & SC_DC_FERROR;
1250 /********************************************************************
1252 * path_to_procfs - find the path to the proc file system mount point
1254 static char proc_path[MAXPATHLEN];
1255 static int proc_path_len;
1257 static char *path_to_procfs(const char *tail)
1259 struct mntent *mntent;
1262 if (proc_path_len == 0) {
1263 /* Default the mount location of /proc */
1264 strlcpy (proc_path, "/proc", sizeof(proc_path));
1266 fp = fopen(MOUNTED, "r");
1268 while ((mntent = getmntent(fp)) != NULL) {
1269 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1271 if (strcmp(mntent->mnt_type, "proc") == 0) {
1272 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1273 proc_path_len = strlen(proc_path);
1281 strlcpy(proc_path + proc_path_len, tail,
1282 sizeof(proc_path) - proc_path_len);
1287 * /proc/net/route parsing stuff.
1289 #define ROUTE_MAX_COLS 12
1290 FILE *route_fd = (FILE *) 0;
1291 static char route_buffer[512];
1292 static int route_dev_col, route_dest_col, route_gw_col;
1293 static int route_flags_col, route_mask_col;
1294 static int route_num_cols;
1296 static int open_route_table (void);
1297 static void close_route_table (void);
1298 static int read_route_table (struct rtentry *rt);
1300 /********************************************************************
1302 * close_route_table - close the interface to the route table
1305 static void close_route_table (void)
1307 if (route_fd != (FILE *) 0) {
1309 route_fd = (FILE *) 0;
1313 /********************************************************************
1315 * open_route_table - open the interface to the route table
1317 static char route_delims[] = " \t\n";
1319 static int open_route_table (void)
1323 close_route_table();
1325 path = path_to_procfs("/net/route");
1326 route_fd = fopen (path, "r");
1327 if (route_fd == NULL) {
1328 error("can't open routing table %s: %m", path);
1332 route_dev_col = 0; /* default to usual columns */
1335 route_flags_col = 3;
1339 /* parse header line */
1340 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1341 char *p = route_buffer, *q;
1343 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1345 if ((q = strtok(p, route_delims)) == 0)
1347 if (strcasecmp(q, "iface") == 0)
1348 route_dev_col = col;
1349 else if (strcasecmp(q, "destination") == 0)
1350 route_dest_col = col;
1351 else if (strcasecmp(q, "gateway") == 0)
1353 else if (strcasecmp(q, "flags") == 0)
1354 route_flags_col = col;
1355 else if (strcasecmp(q, "mask") == 0)
1356 route_mask_col = col;
1359 if (used && col >= route_num_cols)
1360 route_num_cols = col + 1;
1368 /********************************************************************
1370 * read_route_table - read the next entry from the route table
1373 static int read_route_table(struct rtentry *rt)
1375 char *cols[ROUTE_MAX_COLS], *p;
1378 memset (rt, '\0', sizeof (struct rtentry));
1380 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1384 for (col = 0; col < route_num_cols; ++col) {
1385 cols[col] = strtok(p, route_delims);
1386 if (cols[col] == NULL)
1387 return 0; /* didn't get enough columns */
1391 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1392 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1393 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1395 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1396 rt->rt_dev = cols[route_dev_col];
1401 /********************************************************************
1403 * defaultroute_exists - determine if there is a default route
1406 static int defaultroute_exists (struct rtentry *rt)
1410 if (!open_route_table())
1413 while (read_route_table(rt) != 0) {
1414 if ((rt->rt_flags & RTF_UP) == 0)
1417 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1419 if (SIN_ADDR(rt->rt_dst) == 0L) {
1425 close_route_table();
1430 * have_route_to - determine if the system has any route to
1431 * a given IP address. `addr' is in network byte order.
1432 * Return value is 1 if yes, 0 if no, -1 if don't know.
1433 * For demand mode to work properly, we have to ignore routes
1434 * through our own interface.
1436 int have_route_to(u_int32_t addr)
1441 if (!open_route_table())
1442 return -1; /* don't know */
1444 while (read_route_table(&rt)) {
1445 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1447 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1453 close_route_table();
1457 /********************************************************************
1459 * sifdefaultroute - assign a default route through the address given.
1462 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1466 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1467 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1469 if (old_gateway != gateway)
1470 error("not replacing existing default route to %s [%I]",
1471 rt.rt_dev, old_gateway);
1475 memset (&rt, '\0', sizeof (rt));
1476 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1477 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1479 if (kernel_version > KVERSION(2,1,0)) {
1480 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1481 SIN_ADDR(rt.rt_genmask) = 0L;
1484 SIN_ADDR(rt.rt_gateway) = gateway;
1486 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1487 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1488 if ( ! ok_error ( errno ))
1489 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1493 default_route_gateway = gateway;
1497 /********************************************************************
1499 * cifdefaultroute - delete a default route through the address given.
1502 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1506 default_route_gateway = 0;
1508 memset (&rt, '\0', sizeof (rt));
1509 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1510 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1512 if (kernel_version > KVERSION(2,1,0)) {
1513 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1514 SIN_ADDR(rt.rt_genmask) = 0L;
1517 SIN_ADDR(rt.rt_gateway) = gateway;
1519 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1520 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1522 if ( ! ok_error ( errno ))
1523 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1531 /********************************************************************
1533 * sifproxyarp - Make a proxy ARP entry for the peer.
1536 int sifproxyarp (int unit, u_int32_t his_adr)
1538 struct arpreq arpreq;
1541 if (has_proxy_arp == 0) {
1542 memset (&arpreq, '\0', sizeof(arpreq));
1544 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1545 SIN_ADDR(arpreq.arp_pa) = his_adr;
1546 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1548 * Get the hardware address of an interface on the same subnet
1549 * as our local address.
1551 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1552 sizeof(proxy_arp_dev))) {
1553 error("Cannot determine ethernet address for proxy ARP");
1556 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1558 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1559 if ( ! ok_error ( errno ))
1560 error("ioctl(SIOCSARP): %m(%d)", errno);
1563 proxy_arp_addr = his_adr;
1567 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1568 if (forw_path != 0) {
1569 int fd = open(forw_path, O_WRONLY);
1571 if (write(fd, "1", 1) != 1)
1572 error("Couldn't enable IP forwarding: %m");
1582 /********************************************************************
1584 * cifproxyarp - Delete the proxy ARP entry for the peer.
1587 int cifproxyarp (int unit, u_int32_t his_adr)
1589 struct arpreq arpreq;
1591 if (has_proxy_arp) {
1593 memset (&arpreq, '\0', sizeof(arpreq));
1594 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1595 SIN_ADDR(arpreq.arp_pa) = his_adr;
1596 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1597 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1599 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1600 if ( ! ok_error ( errno ))
1601 warn("ioctl(SIOCDARP): %m(%d)", errno);
1608 /********************************************************************
1610 * get_ether_addr - get the hardware address of an interface on the
1611 * the same subnet as ipaddr.
1614 static int get_ether_addr (u_int32_t ipaddr,
1615 struct sockaddr *hwaddr,
1616 char *name, int namelen)
1618 struct ifreq *ifr, *ifend;
1619 u_int32_t ina, mask;
1623 struct ifreq ifs[MAX_IFS];
1625 ifc.ifc_len = sizeof(ifs);
1627 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1628 if ( ! ok_error ( errno ))
1629 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1633 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1634 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1636 * Scan through looking for an interface with an Internet
1637 * address on the same subnet as `ipaddr'.
1639 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1640 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1641 if (ifr->ifr_addr.sa_family == AF_INET) {
1642 ina = SIN_ADDR(ifr->ifr_addr);
1643 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1644 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1647 * Check that the interface is up, and not point-to-point
1650 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1653 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1656 * Get its netmask and check that it's on the right subnet.
1658 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1661 mask = SIN_ADDR(ifreq.ifr_addr);
1662 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1663 ip_ntoa(ina), ntohl(mask)));
1665 if (((ipaddr ^ ina) & mask) != 0)
1674 strlcpy(name, ifreq.ifr_name, namelen);
1676 /* trim off the :1 in eth0:1 */
1677 aliasp = strchr(name, ':');
1681 info("found interface %s for proxy arp", name);
1683 * Now get the hardware address.
1685 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1686 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1687 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1693 sizeof (struct sockaddr));
1695 SYSDEBUG ((LOG_DEBUG,
1696 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1697 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1698 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1699 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1700 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1701 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1702 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1703 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1704 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1709 * get_if_hwaddr - get the hardware address for the specified
1710 * network interface device.
1713 get_if_hwaddr(u_char *addr, char *name)
1718 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1721 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1722 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1723 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1726 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1731 * get_first_ethernet - return the name of the first ethernet-style
1732 * interface on this system.
1735 get_first_ethernet()
1740 /********************************************************************
1742 * Return user specified netmask, modified by any mask we might determine
1743 * for address `addr' (in network byte order).
1744 * Here we scan through the system's list of interfaces, looking for
1745 * any non-point-to-point interfaces which might appear to be on the same
1746 * network as `addr'. If we find any, we OR in their netmask to the
1747 * user-specified netmask.
1750 u_int32_t GetMask (u_int32_t addr)
1752 u_int32_t mask, nmask, ina;
1753 struct ifreq *ifr, *ifend, ifreq;
1755 struct ifreq ifs[MAX_IFS];
1759 if (IN_CLASSA(addr)) /* determine network mask for address class */
1760 nmask = IN_CLASSA_NET;
1761 else if (IN_CLASSB(addr))
1762 nmask = IN_CLASSB_NET;
1764 nmask = IN_CLASSC_NET;
1766 /* class D nets are disallowed by bad_ip_adrs */
1767 mask = netmask | htonl(nmask);
1769 * Scan through the system's network interfaces.
1771 ifc.ifc_len = sizeof(ifs);
1773 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1774 if ( ! ok_error ( errno ))
1775 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1779 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1780 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1782 * Check the interface's internet address.
1784 if (ifr->ifr_addr.sa_family != AF_INET)
1786 ina = SIN_ADDR(ifr->ifr_addr);
1787 if (((ntohl(ina) ^ addr) & nmask) != 0)
1790 * Check that the interface is up, and not point-to-point nor loopback.
1792 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1793 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1796 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1799 * Get its netmask and OR it into our mask.
1801 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1803 mask |= SIN_ADDR(ifreq.ifr_addr);
1809 /********************************************************************
1811 * Internal routine to decode the version.modification.patch level
1814 static void decode_version (char *buf, int *version,
1815 int *modification, int *patch)
1817 *version = (int) strtoul (buf, &buf, 10);
1823 *modification = (int) strtoul (buf, &buf, 10);
1826 *patch = (int) strtoul (buf, &buf, 10);
1837 /********************************************************************
1839 * Procedure to determine if the PPP line discipline is registered.
1843 ppp_registered(void)
1851 * We used to open the serial device and set it to the ppp line
1852 * discipline here, in order to create a ppp unit. But that is
1853 * not a good idea - the user might have specified a device that
1854 * they can't open (permission, or maybe it doesn't really exist).
1855 * So we grab a pty master/slave pair and use that.
1857 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1858 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1863 * Try to put the device into the PPP discipline.
1865 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1866 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1875 /********************************************************************
1877 * ppp_available - check whether the system has any ppp interfaces
1878 * (in fact we check whether we can do an ioctl on ppp0).
1881 int ppp_available(void)
1886 int my_version, my_modification, my_patch;
1887 int osmaj, osmin, ospatch;
1890 "This system lacks kernel support for PPP. This could be because\n"
1891 "the PPP kernel module could not be loaded, or because PPP was not\n"
1892 "included in the kernel configuration. If PPP was included as a\n"
1893 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1894 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1895 "See README.linux file in the ppp distribution for more details.\n";
1897 /* get the kernel version now, since we are called before sys_init */
1899 osmaj = osmin = ospatch = 0;
1900 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1901 kernel_version = KVERSION(osmaj, osmin, ospatch);
1903 fd = open("/dev/ppp", O_RDWR);
1905 if (fd < 0 && errno == ENOENT) {
1906 /* try making it and see if that helps. */
1907 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1908 makedev(108, 0)) >= 0) {
1909 fd = open("/dev/ppp", O_RDWR);
1911 info("Created /dev/ppp device node");
1913 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1914 } else if (errno == EEXIST) {
1915 fd = open("/dev/ppp", O_RDWR);
1920 new_style_driver = 1;
1922 /* XXX should get from driver */
1924 driver_modification = 4;
1929 if (kernel_version >= KVERSION(2,3,13))
1933 * Open a socket for doing the ioctl operations.
1935 s = socket(AF_INET, SOCK_DGRAM, 0);
1939 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1940 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1942 * If the device did not exist then attempt to create one by putting the
1943 * current tty into the PPP discipline. If this works then obtain the
1944 * flags for the device again.
1947 if (ppp_registered()) {
1948 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1949 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1953 * Ensure that the hardware address is for PPP and not something else
1956 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1958 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1962 * This is the PPP device. Validate the version of the driver at this
1963 * point to ensure that this program will work with the driver.
1966 char abBuffer [1024];
1968 ifr.ifr_data = abBuffer;
1969 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1971 error("Couldn't read driver version: %m");
1973 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1976 decode_version(abBuffer,
1978 &driver_modification,
1981 * Validate the version of the driver against the version that we used.
1983 decode_version(VERSION,
1988 /* The version numbers must match */
1989 if (driver_version != my_version)
1992 /* The modification levels must be legal */
1993 if (driver_modification < 3) {
1994 if (driver_modification >= 2) {
1995 /* we can cope with 2.2.0 and above */
2004 slprintf(route_buffer, sizeof(route_buffer),
2005 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2006 driver_version, driver_modification, driver_patch);
2008 no_ppp_msg = route_buffer;
2015 /********************************************************************
2017 * Update the wtmp file with the appropriate user name and tty device.
2020 void logwtmp (const char *line, const char *name, const char *host)
2022 struct utmp ut, *utp;
2023 pid_t mypid = getpid();
2029 * Update the signon database for users.
2030 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2032 utmpname(_PATH_UTMP);
2034 while ((utp = getutent()) && (utp->ut_pid != mypid))
2037 /* Is this call really necessary? There is another one after the 'put' */
2041 memcpy(&ut, utp, sizeof(ut));
2043 /* some gettys/telnetds don't initialize utmp... */
2044 memset(&ut, 0, sizeof(ut));
2046 if (ut.ut_id[0] == 0)
2047 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2049 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2050 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2054 ut.ut_type = USER_PROCESS;
2057 /* Insert the host name if one is supplied */
2059 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2061 /* Insert the IP address of the remote system if IP is enabled */
2062 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2063 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2064 sizeof(ut.ut_addr));
2066 /* CL: Makes sure that the logout works */
2067 if (*host == 0 && *name==0)
2073 * Update the wtmp file.
2076 updwtmp(_PATH_WTMP, &ut);
2078 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2080 flock(wtmp, LOCK_EX);
2082 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2083 warn("error writing %s: %m", _PATH_WTMP);
2085 flock(wtmp, LOCK_UN);
2093 /********************************************************************
2095 * sifvjcomp - config tcp header compression
2098 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2100 u_int x = get_flags(ppp_dev_fd);
2103 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2104 if (! ok_error (errno))
2105 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2110 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2111 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2112 set_flags (ppp_dev_fd, x);
2117 /********************************************************************
2119 * sifup - Config the interface up and enable IP packets to pass.
2126 memset (&ifr, '\0', sizeof (ifr));
2127 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2128 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2129 if (! ok_error (errno))
2130 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2134 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2135 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2136 if (! ok_error (errno))
2137 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2145 /********************************************************************
2147 * sifdown - Disable the indicated protocol and config the interface
2148 * down if there are no remaining protocols.
2155 if (if_is_up && --if_is_up > 0)
2158 memset (&ifr, '\0', sizeof (ifr));
2159 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2160 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2161 if (! ok_error (errno))
2162 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2166 ifr.ifr_flags &= ~IFF_UP;
2167 ifr.ifr_flags |= IFF_POINTOPOINT;
2168 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2169 if (! ok_error (errno))
2170 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2176 /********************************************************************
2178 * sifaddr - Config the interface IP addresses and netmask.
2181 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2187 memset (&ifr, '\0', sizeof (ifr));
2188 memset (&rt, '\0', sizeof (rt));
2190 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2191 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2192 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2194 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2196 * Set our IP address
2198 SIN_ADDR(ifr.ifr_addr) = our_adr;
2199 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2200 if (errno != EEXIST) {
2201 if (! ok_error (errno))
2202 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2205 warn("ioctl(SIOCSIFADDR): Address already exists");
2210 * Set the gateway address
2212 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2213 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2214 if (! ok_error (errno))
2215 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2220 * For recent kernels, force the netmask to 255.255.255.255.
2222 if (kernel_version >= KVERSION(2,1,16))
2224 if (net_mask != 0) {
2225 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2226 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2227 if (! ok_error (errno))
2228 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2233 * Add the device route
2235 if (kernel_version < KVERSION(2,1,16)) {
2236 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2237 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2240 SIN_ADDR(rt.rt_gateway) = 0L;
2241 SIN_ADDR(rt.rt_dst) = his_adr;
2242 rt.rt_flags = RTF_UP | RTF_HOST;
2244 if (kernel_version > KVERSION(2,1,0)) {
2245 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2246 SIN_ADDR(rt.rt_genmask) = -1L;
2249 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2250 if (! ok_error (errno))
2251 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2256 /* set ip_dynaddr in demand mode if address changes */
2257 if (demand && tune_kernel && !dynaddr_set
2258 && our_old_addr && our_old_addr != our_adr) {
2259 /* set ip_dynaddr if possible */
2263 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2264 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2265 if (write(fd, "1", 1) != 1)
2266 error("Couldn't enable dynamic IP addressing: %m");
2269 dynaddr_set = 1; /* only 1 attempt */
2276 /********************************************************************
2278 * cifaddr - Clear the interface IP addresses, and delete routes
2279 * through the interface if possible.
2282 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2286 if (kernel_version < KVERSION(2,1,16)) {
2288 * Delete the route through the device
2291 memset (&rt, '\0', sizeof (rt));
2293 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2294 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2297 SIN_ADDR(rt.rt_gateway) = 0;
2298 SIN_ADDR(rt.rt_dst) = his_adr;
2299 rt.rt_flags = RTF_UP | RTF_HOST;
2301 if (kernel_version > KVERSION(2,1,0)) {
2302 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2303 SIN_ADDR(rt.rt_genmask) = -1L;
2306 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2307 if (still_ppp() && ! ok_error (errno))
2308 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2313 /* This way it is possible to have an IPX-only or IPv6-only interface */
2314 memset(&ifr, 0, sizeof(ifr));
2315 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2316 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2318 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2319 if (! ok_error (errno)) {
2320 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2325 our_old_addr = our_adr;
2331 /********************************************************************
2333 * sif6addr - Config the interface with an IPv6 link-local address
2335 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2337 struct in6_ifreq ifr6;
2339 struct in6_rtmsg rt6;
2343 error("IPv6 socket creation failed: %m");
2346 memset(&ifr, 0, sizeof (ifr));
2347 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2348 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2349 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2353 /* Local interface */
2354 memset(&ifr6, 0, sizeof(ifr6));
2355 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2356 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2357 ifr6.ifr6_prefixlen = 10;
2359 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2360 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2364 /* Route to remote host */
2365 memset(&rt6, 0, sizeof(rt6));
2366 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2367 rt6.rtmsg_flags = RTF_UP;
2368 rt6.rtmsg_dst_len = 10;
2369 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2370 rt6.rtmsg_metric = 1;
2372 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2373 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2381 /********************************************************************
2383 * cif6addr - Remove IPv6 address from interface
2385 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2388 struct in6_ifreq ifr6;
2392 error("IPv6 socket creation failed: %m");
2395 memset(&ifr, 0, sizeof(ifr));
2396 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2397 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2398 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2402 memset(&ifr6, 0, sizeof(ifr6));
2403 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2404 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2405 ifr6.ifr6_prefixlen = 10;
2407 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2408 if (errno != EADDRNOTAVAIL) {
2409 if (! ok_error (errno))
2410 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2413 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2422 * get_pty - get a pty master/slave pair and chown the slave side
2423 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2426 get_pty(master_fdp, slave_fdp, slave_name, uid)
2432 int i, mfd, sfd = -1;
2434 struct termios tios;
2438 * Try the unix98 way first.
2440 mfd = open("/dev/ptmx", O_RDWR);
2443 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2444 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2445 chmod(pty_name, S_IRUSR | S_IWUSR);
2448 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2449 warn("Couldn't unlock pty slave %s: %m", pty_name);
2451 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2452 warn("Couldn't open pty slave %s: %m", pty_name);
2455 #endif /* TIOCGPTN */
2458 /* the old way - scan through the pty name space */
2459 for (i = 0; i < 64; ++i) {
2460 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2461 'p' + i / 16, i % 16);
2462 mfd = open(pty_name, O_RDWR, 0);
2465 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2467 fchown(sfd, uid, -1);
2468 fchmod(sfd, S_IRUSR | S_IWUSR);
2479 strlcpy(slave_name, pty_name, 16);
2482 if (tcgetattr(sfd, &tios) == 0) {
2483 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2484 tios.c_cflag |= CS8 | CREAD;
2485 tios.c_iflag = IGNPAR | CLOCAL;
2488 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2489 warn("couldn't set attributes on pty: %m");
2491 warn("couldn't get attributes on pty: %m");
2496 /********************************************************************
2498 * open_loopback - open the device we use for getting packets
2499 * in demand mode. Under Linux, we use a pty master/slave pair.
2502 open_ppp_loopback(void)
2507 if (new_style_driver) {
2508 /* allocate ourselves a ppp unit */
2509 if (make_ppp_unit() < 0)
2511 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2512 set_kdebugflag(kdebugflag);
2517 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2518 fatal("No free pty for loopback");
2519 SYSDEBUG(("using %s for loopback", loop_name));
2521 set_ppp_fd(slave_fd);
2523 flags = fcntl(master_fd, F_GETFL);
2525 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2526 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2528 flags = fcntl(ppp_fd, F_GETFL);
2530 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2531 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2533 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2534 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2536 * Find out which interface we were given.
2538 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2539 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2541 * Enable debug in the driver if requested.
2543 set_kdebugflag (kdebugflag);
2548 /********************************************************************
2550 * restore_loop - reattach the ppp unit to the loopback.
2552 * The kernel ppp driver automatically reattaches the ppp unit to
2553 * the loopback if the serial port is set to a line discipline other
2554 * than ppp, or if it detects a modem hangup. The former will happen
2555 * in disestablish_ppp if the latter hasn't already happened, so we
2556 * shouldn't need to do anything.
2558 * Just to be sure, set the real serial port to the normal discipline.
2565 if (new_style_driver) {
2566 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2569 if (ppp_fd != slave_fd) {
2570 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2571 set_ppp_fd(slave_fd);
2575 /********************************************************************
2577 * sifnpmode - Set the mode for handling packets for a given NP.
2581 sifnpmode(u, proto, mode)
2588 npi.protocol = proto;
2590 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2591 if (! ok_error (errno))
2592 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2593 proto, mode, errno);
2600 /********************************************************************
2602 * sipxfaddr - Config the interface IPX networknumber
2605 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
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 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2625 sipx->sipx_family = AF_IPX;
2626 sipx->sipx_port = 0;
2627 sipx->sipx_network = htonl (network);
2628 sipx->sipx_type = IPX_FRAME_ETHERII;
2629 sipx->sipx_action = IPX_CRTITF;
2631 * Set the IPX device
2633 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2635 if (errno != EEXIST) {
2636 if (! ok_error (errno))
2637 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2640 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2649 /********************************************************************
2651 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2652 * are removed and the device is no longer able to pass IPX
2656 int cipxfaddr (int unit)
2663 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2665 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2667 if (! ok_error (errno))
2668 dbglog("socket(AF_IPX): %m (%d)", errno);
2672 memset (&ifr, '\0', sizeof (ifr));
2673 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2675 sipx->sipx_type = IPX_FRAME_ETHERII;
2676 sipx->sipx_action = IPX_DLTITF;
2677 sipx->sipx_family = AF_IPX;
2679 * Set the IPX device
2681 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2682 if (! ok_error (errno))
2683 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2693 * Use the hostname as part of the random number seed.
2702 for (p = hostname; *p != 0; ++p)
2707 /********************************************************************
2709 * sys_check_options - check the options that the user specified
2713 sys_check_options(void)
2717 * Disable the IPX protocol if the support is not present in the kernel.
2721 if (ipxcp_protent.enabled_flag) {
2722 struct stat stat_buf;
2723 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2724 || lstat(path, &stat_buf) < 0) {
2725 error("IPX support is not present in the kernel\n");
2726 ipxcp_protent.enabled_flag = 0;
2730 if (demand && driver_is_old) {
2731 option_error("demand dialling is not supported by kernel driver "
2732 "version %d.%d.%d", driver_version, driver_modification,
2736 if (multilink && !new_style_driver) {
2737 warn("Warning: multilink is not supported by the kernel driver");