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>
79 #if __GLIBC__ >= 2 && \
80 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
81 #include <netipx/ipx.h>
83 #include <linux/ipx.h>
85 #endif /* IPX_CHANGE */
89 #include <linux/filter.h>
90 #endif /* PPP_FILTER */
93 #include <sys/locks.h>
99 * This is in linux/include/net/ipv6.h.
103 struct in6_addr ifr6_addr;
104 __u32 ifr6_prefixlen;
105 unsigned int ifr6_ifindex;
109 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
110 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
111 sin6.s6_addr16[0] = htons(0xfe80); \
112 eui64_copy(eui64, sin6.s6_addr32[2]); \
117 /* We can get an EIO error on an ioctl if the modem has hung up */
118 #define ok_error(num) ((num)==EIO)
120 static int tty_disc = N_TTY; /* The TTY discipline */
121 static int ppp_disc = N_PPP; /* The PPP discpline */
122 static int initfdflags = -1; /* Initial file descriptor flags for fd */
123 static int ppp_fd = -1; /* fd which is set to PPP discipline */
124 static int sock_fd = -1; /* socket for doing interface ioctls */
125 static int slave_fd = -1;
126 static int master_fd = -1;
128 static int sock6_fd = -1;
130 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
131 static int chindex; /* channel index (new style driver) */
133 static fd_set in_fds; /* set of fds that wait_input waits for */
134 static int max_in_fd; /* highest fd set in in_fds */
136 static int has_proxy_arp = 0;
137 static int driver_version = 0;
138 static int driver_modification = 0;
139 static int driver_patch = 0;
140 static int driver_is_old = 0;
141 static int restore_term = 0; /* 1 => we've munged the terminal */
142 static struct termios inittermios; /* Initial TTY termios */
144 static int new_style_driver = 0;
146 static char loop_name[20];
147 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
149 static int if_is_up; /* Interface has been marked up */
150 static u_int32_t default_route_gateway; /* Gateway for default route added */
151 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
152 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
153 static u_int32_t our_old_addr; /* for detecting address changes */
154 static int dynaddr_set; /* 1 if ip_dynaddr set */
155 static int looped; /* 1 if using loop */
156 static int link_mtu; /* mtu for the link (not bundle) */
158 static struct utsname utsname; /* for the kernel version */
159 static int kernel_version;
160 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
164 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
165 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
166 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
168 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
170 /* Prototypes for procedures local to this file. */
171 static int get_flags (int fd);
172 static void set_flags (int fd, int flags);
173 static int translate_speed (int bps);
174 static int baud_rate_of (int speed);
175 static void close_route_table (void);
176 static int open_route_table (void);
177 static int read_route_table (struct rtentry *rt);
178 static int defaultroute_exists (struct rtentry *rt);
179 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
180 char *name, int namelen);
181 static void decode_version (char *buf, int *version, int *mod, int *patch);
182 static int set_kdebugflag(int level);
183 static int ppp_registered(void);
184 static int make_ppp_unit(void);
186 extern u_char inpacket_buf[]; /* borrowed from main.c */
189 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
193 #define SET_SA_FAMILY(addr, family) \
194 memset ((char *) &(addr), '\0', sizeof(addr)); \
195 addr.sa_family = (family);
198 * Determine if the PPP connection should still be present.
203 /* new_fd is the fd of a tty */
204 static void set_ppp_fd (int new_fd)
206 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
208 if (!new_style_driver)
212 static int still_ppp(void)
214 if (new_style_driver)
215 return !hungup && ppp_fd >= 0;
216 if (!hungup || ppp_fd == slave_fd)
219 set_ppp_fd(slave_fd);
225 /********************************************************************
227 * Functions to read and set the flags value in the device driver
230 static int get_flags (int fd)
234 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
235 if ( ok_error (errno) )
238 fatal("ioctl(PPPIOCGFLAGS): %m");
241 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
245 /********************************************************************/
247 static void set_flags (int fd, int flags)
249 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
251 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
252 if (! ok_error (errno) )
253 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
257 /********************************************************************
259 * sys_init - System-dependent initialization.
266 if (new_style_driver) {
267 ppp_dev_fd = open("/dev/ppp", O_RDWR);
269 fatal("Couldn't open /dev/ppp: %m");
270 flags = fcntl(ppp_dev_fd, F_GETFL);
272 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
273 warn("Couldn't set /dev/ppp to nonblock: %m");
276 /* Get an internet socket for doing socket ioctls. */
277 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
279 fatal("Couldn't create IP socket: %m(%d)", errno);
282 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
284 sock6_fd = -errno; /* save errno for later */
291 /********************************************************************
293 * sys_cleanup - restore any system state we modified before exiting:
294 * mark the interface down, delete default route and/or proxy arp entry.
295 * This shouldn't call die() because it's called from die().
298 void sys_cleanup(void)
301 * Take down the device
308 * Delete any routes through the device.
310 if (default_route_gateway != 0)
311 cifdefaultroute(0, 0, default_route_gateway);
314 cifproxyarp(0, proxy_arp_addr);
317 /********************************************************************
319 * sys_close - Clean up in a child process before execing.
324 if (new_style_driver)
335 /********************************************************************
337 * set_kdebugflag - Define the debugging level for the kernel
340 static int set_kdebugflag (int requested_level)
342 if (new_style_driver && ifunit < 0)
344 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
345 if ( ! ok_error (errno) )
346 error("ioctl(PPPIOCSDEBUG): %m");
349 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
354 /********************************************************************
356 * tty_establish_ppp - Turn the serial port into a ppp interface.
359 int tty_establish_ppp (int tty_fd)
365 * Ensure that the tty device is in exclusive mode.
367 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
368 if ( ! ok_error ( errno ))
369 warn("Couldn't make tty exclusive: %m");
372 * Demand mode - prime the old ppp device to relinquish the unit.
374 if (!new_style_driver && looped
375 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
376 error("ioctl(transfer ppp unit): %m");
380 * Set the current tty to the PPP discpline
384 #define N_SYNC_PPP 14
386 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
387 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
388 if ( ! ok_error (errno) ) {
389 error("Couldn't set tty to PPP discipline: %m");
394 if (new_style_driver) {
395 /* Open another instance of /dev/ppp and connect the channel to it */
398 if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
399 error("Couldn't get channel number: %m");
402 dbglog("using channel %d", chindex);
403 fd = open("/dev/ppp", O_RDWR);
405 error("Couldn't reopen /dev/ppp: %m");
408 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
409 error("Couldn't attach to channel %d: %m", chindex);
412 flags = fcntl(fd, F_GETFL);
413 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
414 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
419 if (!looped && !multilink) {
421 * Create a new PPP unit.
423 if (make_ppp_unit() < 0)
428 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
432 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
433 error("Couldn't attach to PPP unit %d: %m", ifunit);
440 * Old-style driver: find out which interface we were given.
443 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
444 if (ok_error (errno))
446 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
448 /* Check that we got the same unit again. */
449 if (looped && x != ifunit)
450 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
454 * Fetch the initial file flags and reset blocking mode on the file.
456 initfdflags = fcntl(tty_fd, F_GETFL);
457 if (initfdflags == -1 ||
458 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
459 if ( ! ok_error (errno))
460 warn("Couldn't set device to non-blocking mode: %m");
467 * Enable debug in the driver if requested.
470 set_kdebugflag (kdebugflag);
472 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
473 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
476 set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
477 | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
479 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
480 driver_version, driver_modification, driver_patch));
487 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
488 warn("Couldn't reset tty to normal line discipline: %m");
492 /********************************************************************
494 * tty_disestablish_ppp - Restore the serial port to normal operation,
495 * and reconnect the ppp unit to the loopback if in demand mode.
496 * This shouldn't call die() because it's called from die().
499 void tty_disestablish_ppp(int tty_fd)
503 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
505 if (tcflush(tty_fd, TCIOFLUSH) < 0)
506 warn("tcflush failed: %m");
508 * Restore the previous line discipline
510 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
511 if ( ! ok_error (errno))
512 error("ioctl(TIOCSETD, N_TTY): %m");
515 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
516 if ( ! ok_error (errno))
517 warn("ioctl(TIOCNXCL): %m(%d)", errno);
520 /* Reset non-blocking mode on fd. */
521 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
522 if ( ! ok_error (errno))
523 warn("Couldn't restore device fd flags: %m");
528 if (new_style_driver) {
532 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
534 } else if (ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
535 error("Couldn't release PPP unit: %m");
537 remove_fd(ppp_dev_fd);
539 /* old-style driver */
541 set_ppp_fd(slave_fd);
546 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
547 * Assumes new_style_driver.
549 static int make_ppp_unit()
554 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
555 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
556 warn("Couldn't allocate PPP unit %d as it is already in use");
558 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
561 error("Couldn't create new ppp unit: %m");
566 * cfg_bundle - configure the existing bundle.
567 * Used in demand mode.
569 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
573 if (!new_style_driver)
576 /* set the mrru, mtu and flags */
577 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
578 error("Couldn't set MRRU: %m");
579 flags = get_flags(ppp_dev_fd);
580 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
581 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
582 | (mrru? SC_MULTILINK: 0);
584 set_flags(ppp_dev_fd, flags);
586 /* connect up the channel */
587 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
588 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
593 * make_new_bundle - create a new PPP unit (i.e. a bundle)
594 * and connect our channel to it. This should only get called
595 * if `multilink' was set at the time establish_ppp was called.
596 * In demand mode this uses our existing bundle instead of making
599 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
601 if (!new_style_driver)
604 /* make us a ppp unit */
605 if (make_ppp_unit() < 0)
608 /* set the mrru and flags */
609 cfg_bundle(mrru, mtru, rssn, tssn);
613 * bundle_attach - attach our link to a given PPP unit.
614 * We assume the unit is controlled by another pppd.
616 int bundle_attach(int ifnum)
618 if (!new_style_driver)
621 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
623 return 0; /* doesn't still exist */
624 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
626 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
627 fatal("Couldn't connect to interface unit %d: %m", ifnum);
628 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
634 /********************************************************************
636 * clean_check - Fetch the flags for the device and generate
637 * appropriate error messages.
639 void clean_check(void)
645 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
647 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
649 s = "all had bit 7 set to 1";
653 s = "all had bit 7 set to 0";
657 s = "all had odd parity";
661 s = "all had even parity";
666 warn("Receive serial link is not 8-bit clean:");
667 warn("Problem: %s", s);
675 * List of valid speeds.
679 int speed_int, speed_val;
762 /********************************************************************
764 * Translate from bits/second to a speed_t.
767 static int translate_speed (int bps)
769 struct speed *speedp;
772 for (speedp = speeds; speedp->speed_int; speedp++) {
773 if (bps == speedp->speed_int)
774 return speedp->speed_val;
776 warn("speed %d not supported", bps);
781 /********************************************************************
783 * Translate from a speed_t to bits/second.
786 static int baud_rate_of (int speed)
788 struct speed *speedp;
791 for (speedp = speeds; speedp->speed_int; speedp++) {
792 if (speed == speedp->speed_val)
793 return speedp->speed_int;
799 /********************************************************************
801 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
802 * at the requested speed, etc. If `local' is true, set CLOCAL
803 * regardless of whether the modem option was specified.
806 void set_up_tty(int tty_fd, int local)
812 if (tcgetattr(tty_fd, &tios) < 0) {
813 if (!ok_error(errno))
814 fatal("tcgetattr: %m(%d)", errno);
821 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
822 tios.c_cflag |= CS8 | CREAD | HUPCL;
824 tios.c_iflag = IGNBRK | IGNPAR;
828 tios.c_cc[VTIME] = 0;
831 tios.c_cflag ^= (CLOCAL | HUPCL);
835 tios.c_cflag |= CRTSCTS;
839 tios.c_iflag |= IXON | IXOFF;
840 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
841 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
845 tios.c_cflag &= ~CRTSCTS;
852 speed = translate_speed(inspeed);
854 cfsetospeed (&tios, speed);
855 cfsetispeed (&tios, speed);
858 * We can't proceed if the serial port speed is B0,
859 * since that implies that the serial port is disabled.
862 speed = cfgetospeed(&tios);
864 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
867 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
868 if (!ok_error(errno))
869 fatal("tcsetattr: %m");
871 baud_rate = baud_rate_of(speed);
875 /********************************************************************
877 * setdtr - control the DTR line on the serial port.
878 * This is called from die(), so it shouldn't call die().
881 void setdtr (int tty_fd, int on)
883 int modembits = TIOCM_DTR;
885 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
888 /********************************************************************
890 * restore_tty - restore the terminal to the saved settings.
893 void restore_tty (int tty_fd)
898 * Turn off echoing, because otherwise we can get into
899 * a loop with the tty and the modem echoing to each other.
900 * We presume we are the sole user of this tty device, so
901 * when we close it, it will revert to its defaults anyway.
904 inittermios.c_lflag &= ~(ECHO | ECHONL);
906 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
907 if (! ok_error (errno))
908 warn("tcsetattr: %m");
913 /********************************************************************
915 * output - Output PPP packet.
918 void output (int unit, unsigned char *p, int len)
924 dbglog("sent %P", p, len);
926 if (len < PPP_HDRLEN)
928 if (new_style_driver) {
931 proto = (p[0] << 8) + p[1];
932 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
935 if (write(fd, p, len) < 0) {
936 if (errno == EWOULDBLOCK || errno == ENOBUFS
937 || errno == ENXIO || errno == EIO || errno == EINTR)
938 warn("write: warning: %m (%d)", errno);
940 error("write: %m (%d)", errno);
944 /********************************************************************
946 * wait_input - wait until there is data available,
947 * for the length of time specified by *timo (indefinite
951 void wait_input(struct timeval *timo)
958 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
959 if (n < 0 && errno != EINTR)
960 fatal("select: %m(%d)", errno);
964 * add_fd - add an fd to the set that wait_input waits for.
974 * remove_fd - remove an fd from the set that wait_input waits for.
976 void remove_fd(int fd)
982 /********************************************************************
984 * read_packet - get a PPP packet from the serial device.
987 int read_packet (unsigned char *buf)
991 len = PPP_MRU + PPP_HDRLEN;
992 if (new_style_driver) {
993 *buf++ = PPP_ALLSTATIONS;
999 nr = read(ppp_fd, buf, len);
1000 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1002 if (nr < 0 && errno == ENXIO)
1005 if (nr < 0 && new_style_driver && ifunit >= 0) {
1006 /* N.B. we read ppp_fd first since LCP packets come in there. */
1007 nr = read(ppp_dev_fd, buf, len);
1008 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1009 error("read /dev/ppp: %m");
1010 if (nr < 0 && errno == ENXIO)
1013 return (new_style_driver && nr > 0)? nr+2: nr;
1016 /********************************************************************
1018 * get_loop_output - get outgoing packets from the ppp device,
1019 * and detect when we want to bring the real link up.
1020 * Return value is 1 if we need to bring up the link, 0 otherwise.
1023 get_loop_output(void)
1028 if (new_style_driver) {
1029 while ((n = read_packet(inpacket_buf)) > 0)
1030 if (loop_frame(inpacket_buf, n))
1035 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1036 if (loop_chars(inbuf, n))
1040 fatal("eof on loopback");
1042 if (errno != EWOULDBLOCK)
1043 fatal("read from loopback: %m(%d)", errno);
1049 * netif_set_mtu - set the MTU on the PPP network interface.
1052 netif_set_mtu(int unit, int mtu)
1056 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1058 memset (&ifr, '\0', sizeof (ifr));
1059 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1062 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1063 fatal("ioctl(SIOCSIFMTU): %m");
1066 /********************************************************************
1068 * tty_send_config - configure the transmit characteristics of
1069 * the ppp interface.
1072 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1077 * Set the asyncmap and other parameters for the ppp device
1082 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1083 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1084 if (!ok_error(errno))
1085 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1089 x = get_flags(ppp_fd);
1090 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1091 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1092 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1093 set_flags(ppp_fd, x);
1096 /********************************************************************
1098 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1101 void tty_set_xaccm (ext_accm accm)
1103 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1104 accm[0], accm[1], accm[2], accm[3]));
1108 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1109 if ( ! ok_error (errno))
1110 warn("ioctl(set extended ACCM): %m(%d)", errno);
1114 /********************************************************************
1116 * tty_recv_config - configure the receive-side characteristics of
1117 * the ppp interface.
1120 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1122 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1124 * If we were called because the link has gone down then there is nothing
1125 * which may be done. Just return without incident.
1130 * Set the receiver parameters
1132 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1133 if ( ! ok_error (errno))
1134 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1136 if (new_style_driver && ifunit >= 0
1137 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1138 error("Couldn't set MRU in generic PPP layer: %m");
1140 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1141 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1142 if (!ok_error(errno))
1143 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1147 /********************************************************************
1149 * ccp_test - ask kernel whether a given compression method
1150 * is acceptable for use.
1153 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1155 struct ppp_option_data data;
1157 memset (&data, '\0', sizeof (data));
1159 data.length = opt_len;
1160 data.transmit = for_transmit;
1162 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1165 return (errno == ENOBUFS)? 0: -1;
1168 /********************************************************************
1170 * ccp_flags_set - inform kernel about the current state of CCP.
1173 void ccp_flags_set (int unit, int isopen, int isup)
1175 if (still_ppp() && ifunit >= 0) {
1176 int x = get_flags(ppp_dev_fd);
1177 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1178 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1179 set_flags (ppp_dev_fd, x);
1185 * set_filters - set the active and pass filters in the kernel driver.
1187 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1189 struct sock_fprog fp;
1191 fp.len = pass->bf_len;
1192 fp.filter = (struct sock_filter *) pass->bf_insns;
1193 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1194 if (errno == ENOTTY)
1195 warn("kernel does not support PPP filtering");
1197 error("Couldn't set pass-filter in kernel: %m");
1200 fp.len = active->bf_len;
1201 fp.filter = (struct sock_filter *) active->bf_insns;
1202 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1203 error("Couldn't set active-filter in kernel: %m");
1208 #endif /* PPP_FILTER */
1210 /********************************************************************
1212 * get_idle_time - return how long the link has been idle.
1215 get_idle_time(u, ip)
1217 struct ppp_idle *ip;
1219 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1222 /********************************************************************
1224 * get_ppp_stats - return statistics for the link.
1227 get_ppp_stats(u, stats)
1229 struct pppd_stats *stats;
1231 struct ifpppstatsreq req;
1233 memset (&req, 0, sizeof (req));
1235 req.stats_ptr = (caddr_t) &req.stats;
1236 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1237 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1238 error("Couldn't get PPP statistics: %m");
1241 stats->bytes_in = req.stats.p.ppp_ibytes;
1242 stats->bytes_out = req.stats.p.ppp_obytes;
1243 stats->pkts_in = req.stats.p.ppp_ipackets;
1244 stats->pkts_out = req.stats.p.ppp_opackets;
1248 /********************************************************************
1250 * ccp_fatal_error - returns 1 if decompression was disabled as a
1251 * result of an error detected after decompression of a packet,
1252 * 0 otherwise. This is necessary because of patent nonsense.
1255 int ccp_fatal_error (int unit)
1257 int x = get_flags(ppp_dev_fd);
1259 return x & SC_DC_FERROR;
1262 /********************************************************************
1264 * path_to_procfs - find the path to the proc file system mount point
1266 static char proc_path[MAXPATHLEN];
1267 static int proc_path_len;
1269 static char *path_to_procfs(const char *tail)
1271 struct mntent *mntent;
1274 if (proc_path_len == 0) {
1275 /* Default the mount location of /proc */
1276 strlcpy (proc_path, "/proc", sizeof(proc_path));
1278 fp = fopen(MOUNTED, "r");
1280 while ((mntent = getmntent(fp)) != NULL) {
1281 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1283 if (strcmp(mntent->mnt_type, "proc") == 0) {
1284 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1285 proc_path_len = strlen(proc_path);
1293 strlcpy(proc_path + proc_path_len, tail,
1294 sizeof(proc_path) - proc_path_len);
1299 * /proc/net/route parsing stuff.
1301 #define ROUTE_MAX_COLS 12
1302 FILE *route_fd = (FILE *) 0;
1303 static char route_buffer[512];
1304 static int route_dev_col, route_dest_col, route_gw_col;
1305 static int route_flags_col, route_mask_col;
1306 static int route_num_cols;
1308 static int open_route_table (void);
1309 static void close_route_table (void);
1310 static int read_route_table (struct rtentry *rt);
1312 /********************************************************************
1314 * close_route_table - close the interface to the route table
1317 static void close_route_table (void)
1319 if (route_fd != (FILE *) 0) {
1321 route_fd = (FILE *) 0;
1325 /********************************************************************
1327 * open_route_table - open the interface to the route table
1329 static char route_delims[] = " \t\n";
1331 static int open_route_table (void)
1335 close_route_table();
1337 path = path_to_procfs("/net/route");
1338 route_fd = fopen (path, "r");
1339 if (route_fd == NULL) {
1340 error("can't open routing table %s: %m", path);
1344 route_dev_col = 0; /* default to usual columns */
1347 route_flags_col = 3;
1351 /* parse header line */
1352 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1353 char *p = route_buffer, *q;
1355 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1357 if ((q = strtok(p, route_delims)) == 0)
1359 if (strcasecmp(q, "iface") == 0)
1360 route_dev_col = col;
1361 else if (strcasecmp(q, "destination") == 0)
1362 route_dest_col = col;
1363 else if (strcasecmp(q, "gateway") == 0)
1365 else if (strcasecmp(q, "flags") == 0)
1366 route_flags_col = col;
1367 else if (strcasecmp(q, "mask") == 0)
1368 route_mask_col = col;
1371 if (used && col >= route_num_cols)
1372 route_num_cols = col + 1;
1380 /********************************************************************
1382 * read_route_table - read the next entry from the route table
1385 static int read_route_table(struct rtentry *rt)
1387 char *cols[ROUTE_MAX_COLS], *p;
1390 memset (rt, '\0', sizeof (struct rtentry));
1392 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1396 for (col = 0; col < route_num_cols; ++col) {
1397 cols[col] = strtok(p, route_delims);
1398 if (cols[col] == NULL)
1399 return 0; /* didn't get enough columns */
1403 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1404 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1405 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1407 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1408 rt->rt_dev = cols[route_dev_col];
1413 /********************************************************************
1415 * defaultroute_exists - determine if there is a default route
1418 static int defaultroute_exists (struct rtentry *rt)
1422 if (!open_route_table())
1425 while (read_route_table(rt) != 0) {
1426 if ((rt->rt_flags & RTF_UP) == 0)
1429 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1431 if (SIN_ADDR(rt->rt_dst) == 0L) {
1437 close_route_table();
1442 * have_route_to - determine if the system has any route to
1443 * a given IP address. `addr' is in network byte order.
1444 * Return value is 1 if yes, 0 if no, -1 if don't know.
1445 * For demand mode to work properly, we have to ignore routes
1446 * through our own interface.
1448 int have_route_to(u_int32_t addr)
1453 if (!open_route_table())
1454 return -1; /* don't know */
1456 while (read_route_table(&rt)) {
1457 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1459 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1465 close_route_table();
1469 /********************************************************************
1471 * sifdefaultroute - assign a default route through the address given.
1474 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1478 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1479 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1481 if (old_gateway != gateway)
1482 error("not replacing existing default route to %s [%I]",
1483 rt.rt_dev, old_gateway);
1487 memset (&rt, '\0', sizeof (rt));
1488 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1489 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1491 if (kernel_version > KVERSION(2,1,0)) {
1492 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1493 SIN_ADDR(rt.rt_genmask) = 0L;
1496 SIN_ADDR(rt.rt_gateway) = gateway;
1498 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1499 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1500 if ( ! ok_error ( errno ))
1501 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1505 default_route_gateway = gateway;
1509 /********************************************************************
1511 * cifdefaultroute - delete a default route through the address given.
1514 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1518 default_route_gateway = 0;
1520 memset (&rt, '\0', sizeof (rt));
1521 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1522 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1524 if (kernel_version > KVERSION(2,1,0)) {
1525 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1526 SIN_ADDR(rt.rt_genmask) = 0L;
1529 SIN_ADDR(rt.rt_gateway) = gateway;
1531 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1532 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1534 if ( ! ok_error ( errno ))
1535 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1543 /********************************************************************
1545 * sifproxyarp - Make a proxy ARP entry for the peer.
1548 int sifproxyarp (int unit, u_int32_t his_adr)
1550 struct arpreq arpreq;
1553 if (has_proxy_arp == 0) {
1554 memset (&arpreq, '\0', sizeof(arpreq));
1556 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1557 SIN_ADDR(arpreq.arp_pa) = his_adr;
1558 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1560 * Get the hardware address of an interface on the same subnet
1561 * as our local address.
1563 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1564 sizeof(proxy_arp_dev))) {
1565 error("Cannot determine ethernet address for proxy ARP");
1568 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1570 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1571 if ( ! ok_error ( errno ))
1572 error("ioctl(SIOCSARP): %m(%d)", errno);
1575 proxy_arp_addr = his_adr;
1579 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1580 if (forw_path != 0) {
1581 int fd = open(forw_path, O_WRONLY);
1583 if (write(fd, "1", 1) != 1)
1584 error("Couldn't enable IP forwarding: %m");
1594 /********************************************************************
1596 * cifproxyarp - Delete the proxy ARP entry for the peer.
1599 int cifproxyarp (int unit, u_int32_t his_adr)
1601 struct arpreq arpreq;
1603 if (has_proxy_arp) {
1605 memset (&arpreq, '\0', sizeof(arpreq));
1606 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1607 SIN_ADDR(arpreq.arp_pa) = his_adr;
1608 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1609 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1611 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1612 if ( ! ok_error ( errno ))
1613 warn("ioctl(SIOCDARP): %m(%d)", errno);
1620 /********************************************************************
1622 * get_ether_addr - get the hardware address of an interface on the
1623 * the same subnet as ipaddr.
1626 static int get_ether_addr (u_int32_t ipaddr,
1627 struct sockaddr *hwaddr,
1628 char *name, int namelen)
1630 struct ifreq *ifr, *ifend;
1631 u_int32_t ina, mask;
1635 struct ifreq ifs[MAX_IFS];
1637 ifc.ifc_len = sizeof(ifs);
1639 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1640 if ( ! ok_error ( errno ))
1641 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1645 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1646 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1648 * Scan through looking for an interface with an Internet
1649 * address on the same subnet as `ipaddr'.
1651 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1652 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1653 if (ifr->ifr_addr.sa_family == AF_INET) {
1654 ina = SIN_ADDR(ifr->ifr_addr);
1655 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1656 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1659 * Check that the interface is up, and not point-to-point
1662 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1665 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1668 * Get its netmask and check that it's on the right subnet.
1670 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1673 mask = SIN_ADDR(ifreq.ifr_addr);
1674 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1675 ip_ntoa(ina), ntohl(mask)));
1677 if (((ipaddr ^ ina) & mask) != 0)
1686 strlcpy(name, ifreq.ifr_name, namelen);
1688 /* trim off the :1 in eth0:1 */
1689 aliasp = strchr(name, ':');
1693 info("found interface %s for proxy arp", name);
1695 * Now get the hardware address.
1697 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1698 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1699 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1705 sizeof (struct sockaddr));
1707 SYSDEBUG ((LOG_DEBUG,
1708 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1709 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1710 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1711 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1712 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1713 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1714 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1715 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1716 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1721 * get_if_hwaddr - get the hardware address for the specified
1722 * network interface device.
1725 get_if_hwaddr(u_char *addr, char *name)
1730 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1733 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1734 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1735 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1738 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1743 * get_first_ethernet - return the name of the first ethernet-style
1744 * interface on this system.
1747 get_first_ethernet()
1752 /********************************************************************
1754 * Return user specified netmask, modified by any mask we might determine
1755 * for address `addr' (in network byte order).
1756 * Here we scan through the system's list of interfaces, looking for
1757 * any non-point-to-point interfaces which might appear to be on the same
1758 * network as `addr'. If we find any, we OR in their netmask to the
1759 * user-specified netmask.
1762 u_int32_t GetMask (u_int32_t addr)
1764 u_int32_t mask, nmask, ina;
1765 struct ifreq *ifr, *ifend, ifreq;
1767 struct ifreq ifs[MAX_IFS];
1771 if (IN_CLASSA(addr)) /* determine network mask for address class */
1772 nmask = IN_CLASSA_NET;
1773 else if (IN_CLASSB(addr))
1774 nmask = IN_CLASSB_NET;
1776 nmask = IN_CLASSC_NET;
1778 /* class D nets are disallowed by bad_ip_adrs */
1779 mask = netmask | htonl(nmask);
1781 * Scan through the system's network interfaces.
1783 ifc.ifc_len = sizeof(ifs);
1785 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1786 if ( ! ok_error ( errno ))
1787 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1791 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1792 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1794 * Check the interface's internet address.
1796 if (ifr->ifr_addr.sa_family != AF_INET)
1798 ina = SIN_ADDR(ifr->ifr_addr);
1799 if (((ntohl(ina) ^ addr) & nmask) != 0)
1802 * Check that the interface is up, and not point-to-point nor loopback.
1804 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1805 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1808 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1811 * Get its netmask and OR it into our mask.
1813 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1815 mask |= SIN_ADDR(ifreq.ifr_addr);
1821 /********************************************************************
1823 * Internal routine to decode the version.modification.patch level
1826 static void decode_version (char *buf, int *version,
1827 int *modification, int *patch)
1831 *version = (int) strtoul (buf, &endp, 10);
1835 if (endp != buf && *endp == '.') {
1837 *modification = (int) strtoul (buf, &endp, 10);
1838 if (endp != buf && *endp == '.') {
1840 *patch = (int) strtoul (buf, &buf, 10);
1845 /********************************************************************
1847 * Procedure to determine if the PPP line discipline is registered.
1851 ppp_registered(void)
1859 * We used to open the serial device and set it to the ppp line
1860 * discipline here, in order to create a ppp unit. But that is
1861 * not a good idea - the user might have specified a device that
1862 * they can't open (permission, or maybe it doesn't really exist).
1863 * So we grab a pty master/slave pair and use that.
1865 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1866 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1871 * Try to put the device into the PPP discipline.
1873 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1874 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1883 /********************************************************************
1885 * ppp_available - check whether the system has any ppp interfaces
1886 * (in fact we check whether we can do an ioctl on ppp0).
1889 int ppp_available(void)
1894 int my_version, my_modification, my_patch;
1895 int osmaj, osmin, ospatch;
1898 "This system lacks kernel support for PPP. This could be because\n"
1899 "the PPP kernel module could not be loaded, or because PPP was not\n"
1900 "included in the kernel configuration. If PPP was included as a\n"
1901 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1902 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1903 "See README.linux file in the ppp distribution for more details.\n";
1905 /* get the kernel version now, since we are called before sys_init */
1907 osmaj = osmin = ospatch = 0;
1908 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1909 kernel_version = KVERSION(osmaj, osmin, ospatch);
1911 fd = open("/dev/ppp", O_RDWR);
1913 if (fd < 0 && errno == ENOENT) {
1914 /* try making it and see if that helps. */
1915 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1916 makedev(108, 0)) >= 0) {
1917 fd = open("/dev/ppp", O_RDWR);
1919 info("Created /dev/ppp device node");
1921 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1922 } else if (errno == EEXIST) {
1923 fd = open("/dev/ppp", O_RDWR);
1928 new_style_driver = 1;
1930 /* XXX should get from driver */
1932 driver_modification = 4;
1937 if (kernel_version >= KVERSION(2,3,13)) {
1938 if (errno == ENOENT)
1940 "pppd is unable to open the /dev/ppp device.\n"
1941 "You need to create the /dev/ppp device node by\n"
1942 "executing the following command as root:\n"
1943 " mknod /dev/ppp c 108 0\n";
1948 * Open a socket for doing the ioctl operations.
1950 s = socket(AF_INET, SOCK_DGRAM, 0);
1954 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1955 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1957 * If the device did not exist then attempt to create one by putting the
1958 * current tty into the PPP discipline. If this works then obtain the
1959 * flags for the device again.
1962 if (ppp_registered()) {
1963 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1964 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1968 * Ensure that the hardware address is for PPP and not something else
1971 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1973 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1977 * This is the PPP device. Validate the version of the driver at this
1978 * point to ensure that this program will work with the driver.
1981 char abBuffer [1024];
1983 ifr.ifr_data = abBuffer;
1984 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1986 error("Couldn't read driver version: %m");
1988 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1991 decode_version(abBuffer,
1993 &driver_modification,
1996 * Validate the version of the driver against the version that we used.
1998 decode_version(VERSION,
2003 /* The version numbers must match */
2004 if (driver_version != my_version)
2007 /* The modification levels must be legal */
2008 if (driver_modification < 3) {
2009 if (driver_modification >= 2) {
2010 /* we can cope with 2.2.0 and above */
2019 slprintf(route_buffer, sizeof(route_buffer),
2020 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2021 driver_version, driver_modification, driver_patch);
2023 no_ppp_msg = route_buffer;
2030 /********************************************************************
2032 * Update the wtmp file with the appropriate user name and tty device.
2035 void logwtmp (const char *line, const char *name, const char *host)
2037 struct utmp ut, *utp;
2038 pid_t mypid = getpid();
2044 * Update the signon database for users.
2045 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2047 utmpname(_PATH_UTMP);
2049 while ((utp = getutent()) && (utp->ut_pid != mypid))
2052 /* Is this call really necessary? There is another one after the 'put' */
2056 memcpy(&ut, utp, sizeof(ut));
2058 /* some gettys/telnetds don't initialize utmp... */
2059 memset(&ut, 0, sizeof(ut));
2061 if (ut.ut_id[0] == 0)
2062 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2064 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2065 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2069 ut.ut_type = USER_PROCESS;
2072 /* Insert the host name if one is supplied */
2074 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2076 /* Insert the IP address of the remote system if IP is enabled */
2077 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2078 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2079 sizeof(ut.ut_addr));
2081 /* CL: Makes sure that the logout works */
2082 if (*host == 0 && *name==0)
2088 * Update the wtmp file.
2091 updwtmp(_PATH_WTMP, &ut);
2093 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2095 flock(wtmp, LOCK_EX);
2097 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2098 warn("error writing %s: %m", _PATH_WTMP);
2100 flock(wtmp, LOCK_UN);
2108 /********************************************************************
2110 * sifvjcomp - config tcp header compression
2113 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2115 u_int x = get_flags(ppp_dev_fd);
2118 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2119 if (! ok_error (errno))
2120 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2125 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2126 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2127 set_flags (ppp_dev_fd, x);
2132 /********************************************************************
2134 * sifup - Config the interface up and enable IP packets to pass.
2141 memset (&ifr, '\0', sizeof (ifr));
2142 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2143 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2144 if (! ok_error (errno))
2145 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2149 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2150 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2151 if (! ok_error (errno))
2152 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2160 /********************************************************************
2162 * sifdown - Disable the indicated protocol and config the interface
2163 * down if there are no remaining protocols.
2170 if (if_is_up && --if_is_up > 0)
2173 memset (&ifr, '\0', sizeof (ifr));
2174 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2175 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2176 if (! ok_error (errno))
2177 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2181 ifr.ifr_flags &= ~IFF_UP;
2182 ifr.ifr_flags |= IFF_POINTOPOINT;
2183 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2184 if (! ok_error (errno))
2185 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2191 /********************************************************************
2193 * sifaddr - Config the interface IP addresses and netmask.
2196 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2202 memset (&ifr, '\0', sizeof (ifr));
2203 memset (&rt, '\0', sizeof (rt));
2205 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2206 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2207 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2209 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2211 * Set our IP address
2213 SIN_ADDR(ifr.ifr_addr) = our_adr;
2214 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2215 if (errno != EEXIST) {
2216 if (! ok_error (errno))
2217 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2220 warn("ioctl(SIOCSIFADDR): Address already exists");
2225 * Set the gateway address
2227 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2228 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2229 if (! ok_error (errno))
2230 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2235 * For recent kernels, force the netmask to 255.255.255.255.
2237 if (kernel_version >= KVERSION(2,1,16))
2239 if (net_mask != 0) {
2240 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2241 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2242 if (! ok_error (errno))
2243 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2248 * Add the device route
2250 if (kernel_version < KVERSION(2,1,16)) {
2251 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2252 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2255 SIN_ADDR(rt.rt_gateway) = 0L;
2256 SIN_ADDR(rt.rt_dst) = his_adr;
2257 rt.rt_flags = RTF_UP | RTF_HOST;
2259 if (kernel_version > KVERSION(2,1,0)) {
2260 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2261 SIN_ADDR(rt.rt_genmask) = -1L;
2264 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2265 if (! ok_error (errno))
2266 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2271 /* set ip_dynaddr in demand mode if address changes */
2272 if (demand && tune_kernel && !dynaddr_set
2273 && our_old_addr && our_old_addr != our_adr) {
2274 /* set ip_dynaddr if possible */
2278 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2279 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2280 if (write(fd, "1", 1) != 1)
2281 error("Couldn't enable dynamic IP addressing: %m");
2284 dynaddr_set = 1; /* only 1 attempt */
2291 /********************************************************************
2293 * cifaddr - Clear the interface IP addresses, and delete routes
2294 * through the interface if possible.
2297 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2301 if (kernel_version < KVERSION(2,1,16)) {
2303 * Delete the route through the device
2306 memset (&rt, '\0', sizeof (rt));
2308 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2309 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2312 SIN_ADDR(rt.rt_gateway) = 0;
2313 SIN_ADDR(rt.rt_dst) = his_adr;
2314 rt.rt_flags = RTF_UP | RTF_HOST;
2316 if (kernel_version > KVERSION(2,1,0)) {
2317 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2318 SIN_ADDR(rt.rt_genmask) = -1L;
2321 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2322 if (still_ppp() && ! ok_error (errno))
2323 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2328 /* This way it is possible to have an IPX-only or IPv6-only interface */
2329 memset(&ifr, 0, sizeof(ifr));
2330 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2331 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2333 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2334 if (! ok_error (errno)) {
2335 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2340 our_old_addr = our_adr;
2346 /********************************************************************
2348 * sif6addr - Config the interface with an IPv6 link-local address
2350 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2352 struct in6_ifreq ifr6;
2354 struct in6_rtmsg rt6;
2358 error("IPv6 socket creation failed: %m");
2361 memset(&ifr, 0, sizeof (ifr));
2362 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2363 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2364 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2368 /* Local interface */
2369 memset(&ifr6, 0, sizeof(ifr6));
2370 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2371 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2372 ifr6.ifr6_prefixlen = 10;
2374 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2375 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2379 /* Route to remote host */
2380 memset(&rt6, 0, sizeof(rt6));
2381 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2382 rt6.rtmsg_flags = RTF_UP;
2383 rt6.rtmsg_dst_len = 10;
2384 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2385 rt6.rtmsg_metric = 1;
2387 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2388 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2396 /********************************************************************
2398 * cif6addr - Remove IPv6 address from interface
2400 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2403 struct in6_ifreq ifr6;
2407 error("IPv6 socket creation failed: %m");
2410 memset(&ifr, 0, sizeof(ifr));
2411 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2412 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2413 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2417 memset(&ifr6, 0, sizeof(ifr6));
2418 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2419 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2420 ifr6.ifr6_prefixlen = 10;
2422 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2423 if (errno != EADDRNOTAVAIL) {
2424 if (! ok_error (errno))
2425 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2428 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2437 * get_pty - get a pty master/slave pair and chown the slave side
2438 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2441 get_pty(master_fdp, slave_fdp, slave_name, uid)
2447 int i, mfd, sfd = -1;
2449 struct termios tios;
2453 * Try the unix98 way first.
2455 mfd = open("/dev/ptmx", O_RDWR);
2458 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2459 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2460 chmod(pty_name, S_IRUSR | S_IWUSR);
2463 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2464 warn("Couldn't unlock pty slave %s: %m", pty_name);
2466 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2467 warn("Couldn't open pty slave %s: %m", pty_name);
2470 #endif /* TIOCGPTN */
2473 /* the old way - scan through the pty name space */
2474 for (i = 0; i < 64; ++i) {
2475 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2476 'p' + i / 16, i % 16);
2477 mfd = open(pty_name, O_RDWR, 0);
2480 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2482 fchown(sfd, uid, -1);
2483 fchmod(sfd, S_IRUSR | S_IWUSR);
2494 strlcpy(slave_name, pty_name, 16);
2497 if (tcgetattr(sfd, &tios) == 0) {
2498 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2499 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2500 tios.c_iflag = IGNPAR;
2503 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2504 warn("couldn't set attributes on pty: %m");
2506 warn("couldn't get attributes on pty: %m");
2511 /********************************************************************
2513 * open_loopback - open the device we use for getting packets
2514 * in demand mode. Under Linux, we use a pty master/slave pair.
2517 open_ppp_loopback(void)
2522 if (new_style_driver) {
2523 /* allocate ourselves a ppp unit */
2524 if (make_ppp_unit() < 0)
2526 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2527 set_kdebugflag(kdebugflag);
2532 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2533 fatal("No free pty for loopback");
2534 SYSDEBUG(("using %s for loopback", loop_name));
2536 set_ppp_fd(slave_fd);
2538 flags = fcntl(master_fd, F_GETFL);
2540 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2541 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2543 flags = fcntl(ppp_fd, F_GETFL);
2545 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2546 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2548 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2549 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2551 * Find out which interface we were given.
2553 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2554 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2556 * Enable debug in the driver if requested.
2558 set_kdebugflag (kdebugflag);
2563 /********************************************************************
2565 * sifnpmode - Set the mode for handling packets for a given NP.
2569 sifnpmode(u, proto, mode)
2576 npi.protocol = proto;
2578 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2579 if (! ok_error (errno))
2580 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2581 proto, mode, errno);
2588 /********************************************************************
2590 * sipxfaddr - Config the interface IPX networknumber
2593 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2600 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2602 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2604 if (! ok_error (errno))
2605 dbglog("socket(AF_IPX): %m (%d)", errno);
2609 memset (&ifr, '\0', sizeof (ifr));
2610 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2612 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2613 sipx->sipx_family = AF_IPX;
2614 sipx->sipx_port = 0;
2615 sipx->sipx_network = htonl (network);
2616 sipx->sipx_type = IPX_FRAME_ETHERII;
2617 sipx->sipx_action = IPX_CRTITF;
2619 * Set the IPX device
2621 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2623 if (errno != EEXIST) {
2624 if (! ok_error (errno))
2625 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2628 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2637 /********************************************************************
2639 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2640 * are removed and the device is no longer able to pass IPX
2644 int cipxfaddr (int unit)
2651 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2653 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2655 if (! ok_error (errno))
2656 dbglog("socket(AF_IPX): %m (%d)", errno);
2660 memset (&ifr, '\0', sizeof (ifr));
2661 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2663 sipx->sipx_type = IPX_FRAME_ETHERII;
2664 sipx->sipx_action = IPX_DLTITF;
2665 sipx->sipx_family = AF_IPX;
2667 * Set the IPX device
2669 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2670 if (! ok_error (errno))
2671 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2681 * Use the hostname as part of the random number seed.
2690 for (p = hostname; *p != 0; ++p)
2695 /********************************************************************
2697 * sys_check_options - check the options that the user specified
2701 sys_check_options(void)
2705 * Disable the IPX protocol if the support is not present in the kernel.
2709 if (ipxcp_protent.enabled_flag) {
2710 struct stat stat_buf;
2711 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2712 || lstat(path, &stat_buf) < 0) {
2713 error("IPX support is not present in the kernel\n");
2714 ipxcp_protent.enabled_flag = 0;
2718 if (demand && driver_is_old) {
2719 option_error("demand dialling is not supported by kernel driver "
2720 "version %d.%d.%d", driver_version, driver_modification,
2724 if (multilink && !new_style_driver) {
2725 warn("Warning: multilink is not supported by the kernel driver");