2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1989 Carnegie Mellon University.
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by Carnegie Mellon University. The name of the
14 * University may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 #include <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
25 #include <sys/errno.h>
28 #include <sys/utsname.h>
29 #include <sys/sysmacros.h>
45 /* This is in netdevice.h. However, this compile will fail miserably if
46 you attempt to include netdevice.h because it has so many references
47 to __memcpy functions which it should not attempt to do. So, since I
48 really don't use it, but it must be defined, define it now. */
51 #define MAX_ADDR_LEN 7
55 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
57 #include <net/if_arp.h>
58 #include <net/route.h>
59 #include <netinet/if_ether.h>
61 #include <linux/types.h>
63 #include <linux/if_arp.h>
64 #include <linux/route.h>
65 #include <linux/if_ether.h>
67 #include <netinet/in.h>
68 #include <arpa/inet.h>
70 #include <linux/ppp_defs.h>
71 #include <linux/if_ppp.h>
76 #include "patchlevel.h"
80 #if __GLIBC__ >= 2 && \
81 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
82 #include <netipx/ipx.h>
84 #include <linux/ipx.h>
86 #endif /* IPX_CHANGE */
89 #include <sys/locks.h>
95 * This is in linux/include/net/ipv6.h.
99 struct in6_addr ifr6_addr;
100 __u32 ifr6_prefixlen;
101 unsigned int ifr6_ifindex;
105 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
106 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
107 sin6.s6_addr16[0] = htons(0xfe80); \
108 eui64_copy(eui64, sin6.s6_addr32[2]); \
113 /* We can get an EIO error on an ioctl if the modem has hung up */
114 #define ok_error(num) ((num)==EIO)
116 static int tty_disc = N_TTY; /* The TTY discipline */
117 static int ppp_disc = N_PPP; /* The PPP discpline */
118 static int initfdflags = -1; /* Initial file descriptor flags for fd */
119 static int ppp_fd = -1; /* fd which is set to PPP discipline */
120 static int sock_fd = -1; /* socket for doing interface ioctls */
121 static int slave_fd = -1;
122 static int master_fd = -1;
124 static int sock6_fd = -1;
126 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
128 static fd_set in_fds; /* set of fds that wait_input waits for */
129 static int max_in_fd; /* highest fd set in in_fds */
131 static int has_proxy_arp = 0;
132 static int driver_version = 0;
133 static int driver_modification = 0;
134 static int driver_patch = 0;
135 static int driver_is_old = 0;
136 static int restore_term = 0; /* 1 => we've munged the terminal */
137 static struct termios inittermios; /* Initial TTY termios */
139 static int new_style_driver = 0;
141 static char loop_name[20];
142 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
144 static int if_is_up; /* Interface has been marked up */
145 static u_int32_t default_route_gateway; /* Gateway for default route added */
146 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
147 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
149 static struct utsname utsname; /* for the kernel version */
150 static int kernel_version;
151 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
155 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
156 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
157 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
159 /* Prototypes for procedures local to this file. */
160 static int get_flags (int fd);
161 static void set_flags (int fd, int flags);
162 static int translate_speed (int bps);
163 static int baud_rate_of (int speed);
164 static char *path_to_route (void);
165 static void close_route_table (void);
166 static int open_route_table (void);
167 static int read_route_table (struct rtentry *rt);
168 static int defaultroute_exists (struct rtentry *rt);
169 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
170 char *name, int namelen);
171 static void decode_version (char *buf, int *version, int *mod, int *patch);
172 static int set_kdebugflag(int level);
173 static int ppp_registered(void);
175 extern u_char inpacket_buf[]; /* borrowed from main.c */
178 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
182 #define SET_SA_FAMILY(addr, family) \
183 memset ((char *) &(addr), '\0', sizeof(addr)); \
184 addr.sa_family = (family);
187 * Determine if the PPP connection should still be present.
192 /* new_fd is the fd of a tty */
193 static void set_ppp_fd (int new_fd)
195 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
197 if (!new_style_driver)
201 static int still_ppp(void)
203 if (new_style_driver)
204 return !hungup && ppp_fd >= 0;
205 if (!hungup || ppp_fd == slave_fd)
208 set_ppp_fd(slave_fd);
214 /********************************************************************
216 * Functions to read and set the flags value in the device driver
219 static int get_flags (int fd)
223 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
224 if ( ok_error (errno) )
227 fatal("ioctl(PPPIOCGFLAGS): %m");
230 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
234 /********************************************************************/
236 static void set_flags (int fd, int flags)
238 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
240 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
241 if (! ok_error (errno) )
242 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
246 /********************************************************************
248 * sys_init - System-dependent initialization.
253 int osmaj, osmin, ospatch;
256 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
257 setlogmask(LOG_UPTO(LOG_INFO));
259 setlogmask(LOG_UPTO(LOG_DEBUG));
261 if (new_style_driver) {
262 ppp_dev_fd = open("/dev/ppp", O_RDWR);
264 fatal("Couldn't open /dev/ppp: %m");
265 flags = fcntl(ppp_dev_fd, F_GETFL);
267 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
268 warn("Couldn't set /dev/ppp to nonblock: %m");
271 /* Get an internet socket for doing socket ioctls. */
272 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
274 fatal("Couldn't create IP socket: %m(%d)", errno);
277 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
279 fatal("Couldn't create IPv6 socket: %m(%d)", errno);
286 osmaj = osmin = ospatch = 0;
287 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
288 kernel_version = KVERSION(osmaj, osmin, ospatch);
291 /********************************************************************
293 * sys_cleanup - restore any system state we modified before exiting:
294 * mark the interface down, delete default route and/or proxy arp entry.
295 * This shouldn't call die() because it's called from die().
298 void sys_cleanup(void)
301 * Take down the device
308 * Delete any routes through the device.
310 if (default_route_gateway != 0)
311 cifdefaultroute(0, 0, default_route_gateway);
314 cifproxyarp(0, proxy_arp_addr);
317 /********************************************************************
319 * sys_close - Clean up in a child process before execing.
324 if (new_style_driver)
335 /********************************************************************
337 * set_kdebugflag - Define the debugging level for the kernel
340 static int set_kdebugflag (int requested_level)
342 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
343 if ( ! ok_error (errno) )
344 error("ioctl(PPPIOCSDEBUG): %m");
347 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
352 /********************************************************************
354 * establish_ppp - Turn the serial port into a ppp interface.
357 int establish_ppp (int tty_fd)
362 * The current PPP device will be the tty file.
366 * Ensure that the tty device is in exclusive mode.
368 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
369 if ( ! ok_error ( errno ))
370 warn("ioctl(TIOCEXCL): %m");
373 * Demand mode - prime the old ppp device to relinquish the unit.
375 if (!new_style_driver && demand
376 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
377 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
379 * Set the current tty to the PPP discpline
381 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
382 if ( ! ok_error (errno) )
383 fatal("ioctl(TIOCSETD): %m(%d)", errno);
386 * Find out which interface we were given.
388 if (new_style_driver) {
390 /* allocate ourselves a ppp unit */
392 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
393 fatal("Couldn't create new ppp unit: %m");
394 set_kdebugflag(kdebugflag);
396 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
398 if (ioctl(tty_fd, PPPIOCATTACH, &ifunit) < 0) {
401 fatal("Couldn't attach tty to PPP unit %d: %m", ifunit);
404 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
405 if ( ! ok_error (errno))
406 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
408 /* Check that we got the same unit again. */
409 if (demand && x != ifunit)
410 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
415 * Enable debug in the driver if requested.
418 set_kdebugflag (kdebugflag);
420 set_flags(tty_fd, get_flags(tty_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
421 SC_RCV_EVNP | SC_RCV_ODDP));
423 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
424 driver_version, driver_modification, driver_patch));
427 * Fetch the initial file flags and reset blocking mode on the file.
429 initfdflags = fcntl(tty_fd, F_GETFL);
430 if (initfdflags == -1 ||
431 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
432 if ( ! ok_error (errno))
433 warn("Couldn't set device to non-blocking mode: %m");
439 /********************************************************************
441 * disestablish_ppp - Restore the serial port to normal operation.
442 * This shouldn't call die() because it's called from die().
445 void disestablish_ppp(int tty_fd)
449 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
451 if (tcflush(tty_fd, TCIOFLUSH) < 0)
452 warn("tcflush failed: %m");
454 * Restore the previous line discipline
456 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
457 if ( ! ok_error (errno))
458 error("ioctl(TIOCSETD, N_TTY): %m");
461 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
462 if ( ! ok_error (errno))
463 warn("ioctl(TIOCNXCL): %m(%d)", errno);
466 /* Reset non-blocking mode on fd. */
467 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
468 if ( ! ok_error (errno))
469 warn("Couldn't restore device fd flags: %m");
473 if (new_style_driver)
477 /********************************************************************
479 * clean_check - Fetch the flags for the device and generate
480 * appropriate error messages.
482 void clean_check(void)
488 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
490 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
492 s = "all had bit 7 set to 1";
496 s = "all had bit 7 set to 0";
500 s = "all had odd parity";
504 s = "all had even parity";
509 warn("Receive serial link is not 8-bit clean:");
510 warn("Problem: %s", s);
518 * List of valid speeds.
522 int speed_int, speed_val;
599 /********************************************************************
601 * Translate from bits/second to a speed_t.
604 static int translate_speed (int bps)
606 struct speed *speedp;
609 for (speedp = speeds; speedp->speed_int; speedp++) {
610 if (bps == speedp->speed_int)
611 return speedp->speed_val;
613 warn("speed %d not supported", bps);
618 /********************************************************************
620 * Translate from a speed_t to bits/second.
623 static int baud_rate_of (int speed)
625 struct speed *speedp;
628 for (speedp = speeds; speedp->speed_int; speedp++) {
629 if (speed == speedp->speed_val)
630 return speedp->speed_int;
636 /********************************************************************
638 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
639 * at the requested speed, etc. If `local' is true, set CLOCAL
640 * regardless of whether the modem option was specified.
643 void set_up_tty(int tty_fd, int local)
649 if (tcgetattr(tty_fd, &tios) < 0) {
650 if (!ok_error(errno))
651 fatal("tcgetattr: %m(%d)", errno);
658 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
659 tios.c_cflag |= CS8 | CREAD | HUPCL;
661 tios.c_iflag = IGNBRK | IGNPAR;
665 tios.c_cc[VTIME] = 0;
668 tios.c_cflag ^= (CLOCAL | HUPCL);
672 tios.c_cflag |= CRTSCTS;
676 tios.c_iflag |= IXON | IXOFF;
677 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
678 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
682 tios.c_cflag &= ~CRTSCTS;
689 speed = translate_speed(inspeed);
691 cfsetospeed (&tios, speed);
692 cfsetispeed (&tios, speed);
695 * We can't proceed if the serial port speed is B0,
696 * since that implies that the serial port is disabled.
699 speed = cfgetospeed(&tios);
701 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
704 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
705 if (!ok_error(errno))
706 fatal("tcsetattr: %m");
708 baud_rate = baud_rate_of(speed);
712 /********************************************************************
714 * setdtr - control the DTR line on the serial port.
715 * This is called from die(), so it shouldn't call die().
718 void setdtr (int tty_fd, int on)
720 int modembits = TIOCM_DTR;
722 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
725 /********************************************************************
727 * restore_tty - restore the terminal to the saved settings.
730 void restore_tty (int tty_fd)
735 * Turn off echoing, because otherwise we can get into
736 * a loop with the tty and the modem echoing to each other.
737 * We presume we are the sole user of this tty device, so
738 * when we close it, it will revert to its defaults anyway.
741 inittermios.c_lflag &= ~(ECHO | ECHONL);
743 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
744 if (! ok_error (errno))
745 warn("tcsetattr: %m");
750 /********************************************************************
752 * output - Output PPP packet.
755 void output (int unit, unsigned char *p, int len)
758 dbglog("sent %P", p, len);
760 if (len < PPP_HDRLEN)
762 if (new_style_driver) {
766 if (write(ppp_dev_fd, p, len) < 0) {
767 if (errno == EWOULDBLOCK || errno == ENOBUFS
768 || errno == ENXIO || errno == EIO || errno == EINTR)
769 warn("write: warning: %m (%d)", errno);
771 error("write: %m (%d)", errno);
775 /********************************************************************
777 * wait_input - wait until there is data available,
778 * for the length of time specified by *timo (indefinite
782 void wait_input(struct timeval *timo)
788 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
789 if (n < 0 && errno != EINTR)
790 fatal("select: %m(%d)", errno);
794 * add_fd - add an fd to the set that wait_input waits for.
804 * remove_fd - remove an fd from the set that wait_input waits for.
806 void remove_fd(int fd)
812 /********************************************************************
814 * read_packet - get a PPP packet from the serial device.
817 int read_packet (unsigned char *buf)
821 len = PPP_MRU + PPP_HDRLEN;
822 if (new_style_driver) {
823 *buf++ = PPP_ALLSTATIONS;
827 len = read(ppp_dev_fd, buf, len);
829 if (errno == EWOULDBLOCK || errno == EIO)
831 fatal("read: %m(%d)", errno);
833 return new_style_driver? len+2: len;
836 /********************************************************************
838 * get_loop_output - get outgoing packets from the ppp device,
839 * and detect when we want to bring the real link up.
840 * Return value is 1 if we need to bring up the link, 0 otherwise.
843 get_loop_output(void)
848 if (new_style_driver) {
849 while ((n = read_packet(inpacket_buf)) > 0)
850 if (loop_frame(inpacket_buf, n))
855 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
856 if (loop_chars(inbuf, n))
860 fatal("eof on loopback");
862 if (errno != EWOULDBLOCK)
863 fatal("read from loopback: %m(%d)", errno);
868 /********************************************************************
870 * ppp_send_config - configure the transmit characteristics of
874 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
879 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
881 * Set the MTU and other parameters for the ppp device
883 memset (&ifr, '\0', sizeof (ifr));
884 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
887 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
888 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
892 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
893 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
894 if (!ok_error(errno))
895 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
899 x = get_flags(ppp_fd);
900 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
901 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
902 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
903 set_flags(ppp_fd, x);
906 /********************************************************************
908 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
911 void ppp_set_xaccm (int unit, ext_accm accm)
913 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
914 accm[0], accm[1], accm[2], accm[3]));
918 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
919 if ( ! ok_error (errno))
920 warn("ioctl(set extended ACCM): %m(%d)", errno);
924 /********************************************************************
926 * ppp_recv_config - configure the receive-side characteristics of
930 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
932 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
934 * If we were called because the link has gone down then there is nothing
935 * which may be done. Just return without incident.
940 * Set the receiver parameters
942 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
943 if ( ! ok_error (errno))
944 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
946 if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
947 error("Couldn't set MRU in generic PPP layer: %m");
949 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
950 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
951 if (!ok_error(errno))
952 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
956 /********************************************************************
958 * ccp_test - ask kernel whether a given compression method
959 * is acceptable for use.
962 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
964 struct ppp_option_data data;
966 memset (&data, '\0', sizeof (data));
968 data.length = opt_len;
969 data.transmit = for_transmit;
971 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
974 return (errno == ENOBUFS)? 0: -1;
977 /********************************************************************
979 * ccp_flags_set - inform kernel about the current state of CCP.
982 void ccp_flags_set (int unit, int isopen, int isup)
985 int x = get_flags(ppp_dev_fd);
986 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
987 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
988 set_flags (ppp_dev_fd, x);
992 /********************************************************************
994 * get_idle_time - return how long the link has been idle.
1001 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1004 /********************************************************************
1006 * get_ppp_stats - return statistics for the link.
1009 get_ppp_stats(u, stats)
1011 struct pppd_stats *stats;
1013 struct ifpppstatsreq req;
1015 memset (&req, 0, sizeof (req));
1017 req.stats_ptr = (caddr_t) &req.stats;
1018 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1019 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1020 error("Couldn't get PPP statistics: %m");
1023 stats->bytes_in = req.stats.p.ppp_ibytes;
1024 stats->bytes_out = req.stats.p.ppp_obytes;
1028 /********************************************************************
1030 * ccp_fatal_error - returns 1 if decompression was disabled as a
1031 * result of an error detected after decompression of a packet,
1032 * 0 otherwise. This is necessary because of patent nonsense.
1035 int ccp_fatal_error (int unit)
1037 int x = get_flags(ppp_dev_fd);
1039 return x & SC_DC_FERROR;
1042 /********************************************************************
1044 * path_to_procfs - find the path to the proc file system mount point
1046 static char proc_path[MAXPATHLEN];
1047 static int proc_path_len;
1049 static char *path_to_procfs(const char *tail)
1051 struct mntent *mntent;
1054 if (proc_path_len == 0) {
1055 fp = fopen(MOUNTED, "r");
1057 /* Default the mount location of /proc */
1058 strlcpy (proc_path, "/proc", sizeof(proc_path));
1062 while ((mntent = getmntent(fp)) != NULL) {
1063 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1065 if (strcmp(mntent->mnt_type, "proc") == 0)
1072 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1073 proc_path_len = strlen(proc_path);
1078 if (proc_path_len < 0)
1081 strlcpy(proc_path + proc_path_len, tail,
1082 sizeof(proc_path) - proc_path_len);
1087 * path_to_route - determine the path to the proc file system data
1089 #define ROUTE_MAX_COLS 12
1090 FILE *route_fd = (FILE *) 0;
1091 static char route_buffer[512];
1092 static int route_dev_col, route_dest_col, route_gw_col;
1093 static int route_flags_col, route_mask_col;
1094 static int route_num_cols;
1096 static char *path_to_route (void);
1097 static int open_route_table (void);
1098 static void close_route_table (void);
1099 static int read_route_table (struct rtentry *rt);
1101 /********************************************************************
1103 * path_to_route - find the path to the route tables in the proc file system
1106 static char *path_to_route (void)
1110 path = path_to_procfs("/net/route");
1112 error("proc file system not mounted");
1116 /********************************************************************
1118 * close_route_table - close the interface to the route table
1121 static void close_route_table (void)
1123 if (route_fd != (FILE *) 0) {
1125 route_fd = (FILE *) 0;
1129 /********************************************************************
1131 * open_route_table - open the interface to the route table
1133 static char route_delims[] = " \t\n";
1135 static int open_route_table (void)
1139 close_route_table();
1141 path = path_to_route();
1145 route_fd = fopen (path, "r");
1146 if (route_fd == NULL) {
1147 error("can't open %s: %m (%d)", path, errno);
1151 route_dev_col = 0; /* default to usual columns */
1154 route_flags_col = 3;
1158 /* parse header line */
1159 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1160 char *p = route_buffer, *q;
1162 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1164 if ((q = strtok(p, route_delims)) == 0)
1166 if (strcasecmp(q, "iface") == 0)
1167 route_dev_col = col;
1168 else if (strcasecmp(q, "destination") == 0)
1169 route_dest_col = col;
1170 else if (strcasecmp(q, "gateway") == 0)
1172 else if (strcasecmp(q, "flags") == 0)
1173 route_flags_col = col;
1174 else if (strcasecmp(q, "mask") == 0)
1175 route_mask_col = col;
1178 if (used && col >= route_num_cols)
1179 route_num_cols = col + 1;
1187 /********************************************************************
1189 * read_route_table - read the next entry from the route table
1192 static int read_route_table(struct rtentry *rt)
1194 char *cols[ROUTE_MAX_COLS], *p;
1197 memset (rt, '\0', sizeof (struct rtentry));
1199 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1203 for (col = 0; col < route_num_cols; ++col) {
1204 cols[col] = strtok(p, route_delims);
1205 if (cols[col] == NULL)
1206 return 0; /* didn't get enough columns */
1210 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1211 strtoul(cols[route_dest_col], NULL, 16);
1213 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1214 strtoul(cols[route_gw_col], NULL, 16);
1216 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1217 strtoul(cols[route_mask_col], NULL, 16);
1219 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1220 rt->rt_dev = cols[route_dev_col];
1225 /********************************************************************
1227 * defaultroute_exists - determine if there is a default route
1230 static int defaultroute_exists (struct rtentry *rt)
1234 if (!open_route_table())
1237 while (read_route_table(rt) != 0) {
1238 if ((rt->rt_flags & RTF_UP) == 0)
1241 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1247 close_route_table();
1252 * have_route_to - determine if the system has any route to
1253 * a given IP address. `addr' is in network byte order.
1254 * Return value is 1 if yes, 0 if no, -1 if don't know.
1255 * For demand mode to work properly, we have to ignore routes
1256 * through our own interface.
1258 int have_route_to(u_int32_t addr)
1263 if (!open_route_table())
1264 return -1; /* don't know */
1266 while (read_route_table(&rt)) {
1267 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1269 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1270 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1276 close_route_table();
1280 /********************************************************************
1282 * sifdefaultroute - assign a default route through the address given.
1285 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1289 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1290 struct in_addr old_gateway =
1291 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1293 if (old_gateway.s_addr != gateway)
1294 error("not replacing existing default route to %s [%I]",
1295 rt.rt_dev, old_gateway);
1299 memset (&rt, '\0', sizeof (rt));
1300 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1301 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1303 if (kernel_version > KVERSION(2,1,0)) {
1304 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1305 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1308 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1310 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1311 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1312 if ( ! ok_error ( errno ))
1313 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1317 default_route_gateway = gateway;
1321 /********************************************************************
1323 * cifdefaultroute - delete a default route through the address given.
1326 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1330 default_route_gateway = 0;
1332 memset (&rt, '\0', sizeof (rt));
1333 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1334 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1336 if (kernel_version > KVERSION(2,1,0)) {
1337 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1338 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1341 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1343 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1344 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1346 if ( ! ok_error ( errno ))
1347 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1355 /********************************************************************
1357 * sifproxyarp - Make a proxy ARP entry for the peer.
1360 int sifproxyarp (int unit, u_int32_t his_adr)
1362 struct arpreq arpreq;
1365 if (has_proxy_arp == 0) {
1366 memset (&arpreq, '\0', sizeof(arpreq));
1368 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1369 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1370 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1372 * Get the hardware address of an interface on the same subnet
1373 * as our local address.
1375 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1376 sizeof(proxy_arp_dev))) {
1377 error("Cannot determine ethernet address for proxy ARP");
1380 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1382 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1383 if ( ! ok_error ( errno ))
1384 error("ioctl(SIOCSARP): %m(%d)", errno);
1387 proxy_arp_addr = his_adr;
1390 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1391 if (forw_path != 0) {
1392 int fd = open(forw_path, O_WRONLY);
1403 /********************************************************************
1405 * cifproxyarp - Delete the proxy ARP entry for the peer.
1408 int cifproxyarp (int unit, u_int32_t his_adr)
1410 struct arpreq arpreq;
1412 if (has_proxy_arp) {
1414 memset (&arpreq, '\0', sizeof(arpreq));
1415 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1416 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1417 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1418 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1420 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1421 if ( ! ok_error ( errno ))
1422 warn("ioctl(SIOCDARP): %m(%d)", errno);
1429 /********************************************************************
1431 * get_ether_addr - get the hardware address of an interface on the
1432 * the same subnet as ipaddr.
1435 static int get_ether_addr (u_int32_t ipaddr,
1436 struct sockaddr *hwaddr,
1437 char *name, int namelen)
1439 struct ifreq *ifr, *ifend;
1440 u_int32_t ina, mask;
1444 struct ifreq ifs[MAX_IFS];
1446 ifc.ifc_len = sizeof(ifs);
1448 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1449 if ( ! ok_error ( errno ))
1450 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1454 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1455 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1457 * Scan through looking for an interface with an Internet
1458 * address on the same subnet as `ipaddr'.
1460 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1461 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1462 if (ifr->ifr_addr.sa_family == AF_INET) {
1463 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1464 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1465 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1468 * Check that the interface is up, and not point-to-point
1471 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1474 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1477 * Get its netmask and check that it's on the right subnet.
1479 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1482 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1483 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1484 ip_ntoa(ina), ntohl(mask)));
1486 if (((ipaddr ^ ina) & mask) != 0)
1495 strlcpy(name, ifreq.ifr_name, namelen);
1497 /* trim off the :1 in eth0:1 */
1498 aliasp = strchr(name, ':');
1502 info("found interface %s for proxy arp", name);
1504 * Now get the hardware address.
1506 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1507 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1508 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1514 sizeof (struct sockaddr));
1516 SYSDEBUG ((LOG_DEBUG,
1517 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1518 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1519 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1520 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1521 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1522 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1523 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1524 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1525 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1529 /********************************************************************
1531 * Return user specified netmask, modified by any mask we might determine
1532 * for address `addr' (in network byte order).
1533 * Here we scan through the system's list of interfaces, looking for
1534 * any non-point-to-point interfaces which might appear to be on the same
1535 * network as `addr'. If we find any, we OR in their netmask to the
1536 * user-specified netmask.
1539 u_int32_t GetMask (u_int32_t addr)
1541 u_int32_t mask, nmask, ina;
1542 struct ifreq *ifr, *ifend, ifreq;
1544 struct ifreq ifs[MAX_IFS];
1548 if (IN_CLASSA(addr)) /* determine network mask for address class */
1549 nmask = IN_CLASSA_NET;
1550 else if (IN_CLASSB(addr))
1551 nmask = IN_CLASSB_NET;
1553 nmask = IN_CLASSC_NET;
1555 /* class D nets are disallowed by bad_ip_adrs */
1556 mask = netmask | htonl(nmask);
1558 * Scan through the system's network interfaces.
1560 ifc.ifc_len = sizeof(ifs);
1562 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1563 if ( ! ok_error ( errno ))
1564 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1568 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1569 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1571 * Check the interface's internet address.
1573 if (ifr->ifr_addr.sa_family != AF_INET)
1575 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1576 if (((ntohl(ina) ^ addr) & nmask) != 0)
1579 * Check that the interface is up, and not point-to-point nor loopback.
1581 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1582 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1585 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1588 * Get its netmask and OR it into our mask.
1590 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1592 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1598 /********************************************************************
1600 * Internal routine to decode the version.modification.patch level
1603 static void decode_version (char *buf, int *version,
1604 int *modification, int *patch)
1606 *version = (int) strtoul (buf, &buf, 10);
1612 *modification = (int) strtoul (buf, &buf, 10);
1615 *patch = (int) strtoul (buf, &buf, 10);
1626 /********************************************************************
1628 * Procedure to determine if the PPP line discipline is registered.
1632 ppp_registered(void)
1640 * We used to open the serial device and set it to the ppp line
1641 * discipline here, in order to create a ppp unit. But that is
1642 * not a good idea - the user might have specified a device that
1643 * they can't open (permission, or maybe it doesn't really exist).
1644 * So we grab a pty master/slave pair and use that.
1646 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1647 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1652 * Try to put the device into the PPP discipline.
1654 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1655 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1664 /********************************************************************
1666 * ppp_available - check whether the system has any ppp interfaces
1667 * (in fact we check whether we can do an ioctl on ppp0).
1670 int ppp_available(void)
1675 int my_version, my_modification, my_patch;
1678 "This system lacks kernel support for PPP. This could be because\n"
1679 "the PPP kernel module could not be loaded, or because PPP was not\n"
1680 "included in the kernel configuration. If PPP was included as a\n"
1681 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1682 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1683 "See README.linux file in the ppp distribution for more details.\n";
1685 fd = open("/dev/ppp", O_RDWR);
1686 if (fd < 0 && errno == ENOENT) {
1687 /* try making it and see if that helps. */
1688 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1689 makedev(108, 0)) >= 0) {
1690 fd = open("/dev/ppp", O_RDWR);
1692 info("Created /dev/ppp device node");
1694 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1695 } else if (errno == EEXIST) {
1696 fd = open("/dev/ppp", O_RDWR);
1700 new_style_driver = 1;
1702 /* XXX should get from driver */
1704 driver_modification = 4;
1711 * Open a socket for doing the ioctl operations.
1713 s = socket(AF_INET, SOCK_DGRAM, 0);
1717 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1718 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1720 * If the device did not exist then attempt to create one by putting the
1721 * current tty into the PPP discipline. If this works then obtain the
1722 * flags for the device again.
1725 if (ppp_registered()) {
1726 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1727 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1731 * Ensure that the hardware address is for PPP and not something else
1734 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1736 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1740 * This is the PPP device. Validate the version of the driver at this
1741 * point to ensure that this program will work with the driver.
1744 char abBuffer [1024];
1746 ifr.ifr_data = abBuffer;
1747 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1749 error("Couldn't read driver version: %m");
1751 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1754 decode_version(abBuffer,
1756 &driver_modification,
1759 * Validate the version of the driver against the version that we used.
1761 decode_version(VERSION,
1766 /* The version numbers must match */
1767 if (driver_version != my_version)
1770 /* The modification levels must be legal */
1771 if (driver_modification < 3) {
1772 if (driver_modification >= 2) {
1773 /* we can cope with 2.2.0 and above */
1782 slprintf(route_buffer, sizeof(route_buffer),
1783 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1784 driver_version, driver_modification, driver_patch);
1786 no_ppp_msg = route_buffer;
1793 /********************************************************************
1795 * Update the wtmp file with the appropriate user name and tty device.
1798 void logwtmp (const char *line, const char *name, const char *host)
1800 struct utmp ut, *utp;
1801 pid_t mypid = getpid();
1807 * Update the signon database for users.
1808 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1810 utmpname(_PATH_UTMP);
1812 while ((utp = getutent()) && (utp->ut_pid != mypid))
1815 /* Is this call really necessary? There is another one after the 'put' */
1819 memcpy(&ut, utp, sizeof(ut));
1821 /* some gettys/telnetds don't initialize utmp... */
1822 memset(&ut, 0, sizeof(ut));
1824 if (ut.ut_id[0] == 0)
1825 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1827 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1828 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1832 ut.ut_type = USER_PROCESS;
1835 /* Insert the host name if one is supplied */
1837 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1839 /* Insert the IP address of the remote system if IP is enabled */
1840 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1841 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1842 sizeof(ut.ut_addr));
1844 /* CL: Makes sure that the logout works */
1845 if (*host == 0 && *name==0)
1851 * Update the wtmp file.
1854 updwtmp(_PATH_WTMP, &ut);
1856 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1858 flock(wtmp, LOCK_EX);
1860 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1861 warn("error writing %s: %m", _PATH_WTMP);
1863 flock(wtmp, LOCK_UN);
1871 /********************************************************************
1873 * sifvjcomp - config tcp header compression
1876 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1878 u_int x = get_flags(ppp_dev_fd);
1881 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1882 if (! ok_error (errno))
1883 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1888 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1889 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1890 set_flags (ppp_dev_fd, x);
1895 /********************************************************************
1897 * sifup - Config the interface up and enable IP packets to pass.
1904 memset (&ifr, '\0', sizeof (ifr));
1905 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1906 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1907 if (! ok_error (errno))
1908 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1912 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1913 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1914 if (! ok_error (errno))
1915 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1923 /********************************************************************
1925 * sifdown - Disable the indicated protocol and config the interface
1926 * down if there are no remaining protocols.
1933 if (if_is_up && --if_is_up > 0)
1936 memset (&ifr, '\0', sizeof (ifr));
1937 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1938 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1939 if (! ok_error (errno))
1940 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1944 ifr.ifr_flags &= ~IFF_UP;
1945 ifr.ifr_flags |= IFF_POINTOPOINT;
1946 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1947 if (! ok_error (errno))
1948 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1954 /********************************************************************
1956 * sifaddr - Config the interface IP addresses and netmask.
1959 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1965 memset (&ifr, '\0', sizeof (ifr));
1966 memset (&rt, '\0', sizeof (rt));
1968 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
1969 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
1970 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
1972 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1974 * Set our IP address
1976 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
1977 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
1978 if (errno != EEXIST) {
1979 if (! ok_error (errno))
1980 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
1983 warn("ioctl(SIOCSIFADDR): Address already exists");
1988 * Set the gateway address
1990 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
1991 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
1992 if (! ok_error (errno))
1993 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
1998 * For recent kernels, force the netmask to 255.255.255.255.
2000 if (kernel_version >= KVERSION(2,1,16))
2002 if (net_mask != 0) {
2003 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2004 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2005 if (! ok_error (errno))
2006 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2011 * Add the device route
2013 if (kernel_version < KVERSION(2,1,16)) {
2014 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2015 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2018 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2019 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2020 rt.rt_flags = RTF_UP | RTF_HOST;
2022 if (kernel_version > KVERSION(2,1,0)) {
2023 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2024 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2027 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2028 if (! ok_error (errno))
2029 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2036 /********************************************************************
2038 * cifaddr - Clear the interface IP addresses, and delete routes
2039 * through the interface if possible.
2042 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2046 if (kernel_version < KVERSION(2,1,16)) {
2048 * Delete the route through the device
2051 memset (&rt, '\0', sizeof (rt));
2053 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2054 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2057 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2058 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2059 rt.rt_flags = RTF_UP | RTF_HOST;
2061 if (kernel_version > KVERSION(2,1,0)) {
2062 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2063 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2066 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2067 if (still_ppp() && ! ok_error (errno))
2068 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2073 /* This way it is possible to have an IPX-only or IPv6-only interface */
2074 memset(&ifr, 0, sizeof(ifr));
2075 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2076 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2078 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2079 if (! ok_error (errno)) {
2080 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2089 /********************************************************************
2091 * sif6addr - Config the interface with an IPv6 link-local address
2093 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2095 struct in6_ifreq ifr6;
2097 struct in6_rtmsg rt6;
2099 memset(&ifr, 0, sizeof (ifr));
2100 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2101 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2102 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2106 /* Local interface */
2107 memset(&ifr6, 0, sizeof(ifr6));
2108 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2109 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2110 ifr6.ifr6_prefixlen = 10;
2112 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2113 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2117 /* Route to remote host */
2118 memset(&rt6, 0, sizeof(rt6));
2119 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2120 rt6.rtmsg_flags = RTF_UP;
2121 rt6.rtmsg_dst_len = 10;
2122 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2123 rt6.rtmsg_metric = 1;
2125 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2126 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2134 /********************************************************************
2136 * cif6addr - Remove IPv6 address from interface
2138 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2141 struct in6_ifreq ifr6;
2143 memset(&ifr, 0, sizeof(ifr));
2144 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2145 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2146 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2150 memset(&ifr6, 0, sizeof(ifr6));
2151 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2152 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2153 ifr6.ifr6_prefixlen = 10;
2155 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2156 if (errno != EADDRNOTAVAIL) {
2157 if (! ok_error (errno))
2158 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2161 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2170 * get_pty - get a pty master/slave pair and chown the slave side
2171 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2174 get_pty(master_fdp, slave_fdp, slave_name, uid)
2180 int i, mfd, sfd = -1;
2182 struct termios tios;
2186 * Try the unix98 way first.
2188 mfd = open("/dev/ptmx", O_RDWR);
2191 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2192 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2193 chmod(pty_name, S_IRUSR | S_IWUSR);
2196 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2197 warn("Couldn't unlock pty slave %s: %m", pty_name);
2199 if ((sfd = open(pty_name, O_RDWR)) < 0)
2200 warn("Couldn't open pty slave %s: %m", pty_name);
2203 #endif /* TIOCGPTN */
2206 /* the old way - scan through the pty name space */
2207 for (i = 0; i < 64; ++i) {
2208 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2209 'p' + i / 16, i % 16);
2210 mfd = open(pty_name, O_RDWR, 0);
2213 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2215 fchown(sfd, uid, -1);
2216 fchmod(sfd, S_IRUSR | S_IWUSR);
2227 strlcpy(slave_name, pty_name, 16);
2230 if (tcgetattr(sfd, &tios) == 0) {
2231 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2232 tios.c_cflag |= CS8 | CREAD;
2233 tios.c_iflag = IGNPAR | CLOCAL;
2236 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2237 warn("couldn't set attributes on pty: %m");
2239 warn("couldn't get attributes on pty: %m");
2244 /********************************************************************
2246 * open_loopback - open the device we use for getting packets
2247 * in demand mode. Under Linux, we use a pty master/slave pair.
2250 open_ppp_loopback(void)
2254 if (new_style_driver) {
2255 /* allocate ourselves a ppp unit */
2257 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
2258 fatal("Couldn't create PPP unit: %m");
2259 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2260 set_kdebugflag(kdebugflag);
2265 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2266 fatal("No free pty for loopback");
2267 SYSDEBUG(("using %s for loopback", loop_name));
2269 set_ppp_fd(slave_fd);
2271 flags = fcntl(master_fd, F_GETFL);
2273 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2274 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2276 flags = fcntl(ppp_fd, F_GETFL);
2278 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2279 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2281 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2282 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2284 * Find out which interface we were given.
2286 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2287 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2289 * Enable debug in the driver if requested.
2291 set_kdebugflag (kdebugflag);
2296 /********************************************************************
2298 * restore_loop - reattach the ppp unit to the loopback.
2300 * The kernel ppp driver automatically reattaches the ppp unit to
2301 * the loopback if the serial port is set to a line discipline other
2302 * than ppp, or if it detects a modem hangup. The former will happen
2303 * in disestablish_ppp if the latter hasn't already happened, so we
2304 * shouldn't need to do anything.
2306 * Just to be sure, set the real serial port to the normal discipline.
2312 if (new_style_driver) {
2313 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2316 if (ppp_fd != slave_fd) {
2317 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2318 set_ppp_fd(slave_fd);
2322 /********************************************************************
2324 * sifnpmode - Set the mode for handling packets for a given NP.
2328 sifnpmode(u, proto, mode)
2335 npi.protocol = proto;
2337 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2338 if (! ok_error (errno)) {
2339 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2340 proto, mode, errno);
2341 error("ppp_dev_fd=%d slave_fd=%d\n", ppp_dev_fd, slave_fd);
2349 /********************************************************************
2351 * sipxfaddr - Config the interface IPX networknumber
2354 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2361 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2363 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2365 if (! ok_error (errno))
2366 dbglog("socket(AF_IPX): %m (%d)", errno);
2370 memset (&ifr, '\0', sizeof (ifr));
2371 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2373 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2374 sipx->sipx_family = AF_IPX;
2375 sipx->sipx_port = 0;
2376 sipx->sipx_network = htonl (network);
2377 sipx->sipx_type = IPX_FRAME_ETHERII;
2378 sipx->sipx_action = IPX_CRTITF;
2380 * Set the IPX device
2382 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2384 if (errno != EEXIST) {
2385 if (! ok_error (errno))
2386 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2389 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2398 /********************************************************************
2400 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2401 * are removed and the device is no longer able to pass IPX
2405 int cipxfaddr (int unit)
2412 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2414 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2416 if (! ok_error (errno))
2417 dbglog("socket(AF_IPX): %m (%d)", errno);
2421 memset (&ifr, '\0', sizeof (ifr));
2422 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2424 sipx->sipx_type = IPX_FRAME_ETHERII;
2425 sipx->sipx_action = IPX_DLTITF;
2426 sipx->sipx_family = AF_IPX;
2428 * Set the IPX device
2430 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2431 if (! ok_error (errno))
2432 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2442 * Use the hostname as part of the random number seed.
2451 for (p = hostname; *p != 0; ++p)
2456 /********************************************************************
2458 * sys_check_options - check the options that the user specified
2462 sys_check_options(void)
2466 * Disable the IPX protocol if the support is not present in the kernel.
2471 if (ipxcp_protent.enabled_flag) {
2472 struct stat stat_buf;
2473 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2474 || lstat(path, &stat_buf) < 0) {
2475 error("IPX support is not present in the kernel\n");
2476 ipxcp_protent.enabled_flag = 0;
2480 if (demand && driver_is_old) {
2481 option_error("demand dialling is not supported by kernel driver "
2482 "version %d.%d.%d", driver_version, driver_modification,
2487 /* set ip_dynaddr if possible */
2488 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2489 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {