2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1989 Carnegie Mellon University.
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by Carnegie Mellon University. The name of the
14 * University may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 #include <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
25 #include <sys/errno.h>
28 #include <sys/utsname.h>
29 #include <sys/sysmacros.h>
45 /* This is in netdevice.h. However, this compile will fail miserably if
46 you attempt to include netdevice.h because it has so many references
47 to __memcpy functions which it should not attempt to do. So, since I
48 really don't use it, but it must be defined, define it now. */
51 #define MAX_ADDR_LEN 7
55 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
57 #include <net/if_arp.h>
58 #include <net/route.h>
59 #include <netinet/if_ether.h>
61 #include <linux/types.h>
63 #include <linux/if_arp.h>
64 #include <linux/route.h>
65 #include <linux/if_ether.h>
67 #include <netinet/in.h>
68 #include <arpa/inet.h>
70 #include <linux/ppp_defs.h>
71 #include <linux/if_ppp.h>
76 #include "patchlevel.h"
80 #if __GLIBC__ >= 2 && \
81 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
82 #include <netipx/ipx.h>
84 #include <linux/ipx.h>
86 #endif /* IPX_CHANGE */
90 #include <linux/filter.h>
91 #endif /* PPP_FILTER */
94 #include <sys/locks.h>
100 * This is in linux/include/net/ipv6.h.
104 struct in6_addr ifr6_addr;
105 __u32 ifr6_prefixlen;
106 unsigned int ifr6_ifindex;
110 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
111 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
112 sin6.s6_addr16[0] = htons(0xfe80); \
113 eui64_copy(eui64, sin6.s6_addr32[2]); \
118 /* We can get an EIO error on an ioctl if the modem has hung up */
119 #define ok_error(num) ((num)==EIO)
121 static int tty_disc = N_TTY; /* The TTY discipline */
122 static int ppp_disc = N_PPP; /* The PPP discpline */
123 static int initfdflags = -1; /* Initial file descriptor flags for fd */
124 static int ppp_fd = -1; /* fd which is set to PPP discipline */
125 static int sock_fd = -1; /* socket for doing interface ioctls */
126 static int slave_fd = -1;
127 static int master_fd = -1;
129 static int sock6_fd = -1;
131 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
132 static int chindex; /* channel index (new style driver) */
134 static fd_set in_fds; /* set of fds that wait_input waits for */
135 static int max_in_fd; /* highest fd set in in_fds */
137 static int has_proxy_arp = 0;
138 static int driver_version = 0;
139 static int driver_modification = 0;
140 static int driver_patch = 0;
141 static int driver_is_old = 0;
142 static int restore_term = 0; /* 1 => we've munged the terminal */
143 static struct termios inittermios; /* Initial TTY termios */
145 static int new_style_driver = 0;
147 static char loop_name[20];
148 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
150 static int if_is_up; /* Interface has been marked up */
151 static u_int32_t default_route_gateway; /* Gateway for default route added */
152 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
153 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
154 static u_int32_t our_old_addr; /* for detecting address changes */
155 static int dynaddr_set; /* 1 if ip_dynaddr set */
156 static int looped; /* 1 if using loop */
157 static int link_mtu; /* mtu for the link (not bundle) */
159 static struct utsname utsname; /* for the kernel version */
160 static int kernel_version;
161 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
165 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
166 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
167 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
169 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
171 /* Prototypes for procedures local to this file. */
172 static int get_flags (int fd);
173 static void set_flags (int fd, int flags);
174 static int translate_speed (int bps);
175 static int baud_rate_of (int speed);
176 static void close_route_table (void);
177 static int open_route_table (void);
178 static int read_route_table (struct rtentry *rt);
179 static int defaultroute_exists (struct rtentry *rt);
180 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
181 char *name, int namelen);
182 static void decode_version (char *buf, int *version, int *mod, int *patch);
183 static int set_kdebugflag(int level);
184 static int ppp_registered(void);
185 static int make_ppp_unit(void);
187 extern u_char inpacket_buf[]; /* borrowed from main.c */
190 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
194 #define SET_SA_FAMILY(addr, family) \
195 memset ((char *) &(addr), '\0', sizeof(addr)); \
196 addr.sa_family = (family);
199 * Determine if the PPP connection should still be present.
204 /* new_fd is the fd of a tty */
205 static void set_ppp_fd (int new_fd)
207 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
209 if (!new_style_driver)
213 static int still_ppp(void)
215 if (new_style_driver)
216 return !hungup && ppp_fd >= 0;
217 if (!hungup || ppp_fd == slave_fd)
220 set_ppp_fd(slave_fd);
226 /********************************************************************
228 * Functions to read and set the flags value in the device driver
231 static int get_flags (int fd)
235 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
236 if ( ok_error (errno) )
239 fatal("ioctl(PPPIOCGFLAGS): %m");
242 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
246 /********************************************************************/
248 static void set_flags (int fd, int flags)
250 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
252 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
253 if (! ok_error (errno) )
254 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
258 /********************************************************************
260 * sys_init - System-dependent initialization.
267 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
268 setlogmask(LOG_UPTO(LOG_INFO));
270 setlogmask(LOG_UPTO(LOG_DEBUG));
272 if (new_style_driver) {
273 ppp_dev_fd = open("/dev/ppp", O_RDWR);
275 fatal("Couldn't open /dev/ppp: %m");
276 flags = fcntl(ppp_dev_fd, F_GETFL);
278 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
279 warn("Couldn't set /dev/ppp to nonblock: %m");
282 /* Get an internet socket for doing socket ioctls. */
283 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
285 fatal("Couldn't create IP socket: %m(%d)", errno);
288 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
290 sock6_fd = -errno; /* save errno for later */
297 /********************************************************************
299 * sys_cleanup - restore any system state we modified before exiting:
300 * mark the interface down, delete default route and/or proxy arp entry.
301 * This shouldn't call die() because it's called from die().
304 void sys_cleanup(void)
307 * Take down the device
314 * Delete any routes through the device.
316 if (default_route_gateway != 0)
317 cifdefaultroute(0, 0, default_route_gateway);
320 cifproxyarp(0, proxy_arp_addr);
323 /********************************************************************
325 * sys_close - Clean up in a child process before execing.
330 if (new_style_driver)
341 /********************************************************************
343 * set_kdebugflag - Define the debugging level for the kernel
346 static int set_kdebugflag (int requested_level)
348 if (new_style_driver && ifunit < 0)
350 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
351 if ( ! ok_error (errno) )
352 error("ioctl(PPPIOCSDEBUG): %m");
355 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
360 /********************************************************************
362 * establish_ppp - Turn the serial port into a ppp interface.
365 int establish_ppp (int tty_fd)
371 * Ensure that the tty device is in exclusive mode.
373 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
374 if ( ! ok_error ( errno ))
375 warn("Couldn't make tty exclusive: %m");
378 * Demand mode - prime the old ppp device to relinquish the unit.
380 if (!new_style_driver && looped
381 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
382 error("ioctl(transfer ppp unit): %m");
386 * Set the current tty to the PPP discpline
390 #define N_SYNC_PPP 14
392 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
393 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
394 if ( ! ok_error (errno) ) {
395 error("Couldn't set tty to PPP discipline: %m");
400 if (new_style_driver) {
401 /* Open another instance of /dev/ppp and connect the channel to it */
404 if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
405 error("Couldn't get channel number: %m");
408 dbglog("using channel %d", chindex);
409 fd = open("/dev/ppp", O_RDWR);
411 error("Couldn't reopen /dev/ppp: %m");
414 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
415 error("Couldn't attach to channel %d: %m", chindex);
418 flags = fcntl(fd, F_GETFL);
419 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
420 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
425 if (!looped && !multilink) {
427 * Create a new PPP unit.
429 if (make_ppp_unit() < 0)
434 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
438 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
439 error("Couldn't attach to PPP unit %d: %m", ifunit);
446 * Old-style driver: find out which interface we were given.
449 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
450 if (ok_error (errno))
452 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
454 /* Check that we got the same unit again. */
455 if (looped && x != ifunit)
456 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
460 * Fetch the initial file flags and reset blocking mode on the file.
462 initfdflags = fcntl(tty_fd, F_GETFL);
463 if (initfdflags == -1 ||
464 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
465 if ( ! ok_error (errno))
466 warn("Couldn't set device to non-blocking mode: %m");
473 * Enable debug in the driver if requested.
476 set_kdebugflag (kdebugflag);
478 set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
479 SC_RCV_EVNP | SC_RCV_ODDP));
481 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
482 driver_version, driver_modification, driver_patch));
489 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
490 warn("Couldn't reset tty to normal line discipline: %m");
494 /********************************************************************
496 * disestablish_ppp - Restore the serial port to normal operation.
497 * This shouldn't call die() because it's called from die().
500 void disestablish_ppp(int tty_fd)
504 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
506 if (tcflush(tty_fd, TCIOFLUSH) < 0)
507 warn("tcflush failed: %m");
509 * Restore the previous line discipline
511 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
512 if ( ! ok_error (errno))
513 error("ioctl(TIOCSETD, N_TTY): %m");
516 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
517 if ( ! ok_error (errno))
518 warn("ioctl(TIOCNXCL): %m(%d)", errno);
521 /* Reset non-blocking mode on fd. */
522 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
523 if ( ! ok_error (errno))
524 warn("Couldn't restore device fd flags: %m");
529 if (new_style_driver) {
532 if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
533 error("Couldn't release PPP unit: %m");
535 remove_fd(ppp_dev_fd);
540 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
541 * Assumes new_style_driver.
543 static int make_ppp_unit()
548 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
549 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
550 warn("Couldn't allocate PPP unit %d as it is already in use");
552 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
555 error("Couldn't create new ppp unit: %m");
560 * cfg_bundle - configure the existing bundle.
561 * Used in demand mode.
563 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
568 if (!new_style_driver)
571 /* set the mrru, mtu and flags */
572 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
573 error("Couldn't set MRRU: %m");
574 flags = get_flags(ppp_dev_fd);
575 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
576 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0);
578 if (mtru > 0 && mtru != link_mtu) {
579 memset(&ifr, 0, sizeof(ifr));
580 slprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ppp%d", ifunit);
582 if (ioctl(sock_fd, SIOCSIFMTU, &ifr) < 0)
583 error("Couldn't set interface MTU: %m");
584 flags |= SC_MULTILINK;
587 set_flags(ppp_dev_fd, flags);
589 /* connect up the channel */
590 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
591 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
596 * make_new_bundle - create a new PPP unit (i.e. a bundle)
597 * and connect our channel to it. This should only get called
598 * if `multilink' was set at the time establish_ppp was called.
599 * In demand mode this uses our existing bundle instead of making
602 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
604 if (!new_style_driver)
607 /* make us a ppp unit */
608 if (make_ppp_unit() < 0)
611 /* set the mrru, mtu and flags */
612 cfg_bundle(mrru, mtru, rssn, tssn);
616 * bundle_attach - attach our link to a given PPP unit.
617 * We assume the unit is controlled by another pppd.
619 int bundle_attach(int ifnum)
621 if (!new_style_driver)
624 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
626 return 0; /* doesn't still exist */
627 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
629 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
630 fatal("Couldn't connect to interface unit %d: %m", ifnum);
631 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
637 /********************************************************************
639 * clean_check - Fetch the flags for the device and generate
640 * appropriate error messages.
642 void clean_check(void)
648 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
650 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
652 s = "all had bit 7 set to 1";
656 s = "all had bit 7 set to 0";
660 s = "all had odd parity";
664 s = "all had even parity";
669 warn("Receive serial link is not 8-bit clean:");
670 warn("Problem: %s", s);
678 * List of valid speeds.
682 int speed_int, speed_val;
759 /********************************************************************
761 * Translate from bits/second to a speed_t.
764 static int translate_speed (int bps)
766 struct speed *speedp;
769 for (speedp = speeds; speedp->speed_int; speedp++) {
770 if (bps == speedp->speed_int)
771 return speedp->speed_val;
773 warn("speed %d not supported", bps);
778 /********************************************************************
780 * Translate from a speed_t to bits/second.
783 static int baud_rate_of (int speed)
785 struct speed *speedp;
788 for (speedp = speeds; speedp->speed_int; speedp++) {
789 if (speed == speedp->speed_val)
790 return speedp->speed_int;
796 /********************************************************************
798 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
799 * at the requested speed, etc. If `local' is true, set CLOCAL
800 * regardless of whether the modem option was specified.
803 void set_up_tty(int tty_fd, int local)
809 if (tcgetattr(tty_fd, &tios) < 0) {
810 if (!ok_error(errno))
811 fatal("tcgetattr: %m(%d)", errno);
818 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
819 tios.c_cflag |= CS8 | CREAD | HUPCL;
821 tios.c_iflag = IGNBRK | IGNPAR;
825 tios.c_cc[VTIME] = 0;
828 tios.c_cflag ^= (CLOCAL | HUPCL);
832 tios.c_cflag |= CRTSCTS;
836 tios.c_iflag |= IXON | IXOFF;
837 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
838 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
842 tios.c_cflag &= ~CRTSCTS;
849 speed = translate_speed(inspeed);
851 cfsetospeed (&tios, speed);
852 cfsetispeed (&tios, speed);
855 * We can't proceed if the serial port speed is B0,
856 * since that implies that the serial port is disabled.
859 speed = cfgetospeed(&tios);
861 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
864 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
865 if (!ok_error(errno))
866 fatal("tcsetattr: %m");
868 baud_rate = baud_rate_of(speed);
872 /********************************************************************
874 * setdtr - control the DTR line on the serial port.
875 * This is called from die(), so it shouldn't call die().
878 void setdtr (int tty_fd, int on)
880 int modembits = TIOCM_DTR;
882 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
885 /********************************************************************
887 * restore_tty - restore the terminal to the saved settings.
890 void restore_tty (int tty_fd)
895 * Turn off echoing, because otherwise we can get into
896 * a loop with the tty and the modem echoing to each other.
897 * We presume we are the sole user of this tty device, so
898 * when we close it, it will revert to its defaults anyway.
901 inittermios.c_lflag &= ~(ECHO | ECHONL);
903 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
904 if (! ok_error (errno))
905 warn("tcsetattr: %m");
910 /********************************************************************
912 * output - Output PPP packet.
915 void output (int unit, unsigned char *p, int len)
921 dbglog("sent %P", p, len);
923 if (len < PPP_HDRLEN)
925 if (new_style_driver) {
928 proto = (p[0] << 8) + p[1];
929 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
932 if (write(fd, p, len) < 0) {
933 if (errno == EWOULDBLOCK || errno == ENOBUFS
934 || errno == ENXIO || errno == EIO || errno == EINTR)
935 warn("write: warning: %m (%d)", errno);
937 error("write: %m (%d)", errno);
941 /********************************************************************
943 * wait_input - wait until there is data available,
944 * for the length of time specified by *timo (indefinite
948 void wait_input(struct timeval *timo)
955 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
956 if (n < 0 && errno != EINTR)
957 fatal("select: %m(%d)", errno);
961 * add_fd - add an fd to the set that wait_input waits for.
971 * remove_fd - remove an fd from the set that wait_input waits for.
973 void remove_fd(int fd)
979 /********************************************************************
981 * read_packet - get a PPP packet from the serial device.
984 int read_packet (unsigned char *buf)
988 len = PPP_MRU + PPP_HDRLEN;
989 if (new_style_driver) {
990 *buf++ = PPP_ALLSTATIONS;
996 nr = read(ppp_fd, buf, len);
997 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1000 if (nr < 0 && new_style_driver && ifunit >= 0) {
1001 /* N.B. we read ppp_fd first since LCP packets come in there. */
1002 nr = read(ppp_dev_fd, buf, len);
1003 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1004 error("read /dev/ppp: %m");
1006 return (new_style_driver && nr > 0)? nr+2: nr;
1009 /********************************************************************
1011 * get_loop_output - get outgoing packets from the ppp device,
1012 * and detect when we want to bring the real link up.
1013 * Return value is 1 if we need to bring up the link, 0 otherwise.
1016 get_loop_output(void)
1021 if (new_style_driver) {
1022 while ((n = read_packet(inpacket_buf)) > 0)
1023 if (loop_frame(inpacket_buf, n))
1028 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1029 if (loop_chars(inbuf, n))
1033 fatal("eof on loopback");
1035 if (errno != EWOULDBLOCK)
1036 fatal("read from loopback: %m(%d)", errno);
1041 /********************************************************************
1043 * ppp_send_config - configure the transmit characteristics of
1044 * the ppp interface.
1047 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1052 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
1054 * Set the MTU and other parameters for the ppp device
1056 memset (&ifr, '\0', sizeof (ifr));
1057 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1060 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1061 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
1066 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1067 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1068 if (!ok_error(errno))
1069 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1073 x = get_flags(ppp_fd);
1074 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1075 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1076 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1077 set_flags(ppp_fd, x);
1080 /********************************************************************
1082 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1085 void ppp_set_xaccm (int unit, ext_accm accm)
1087 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1088 accm[0], accm[1], accm[2], accm[3]));
1092 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1093 if ( ! ok_error (errno))
1094 warn("ioctl(set extended ACCM): %m(%d)", errno);
1098 /********************************************************************
1100 * ppp_recv_config - configure the receive-side characteristics of
1101 * the ppp interface.
1104 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1106 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1108 * If we were called because the link has gone down then there is nothing
1109 * which may be done. Just return without incident.
1114 * Set the receiver parameters
1116 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1117 if ( ! ok_error (errno))
1118 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1120 if (new_style_driver && ifunit >= 0
1121 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1122 error("Couldn't set MRU in generic PPP layer: %m");
1124 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1125 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1126 if (!ok_error(errno))
1127 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1131 /********************************************************************
1133 * ccp_test - ask kernel whether a given compression method
1134 * is acceptable for use.
1137 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1139 struct ppp_option_data data;
1141 memset (&data, '\0', sizeof (data));
1143 data.length = opt_len;
1144 data.transmit = for_transmit;
1146 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1149 return (errno == ENOBUFS)? 0: -1;
1152 /********************************************************************
1154 * ccp_flags_set - inform kernel about the current state of CCP.
1157 void ccp_flags_set (int unit, int isopen, int isup)
1160 int x = get_flags(ppp_dev_fd);
1161 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1162 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1163 set_flags (ppp_dev_fd, x);
1169 * set_filters - set the active and pass filters in the kernel driver.
1171 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1173 struct sock_fprog fp;
1175 fp.len = pass->bf_len;
1176 fp.filter = (struct sock_filter *) pass->bf_insns;
1177 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1178 if (errno == ENOTTY)
1179 warn("kernel does not support PPP filtering");
1181 error("Couldn't set pass-filter in kernel: %m");
1184 fp.len = active->bf_len;
1185 fp.filter = (struct sock_filter *) active->bf_insns;
1186 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1187 error("Couldn't set active-filter in kernel: %m");
1192 #endif /* PPP_FILTER */
1194 /********************************************************************
1196 * get_idle_time - return how long the link has been idle.
1199 get_idle_time(u, ip)
1201 struct ppp_idle *ip;
1203 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1206 /********************************************************************
1208 * get_ppp_stats - return statistics for the link.
1211 get_ppp_stats(u, stats)
1213 struct pppd_stats *stats;
1215 struct ifpppstatsreq req;
1217 memset (&req, 0, sizeof (req));
1219 req.stats_ptr = (caddr_t) &req.stats;
1220 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1221 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1222 error("Couldn't get PPP statistics: %m");
1225 stats->bytes_in = req.stats.p.ppp_ibytes;
1226 stats->bytes_out = req.stats.p.ppp_obytes;
1230 /********************************************************************
1232 * ccp_fatal_error - returns 1 if decompression was disabled as a
1233 * result of an error detected after decompression of a packet,
1234 * 0 otherwise. This is necessary because of patent nonsense.
1237 int ccp_fatal_error (int unit)
1239 int x = get_flags(ppp_dev_fd);
1241 return x & SC_DC_FERROR;
1244 /********************************************************************
1246 * path_to_procfs - find the path to the proc file system mount point
1248 static char proc_path[MAXPATHLEN];
1249 static int proc_path_len;
1251 static char *path_to_procfs(const char *tail)
1253 struct mntent *mntent;
1256 if (proc_path_len == 0) {
1257 /* Default the mount location of /proc */
1258 strlcpy (proc_path, "/proc", sizeof(proc_path));
1260 fp = fopen(MOUNTED, "r");
1262 while ((mntent = getmntent(fp)) != NULL) {
1263 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1265 if (strcmp(mntent->mnt_type, "proc") == 0) {
1266 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1267 proc_path_len = strlen(proc_path);
1275 strlcpy(proc_path + proc_path_len, tail,
1276 sizeof(proc_path) - proc_path_len);
1281 * /proc/net/route parsing stuff.
1283 #define ROUTE_MAX_COLS 12
1284 FILE *route_fd = (FILE *) 0;
1285 static char route_buffer[512];
1286 static int route_dev_col, route_dest_col, route_gw_col;
1287 static int route_flags_col, route_mask_col;
1288 static int route_num_cols;
1290 static int open_route_table (void);
1291 static void close_route_table (void);
1292 static int read_route_table (struct rtentry *rt);
1294 /********************************************************************
1296 * close_route_table - close the interface to the route table
1299 static void close_route_table (void)
1301 if (route_fd != (FILE *) 0) {
1303 route_fd = (FILE *) 0;
1307 /********************************************************************
1309 * open_route_table - open the interface to the route table
1311 static char route_delims[] = " \t\n";
1313 static int open_route_table (void)
1317 close_route_table();
1319 path = path_to_procfs("/net/route");
1320 route_fd = fopen (path, "r");
1321 if (route_fd == NULL) {
1322 error("can't open routing table %s: %m", path);
1326 route_dev_col = 0; /* default to usual columns */
1329 route_flags_col = 3;
1333 /* parse header line */
1334 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1335 char *p = route_buffer, *q;
1337 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1339 if ((q = strtok(p, route_delims)) == 0)
1341 if (strcasecmp(q, "iface") == 0)
1342 route_dev_col = col;
1343 else if (strcasecmp(q, "destination") == 0)
1344 route_dest_col = col;
1345 else if (strcasecmp(q, "gateway") == 0)
1347 else if (strcasecmp(q, "flags") == 0)
1348 route_flags_col = col;
1349 else if (strcasecmp(q, "mask") == 0)
1350 route_mask_col = col;
1353 if (used && col >= route_num_cols)
1354 route_num_cols = col + 1;
1362 /********************************************************************
1364 * read_route_table - read the next entry from the route table
1367 static int read_route_table(struct rtentry *rt)
1369 char *cols[ROUTE_MAX_COLS], *p;
1372 memset (rt, '\0', sizeof (struct rtentry));
1374 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1378 for (col = 0; col < route_num_cols; ++col) {
1379 cols[col] = strtok(p, route_delims);
1380 if (cols[col] == NULL)
1381 return 0; /* didn't get enough columns */
1385 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1386 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1387 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1389 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1390 rt->rt_dev = cols[route_dev_col];
1395 /********************************************************************
1397 * defaultroute_exists - determine if there is a default route
1400 static int defaultroute_exists (struct rtentry *rt)
1404 if (!open_route_table())
1407 while (read_route_table(rt) != 0) {
1408 if ((rt->rt_flags & RTF_UP) == 0)
1411 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1413 if (SIN_ADDR(rt->rt_dst) == 0L) {
1419 close_route_table();
1424 * have_route_to - determine if the system has any route to
1425 * a given IP address. `addr' is in network byte order.
1426 * Return value is 1 if yes, 0 if no, -1 if don't know.
1427 * For demand mode to work properly, we have to ignore routes
1428 * through our own interface.
1430 int have_route_to(u_int32_t addr)
1435 if (!open_route_table())
1436 return -1; /* don't know */
1438 while (read_route_table(&rt)) {
1439 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1441 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1447 close_route_table();
1451 /********************************************************************
1453 * sifdefaultroute - assign a default route through the address given.
1456 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1460 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1461 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1463 if (old_gateway != gateway)
1464 error("not replacing existing default route to %s [%I]",
1465 rt.rt_dev, old_gateway);
1469 memset (&rt, '\0', sizeof (rt));
1470 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1471 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1473 if (kernel_version > KVERSION(2,1,0)) {
1474 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1475 SIN_ADDR(rt.rt_genmask) = 0L;
1478 SIN_ADDR(rt.rt_gateway) = gateway;
1480 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1481 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1482 if ( ! ok_error ( errno ))
1483 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1487 default_route_gateway = gateway;
1491 /********************************************************************
1493 * cifdefaultroute - delete a default route through the address given.
1496 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1500 default_route_gateway = 0;
1502 memset (&rt, '\0', sizeof (rt));
1503 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1504 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1506 if (kernel_version > KVERSION(2,1,0)) {
1507 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1508 SIN_ADDR(rt.rt_genmask) = 0L;
1511 SIN_ADDR(rt.rt_gateway) = gateway;
1513 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1514 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1516 if ( ! ok_error ( errno ))
1517 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1525 /********************************************************************
1527 * sifproxyarp - Make a proxy ARP entry for the peer.
1530 int sifproxyarp (int unit, u_int32_t his_adr)
1532 struct arpreq arpreq;
1535 if (has_proxy_arp == 0) {
1536 memset (&arpreq, '\0', sizeof(arpreq));
1538 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1539 SIN_ADDR(arpreq.arp_pa) = his_adr;
1540 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1542 * Get the hardware address of an interface on the same subnet
1543 * as our local address.
1545 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1546 sizeof(proxy_arp_dev))) {
1547 error("Cannot determine ethernet address for proxy ARP");
1550 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1552 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1553 if ( ! ok_error ( errno ))
1554 error("ioctl(SIOCSARP): %m(%d)", errno);
1557 proxy_arp_addr = his_adr;
1561 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1562 if (forw_path != 0) {
1563 int fd = open(forw_path, O_WRONLY);
1565 if (write(fd, "1", 1) != 1)
1566 error("Couldn't enable IP forwarding: %m");
1576 /********************************************************************
1578 * cifproxyarp - Delete the proxy ARP entry for the peer.
1581 int cifproxyarp (int unit, u_int32_t his_adr)
1583 struct arpreq arpreq;
1585 if (has_proxy_arp) {
1587 memset (&arpreq, '\0', sizeof(arpreq));
1588 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1589 SIN_ADDR(arpreq.arp_pa) = his_adr;
1590 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1591 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1593 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1594 if ( ! ok_error ( errno ))
1595 warn("ioctl(SIOCDARP): %m(%d)", errno);
1602 /********************************************************************
1604 * get_ether_addr - get the hardware address of an interface on the
1605 * the same subnet as ipaddr.
1608 static int get_ether_addr (u_int32_t ipaddr,
1609 struct sockaddr *hwaddr,
1610 char *name, int namelen)
1612 struct ifreq *ifr, *ifend;
1613 u_int32_t ina, mask;
1617 struct ifreq ifs[MAX_IFS];
1619 ifc.ifc_len = sizeof(ifs);
1621 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1622 if ( ! ok_error ( errno ))
1623 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1627 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1628 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1630 * Scan through looking for an interface with an Internet
1631 * address on the same subnet as `ipaddr'.
1633 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1634 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1635 if (ifr->ifr_addr.sa_family == AF_INET) {
1636 ina = SIN_ADDR(ifr->ifr_addr);
1637 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1638 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1641 * Check that the interface is up, and not point-to-point
1644 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1647 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1650 * Get its netmask and check that it's on the right subnet.
1652 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1655 mask = SIN_ADDR(ifreq.ifr_addr);
1656 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1657 ip_ntoa(ina), ntohl(mask)));
1659 if (((ipaddr ^ ina) & mask) != 0)
1668 strlcpy(name, ifreq.ifr_name, namelen);
1670 /* trim off the :1 in eth0:1 */
1671 aliasp = strchr(name, ':');
1675 info("found interface %s for proxy arp", name);
1677 * Now get the hardware address.
1679 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1680 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1681 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1687 sizeof (struct sockaddr));
1689 SYSDEBUG ((LOG_DEBUG,
1690 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1691 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1692 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1693 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1694 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1695 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1696 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1697 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1698 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1703 * get_if_hwaddr - get the hardware address for the specified
1704 * network interface device.
1707 get_if_hwaddr(u_char *addr, char *name)
1712 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1715 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1716 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1717 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1720 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1725 * get_first_ethernet - return the name of the first ethernet-style
1726 * interface on this system.
1729 get_first_ethernet()
1734 /********************************************************************
1736 * Return user specified netmask, modified by any mask we might determine
1737 * for address `addr' (in network byte order).
1738 * Here we scan through the system's list of interfaces, looking for
1739 * any non-point-to-point interfaces which might appear to be on the same
1740 * network as `addr'. If we find any, we OR in their netmask to the
1741 * user-specified netmask.
1744 u_int32_t GetMask (u_int32_t addr)
1746 u_int32_t mask, nmask, ina;
1747 struct ifreq *ifr, *ifend, ifreq;
1749 struct ifreq ifs[MAX_IFS];
1753 if (IN_CLASSA(addr)) /* determine network mask for address class */
1754 nmask = IN_CLASSA_NET;
1755 else if (IN_CLASSB(addr))
1756 nmask = IN_CLASSB_NET;
1758 nmask = IN_CLASSC_NET;
1760 /* class D nets are disallowed by bad_ip_adrs */
1761 mask = netmask | htonl(nmask);
1763 * Scan through the system's network interfaces.
1765 ifc.ifc_len = sizeof(ifs);
1767 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1768 if ( ! ok_error ( errno ))
1769 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1773 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1774 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1776 * Check the interface's internet address.
1778 if (ifr->ifr_addr.sa_family != AF_INET)
1780 ina = SIN_ADDR(ifr->ifr_addr);
1781 if (((ntohl(ina) ^ addr) & nmask) != 0)
1784 * Check that the interface is up, and not point-to-point nor loopback.
1786 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1787 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1790 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1793 * Get its netmask and OR it into our mask.
1795 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1797 mask |= SIN_ADDR(ifreq.ifr_addr);
1803 /********************************************************************
1805 * Internal routine to decode the version.modification.patch level
1808 static void decode_version (char *buf, int *version,
1809 int *modification, int *patch)
1811 *version = (int) strtoul (buf, &buf, 10);
1817 *modification = (int) strtoul (buf, &buf, 10);
1820 *patch = (int) strtoul (buf, &buf, 10);
1831 /********************************************************************
1833 * Procedure to determine if the PPP line discipline is registered.
1837 ppp_registered(void)
1845 * We used to open the serial device and set it to the ppp line
1846 * discipline here, in order to create a ppp unit. But that is
1847 * not a good idea - the user might have specified a device that
1848 * they can't open (permission, or maybe it doesn't really exist).
1849 * So we grab a pty master/slave pair and use that.
1851 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1852 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1857 * Try to put the device into the PPP discipline.
1859 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1860 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1869 /********************************************************************
1871 * ppp_available - check whether the system has any ppp interfaces
1872 * (in fact we check whether we can do an ioctl on ppp0).
1875 int ppp_available(void)
1880 int my_version, my_modification, my_patch;
1881 int osmaj, osmin, ospatch;
1884 "This system lacks kernel support for PPP. This could be because\n"
1885 "the PPP kernel module could not be loaded, or because PPP was not\n"
1886 "included in the kernel configuration. If PPP was included as a\n"
1887 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1888 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1889 "See README.linux file in the ppp distribution for more details.\n";
1891 /* get the kernel version now, since we are called before sys_init */
1893 osmaj = osmin = ospatch = 0;
1894 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1895 kernel_version = KVERSION(osmaj, osmin, ospatch);
1897 fd = open("/dev/ppp", O_RDWR);
1899 if (fd < 0 && errno == ENOENT) {
1900 /* try making it and see if that helps. */
1901 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1902 makedev(108, 0)) >= 0) {
1903 fd = open("/dev/ppp", O_RDWR);
1905 info("Created /dev/ppp device node");
1907 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1908 } else if (errno == EEXIST) {
1909 fd = open("/dev/ppp", O_RDWR);
1914 new_style_driver = 1;
1916 /* XXX should get from driver */
1918 driver_modification = 4;
1923 if (kernel_version >= KVERSION(2,3,13))
1927 * Open a socket for doing the ioctl operations.
1929 s = socket(AF_INET, SOCK_DGRAM, 0);
1933 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1934 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1936 * If the device did not exist then attempt to create one by putting the
1937 * current tty into the PPP discipline. If this works then obtain the
1938 * flags for the device again.
1941 if (ppp_registered()) {
1942 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1943 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1947 * Ensure that the hardware address is for PPP and not something else
1950 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1952 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1956 * This is the PPP device. Validate the version of the driver at this
1957 * point to ensure that this program will work with the driver.
1960 char abBuffer [1024];
1962 ifr.ifr_data = abBuffer;
1963 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1965 error("Couldn't read driver version: %m");
1967 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1970 decode_version(abBuffer,
1972 &driver_modification,
1975 * Validate the version of the driver against the version that we used.
1977 decode_version(VERSION,
1982 /* The version numbers must match */
1983 if (driver_version != my_version)
1986 /* The modification levels must be legal */
1987 if (driver_modification < 3) {
1988 if (driver_modification >= 2) {
1989 /* we can cope with 2.2.0 and above */
1998 slprintf(route_buffer, sizeof(route_buffer),
1999 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2000 driver_version, driver_modification, driver_patch);
2002 no_ppp_msg = route_buffer;
2009 /********************************************************************
2011 * Update the wtmp file with the appropriate user name and tty device.
2014 void logwtmp (const char *line, const char *name, const char *host)
2016 struct utmp ut, *utp;
2017 pid_t mypid = getpid();
2023 * Update the signon database for users.
2024 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2026 utmpname(_PATH_UTMP);
2028 while ((utp = getutent()) && (utp->ut_pid != mypid))
2031 /* Is this call really necessary? There is another one after the 'put' */
2035 memcpy(&ut, utp, sizeof(ut));
2037 /* some gettys/telnetds don't initialize utmp... */
2038 memset(&ut, 0, sizeof(ut));
2040 if (ut.ut_id[0] == 0)
2041 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2043 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2044 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2048 ut.ut_type = USER_PROCESS;
2051 /* Insert the host name if one is supplied */
2053 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2055 /* Insert the IP address of the remote system if IP is enabled */
2056 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2057 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2058 sizeof(ut.ut_addr));
2060 /* CL: Makes sure that the logout works */
2061 if (*host == 0 && *name==0)
2067 * Update the wtmp file.
2070 updwtmp(_PATH_WTMP, &ut);
2072 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2074 flock(wtmp, LOCK_EX);
2076 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2077 warn("error writing %s: %m", _PATH_WTMP);
2079 flock(wtmp, LOCK_UN);
2087 /********************************************************************
2089 * sifvjcomp - config tcp header compression
2092 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2094 u_int x = get_flags(ppp_dev_fd);
2097 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2098 if (! ok_error (errno))
2099 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2104 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2105 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2106 set_flags (ppp_dev_fd, x);
2111 /********************************************************************
2113 * sifup - Config the interface up and enable IP packets to pass.
2120 memset (&ifr, '\0', sizeof (ifr));
2121 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2122 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2123 if (! ok_error (errno))
2124 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2128 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2129 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2130 if (! ok_error (errno))
2131 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2139 /********************************************************************
2141 * sifdown - Disable the indicated protocol and config the interface
2142 * down if there are no remaining protocols.
2149 if (if_is_up && --if_is_up > 0)
2152 memset (&ifr, '\0', sizeof (ifr));
2153 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2154 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2155 if (! ok_error (errno))
2156 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2160 ifr.ifr_flags &= ~IFF_UP;
2161 ifr.ifr_flags |= IFF_POINTOPOINT;
2162 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2163 if (! ok_error (errno))
2164 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2170 /********************************************************************
2172 * sifaddr - Config the interface IP addresses and netmask.
2175 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2181 memset (&ifr, '\0', sizeof (ifr));
2182 memset (&rt, '\0', sizeof (rt));
2184 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2185 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2186 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2188 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2190 * Set our IP address
2192 SIN_ADDR(ifr.ifr_addr) = our_adr;
2193 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2194 if (errno != EEXIST) {
2195 if (! ok_error (errno))
2196 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2199 warn("ioctl(SIOCSIFADDR): Address already exists");
2204 * Set the gateway address
2206 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2207 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2208 if (! ok_error (errno))
2209 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2214 * For recent kernels, force the netmask to 255.255.255.255.
2216 if (kernel_version >= KVERSION(2,1,16))
2218 if (net_mask != 0) {
2219 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2220 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2221 if (! ok_error (errno))
2222 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2227 * Add the device route
2229 if (kernel_version < KVERSION(2,1,16)) {
2230 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2231 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2234 SIN_ADDR(rt.rt_gateway) = 0L;
2235 SIN_ADDR(rt.rt_dst) = his_adr;
2236 rt.rt_flags = RTF_UP | RTF_HOST;
2238 if (kernel_version > KVERSION(2,1,0)) {
2239 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2240 SIN_ADDR(rt.rt_genmask) = -1L;
2243 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2244 if (! ok_error (errno))
2245 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2250 /* set ip_dynaddr in demand mode if address changes */
2251 if (demand && tune_kernel && !dynaddr_set
2252 && our_old_addr && our_old_addr != our_adr) {
2253 /* set ip_dynaddr if possible */
2257 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2258 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2259 if (write(fd, "1", 1) != 1)
2260 error("Couldn't enable dynamic IP addressing: %m");
2263 dynaddr_set = 1; /* only 1 attempt */
2270 /********************************************************************
2272 * cifaddr - Clear the interface IP addresses, and delete routes
2273 * through the interface if possible.
2276 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2280 if (kernel_version < KVERSION(2,1,16)) {
2282 * Delete the route through the device
2285 memset (&rt, '\0', sizeof (rt));
2287 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2288 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2291 SIN_ADDR(rt.rt_gateway) = 0;
2292 SIN_ADDR(rt.rt_dst) = his_adr;
2293 rt.rt_flags = RTF_UP | RTF_HOST;
2295 if (kernel_version > KVERSION(2,1,0)) {
2296 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2297 SIN_ADDR(rt.rt_genmask) = -1L;
2300 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2301 if (still_ppp() && ! ok_error (errno))
2302 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2307 /* This way it is possible to have an IPX-only or IPv6-only interface */
2308 memset(&ifr, 0, sizeof(ifr));
2309 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2310 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2312 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2313 if (! ok_error (errno)) {
2314 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2319 our_old_addr = our_adr;
2325 /********************************************************************
2327 * sif6addr - Config the interface with an IPv6 link-local address
2329 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2331 struct in6_ifreq ifr6;
2333 struct in6_rtmsg rt6;
2337 error("IPv6 socket creation failed: %m");
2340 memset(&ifr, 0, sizeof (ifr));
2341 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2342 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2343 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2347 /* Local interface */
2348 memset(&ifr6, 0, sizeof(ifr6));
2349 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2350 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2351 ifr6.ifr6_prefixlen = 10;
2353 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2354 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2358 /* Route to remote host */
2359 memset(&rt6, 0, sizeof(rt6));
2360 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2361 rt6.rtmsg_flags = RTF_UP;
2362 rt6.rtmsg_dst_len = 10;
2363 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2364 rt6.rtmsg_metric = 1;
2366 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2367 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2375 /********************************************************************
2377 * cif6addr - Remove IPv6 address from interface
2379 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2382 struct in6_ifreq ifr6;
2386 error("IPv6 socket creation failed: %m");
2389 memset(&ifr, 0, sizeof(ifr));
2390 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2391 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2392 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2396 memset(&ifr6, 0, sizeof(ifr6));
2397 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2398 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2399 ifr6.ifr6_prefixlen = 10;
2401 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2402 if (errno != EADDRNOTAVAIL) {
2403 if (! ok_error (errno))
2404 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2407 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2416 * get_pty - get a pty master/slave pair and chown the slave side
2417 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2420 get_pty(master_fdp, slave_fdp, slave_name, uid)
2426 int i, mfd, sfd = -1;
2428 struct termios tios;
2432 * Try the unix98 way first.
2434 mfd = open("/dev/ptmx", O_RDWR);
2437 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2438 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2439 chmod(pty_name, S_IRUSR | S_IWUSR);
2442 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2443 warn("Couldn't unlock pty slave %s: %m", pty_name);
2445 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2446 warn("Couldn't open pty slave %s: %m", pty_name);
2449 #endif /* TIOCGPTN */
2452 /* the old way - scan through the pty name space */
2453 for (i = 0; i < 64; ++i) {
2454 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2455 'p' + i / 16, i % 16);
2456 mfd = open(pty_name, O_RDWR, 0);
2459 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2461 fchown(sfd, uid, -1);
2462 fchmod(sfd, S_IRUSR | S_IWUSR);
2473 strlcpy(slave_name, pty_name, 16);
2476 if (tcgetattr(sfd, &tios) == 0) {
2477 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2478 tios.c_cflag |= CS8 | CREAD;
2479 tios.c_iflag = IGNPAR | CLOCAL;
2482 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2483 warn("couldn't set attributes on pty: %m");
2485 warn("couldn't get attributes on pty: %m");
2490 /********************************************************************
2492 * open_loopback - open the device we use for getting packets
2493 * in demand mode. Under Linux, we use a pty master/slave pair.
2496 open_ppp_loopback(void)
2501 if (new_style_driver) {
2502 /* allocate ourselves a ppp unit */
2503 if (make_ppp_unit() < 0)
2505 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2506 set_kdebugflag(kdebugflag);
2511 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2512 fatal("No free pty for loopback");
2513 SYSDEBUG(("using %s for loopback", loop_name));
2515 set_ppp_fd(slave_fd);
2517 flags = fcntl(master_fd, F_GETFL);
2519 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2520 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2522 flags = fcntl(ppp_fd, F_GETFL);
2524 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2525 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2527 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2528 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2530 * Find out which interface we were given.
2532 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2533 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2535 * Enable debug in the driver if requested.
2537 set_kdebugflag (kdebugflag);
2542 /********************************************************************
2544 * restore_loop - reattach the ppp unit to the loopback.
2546 * The kernel ppp driver automatically reattaches the ppp unit to
2547 * the loopback if the serial port is set to a line discipline other
2548 * than ppp, or if it detects a modem hangup. The former will happen
2549 * in disestablish_ppp if the latter hasn't already happened, so we
2550 * shouldn't need to do anything.
2552 * Just to be sure, set the real serial port to the normal discipline.
2559 if (new_style_driver) {
2560 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2563 if (ppp_fd != slave_fd) {
2564 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2565 set_ppp_fd(slave_fd);
2569 /********************************************************************
2571 * sifnpmode - Set the mode for handling packets for a given NP.
2575 sifnpmode(u, proto, mode)
2582 npi.protocol = proto;
2584 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2585 if (! ok_error (errno))
2586 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2587 proto, mode, errno);
2594 /********************************************************************
2596 * sipxfaddr - Config the interface IPX networknumber
2599 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2606 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2608 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2610 if (! ok_error (errno))
2611 dbglog("socket(AF_IPX): %m (%d)", errno);
2615 memset (&ifr, '\0', sizeof (ifr));
2616 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2618 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2619 sipx->sipx_family = AF_IPX;
2620 sipx->sipx_port = 0;
2621 sipx->sipx_network = htonl (network);
2622 sipx->sipx_type = IPX_FRAME_ETHERII;
2623 sipx->sipx_action = IPX_CRTITF;
2625 * Set the IPX device
2627 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2629 if (errno != EEXIST) {
2630 if (! ok_error (errno))
2631 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2634 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2643 /********************************************************************
2645 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2646 * are removed and the device is no longer able to pass IPX
2650 int cipxfaddr (int unit)
2657 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2659 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2661 if (! ok_error (errno))
2662 dbglog("socket(AF_IPX): %m (%d)", errno);
2666 memset (&ifr, '\0', sizeof (ifr));
2667 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2669 sipx->sipx_type = IPX_FRAME_ETHERII;
2670 sipx->sipx_action = IPX_DLTITF;
2671 sipx->sipx_family = AF_IPX;
2673 * Set the IPX device
2675 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2676 if (! ok_error (errno))
2677 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2687 * Use the hostname as part of the random number seed.
2696 for (p = hostname; *p != 0; ++p)
2701 /********************************************************************
2703 * sys_check_options - check the options that the user specified
2707 sys_check_options(void)
2711 * Disable the IPX protocol if the support is not present in the kernel.
2715 if (ipxcp_protent.enabled_flag) {
2716 struct stat stat_buf;
2717 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2718 || lstat(path, &stat_buf) < 0) {
2719 error("IPX support is not present in the kernel\n");
2720 ipxcp_protent.enabled_flag = 0;
2724 if (demand && driver_is_old) {
2725 option_error("demand dialling is not supported by kernel driver "
2726 "version %d.%d.%d", driver_version, driver_modification,
2730 if (multilink && !new_style_driver) {
2731 warn("Warning: multilink is not supported by the kernel driver");