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 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
267 setlogmask(LOG_UPTO(LOG_INFO));
269 setlogmask(LOG_UPTO(LOG_DEBUG));
271 if (new_style_driver) {
272 ppp_dev_fd = open("/dev/ppp", O_RDWR);
274 fatal("Couldn't open /dev/ppp: %m");
275 flags = fcntl(ppp_dev_fd, F_GETFL);
277 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
278 warn("Couldn't set /dev/ppp to nonblock: %m");
281 /* Get an internet socket for doing socket ioctls. */
282 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
284 fatal("Couldn't create IP socket: %m(%d)", errno);
287 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
289 sock6_fd = -errno; /* save errno for later */
296 /********************************************************************
298 * sys_cleanup - restore any system state we modified before exiting:
299 * mark the interface down, delete default route and/or proxy arp entry.
300 * This shouldn't call die() because it's called from die().
303 void sys_cleanup(void)
306 * Take down the device
313 * Delete any routes through the device.
315 if (default_route_gateway != 0)
316 cifdefaultroute(0, 0, default_route_gateway);
319 cifproxyarp(0, proxy_arp_addr);
322 /********************************************************************
324 * sys_close - Clean up in a child process before execing.
329 if (new_style_driver)
340 /********************************************************************
342 * set_kdebugflag - Define the debugging level for the kernel
345 static int set_kdebugflag (int requested_level)
347 if (new_style_driver && ifunit < 0)
349 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
350 if ( ! ok_error (errno) )
351 error("ioctl(PPPIOCSDEBUG): %m");
354 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
359 /********************************************************************
361 * establish_ppp - Turn the serial port into a ppp interface.
364 int establish_ppp (int tty_fd)
370 * Ensure that the tty device is in exclusive mode.
372 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
373 if ( ! ok_error ( errno ))
374 warn("Couldn't make tty exclusive: %m");
377 * Demand mode - prime the old ppp device to relinquish the unit.
379 if (!new_style_driver && looped
380 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
381 error("ioctl(transfer ppp unit): %m");
385 * Set the current tty to the PPP discpline
389 #define N_SYNC_PPP 14
391 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
392 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
393 if ( ! ok_error (errno) ) {
394 error("Couldn't set tty to PPP discipline: %m");
399 if (new_style_driver) {
400 /* Open another instance of /dev/ppp and connect the channel to it */
403 if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
404 error("Couldn't get channel number: %m");
407 dbglog("using channel %d", chindex);
408 fd = open("/dev/ppp", O_RDWR);
410 error("Couldn't reopen /dev/ppp: %m");
413 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
414 error("Couldn't attach to channel %d: %m", chindex);
417 flags = fcntl(fd, F_GETFL);
418 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
419 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
424 if (!looped && !multilink) {
426 * Create a new PPP unit.
428 if (make_ppp_unit() < 0)
433 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
437 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
438 error("Couldn't attach to PPP unit %d: %m", ifunit);
445 * Old-style driver: find out which interface we were given.
448 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
449 if (ok_error (errno))
451 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
453 /* Check that we got the same unit again. */
454 if (looped && x != ifunit)
455 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
459 * Fetch the initial file flags and reset blocking mode on the file.
461 initfdflags = fcntl(tty_fd, F_GETFL);
462 if (initfdflags == -1 ||
463 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
464 if ( ! ok_error (errno))
465 warn("Couldn't set device to non-blocking mode: %m");
472 * Enable debug in the driver if requested.
475 set_kdebugflag (kdebugflag);
477 set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
478 SC_RCV_EVNP | SC_RCV_ODDP));
480 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
481 driver_version, driver_modification, driver_patch));
488 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
489 warn("Couldn't reset tty to normal line discipline: %m");
493 /********************************************************************
495 * disestablish_ppp - Restore the serial port to normal operation.
496 * This shouldn't call die() because it's called from die().
499 void 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) {
531 if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
532 error("Couldn't release PPP unit: %m");
534 remove_fd(ppp_dev_fd);
539 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
540 * Assumes new_style_driver.
542 static int make_ppp_unit()
547 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
548 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
549 warn("Couldn't allocate PPP unit %d as it is already in use");
551 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
554 error("Couldn't create new ppp unit: %m");
559 * cfg_bundle - configure the existing bundle.
560 * Used in demand mode.
562 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
566 if (!new_style_driver)
569 /* set the mrru, mtu and flags */
570 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
571 error("Couldn't set MRRU: %m");
572 flags = get_flags(ppp_dev_fd);
573 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
574 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
575 | (mrru? SC_MULTILINK: 0);
577 set_flags(ppp_dev_fd, flags);
579 /* connect up the channel */
580 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
581 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
586 * make_new_bundle - create a new PPP unit (i.e. a bundle)
587 * and connect our channel to it. This should only get called
588 * if `multilink' was set at the time establish_ppp was called.
589 * In demand mode this uses our existing bundle instead of making
592 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
594 if (!new_style_driver)
597 /* make us a ppp unit */
598 if (make_ppp_unit() < 0)
601 /* set the mrru and flags */
602 cfg_bundle(mrru, mtru, rssn, tssn);
606 * bundle_attach - attach our link to a given PPP unit.
607 * We assume the unit is controlled by another pppd.
609 int bundle_attach(int ifnum)
611 if (!new_style_driver)
614 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
616 return 0; /* doesn't still exist */
617 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
619 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
620 fatal("Couldn't connect to interface unit %d: %m", ifnum);
621 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
627 /********************************************************************
629 * clean_check - Fetch the flags for the device and generate
630 * appropriate error messages.
632 void clean_check(void)
638 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
640 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
642 s = "all had bit 7 set to 1";
646 s = "all had bit 7 set to 0";
650 s = "all had odd parity";
654 s = "all had even parity";
659 warn("Receive serial link is not 8-bit clean:");
660 warn("Problem: %s", s);
668 * List of valid speeds.
672 int speed_int, speed_val;
755 /********************************************************************
757 * Translate from bits/second to a speed_t.
760 static int translate_speed (int bps)
762 struct speed *speedp;
765 for (speedp = speeds; speedp->speed_int; speedp++) {
766 if (bps == speedp->speed_int)
767 return speedp->speed_val;
769 warn("speed %d not supported", bps);
774 /********************************************************************
776 * Translate from a speed_t to bits/second.
779 static int baud_rate_of (int speed)
781 struct speed *speedp;
784 for (speedp = speeds; speedp->speed_int; speedp++) {
785 if (speed == speedp->speed_val)
786 return speedp->speed_int;
792 /********************************************************************
794 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
795 * at the requested speed, etc. If `local' is true, set CLOCAL
796 * regardless of whether the modem option was specified.
799 void set_up_tty(int tty_fd, int local)
805 if (tcgetattr(tty_fd, &tios) < 0) {
806 if (!ok_error(errno))
807 fatal("tcgetattr: %m(%d)", errno);
814 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
815 tios.c_cflag |= CS8 | CREAD | HUPCL;
817 tios.c_iflag = IGNBRK | IGNPAR;
821 tios.c_cc[VTIME] = 0;
824 tios.c_cflag ^= (CLOCAL | HUPCL);
828 tios.c_cflag |= CRTSCTS;
832 tios.c_iflag |= IXON | IXOFF;
833 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
834 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
838 tios.c_cflag &= ~CRTSCTS;
845 speed = translate_speed(inspeed);
847 cfsetospeed (&tios, speed);
848 cfsetispeed (&tios, speed);
851 * We can't proceed if the serial port speed is B0,
852 * since that implies that the serial port is disabled.
855 speed = cfgetospeed(&tios);
857 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
860 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
861 if (!ok_error(errno))
862 fatal("tcsetattr: %m");
864 baud_rate = baud_rate_of(speed);
868 /********************************************************************
870 * setdtr - control the DTR line on the serial port.
871 * This is called from die(), so it shouldn't call die().
874 void setdtr (int tty_fd, int on)
876 int modembits = TIOCM_DTR;
878 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
881 /********************************************************************
883 * restore_tty - restore the terminal to the saved settings.
886 void restore_tty (int tty_fd)
891 * Turn off echoing, because otherwise we can get into
892 * a loop with the tty and the modem echoing to each other.
893 * We presume we are the sole user of this tty device, so
894 * when we close it, it will revert to its defaults anyway.
897 inittermios.c_lflag &= ~(ECHO | ECHONL);
899 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
900 if (! ok_error (errno))
901 warn("tcsetattr: %m");
906 /********************************************************************
908 * output - Output PPP packet.
911 void output (int unit, unsigned char *p, int len)
917 dbglog("sent %P", p, len);
919 if (len < PPP_HDRLEN)
921 if (new_style_driver) {
924 proto = (p[0] << 8) + p[1];
925 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
928 if (write(fd, p, len) < 0) {
929 if (errno == EWOULDBLOCK || errno == ENOBUFS
930 || errno == ENXIO || errno == EIO || errno == EINTR)
931 warn("write: warning: %m (%d)", errno);
933 error("write: %m (%d)", errno);
937 /********************************************************************
939 * wait_input - wait until there is data available,
940 * for the length of time specified by *timo (indefinite
944 void wait_input(struct timeval *timo)
951 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
952 if (n < 0 && errno != EINTR)
953 fatal("select: %m(%d)", errno);
957 * add_fd - add an fd to the set that wait_input waits for.
967 * remove_fd - remove an fd from the set that wait_input waits for.
969 void remove_fd(int fd)
975 /********************************************************************
977 * read_packet - get a PPP packet from the serial device.
980 int read_packet (unsigned char *buf)
984 len = PPP_MRU + PPP_HDRLEN;
985 if (new_style_driver) {
986 *buf++ = PPP_ALLSTATIONS;
992 nr = read(ppp_fd, buf, len);
993 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
996 if (nr < 0 && new_style_driver && ifunit >= 0) {
997 /* N.B. we read ppp_fd first since LCP packets come in there. */
998 nr = read(ppp_dev_fd, buf, len);
999 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1000 error("read /dev/ppp: %m");
1002 return (new_style_driver && nr > 0)? nr+2: nr;
1005 /********************************************************************
1007 * get_loop_output - get outgoing packets from the ppp device,
1008 * and detect when we want to bring the real link up.
1009 * Return value is 1 if we need to bring up the link, 0 otherwise.
1012 get_loop_output(void)
1017 if (new_style_driver) {
1018 while ((n = read_packet(inpacket_buf)) > 0)
1019 if (loop_frame(inpacket_buf, n))
1024 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1025 if (loop_chars(inbuf, n))
1029 fatal("eof on loopback");
1031 if (errno != EWOULDBLOCK)
1032 fatal("read from loopback: %m(%d)", errno);
1038 * netif_set_mtu - set the MTU on the PPP network interface.
1041 netif_set_mtu(int unit, int mtu)
1045 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1047 memset (&ifr, '\0', sizeof (ifr));
1048 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1051 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1052 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
1055 /********************************************************************
1057 * tty_send_config - configure the transmit characteristics of
1058 * the ppp interface.
1061 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1066 * Set the asyncmap and other parameters for the ppp device
1071 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1072 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1073 if (!ok_error(errno))
1074 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1078 x = get_flags(ppp_fd);
1079 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1080 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1081 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1082 set_flags(ppp_fd, x);
1085 /********************************************************************
1087 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1090 void tty_set_xaccm (ext_accm accm)
1092 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1093 accm[0], accm[1], accm[2], accm[3]));
1097 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1098 if ( ! ok_error (errno))
1099 warn("ioctl(set extended ACCM): %m(%d)", errno);
1103 /********************************************************************
1105 * tty_recv_config - configure the receive-side characteristics of
1106 * the ppp interface.
1109 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1111 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1113 * If we were called because the link has gone down then there is nothing
1114 * which may be done. Just return without incident.
1119 * Set the receiver parameters
1121 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1122 if ( ! ok_error (errno))
1123 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1125 if (new_style_driver && ifunit >= 0
1126 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1127 error("Couldn't set MRU in generic PPP layer: %m");
1129 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1130 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1131 if (!ok_error(errno))
1132 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1136 /********************************************************************
1138 * ccp_test - ask kernel whether a given compression method
1139 * is acceptable for use.
1142 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1144 struct ppp_option_data data;
1146 memset (&data, '\0', sizeof (data));
1148 data.length = opt_len;
1149 data.transmit = for_transmit;
1151 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1154 return (errno == ENOBUFS)? 0: -1;
1157 /********************************************************************
1159 * ccp_flags_set - inform kernel about the current state of CCP.
1162 void ccp_flags_set (int unit, int isopen, int isup)
1165 int x = get_flags(ppp_dev_fd);
1166 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1167 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1168 set_flags (ppp_dev_fd, x);
1174 * set_filters - set the active and pass filters in the kernel driver.
1176 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1178 struct sock_fprog fp;
1180 fp.len = pass->bf_len;
1181 fp.filter = (struct sock_filter *) pass->bf_insns;
1182 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1183 if (errno == ENOTTY)
1184 warn("kernel does not support PPP filtering");
1186 error("Couldn't set pass-filter in kernel: %m");
1189 fp.len = active->bf_len;
1190 fp.filter = (struct sock_filter *) active->bf_insns;
1191 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1192 error("Couldn't set active-filter in kernel: %m");
1197 #endif /* PPP_FILTER */
1199 /********************************************************************
1201 * get_idle_time - return how long the link has been idle.
1204 get_idle_time(u, ip)
1206 struct ppp_idle *ip;
1208 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1211 /********************************************************************
1213 * get_ppp_stats - return statistics for the link.
1216 get_ppp_stats(u, stats)
1218 struct pppd_stats *stats;
1220 struct ifpppstatsreq req;
1222 memset (&req, 0, sizeof (req));
1224 req.stats_ptr = (caddr_t) &req.stats;
1225 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1226 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1227 error("Couldn't get PPP statistics: %m");
1230 stats->bytes_in = req.stats.p.ppp_ibytes;
1231 stats->bytes_out = req.stats.p.ppp_obytes;
1235 /********************************************************************
1237 * ccp_fatal_error - returns 1 if decompression was disabled as a
1238 * result of an error detected after decompression of a packet,
1239 * 0 otherwise. This is necessary because of patent nonsense.
1242 int ccp_fatal_error (int unit)
1244 int x = get_flags(ppp_dev_fd);
1246 return x & SC_DC_FERROR;
1249 /********************************************************************
1251 * path_to_procfs - find the path to the proc file system mount point
1253 static char proc_path[MAXPATHLEN];
1254 static int proc_path_len;
1256 static char *path_to_procfs(const char *tail)
1258 struct mntent *mntent;
1261 if (proc_path_len == 0) {
1262 /* Default the mount location of /proc */
1263 strlcpy (proc_path, "/proc", sizeof(proc_path));
1265 fp = fopen(MOUNTED, "r");
1267 while ((mntent = getmntent(fp)) != NULL) {
1268 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1270 if (strcmp(mntent->mnt_type, "proc") == 0) {
1271 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1272 proc_path_len = strlen(proc_path);
1280 strlcpy(proc_path + proc_path_len, tail,
1281 sizeof(proc_path) - proc_path_len);
1286 * /proc/net/route parsing stuff.
1288 #define ROUTE_MAX_COLS 12
1289 FILE *route_fd = (FILE *) 0;
1290 static char route_buffer[512];
1291 static int route_dev_col, route_dest_col, route_gw_col;
1292 static int route_flags_col, route_mask_col;
1293 static int route_num_cols;
1295 static int open_route_table (void);
1296 static void close_route_table (void);
1297 static int read_route_table (struct rtentry *rt);
1299 /********************************************************************
1301 * close_route_table - close the interface to the route table
1304 static void close_route_table (void)
1306 if (route_fd != (FILE *) 0) {
1308 route_fd = (FILE *) 0;
1312 /********************************************************************
1314 * open_route_table - open the interface to the route table
1316 static char route_delims[] = " \t\n";
1318 static int open_route_table (void)
1322 close_route_table();
1324 path = path_to_procfs("/net/route");
1325 route_fd = fopen (path, "r");
1326 if (route_fd == NULL) {
1327 error("can't open routing table %s: %m", path);
1331 route_dev_col = 0; /* default to usual columns */
1334 route_flags_col = 3;
1338 /* parse header line */
1339 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1340 char *p = route_buffer, *q;
1342 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1344 if ((q = strtok(p, route_delims)) == 0)
1346 if (strcasecmp(q, "iface") == 0)
1347 route_dev_col = col;
1348 else if (strcasecmp(q, "destination") == 0)
1349 route_dest_col = col;
1350 else if (strcasecmp(q, "gateway") == 0)
1352 else if (strcasecmp(q, "flags") == 0)
1353 route_flags_col = col;
1354 else if (strcasecmp(q, "mask") == 0)
1355 route_mask_col = col;
1358 if (used && col >= route_num_cols)
1359 route_num_cols = col + 1;
1367 /********************************************************************
1369 * read_route_table - read the next entry from the route table
1372 static int read_route_table(struct rtentry *rt)
1374 char *cols[ROUTE_MAX_COLS], *p;
1377 memset (rt, '\0', sizeof (struct rtentry));
1379 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1383 for (col = 0; col < route_num_cols; ++col) {
1384 cols[col] = strtok(p, route_delims);
1385 if (cols[col] == NULL)
1386 return 0; /* didn't get enough columns */
1390 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1391 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1392 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1394 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1395 rt->rt_dev = cols[route_dev_col];
1400 /********************************************************************
1402 * defaultroute_exists - determine if there is a default route
1405 static int defaultroute_exists (struct rtentry *rt)
1409 if (!open_route_table())
1412 while (read_route_table(rt) != 0) {
1413 if ((rt->rt_flags & RTF_UP) == 0)
1416 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1418 if (SIN_ADDR(rt->rt_dst) == 0L) {
1424 close_route_table();
1429 * have_route_to - determine if the system has any route to
1430 * a given IP address. `addr' is in network byte order.
1431 * Return value is 1 if yes, 0 if no, -1 if don't know.
1432 * For demand mode to work properly, we have to ignore routes
1433 * through our own interface.
1435 int have_route_to(u_int32_t addr)
1440 if (!open_route_table())
1441 return -1; /* don't know */
1443 while (read_route_table(&rt)) {
1444 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1446 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1452 close_route_table();
1456 /********************************************************************
1458 * sifdefaultroute - assign a default route through the address given.
1461 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1465 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1466 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1468 if (old_gateway != gateway)
1469 error("not replacing existing default route to %s [%I]",
1470 rt.rt_dev, old_gateway);
1474 memset (&rt, '\0', sizeof (rt));
1475 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1476 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1478 if (kernel_version > KVERSION(2,1,0)) {
1479 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1480 SIN_ADDR(rt.rt_genmask) = 0L;
1483 SIN_ADDR(rt.rt_gateway) = gateway;
1485 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1486 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1487 if ( ! ok_error ( errno ))
1488 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1492 default_route_gateway = gateway;
1496 /********************************************************************
1498 * cifdefaultroute - delete a default route through the address given.
1501 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1505 default_route_gateway = 0;
1507 memset (&rt, '\0', sizeof (rt));
1508 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1509 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1511 if (kernel_version > KVERSION(2,1,0)) {
1512 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1513 SIN_ADDR(rt.rt_genmask) = 0L;
1516 SIN_ADDR(rt.rt_gateway) = gateway;
1518 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1519 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1521 if ( ! ok_error ( errno ))
1522 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1530 /********************************************************************
1532 * sifproxyarp - Make a proxy ARP entry for the peer.
1535 int sifproxyarp (int unit, u_int32_t his_adr)
1537 struct arpreq arpreq;
1540 if (has_proxy_arp == 0) {
1541 memset (&arpreq, '\0', sizeof(arpreq));
1543 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1544 SIN_ADDR(arpreq.arp_pa) = his_adr;
1545 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1547 * Get the hardware address of an interface on the same subnet
1548 * as our local address.
1550 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1551 sizeof(proxy_arp_dev))) {
1552 error("Cannot determine ethernet address for proxy ARP");
1555 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1557 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1558 if ( ! ok_error ( errno ))
1559 error("ioctl(SIOCSARP): %m(%d)", errno);
1562 proxy_arp_addr = his_adr;
1566 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1567 if (forw_path != 0) {
1568 int fd = open(forw_path, O_WRONLY);
1570 if (write(fd, "1", 1) != 1)
1571 error("Couldn't enable IP forwarding: %m");
1581 /********************************************************************
1583 * cifproxyarp - Delete the proxy ARP entry for the peer.
1586 int cifproxyarp (int unit, u_int32_t his_adr)
1588 struct arpreq arpreq;
1590 if (has_proxy_arp) {
1592 memset (&arpreq, '\0', sizeof(arpreq));
1593 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1594 SIN_ADDR(arpreq.arp_pa) = his_adr;
1595 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1596 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1598 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1599 if ( ! ok_error ( errno ))
1600 warn("ioctl(SIOCDARP): %m(%d)", errno);
1607 /********************************************************************
1609 * get_ether_addr - get the hardware address of an interface on the
1610 * the same subnet as ipaddr.
1613 static int get_ether_addr (u_int32_t ipaddr,
1614 struct sockaddr *hwaddr,
1615 char *name, int namelen)
1617 struct ifreq *ifr, *ifend;
1618 u_int32_t ina, mask;
1622 struct ifreq ifs[MAX_IFS];
1624 ifc.ifc_len = sizeof(ifs);
1626 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1627 if ( ! ok_error ( errno ))
1628 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1632 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1633 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1635 * Scan through looking for an interface with an Internet
1636 * address on the same subnet as `ipaddr'.
1638 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1639 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1640 if (ifr->ifr_addr.sa_family == AF_INET) {
1641 ina = SIN_ADDR(ifr->ifr_addr);
1642 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1643 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1646 * Check that the interface is up, and not point-to-point
1649 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1652 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1655 * Get its netmask and check that it's on the right subnet.
1657 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1660 mask = SIN_ADDR(ifreq.ifr_addr);
1661 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1662 ip_ntoa(ina), ntohl(mask)));
1664 if (((ipaddr ^ ina) & mask) != 0)
1673 strlcpy(name, ifreq.ifr_name, namelen);
1675 /* trim off the :1 in eth0:1 */
1676 aliasp = strchr(name, ':');
1680 info("found interface %s for proxy arp", name);
1682 * Now get the hardware address.
1684 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1685 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1686 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1692 sizeof (struct sockaddr));
1694 SYSDEBUG ((LOG_DEBUG,
1695 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1696 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1697 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1698 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1699 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1700 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1701 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1702 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1703 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1708 * get_if_hwaddr - get the hardware address for the specified
1709 * network interface device.
1712 get_if_hwaddr(u_char *addr, char *name)
1717 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1720 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1721 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1722 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1725 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1730 * get_first_ethernet - return the name of the first ethernet-style
1731 * interface on this system.
1734 get_first_ethernet()
1739 /********************************************************************
1741 * Return user specified netmask, modified by any mask we might determine
1742 * for address `addr' (in network byte order).
1743 * Here we scan through the system's list of interfaces, looking for
1744 * any non-point-to-point interfaces which might appear to be on the same
1745 * network as `addr'. If we find any, we OR in their netmask to the
1746 * user-specified netmask.
1749 u_int32_t GetMask (u_int32_t addr)
1751 u_int32_t mask, nmask, ina;
1752 struct ifreq *ifr, *ifend, ifreq;
1754 struct ifreq ifs[MAX_IFS];
1758 if (IN_CLASSA(addr)) /* determine network mask for address class */
1759 nmask = IN_CLASSA_NET;
1760 else if (IN_CLASSB(addr))
1761 nmask = IN_CLASSB_NET;
1763 nmask = IN_CLASSC_NET;
1765 /* class D nets are disallowed by bad_ip_adrs */
1766 mask = netmask | htonl(nmask);
1768 * Scan through the system's network interfaces.
1770 ifc.ifc_len = sizeof(ifs);
1772 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1773 if ( ! ok_error ( errno ))
1774 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1778 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1779 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1781 * Check the interface's internet address.
1783 if (ifr->ifr_addr.sa_family != AF_INET)
1785 ina = SIN_ADDR(ifr->ifr_addr);
1786 if (((ntohl(ina) ^ addr) & nmask) != 0)
1789 * Check that the interface is up, and not point-to-point nor loopback.
1791 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1792 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1795 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1798 * Get its netmask and OR it into our mask.
1800 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1802 mask |= SIN_ADDR(ifreq.ifr_addr);
1808 /********************************************************************
1810 * Internal routine to decode the version.modification.patch level
1813 static void decode_version (char *buf, int *version,
1814 int *modification, int *patch)
1816 *version = (int) strtoul (buf, &buf, 10);
1822 *modification = (int) strtoul (buf, &buf, 10);
1825 *patch = (int) strtoul (buf, &buf, 10);
1836 /********************************************************************
1838 * Procedure to determine if the PPP line discipline is registered.
1842 ppp_registered(void)
1850 * We used to open the serial device and set it to the ppp line
1851 * discipline here, in order to create a ppp unit. But that is
1852 * not a good idea - the user might have specified a device that
1853 * they can't open (permission, or maybe it doesn't really exist).
1854 * So we grab a pty master/slave pair and use that.
1856 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1857 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1862 * Try to put the device into the PPP discipline.
1864 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1865 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1874 /********************************************************************
1876 * ppp_available - check whether the system has any ppp interfaces
1877 * (in fact we check whether we can do an ioctl on ppp0).
1880 int ppp_available(void)
1885 int my_version, my_modification, my_patch;
1886 int osmaj, osmin, ospatch;
1889 "This system lacks kernel support for PPP. This could be because\n"
1890 "the PPP kernel module could not be loaded, or because PPP was not\n"
1891 "included in the kernel configuration. If PPP was included as a\n"
1892 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1893 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1894 "See README.linux file in the ppp distribution for more details.\n";
1896 /* get the kernel version now, since we are called before sys_init */
1898 osmaj = osmin = ospatch = 0;
1899 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1900 kernel_version = KVERSION(osmaj, osmin, ospatch);
1902 fd = open("/dev/ppp", O_RDWR);
1904 if (fd < 0 && errno == ENOENT) {
1905 /* try making it and see if that helps. */
1906 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1907 makedev(108, 0)) >= 0) {
1908 fd = open("/dev/ppp", O_RDWR);
1910 info("Created /dev/ppp device node");
1912 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1913 } else if (errno == EEXIST) {
1914 fd = open("/dev/ppp", O_RDWR);
1919 new_style_driver = 1;
1921 /* XXX should get from driver */
1923 driver_modification = 4;
1928 if (kernel_version >= KVERSION(2,3,13))
1932 * Open a socket for doing the ioctl operations.
1934 s = socket(AF_INET, SOCK_DGRAM, 0);
1938 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1939 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1941 * If the device did not exist then attempt to create one by putting the
1942 * current tty into the PPP discipline. If this works then obtain the
1943 * flags for the device again.
1946 if (ppp_registered()) {
1947 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1948 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1952 * Ensure that the hardware address is for PPP and not something else
1955 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1957 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1961 * This is the PPP device. Validate the version of the driver at this
1962 * point to ensure that this program will work with the driver.
1965 char abBuffer [1024];
1967 ifr.ifr_data = abBuffer;
1968 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1970 error("Couldn't read driver version: %m");
1972 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1975 decode_version(abBuffer,
1977 &driver_modification,
1980 * Validate the version of the driver against the version that we used.
1982 decode_version(VERSION,
1987 /* The version numbers must match */
1988 if (driver_version != my_version)
1991 /* The modification levels must be legal */
1992 if (driver_modification < 3) {
1993 if (driver_modification >= 2) {
1994 /* we can cope with 2.2.0 and above */
2003 slprintf(route_buffer, sizeof(route_buffer),
2004 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2005 driver_version, driver_modification, driver_patch);
2007 no_ppp_msg = route_buffer;
2014 /********************************************************************
2016 * Update the wtmp file with the appropriate user name and tty device.
2019 void logwtmp (const char *line, const char *name, const char *host)
2021 struct utmp ut, *utp;
2022 pid_t mypid = getpid();
2028 * Update the signon database for users.
2029 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2031 utmpname(_PATH_UTMP);
2033 while ((utp = getutent()) && (utp->ut_pid != mypid))
2036 /* Is this call really necessary? There is another one after the 'put' */
2040 memcpy(&ut, utp, sizeof(ut));
2042 /* some gettys/telnetds don't initialize utmp... */
2043 memset(&ut, 0, sizeof(ut));
2045 if (ut.ut_id[0] == 0)
2046 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2048 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2049 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2053 ut.ut_type = USER_PROCESS;
2056 /* Insert the host name if one is supplied */
2058 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2060 /* Insert the IP address of the remote system if IP is enabled */
2061 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2062 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2063 sizeof(ut.ut_addr));
2065 /* CL: Makes sure that the logout works */
2066 if (*host == 0 && *name==0)
2072 * Update the wtmp file.
2075 updwtmp(_PATH_WTMP, &ut);
2077 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2079 flock(wtmp, LOCK_EX);
2081 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2082 warn("error writing %s: %m", _PATH_WTMP);
2084 flock(wtmp, LOCK_UN);
2092 /********************************************************************
2094 * sifvjcomp - config tcp header compression
2097 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2099 u_int x = get_flags(ppp_dev_fd);
2102 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2103 if (! ok_error (errno))
2104 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2109 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2110 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2111 set_flags (ppp_dev_fd, x);
2116 /********************************************************************
2118 * sifup - Config the interface up and enable IP packets to pass.
2125 memset (&ifr, '\0', sizeof (ifr));
2126 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2127 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2128 if (! ok_error (errno))
2129 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2133 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2134 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2135 if (! ok_error (errno))
2136 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2144 /********************************************************************
2146 * sifdown - Disable the indicated protocol and config the interface
2147 * down if there are no remaining protocols.
2154 if (if_is_up && --if_is_up > 0)
2157 memset (&ifr, '\0', sizeof (ifr));
2158 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2159 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2160 if (! ok_error (errno))
2161 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2165 ifr.ifr_flags &= ~IFF_UP;
2166 ifr.ifr_flags |= IFF_POINTOPOINT;
2167 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2168 if (! ok_error (errno))
2169 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2175 /********************************************************************
2177 * sifaddr - Config the interface IP addresses and netmask.
2180 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2186 memset (&ifr, '\0', sizeof (ifr));
2187 memset (&rt, '\0', sizeof (rt));
2189 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2190 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2191 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2193 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2195 * Set our IP address
2197 SIN_ADDR(ifr.ifr_addr) = our_adr;
2198 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2199 if (errno != EEXIST) {
2200 if (! ok_error (errno))
2201 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2204 warn("ioctl(SIOCSIFADDR): Address already exists");
2209 * Set the gateway address
2211 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2212 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2213 if (! ok_error (errno))
2214 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2219 * For recent kernels, force the netmask to 255.255.255.255.
2221 if (kernel_version >= KVERSION(2,1,16))
2223 if (net_mask != 0) {
2224 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2225 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2226 if (! ok_error (errno))
2227 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2232 * Add the device route
2234 if (kernel_version < KVERSION(2,1,16)) {
2235 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2236 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2239 SIN_ADDR(rt.rt_gateway) = 0L;
2240 SIN_ADDR(rt.rt_dst) = his_adr;
2241 rt.rt_flags = RTF_UP | RTF_HOST;
2243 if (kernel_version > KVERSION(2,1,0)) {
2244 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2245 SIN_ADDR(rt.rt_genmask) = -1L;
2248 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2249 if (! ok_error (errno))
2250 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2255 /* set ip_dynaddr in demand mode if address changes */
2256 if (demand && tune_kernel && !dynaddr_set
2257 && our_old_addr && our_old_addr != our_adr) {
2258 /* set ip_dynaddr if possible */
2262 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2263 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2264 if (write(fd, "1", 1) != 1)
2265 error("Couldn't enable dynamic IP addressing: %m");
2268 dynaddr_set = 1; /* only 1 attempt */
2275 /********************************************************************
2277 * cifaddr - Clear the interface IP addresses, and delete routes
2278 * through the interface if possible.
2281 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2285 if (kernel_version < KVERSION(2,1,16)) {
2287 * Delete the route through the device
2290 memset (&rt, '\0', sizeof (rt));
2292 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2293 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2296 SIN_ADDR(rt.rt_gateway) = 0;
2297 SIN_ADDR(rt.rt_dst) = his_adr;
2298 rt.rt_flags = RTF_UP | RTF_HOST;
2300 if (kernel_version > KVERSION(2,1,0)) {
2301 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2302 SIN_ADDR(rt.rt_genmask) = -1L;
2305 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2306 if (still_ppp() && ! ok_error (errno))
2307 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2312 /* This way it is possible to have an IPX-only or IPv6-only interface */
2313 memset(&ifr, 0, sizeof(ifr));
2314 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2315 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2317 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2318 if (! ok_error (errno)) {
2319 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2324 our_old_addr = our_adr;
2330 /********************************************************************
2332 * sif6addr - Config the interface with an IPv6 link-local address
2334 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2336 struct in6_ifreq ifr6;
2338 struct in6_rtmsg rt6;
2342 error("IPv6 socket creation failed: %m");
2345 memset(&ifr, 0, sizeof (ifr));
2346 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2347 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2348 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2352 /* Local interface */
2353 memset(&ifr6, 0, sizeof(ifr6));
2354 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2355 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2356 ifr6.ifr6_prefixlen = 10;
2358 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2359 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2363 /* Route to remote host */
2364 memset(&rt6, 0, sizeof(rt6));
2365 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2366 rt6.rtmsg_flags = RTF_UP;
2367 rt6.rtmsg_dst_len = 10;
2368 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2369 rt6.rtmsg_metric = 1;
2371 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2372 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2380 /********************************************************************
2382 * cif6addr - Remove IPv6 address from interface
2384 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2387 struct in6_ifreq ifr6;
2391 error("IPv6 socket creation failed: %m");
2394 memset(&ifr, 0, sizeof(ifr));
2395 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2396 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2397 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2401 memset(&ifr6, 0, sizeof(ifr6));
2402 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2403 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2404 ifr6.ifr6_prefixlen = 10;
2406 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2407 if (errno != EADDRNOTAVAIL) {
2408 if (! ok_error (errno))
2409 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2412 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2421 * get_pty - get a pty master/slave pair and chown the slave side
2422 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2425 get_pty(master_fdp, slave_fdp, slave_name, uid)
2431 int i, mfd, sfd = -1;
2433 struct termios tios;
2437 * Try the unix98 way first.
2439 mfd = open("/dev/ptmx", O_RDWR);
2442 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2443 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2444 chmod(pty_name, S_IRUSR | S_IWUSR);
2447 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2448 warn("Couldn't unlock pty slave %s: %m", pty_name);
2450 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2451 warn("Couldn't open pty slave %s: %m", pty_name);
2454 #endif /* TIOCGPTN */
2457 /* the old way - scan through the pty name space */
2458 for (i = 0; i < 64; ++i) {
2459 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2460 'p' + i / 16, i % 16);
2461 mfd = open(pty_name, O_RDWR, 0);
2464 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2466 fchown(sfd, uid, -1);
2467 fchmod(sfd, S_IRUSR | S_IWUSR);
2478 strlcpy(slave_name, pty_name, 16);
2481 if (tcgetattr(sfd, &tios) == 0) {
2482 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2483 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2484 tios.c_iflag = IGNPAR;
2487 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2488 warn("couldn't set attributes on pty: %m");
2490 warn("couldn't get attributes on pty: %m");
2495 /********************************************************************
2497 * open_loopback - open the device we use for getting packets
2498 * in demand mode. Under Linux, we use a pty master/slave pair.
2501 open_ppp_loopback(void)
2506 if (new_style_driver) {
2507 /* allocate ourselves a ppp unit */
2508 if (make_ppp_unit() < 0)
2510 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2511 set_kdebugflag(kdebugflag);
2516 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2517 fatal("No free pty for loopback");
2518 SYSDEBUG(("using %s for loopback", loop_name));
2520 set_ppp_fd(slave_fd);
2522 flags = fcntl(master_fd, F_GETFL);
2524 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2525 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2527 flags = fcntl(ppp_fd, F_GETFL);
2529 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2530 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2532 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2533 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2535 * Find out which interface we were given.
2537 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2538 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2540 * Enable debug in the driver if requested.
2542 set_kdebugflag (kdebugflag);
2547 /********************************************************************
2549 * restore_loop - reattach the ppp unit to the loopback.
2551 * The kernel ppp driver automatically reattaches the ppp unit to
2552 * the loopback if the serial port is set to a line discipline other
2553 * than ppp, or if it detects a modem hangup. The former will happen
2554 * in disestablish_ppp if the latter hasn't already happened, so we
2555 * shouldn't need to do anything.
2557 * Just to be sure, set the real serial port to the normal discipline.
2564 if (new_style_driver) {
2565 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2568 if (ppp_fd != slave_fd) {
2569 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2570 set_ppp_fd(slave_fd);
2574 /********************************************************************
2576 * sifnpmode - Set the mode for handling packets for a given NP.
2580 sifnpmode(u, proto, mode)
2587 npi.protocol = proto;
2589 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2590 if (! ok_error (errno))
2591 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2592 proto, mode, errno);
2599 /********************************************************************
2601 * sipxfaddr - Config the interface IPX networknumber
2604 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2611 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2613 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2615 if (! ok_error (errno))
2616 dbglog("socket(AF_IPX): %m (%d)", errno);
2620 memset (&ifr, '\0', sizeof (ifr));
2621 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2623 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2624 sipx->sipx_family = AF_IPX;
2625 sipx->sipx_port = 0;
2626 sipx->sipx_network = htonl (network);
2627 sipx->sipx_type = IPX_FRAME_ETHERII;
2628 sipx->sipx_action = IPX_CRTITF;
2630 * Set the IPX device
2632 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2634 if (errno != EEXIST) {
2635 if (! ok_error (errno))
2636 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2639 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2648 /********************************************************************
2650 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2651 * are removed and the device is no longer able to pass IPX
2655 int cipxfaddr (int unit)
2662 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2664 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2666 if (! ok_error (errno))
2667 dbglog("socket(AF_IPX): %m (%d)", errno);
2671 memset (&ifr, '\0', sizeof (ifr));
2672 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2674 sipx->sipx_type = IPX_FRAME_ETHERII;
2675 sipx->sipx_action = IPX_DLTITF;
2676 sipx->sipx_family = AF_IPX;
2678 * Set the IPX device
2680 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2681 if (! ok_error (errno))
2682 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2692 * Use the hostname as part of the random number seed.
2701 for (p = hostname; *p != 0; ++p)
2706 /********************************************************************
2708 * sys_check_options - check the options that the user specified
2712 sys_check_options(void)
2716 * Disable the IPX protocol if the support is not present in the kernel.
2720 if (ipxcp_protent.enabled_flag) {
2721 struct stat stat_buf;
2722 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2723 || lstat(path, &stat_buf) < 0) {
2724 error("IPX support is not present in the kernel\n");
2725 ipxcp_protent.enabled_flag = 0;
2729 if (demand && driver_is_old) {
2730 option_error("demand dialling is not supported by kernel driver "
2731 "version %d.%d.%d", driver_version, driver_modification,
2735 if (multilink && !new_style_driver) {
2736 warn("Warning: multilink is not supported by the kernel driver");