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>
44 /* This is in netdevice.h. However, this compile will fail miserably if
45 you attempt to include netdevice.h because it has so many references
46 to __memcpy functions which it should not attempt to do. So, since I
47 really don't use it, but it must be defined, define it now. */
50 #define MAX_ADDR_LEN 7
54 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
56 #include <net/if_arp.h>
57 #include <net/route.h>
58 #include <netinet/if_ether.h>
60 #include <linux/types.h>
62 #include <linux/if_arp.h>
63 #include <linux/route.h>
64 #include <linux/if_ether.h>
66 #include <netinet/in.h>
67 #include <arpa/inet.h>
69 #include <linux/ppp_defs.h>
70 #include <linux/if_ppp.h>
75 #include "patchlevel.h"
79 #if __GLIBC__ >= 2 && \
80 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
81 #include <netipx/ipx.h>
83 #include <linux/ipx.h>
85 #endif /* IPX_CHANGE */
88 #include <sys/locks.h>
91 #ifndef RTF_DEFAULT /* Normally in <linux/route.h> from <net/route.h> */
95 /* We can get an EIO error on an ioctl if the modem has hung up */
96 #define ok_error(num) ((num)==EIO)
98 static int tty_disc = N_TTY; /* The TTY discipline */
99 static int ppp_disc = N_PPP; /* The PPP discpline */
100 static int initfdflags = -1; /* Initial file descriptor flags for fd */
101 static int ppp_fd = -1; /* fd which is set to PPP discipline */
102 static int sock_fd = -1; /* socket for doing interface ioctls */
103 static int slave_fd = -1;
104 static int master_fd = -1;
105 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
107 static fd_set in_fds; /* set of fds that wait_input waits for */
108 static int max_in_fd; /* highest fd set in in_fds */
110 static int has_proxy_arp = 0;
111 static int driver_version = 0;
112 static int driver_modification = 0;
113 static int driver_patch = 0;
114 static int driver_is_old = 0;
115 static int restore_term = 0; /* 1 => we've munged the terminal */
116 static struct termios inittermios; /* Initial TTY termios */
118 static int new_style_driver = 0;
120 static char loop_name[20];
121 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
123 static int if_is_up; /* Interface has been marked up */
124 static u_int32_t default_route_gateway; /* Gateway for default route added */
125 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
126 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
128 static struct utsname utsname; /* for the kernel version */
129 static int kernel_version;
130 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
134 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
135 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
136 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
138 /* Prototypes for procedures local to this file. */
139 static int get_flags (int fd);
140 static void set_flags (int fd, int flags);
141 static int translate_speed (int bps);
142 static int baud_rate_of (int speed);
143 static char *path_to_route (void);
144 static void close_route_table (void);
145 static int open_route_table (void);
146 static int read_route_table (struct rtentry *rt);
147 static int defaultroute_exists (struct rtentry *rt);
148 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
149 char *name, int namelen);
150 static void decode_version (char *buf, int *version, int *mod, int *patch);
151 static int set_kdebugflag(int level);
152 static int ppp_registered(void);
154 extern u_char inpacket_buf[]; /* borrowed from main.c */
157 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
161 #define SET_SA_FAMILY(addr, family) \
162 memset ((char *) &(addr), '\0', sizeof(addr)); \
163 addr.sa_family = (family);
166 * Determine if the PPP connection should still be present.
171 /* new_fd is the fd of a tty */
172 static void set_ppp_fd (int new_fd)
174 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
176 if (!new_style_driver)
180 static int still_ppp(void)
182 if (new_style_driver)
183 return !hungup && ppp_fd >= 0;
184 if (!hungup || ppp_fd == slave_fd)
187 set_ppp_fd(slave_fd);
193 /********************************************************************
195 * Functions to read and set the flags value in the device driver
198 static int get_flags (int fd)
202 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
203 if ( ok_error (errno) )
206 fatal("ioctl(PPPIOCGFLAGS): %m");
209 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
213 /********************************************************************/
215 static void set_flags (int fd, int flags)
217 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
219 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
220 if (! ok_error (errno) )
221 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
225 /********************************************************************
227 * sys_init - System-dependent initialization.
232 int osmaj, osmin, ospatch;
235 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
236 setlogmask(LOG_UPTO(LOG_INFO));
238 setlogmask(LOG_UPTO(LOG_DEBUG));
240 if (new_style_driver) {
241 ppp_dev_fd = open("/dev/ppp", O_RDWR);
243 fatal("Couldn't open /dev/ppp: %m");
244 flags = fcntl(ppp_dev_fd, F_GETFL);
246 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
247 warn("Couldn't set /dev/ppp to nonblock: %m");
250 /* Get an internet socket for doing socket ioctls. */
251 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
253 if ( ! ok_error ( errno ))
254 fatal("Couldn't create IP socket: %m(%d)", errno);
261 osmaj = osmin = ospatch = 0;
262 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
263 kernel_version = KVERSION(osmaj, osmin, ospatch);
266 /********************************************************************
268 * sys_cleanup - restore any system state we modified before exiting:
269 * mark the interface down, delete default route and/or proxy arp entry.
270 * This shouldn't call die() because it's called from die().
273 void sys_cleanup(void)
276 * Take down the device
281 * Delete any routes through the device.
283 if (default_route_gateway != 0)
284 cifdefaultroute(0, 0, default_route_gateway);
287 cifproxyarp(0, proxy_arp_addr);
290 /********************************************************************
292 * sys_close - Clean up in a child process before execing.
297 if (new_style_driver)
308 /********************************************************************
310 * set_kdebugflag - Define the debugging level for the kernel
313 static int set_kdebugflag (int requested_level)
315 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
316 if ( ! ok_error (errno) )
317 error("ioctl(PPPIOCSDEBUG): %m");
320 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
325 /********************************************************************
327 * establish_ppp - Turn the serial port into a ppp interface.
330 int establish_ppp (int tty_fd)
335 * The current PPP device will be the tty file.
339 * Ensure that the tty device is in exclusive mode.
341 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
342 if ( ! ok_error ( errno ))
343 warn("ioctl(TIOCEXCL): %m");
346 * Demand mode - prime the old ppp device to relinquish the unit.
348 if (!new_style_driver && demand
349 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
350 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
352 * Set the current tty to the PPP discpline
354 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
355 if ( ! ok_error (errno) )
356 fatal("ioctl(TIOCSETD): %m(%d)", errno);
359 * Find out which interface we were given.
361 if (new_style_driver) {
363 /* allocate ourselves a ppp unit */
365 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
366 fatal("Couldn't create new ppp unit: %m");
367 set_kdebugflag(kdebugflag);
369 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
371 if (ioctl(tty_fd, PPPIOCATTACH, &ifunit) < 0) {
374 fatal("Couldn't attach tty to PPP unit %d: %m", ifunit);
377 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
378 if ( ! ok_error (errno))
379 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
381 /* Check that we got the same unit again. */
382 if (demand && x != ifunit)
383 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
388 * Enable debug in the driver if requested.
391 set_kdebugflag (kdebugflag);
393 set_flags(tty_fd, get_flags(tty_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
394 SC_RCV_EVNP | SC_RCV_ODDP));
396 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
397 driver_version, driver_modification, driver_patch));
400 * Fetch the initial file flags and reset blocking mode on the file.
402 initfdflags = fcntl(tty_fd, F_GETFL);
403 if (initfdflags == -1 ||
404 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
405 if ( ! ok_error (errno))
406 warn("Couldn't set device to non-blocking mode: %m");
412 /********************************************************************
414 * disestablish_ppp - Restore the serial port to normal operation.
415 * This shouldn't call die() because it's called from die().
418 void disestablish_ppp(int tty_fd)
422 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
424 if (tcflush(tty_fd, TCIOFLUSH) < 0)
425 warn("tcflush failed: %m");
427 * Restore the previous line discipline
429 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
430 if ( ! ok_error (errno))
431 error("ioctl(TIOCSETD, N_TTY): %m");
434 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
435 if ( ! ok_error (errno))
436 warn("ioctl(TIOCNXCL): %m(%d)", errno);
439 /* Reset non-blocking mode on fd. */
440 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
441 if ( ! ok_error (errno))
442 warn("Couldn't restore device fd flags: %m");
446 if (new_style_driver)
450 /********************************************************************
452 * clean_check - Fetch the flags for the device and generate
453 * appropriate error messages.
455 void clean_check(void)
461 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
463 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
465 s = "all had bit 7 set to 1";
469 s = "all had bit 7 set to 0";
473 s = "all had odd parity";
477 s = "all had even parity";
482 warn("Receive serial link is not 8-bit clean:");
483 warn("Problem: %s", s);
491 * List of valid speeds.
495 int speed_int, speed_val;
572 /********************************************************************
574 * Translate from bits/second to a speed_t.
577 static int translate_speed (int bps)
579 struct speed *speedp;
582 for (speedp = speeds; speedp->speed_int; speedp++) {
583 if (bps == speedp->speed_int)
584 return speedp->speed_val;
586 warn("speed %d not supported", bps);
591 /********************************************************************
593 * Translate from a speed_t to bits/second.
596 static int baud_rate_of (int speed)
598 struct speed *speedp;
601 for (speedp = speeds; speedp->speed_int; speedp++) {
602 if (speed == speedp->speed_val)
603 return speedp->speed_int;
609 /********************************************************************
611 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
612 * at the requested speed, etc. If `local' is true, set CLOCAL
613 * regardless of whether the modem option was specified.
616 void set_up_tty(int tty_fd, int local)
622 if (tcgetattr(tty_fd, &tios) < 0) {
623 if (!ok_error(errno))
624 fatal("tcgetattr: %m(%d)", errno);
631 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
632 tios.c_cflag |= CS8 | CREAD | HUPCL;
634 tios.c_iflag = IGNBRK | IGNPAR;
638 tios.c_cc[VTIME] = 0;
641 tios.c_cflag ^= (CLOCAL | HUPCL);
645 tios.c_cflag |= CRTSCTS;
649 tios.c_iflag |= IXON | IXOFF;
650 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
651 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
655 tios.c_cflag &= ~CRTSCTS;
662 speed = translate_speed(inspeed);
664 cfsetospeed (&tios, speed);
665 cfsetispeed (&tios, speed);
668 * We can't proceed if the serial port speed is B0,
669 * since that implies that the serial port is disabled.
672 speed = cfgetospeed(&tios);
674 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
677 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
678 if (!ok_error(errno))
679 fatal("tcsetattr: %m");
681 baud_rate = baud_rate_of(speed);
685 /********************************************************************
687 * setdtr - control the DTR line on the serial port.
688 * This is called from die(), so it shouldn't call die().
691 void setdtr (int tty_fd, int on)
693 int modembits = TIOCM_DTR;
695 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
698 /********************************************************************
700 * restore_tty - restore the terminal to the saved settings.
703 void restore_tty (int tty_fd)
708 * Turn off echoing, because otherwise we can get into
709 * a loop with the tty and the modem echoing to each other.
710 * We presume we are the sole user of this tty device, so
711 * when we close it, it will revert to its defaults anyway.
714 inittermios.c_lflag &= ~(ECHO | ECHONL);
716 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
717 if (! ok_error (errno))
718 warn("tcsetattr: %m");
723 /********************************************************************
725 * output - Output PPP packet.
728 void output (int unit, unsigned char *p, int len)
731 dbglog("sent %P", p, len);
733 if (len < PPP_HDRLEN)
735 if (new_style_driver) {
739 if (write(ppp_dev_fd, p, len) < 0) {
740 if (errno == EWOULDBLOCK || errno == ENOBUFS
741 || errno == ENXIO || errno == EIO || errno == EINTR)
742 warn("write: warning: %m (%d)", errno);
744 error("write: %m (%d)", errno);
748 /********************************************************************
750 * wait_input - wait until there is data available,
751 * for the length of time specified by *timo (indefinite
755 void wait_input(struct timeval *timo)
761 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
762 if (n < 0 && errno != EINTR)
763 fatal("select: %m(%d)", errno);
767 * add_fd - add an fd to the set that wait_input waits for.
777 * remove_fd - remove an fd from the set that wait_input waits for.
779 void remove_fd(int fd)
785 /********************************************************************
787 * read_packet - get a PPP packet from the serial device.
790 int read_packet (unsigned char *buf)
794 len = PPP_MRU + PPP_HDRLEN;
795 if (new_style_driver) {
796 *buf++ = PPP_ALLSTATIONS;
800 len = read(ppp_dev_fd, buf, len);
802 if (errno == EWOULDBLOCK || errno == EIO)
804 fatal("read: %m(%d)", errno);
806 return new_style_driver? len+2: len;
809 /********************************************************************
811 * get_loop_output - get outgoing packets from the ppp device,
812 * and detect when we want to bring the real link up.
813 * Return value is 1 if we need to bring up the link, 0 otherwise.
816 get_loop_output(void)
821 if (new_style_driver) {
822 while ((n = read_packet(inpacket_buf)) > 0)
823 if (loop_frame(inpacket_buf, n))
828 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
829 if (loop_chars(inbuf, n))
833 fatal("eof on loopback");
835 if (errno != EWOULDBLOCK)
836 fatal("read from loopback: %m(%d)", errno);
841 /********************************************************************
843 * ppp_send_config - configure the transmit characteristics of
847 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
852 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
854 * Set the MTU and other parameters for the ppp device
856 memset (&ifr, '\0', sizeof (ifr));
857 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
860 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
861 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
865 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
866 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
867 if (!ok_error(errno))
868 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
872 x = get_flags(ppp_fd);
873 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
874 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
875 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
876 set_flags(ppp_fd, x);
879 /********************************************************************
881 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
884 void ppp_set_xaccm (int unit, ext_accm accm)
886 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
887 accm[0], accm[1], accm[2], accm[3]));
891 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
892 if ( ! ok_error (errno))
893 warn("ioctl(set extended ACCM): %m(%d)", errno);
897 /********************************************************************
899 * ppp_recv_config - configure the receive-side characteristics of
903 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
905 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
907 * If we were called because the link has gone down then there is nothing
908 * which may be done. Just return without incident.
913 * Set the receiver parameters
915 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
916 if ( ! ok_error (errno))
917 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
919 if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
920 error("Couldn't set MRU in generic PPP layer: %m");
922 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
923 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
924 if (!ok_error(errno))
925 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
929 /********************************************************************
931 * ccp_test - ask kernel whether a given compression method
932 * is acceptable for use.
935 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
937 struct ppp_option_data data;
939 memset (&data, '\0', sizeof (data));
941 data.length = opt_len;
942 data.transmit = for_transmit;
944 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
947 return (errno == ENOBUFS)? 0: -1;
950 /********************************************************************
952 * ccp_flags_set - inform kernel about the current state of CCP.
955 void ccp_flags_set (int unit, int isopen, int isup)
958 int x = get_flags(ppp_dev_fd);
959 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
960 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
961 set_flags (ppp_dev_fd, x);
965 /********************************************************************
967 * get_idle_time - return how long the link has been idle.
974 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
977 /********************************************************************
979 * get_ppp_stats - return statistics for the link.
982 get_ppp_stats(u, stats)
984 struct pppd_stats *stats;
986 struct ifpppstatsreq req;
988 memset (&req, 0, sizeof (req));
990 req.stats_ptr = (caddr_t) &req.stats;
991 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
992 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
993 error("Couldn't get PPP statistics: %m");
996 stats->bytes_in = req.stats.p.ppp_ibytes;
997 stats->bytes_out = req.stats.p.ppp_obytes;
1001 /********************************************************************
1003 * ccp_fatal_error - returns 1 if decompression was disabled as a
1004 * result of an error detected after decompression of a packet,
1005 * 0 otherwise. This is necessary because of patent nonsense.
1008 int ccp_fatal_error (int unit)
1010 int x = get_flags(ppp_dev_fd);
1012 return x & SC_DC_FERROR;
1016 * path_to_route - determine the path to the proc file system data
1018 #define ROUTE_MAX_COLS 12
1019 FILE *route_fd = (FILE *) 0;
1020 static char route_buffer [512];
1021 static int route_dev_col, route_dest_col, route_gw_col;
1022 static int route_flags_col, route_mask_col;
1023 static int route_num_cols;
1025 static char *path_to_route (void);
1026 static int open_route_table (void);
1027 static void close_route_table (void);
1028 static int read_route_table (struct rtentry *rt);
1030 /********************************************************************
1032 * path_to_procfs - find the path to the proc file system mount point
1035 static int path_to_procfs (const char *tail)
1037 struct mntent *mntent;
1040 fp = fopen(MOUNTED, "r");
1042 /* Default the mount location of /proc */
1043 strlcpy (route_buffer, "/proc", sizeof (route_buffer));
1044 strlcat (route_buffer, tail, sizeof(route_buffer));
1048 while ((mntent = getmntent(fp)) != NULL) {
1049 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1051 if (strcmp(mntent->mnt_type, "proc") == 0)
1058 strlcpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer));
1059 strlcat (route_buffer, tail, sizeof(route_buffer));
1063 /********************************************************************
1065 * path_to_route - find the path to the route tables in the proc file system
1068 static char *path_to_route (void)
1070 if (!path_to_procfs("/net/route")) {
1071 error("proc file system not mounted");
1074 return (route_buffer);
1077 /********************************************************************
1079 * close_route_table - close the interface to the route table
1082 static void close_route_table (void)
1084 if (route_fd != (FILE *) 0) {
1086 route_fd = (FILE *) 0;
1090 /********************************************************************
1092 * open_route_table - open the interface to the route table
1094 static char route_delims[] = " \t\n";
1096 static int open_route_table (void)
1100 close_route_table();
1102 path = path_to_route();
1106 route_fd = fopen (path, "r");
1107 if (route_fd == NULL) {
1108 error("can't open %s: %m (%d)", path, errno);
1112 route_dev_col = 0; /* default to usual columns */
1115 route_flags_col = 3;
1119 /* parse header line */
1120 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1121 char *p = route_buffer, *q;
1123 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1125 if ((q = strtok(p, route_delims)) == 0)
1127 if (strcasecmp(q, "iface") == 0)
1128 route_dev_col = col;
1129 else if (strcasecmp(q, "destination") == 0)
1130 route_dest_col = col;
1131 else if (strcasecmp(q, "gateway") == 0)
1133 else if (strcasecmp(q, "flags") == 0)
1134 route_flags_col = col;
1135 else if (strcasecmp(q, "mask") == 0)
1136 route_mask_col = col;
1139 if (used && col >= route_num_cols)
1140 route_num_cols = col + 1;
1148 /********************************************************************
1150 * read_route_table - read the next entry from the route table
1153 static int read_route_table(struct rtentry *rt)
1155 char *cols[ROUTE_MAX_COLS], *p;
1158 memset (rt, '\0', sizeof (struct rtentry));
1160 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1164 for (col = 0; col < route_num_cols; ++col) {
1165 cols[col] = strtok(p, route_delims);
1166 if (cols[col] == NULL)
1167 return 0; /* didn't get enough columns */
1171 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1172 strtoul(cols[route_dest_col], NULL, 16);
1174 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1175 strtoul(cols[route_gw_col], NULL, 16);
1177 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1178 strtoul(cols[route_mask_col], NULL, 16);
1180 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1181 rt->rt_dev = cols[route_dev_col];
1186 /********************************************************************
1188 * defaultroute_exists - determine if there is a default route
1191 static int defaultroute_exists (struct rtentry *rt)
1195 if (!open_route_table())
1198 while (read_route_table(rt) != 0) {
1199 if ((rt->rt_flags & RTF_UP) == 0)
1202 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1208 close_route_table();
1213 * have_route_to - determine if the system has any route to
1214 * a given IP address. `addr' is in network byte order.
1215 * Return value is 1 if yes, 0 if no, -1 if don't know.
1216 * For demand mode to work properly, we have to ignore routes
1217 * through our own interface.
1219 int have_route_to(u_int32_t addr)
1224 if (!open_route_table())
1225 return -1; /* don't know */
1227 while (read_route_table(&rt)) {
1228 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1230 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1231 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1237 close_route_table();
1241 /********************************************************************
1243 * sifdefaultroute - assign a default route through the address given.
1246 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1250 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1251 struct in_addr old_gateway =
1252 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1254 if (old_gateway.s_addr != gateway)
1255 error("not replacing existing default route to %s [%I]",
1256 rt.rt_dev, old_gateway);
1260 memset (&rt, '\0', sizeof (rt));
1261 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1262 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1264 if (kernel_version > KVERSION(2,1,0)) {
1265 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1266 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1269 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1271 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1272 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1273 if ( ! ok_error ( errno ))
1274 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1278 default_route_gateway = gateway;
1282 /********************************************************************
1284 * cifdefaultroute - delete a default route through the address given.
1287 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1291 default_route_gateway = 0;
1293 memset (&rt, '\0', sizeof (rt));
1294 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1295 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1297 if (kernel_version > KVERSION(2,1,0)) {
1298 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1299 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1302 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1304 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1305 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1307 if ( ! ok_error ( errno ))
1308 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1316 /********************************************************************
1318 * sifproxyarp - Make a proxy ARP entry for the peer.
1321 int sifproxyarp (int unit, u_int32_t his_adr)
1323 struct arpreq arpreq;
1325 if (has_proxy_arp == 0) {
1326 memset (&arpreq, '\0', sizeof(arpreq));
1328 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1329 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1330 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1332 * Get the hardware address of an interface on the same subnet
1333 * as our local address.
1335 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1336 sizeof(proxy_arp_dev))) {
1337 error("Cannot determine ethernet address for proxy ARP");
1340 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1342 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1343 if ( ! ok_error ( errno ))
1344 error("ioctl(SIOCSARP): %m(%d)", errno);
1347 proxy_arp_addr = his_adr;
1354 /********************************************************************
1356 * cifproxyarp - Delete the proxy ARP entry for the peer.
1359 int cifproxyarp (int unit, u_int32_t his_adr)
1361 struct arpreq arpreq;
1363 if (has_proxy_arp) {
1365 memset (&arpreq, '\0', sizeof(arpreq));
1366 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1367 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1368 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1369 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1371 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1372 if ( ! ok_error ( errno ))
1373 warn("ioctl(SIOCDARP): %m(%d)", errno);
1380 /********************************************************************
1382 * get_ether_addr - get the hardware address of an interface on the
1383 * the same subnet as ipaddr.
1386 static int get_ether_addr (u_int32_t ipaddr,
1387 struct sockaddr *hwaddr,
1388 char *name, int namelen)
1390 struct ifreq *ifr, *ifend;
1391 u_int32_t ina, mask;
1395 struct ifreq ifs[MAX_IFS];
1397 ifc.ifc_len = sizeof(ifs);
1399 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1400 if ( ! ok_error ( errno ))
1401 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1405 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1406 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1408 * Scan through looking for an interface with an Internet
1409 * address on the same subnet as `ipaddr'.
1411 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1412 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1413 if (ifr->ifr_addr.sa_family == AF_INET) {
1414 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1415 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1416 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1419 * Check that the interface is up, and not point-to-point
1422 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1425 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1428 * Get its netmask and check that it's on the right subnet.
1430 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1433 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1434 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1435 ip_ntoa(ina), ntohl(mask)));
1437 if (((ipaddr ^ ina) & mask) != 0)
1446 strlcpy(name, ifreq.ifr_name, namelen);
1448 /* trim off the :1 in eth0:1 */
1449 aliasp = strchr(name, ':');
1453 info("found interface %s for proxy arp", name);
1455 * Now get the hardware address.
1457 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1458 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1459 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1465 sizeof (struct sockaddr));
1467 SYSDEBUG ((LOG_DEBUG,
1468 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1469 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1470 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1471 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1472 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1473 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1474 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1475 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1476 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1480 /********************************************************************
1482 * Return user specified netmask, modified by any mask we might determine
1483 * for address `addr' (in network byte order).
1484 * Here we scan through the system's list of interfaces, looking for
1485 * any non-point-to-point interfaces which might appear to be on the same
1486 * network as `addr'. If we find any, we OR in their netmask to the
1487 * user-specified netmask.
1490 u_int32_t GetMask (u_int32_t addr)
1492 u_int32_t mask, nmask, ina;
1493 struct ifreq *ifr, *ifend, ifreq;
1495 struct ifreq ifs[MAX_IFS];
1499 if (IN_CLASSA(addr)) /* determine network mask for address class */
1500 nmask = IN_CLASSA_NET;
1501 else if (IN_CLASSB(addr))
1502 nmask = IN_CLASSB_NET;
1504 nmask = IN_CLASSC_NET;
1506 /* class D nets are disallowed by bad_ip_adrs */
1507 mask = netmask | htonl(nmask);
1509 * Scan through the system's network interfaces.
1511 ifc.ifc_len = sizeof(ifs);
1513 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1514 if ( ! ok_error ( errno ))
1515 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1519 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1520 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1522 * Check the interface's internet address.
1524 if (ifr->ifr_addr.sa_family != AF_INET)
1526 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1527 if (((ntohl(ina) ^ addr) & nmask) != 0)
1530 * Check that the interface is up, and not point-to-point nor loopback.
1532 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1533 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1536 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1539 * Get its netmask and OR it into our mask.
1541 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1543 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1549 /********************************************************************
1551 * Internal routine to decode the version.modification.patch level
1554 static void decode_version (char *buf, int *version,
1555 int *modification, int *patch)
1557 *version = (int) strtoul (buf, &buf, 10);
1563 *modification = (int) strtoul (buf, &buf, 10);
1566 *patch = (int) strtoul (buf, &buf, 10);
1577 /********************************************************************
1579 * Procedure to determine if the PPP line discipline is registered.
1583 ppp_registered(void)
1591 * We used to open the serial device and set it to the ppp line
1592 * discipline here, in order to create a ppp unit. But that is
1593 * not a good idea - the user might have specified a device that
1594 * they can't open (permission, or maybe it doesn't really exist).
1595 * So we grab a pty master/slave pair and use that.
1597 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1598 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1603 * Try to put the device into the PPP discipline.
1605 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1606 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1615 /********************************************************************
1617 * ppp_available - check whether the system has any ppp interfaces
1618 * (in fact we check whether we can do an ioctl on ppp0).
1621 int ppp_available(void)
1626 int my_version, my_modification, my_patch;
1629 "This system lacks kernel support for PPP. This could be because\n"
1630 "the PPP kernel module could not be loaded, or because PPP was not\n"
1631 "included in the kernel configuration. If PPP was included as a\n"
1632 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1633 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1634 "See README.linux file in the ppp distribution for more details.\n";
1636 fd = open("/dev/ppp", O_RDWR);
1637 if (fd < 0 && errno == ENOENT) {
1638 /* try making it and see if that helps. */
1639 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1640 makedev(108, 0)) >= 0) {
1641 fd = open("/dev/ppp", O_RDWR);
1643 info("Created /dev/ppp device node");
1645 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1646 } else if (errno == EEXIST) {
1647 fd = open("/dev/ppp", O_RDWR);
1651 new_style_driver = 1;
1653 /* XXX should get from driver */
1655 driver_modification = 4;
1662 * Open a socket for doing the ioctl operations.
1664 s = socket(AF_INET, SOCK_DGRAM, 0);
1668 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1669 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1671 * If the device did not exist then attempt to create one by putting the
1672 * current tty into the PPP discipline. If this works then obtain the
1673 * flags for the device again.
1676 if (ppp_registered()) {
1677 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1678 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1682 * Ensure that the hardware address is for PPP and not something else
1685 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1687 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1691 * This is the PPP device. Validate the version of the driver at this
1692 * point to ensure that this program will work with the driver.
1695 char abBuffer [1024];
1697 ifr.ifr_data = abBuffer;
1698 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1700 error("Couldn't read driver version: %m");
1702 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1705 decode_version(abBuffer,
1707 &driver_modification,
1710 * Validate the version of the driver against the version that we used.
1712 decode_version(VERSION,
1717 /* The version numbers must match */
1718 if (driver_version != my_version)
1721 /* The modification levels must be legal */
1722 if (driver_modification < 3) {
1723 if (driver_modification >= 2) {
1724 /* we can cope with 2.2.0 and above */
1733 slprintf(route_buffer, sizeof(route_buffer),
1734 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1735 driver_version, driver_modification, driver_patch);
1737 no_ppp_msg = route_buffer;
1744 /********************************************************************
1746 * Update the wtmp file with the appropriate user name and tty device.
1749 void logwtmp (const char *line, const char *name, const char *host)
1751 struct utmp ut, *utp;
1752 pid_t mypid = getpid();
1758 * Update the signon database for users.
1759 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1761 utmpname(_PATH_UTMP);
1763 while ((utp = getutent()) && (utp->ut_pid != mypid))
1766 /* Is this call really necessary? There is another one after the 'put' */
1770 memcpy(&ut, utp, sizeof(ut));
1772 /* some gettys/telnetds don't initialize utmp... */
1773 memset(&ut, 0, sizeof(ut));
1775 if (ut.ut_id[0] == 0)
1776 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1778 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1779 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1783 ut.ut_type = USER_PROCESS;
1786 /* Insert the host name if one is supplied */
1788 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1790 /* Insert the IP address of the remote system if IP is enabled */
1791 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1792 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1793 sizeof(ut.ut_addr));
1795 /* CL: Makes sure that the logout works */
1796 if (*host == 0 && *name==0)
1802 * Update the wtmp file.
1805 updwtmp(_PATH_WTMP, &ut);
1807 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1809 flock(wtmp, LOCK_EX);
1811 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1812 warn("error writing %s: %m", _PATH_WTMP);
1814 flock(wtmp, LOCK_UN);
1822 /********************************************************************
1824 * sifvjcomp - config tcp header compression
1827 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1829 u_int x = get_flags(ppp_dev_fd);
1832 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1833 if (! ok_error (errno))
1834 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1839 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1840 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1841 set_flags (ppp_dev_fd, x);
1846 /********************************************************************
1848 * sifup - Config the interface up and enable IP packets to pass.
1855 memset (&ifr, '\0', sizeof (ifr));
1856 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1857 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1858 if (! ok_error (errno))
1859 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1863 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1864 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1865 if (! ok_error (errno))
1866 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1873 /********************************************************************
1875 * sifdown - Config the interface down and disable IP.
1884 memset (&ifr, '\0', sizeof (ifr));
1885 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1886 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1887 if (! ok_error (errno))
1888 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1892 ifr.ifr_flags &= ~IFF_UP;
1893 ifr.ifr_flags |= IFF_POINTOPOINT;
1894 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1895 if (! ok_error (errno))
1896 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1902 /********************************************************************
1904 * sifaddr - Config the interface IP addresses and netmask.
1907 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1913 memset (&ifr, '\0', sizeof (ifr));
1914 memset (&rt, '\0', sizeof (rt));
1916 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
1917 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
1918 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
1920 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1922 * Set our IP address
1924 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
1925 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
1926 if (errno != EEXIST) {
1927 if (! ok_error (errno))
1928 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
1931 warn("ioctl(SIOCSIFADDR): Address already exists");
1936 * Set the gateway address
1938 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
1939 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
1940 if (! ok_error (errno))
1941 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
1946 * For recent kernels, force the netmask to 255.255.255.255.
1948 if (kernel_version >= KVERSION(2,1,16))
1950 if (net_mask != 0) {
1951 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
1952 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
1953 if (! ok_error (errno))
1954 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
1959 * Add the device route
1961 if (kernel_version < KVERSION(2,1,16)) {
1962 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1963 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1966 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
1967 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
1968 rt.rt_flags = RTF_UP | RTF_HOST;
1970 if (kernel_version > KVERSION(2,1,0)) {
1971 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1972 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
1975 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1976 if (! ok_error (errno))
1977 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
1984 /********************************************************************
1986 * cifaddr - Clear the interface IP addresses, and delete routes
1987 * through the interface if possible.
1990 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
1994 if (kernel_version < KVERSION(2,1,16)) {
1996 * Delete the route through the device
1998 memset (&rt, '\0', sizeof (rt));
2000 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2001 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2004 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2005 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2006 rt.rt_flags = RTF_UP | RTF_HOST;
2008 if (kernel_version > KVERSION(2,1,0)) {
2009 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2010 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2013 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2014 if (still_ppp() && ! ok_error (errno))
2015 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2023 * get_pty - get a pty master/slave pair and chown the slave side
2024 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2027 get_pty(master_fdp, slave_fdp, slave_name, uid)
2033 int i, mfd, sfd = -1;
2035 struct termios tios;
2039 * Try the unix98 way first.
2041 mfd = open("/dev/ptmx", O_RDWR);
2044 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2045 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2046 chmod(pty_name, S_IRUSR | S_IWUSR);
2049 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2050 warn("Couldn't unlock pty slave %s: %m", pty_name);
2052 if ((sfd = open(pty_name, O_RDWR)) < 0)
2053 warn("Couldn't open pty slave %s: %m", pty_name);
2056 #endif /* TIOCGPTN */
2059 /* the old way - scan through the pty name space */
2060 for (i = 0; i < 64; ++i) {
2061 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2062 'p' + i / 16, i % 16);
2063 mfd = open(pty_name, O_RDWR, 0);
2066 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2068 fchown(sfd, uid, -1);
2069 fchmod(sfd, S_IRUSR | S_IWUSR);
2080 strlcpy(slave_name, pty_name, 16);
2083 if (tcgetattr(sfd, &tios) == 0) {
2084 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2085 tios.c_cflag |= CS8 | CREAD;
2086 tios.c_iflag = IGNPAR | CLOCAL;
2089 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2090 warn("couldn't set attributes on pty: %m");
2092 warn("couldn't get attributes on pty: %m");
2097 /********************************************************************
2099 * open_loopback - open the device we use for getting packets
2100 * in demand mode. Under Linux, we use a pty master/slave pair.
2103 open_ppp_loopback(void)
2107 if (new_style_driver) {
2108 /* allocate ourselves a ppp unit */
2110 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
2111 fatal("Couldn't create PPP unit: %m");
2112 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2113 set_kdebugflag(kdebugflag);
2118 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2119 fatal("No free pty for loopback");
2120 SYSDEBUG(("using %s for loopback", loop_name));
2122 set_ppp_fd(slave_fd);
2124 flags = fcntl(master_fd, F_GETFL);
2126 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2127 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2129 flags = fcntl(ppp_fd, F_GETFL);
2131 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2132 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2134 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2135 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2137 * Find out which interface we were given.
2139 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2140 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2142 * Enable debug in the driver if requested.
2144 set_kdebugflag (kdebugflag);
2149 /********************************************************************
2151 * restore_loop - reattach the ppp unit to the loopback.
2153 * The kernel ppp driver automatically reattaches the ppp unit to
2154 * the loopback if the serial port is set to a line discipline other
2155 * than ppp, or if it detects a modem hangup. The former will happen
2156 * in disestablish_ppp if the latter hasn't already happened, so we
2157 * shouldn't need to do anything.
2159 * Just to be sure, set the real serial port to the normal discipline.
2165 if (new_style_driver) {
2166 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & SC_LOOP_TRAFFIC);
2169 if (ppp_fd != slave_fd) {
2170 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2171 set_ppp_fd(slave_fd);
2175 /********************************************************************
2177 * sifnpmode - Set the mode for handling packets for a given NP.
2181 sifnpmode(u, proto, mode)
2188 npi.protocol = proto;
2190 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2191 if (! ok_error (errno)) {
2192 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2193 proto, mode, errno);
2194 error("ppp_dev_fd=%d slave_fd=%d\n", ppp_dev_fd, slave_fd);
2202 /********************************************************************
2204 * sipxfaddr - Config the interface IPX networknumber
2207 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2214 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2216 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2218 if (! ok_error (errno))
2219 dbglog("socket(AF_IPX): %m (%d)", errno);
2223 memset (&ifr, '\0', sizeof (ifr));
2224 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2226 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2227 sipx->sipx_family = AF_IPX;
2228 sipx->sipx_port = 0;
2229 sipx->sipx_network = htonl (network);
2230 sipx->sipx_type = IPX_FRAME_ETHERII;
2231 sipx->sipx_action = IPX_CRTITF;
2233 * Set the IPX device
2235 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2237 if (errno != EEXIST) {
2238 if (! ok_error (errno))
2239 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2242 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2251 /********************************************************************
2253 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2254 * are removed and the device is no longer able to pass IPX
2258 int cipxfaddr (int unit)
2265 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2267 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2269 if (! ok_error (errno))
2270 dbglog("socket(AF_IPX): %m (%d)", errno);
2274 memset (&ifr, '\0', sizeof (ifr));
2275 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2277 sipx->sipx_type = IPX_FRAME_ETHERII;
2278 sipx->sipx_action = IPX_DLTITF;
2279 sipx->sipx_family = AF_IPX;
2281 * Set the IPX device
2283 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2284 if (! ok_error (errno))
2285 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2295 * Use the hostname as part of the random number seed.
2304 for (p = hostname; *p != 0; ++p)
2309 /********************************************************************
2311 * sys_check_options - check the options that the user specified
2315 sys_check_options(void)
2319 * Disable the IPX protocol if the support is not present in the kernel.
2321 if (ipxcp_protent.enabled_flag) {
2322 struct stat stat_buf;
2323 if (!path_to_procfs("/net/ipx_interface")
2324 || lstat (route_buffer, &stat_buf) < 0) {
2325 error("IPX support is not present in the kernel\n");
2326 ipxcp_protent.enabled_flag = 0;
2330 if (demand && driver_is_old) {
2331 option_error("demand dialling is not supported by kernel driver "
2332 "version %d.%d.%d", driver_version, driver_modification,