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)
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");
448 /********************************************************************
450 * clean_check - Fetch the flags for the device and generate
451 * appropriate error messages.
453 void clean_check(void)
459 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
461 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
463 s = "all had bit 7 set to 1";
467 s = "all had bit 7 set to 0";
471 s = "all had odd parity";
475 s = "all had even parity";
480 warn("Receive serial link is not 8-bit clean:");
481 warn("Problem: %s", s);
489 * List of valid speeds.
493 int speed_int, speed_val;
570 /********************************************************************
572 * Translate from bits/second to a speed_t.
575 static int translate_speed (int bps)
577 struct speed *speedp;
580 for (speedp = speeds; speedp->speed_int; speedp++) {
581 if (bps == speedp->speed_int)
582 return speedp->speed_val;
584 warn("speed %d not supported", bps);
589 /********************************************************************
591 * Translate from a speed_t to bits/second.
594 static int baud_rate_of (int speed)
596 struct speed *speedp;
599 for (speedp = speeds; speedp->speed_int; speedp++) {
600 if (speed == speedp->speed_val)
601 return speedp->speed_int;
607 /********************************************************************
609 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
610 * at the requested speed, etc. If `local' is true, set CLOCAL
611 * regardless of whether the modem option was specified.
614 void set_up_tty(int tty_fd, int local)
620 if (tcgetattr(tty_fd, &tios) < 0) {
621 if (!ok_error(errno))
622 fatal("tcgetattr: %m(%d)", errno);
629 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
630 tios.c_cflag |= CS8 | CREAD | HUPCL;
632 tios.c_iflag = IGNBRK | IGNPAR;
636 tios.c_cc[VTIME] = 0;
639 tios.c_cflag ^= (CLOCAL | HUPCL);
643 tios.c_cflag |= CRTSCTS;
647 tios.c_iflag |= IXON | IXOFF;
648 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
649 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
653 tios.c_cflag &= ~CRTSCTS;
660 speed = translate_speed(inspeed);
662 cfsetospeed (&tios, speed);
663 cfsetispeed (&tios, speed);
666 * We can't proceed if the serial port speed is B0,
667 * since that implies that the serial port is disabled.
670 speed = cfgetospeed(&tios);
672 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
675 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
676 if (!ok_error(errno))
677 fatal("tcsetattr: %m");
679 baud_rate = baud_rate_of(speed);
683 /********************************************************************
685 * setdtr - control the DTR line on the serial port.
686 * This is called from die(), so it shouldn't call die().
689 void setdtr (int tty_fd, int on)
691 int modembits = TIOCM_DTR;
693 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
696 /********************************************************************
698 * restore_tty - restore the terminal to the saved settings.
701 void restore_tty (int tty_fd)
706 * Turn off echoing, because otherwise we can get into
707 * a loop with the tty and the modem echoing to each other.
708 * We presume we are the sole user of this tty device, so
709 * when we close it, it will revert to its defaults anyway.
712 inittermios.c_lflag &= ~(ECHO | ECHONL);
714 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
715 if (! ok_error (errno))
716 warn("tcsetattr: %m");
721 /********************************************************************
723 * output - Output PPP packet.
726 void output (int unit, unsigned char *p, int len)
729 dbglog("sent %P", p, len);
731 if (len < PPP_HDRLEN)
733 if (new_style_driver) {
737 if (write(ppp_dev_fd, p, len) < 0) {
738 if (errno == EWOULDBLOCK || errno == ENOBUFS
739 || errno == ENXIO || errno == EIO || errno == EINTR)
740 warn("write: warning: %m (%d)", errno);
742 error("write: %m (%d)", errno);
746 /********************************************************************
748 * wait_input - wait until there is data available,
749 * for the length of time specified by *timo (indefinite
753 void wait_input(struct timeval *timo)
759 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
760 if (n < 0 && errno != EINTR)
761 fatal("select: %m(%d)", errno);
765 * add_fd - add an fd to the set that wait_input waits for.
775 * remove_fd - remove an fd from the set that wait_input waits for.
777 void remove_fd(int fd)
783 /********************************************************************
785 * read_packet - get a PPP packet from the serial device.
788 int read_packet (unsigned char *buf)
792 len = PPP_MRU + PPP_HDRLEN;
793 if (new_style_driver) {
794 *buf++ = PPP_ALLSTATIONS;
798 len = read(ppp_dev_fd, buf, len);
800 if (errno == EWOULDBLOCK || errno == EIO)
802 fatal("read: %m(%d)", errno);
804 return new_style_driver? len+2: len;
807 /********************************************************************
809 * get_loop_output - get outgoing packets from the ppp device,
810 * and detect when we want to bring the real link up.
811 * Return value is 1 if we need to bring up the link, 0 otherwise.
814 get_loop_output(void)
819 if (new_style_driver) {
820 while ((n = read_packet(inpacket_buf)) > 0)
821 if (loop_frame(inpacket_buf, n))
826 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
827 if (loop_chars(inbuf, n))
831 fatal("eof on loopback");
833 if (errno != EWOULDBLOCK)
834 fatal("read from loopback: %m(%d)", errno);
839 /********************************************************************
841 * ppp_send_config - configure the transmit characteristics of
845 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
850 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
852 * Ensure that the link is still up.
857 * Set the MTU and other parameters for the ppp device
859 memset (&ifr, '\0', sizeof (ifr));
860 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
863 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
864 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
866 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
867 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
868 if (!ok_error(errno))
869 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
873 x = get_flags(ppp_fd);
874 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
875 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
876 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
877 set_flags(ppp_fd, x);
880 /********************************************************************
882 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
885 void ppp_set_xaccm (int unit, ext_accm accm)
887 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
888 accm[0], accm[1], accm[2], accm[3]));
890 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
891 if ( ! ok_error (errno))
892 warn("ioctl(set extended ACCM): %m(%d)", errno);
896 /********************************************************************
898 * ppp_recv_config - configure the receive-side characteristics of
902 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
904 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
906 * If we were called because the link has gone down then there is nothing
907 * which may be done. Just return without incident.
912 * Set the receiver parameters
914 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
915 if ( ! ok_error (errno))
916 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
918 if (new_style_driver && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
919 error("Couldn't set MRU in generic PPP layer: %m");
921 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
922 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
923 if (!ok_error(errno))
924 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
928 /********************************************************************
930 * ccp_test - ask kernel whether a given compression method
931 * is acceptable for use.
934 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
936 struct ppp_option_data data;
938 memset (&data, '\0', sizeof (data));
940 data.length = opt_len;
941 data.transmit = for_transmit;
943 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
946 return (errno == ENOBUFS)? 0: -1;
949 /********************************************************************
951 * ccp_flags_set - inform kernel about the current state of CCP.
954 void ccp_flags_set (int unit, int isopen, int isup)
957 int x = get_flags(ppp_dev_fd);
958 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
959 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
960 set_flags (ppp_dev_fd, x);
964 /********************************************************************
966 * get_idle_time - return how long the link has been idle.
973 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
976 /********************************************************************
978 * get_ppp_stats - return statistics for the link.
981 get_ppp_stats(u, stats)
983 struct pppd_stats *stats;
985 struct ifpppstatsreq req;
987 memset (&req, 0, sizeof (req));
989 req.stats_ptr = (caddr_t) &req.stats;
990 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
991 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
992 error("Couldn't get PPP statistics: %m");
995 stats->bytes_in = req.stats.p.ppp_ibytes;
996 stats->bytes_out = req.stats.p.ppp_obytes;
1000 /********************************************************************
1002 * ccp_fatal_error - returns 1 if decompression was disabled as a
1003 * result of an error detected after decompression of a packet,
1004 * 0 otherwise. This is necessary because of patent nonsense.
1007 int ccp_fatal_error (int unit)
1009 int x = get_flags(ppp_dev_fd);
1011 return x & SC_DC_FERROR;
1015 * path_to_route - determine the path to the proc file system data
1017 #define ROUTE_MAX_COLS 12
1018 FILE *route_fd = (FILE *) 0;
1019 static char route_buffer [512];
1020 static int route_dev_col, route_dest_col, route_gw_col;
1021 static int route_flags_col, route_mask_col;
1022 static int route_num_cols;
1024 static char *path_to_route (void);
1025 static int open_route_table (void);
1026 static void close_route_table (void);
1027 static int read_route_table (struct rtentry *rt);
1029 /********************************************************************
1031 * path_to_procfs - find the path to the proc file system mount point
1034 static int path_to_procfs (const char *tail)
1036 struct mntent *mntent;
1039 fp = fopen(MOUNTED, "r");
1041 /* Default the mount location of /proc */
1042 strlcpy (route_buffer, "/proc", sizeof (route_buffer));
1043 strlcat (route_buffer, tail, sizeof(route_buffer));
1047 while ((mntent = getmntent(fp)) != NULL) {
1048 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1050 if (strcmp(mntent->mnt_type, "proc") == 0)
1057 strlcpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer));
1058 strlcat (route_buffer, tail, sizeof(route_buffer));
1062 /********************************************************************
1064 * path_to_route - find the path to the route tables in the proc file system
1067 static char *path_to_route (void)
1069 if (!path_to_procfs("/net/route")) {
1070 error("proc file system not mounted");
1073 return (route_buffer);
1076 /********************************************************************
1078 * close_route_table - close the interface to the route table
1081 static void close_route_table (void)
1083 if (route_fd != (FILE *) 0) {
1085 route_fd = (FILE *) 0;
1089 /********************************************************************
1091 * open_route_table - open the interface to the route table
1093 static char route_delims[] = " \t\n";
1095 static int open_route_table (void)
1099 close_route_table();
1101 path = path_to_route();
1105 route_fd = fopen (path, "r");
1106 if (route_fd == NULL) {
1107 error("can't open %s: %m (%d)", path, errno);
1111 route_dev_col = 0; /* default to usual columns */
1114 route_flags_col = 3;
1118 /* parse header line */
1119 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1120 char *p = route_buffer, *q;
1122 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1124 if ((q = strtok(p, route_delims)) == 0)
1126 if (strcasecmp(q, "iface") == 0)
1127 route_dev_col = col;
1128 else if (strcasecmp(q, "destination") == 0)
1129 route_dest_col = col;
1130 else if (strcasecmp(q, "gateway") == 0)
1132 else if (strcasecmp(q, "flags") == 0)
1133 route_flags_col = col;
1134 else if (strcasecmp(q, "mask") == 0)
1135 route_mask_col = col;
1138 if (used && col >= route_num_cols)
1139 route_num_cols = col + 1;
1147 /********************************************************************
1149 * read_route_table - read the next entry from the route table
1152 static int read_route_table(struct rtentry *rt)
1154 char *cols[ROUTE_MAX_COLS], *p;
1157 memset (rt, '\0', sizeof (struct rtentry));
1159 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1163 for (col = 0; col < route_num_cols; ++col) {
1164 cols[col] = strtok(p, route_delims);
1165 if (cols[col] == NULL)
1166 return 0; /* didn't get enough columns */
1170 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1171 strtoul(cols[route_dest_col], NULL, 16);
1173 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1174 strtoul(cols[route_gw_col], NULL, 16);
1176 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1177 strtoul(cols[route_mask_col], NULL, 16);
1179 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1180 rt->rt_dev = cols[route_dev_col];
1185 /********************************************************************
1187 * defaultroute_exists - determine if there is a default route
1190 static int defaultroute_exists (struct rtentry *rt)
1194 if (!open_route_table())
1197 while (read_route_table(rt) != 0) {
1198 if ((rt->rt_flags & RTF_UP) == 0)
1201 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1207 close_route_table();
1212 * have_route_to - determine if the system has any route to
1213 * a given IP address. `addr' is in network byte order.
1214 * Return value is 1 if yes, 0 if no, -1 if don't know.
1215 * For demand mode to work properly, we have to ignore routes
1216 * through our own interface.
1218 int have_route_to(u_int32_t addr)
1223 if (!open_route_table())
1224 return -1; /* don't know */
1226 while (read_route_table(&rt)) {
1227 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1229 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1230 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1236 close_route_table();
1240 /********************************************************************
1242 * sifdefaultroute - assign a default route through the address given.
1245 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1249 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1250 struct in_addr old_gateway =
1251 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1253 if (old_gateway.s_addr != gateway)
1254 error("not replacing existing default route to %s [%I]",
1255 rt.rt_dev, old_gateway);
1259 memset (&rt, '\0', sizeof (rt));
1260 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1261 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1263 if (kernel_version > KVERSION(2,1,0)) {
1264 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1265 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1268 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1270 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1271 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1272 if ( ! ok_error ( errno ))
1273 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1277 default_route_gateway = gateway;
1281 /********************************************************************
1283 * cifdefaultroute - delete a default route through the address given.
1286 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1290 default_route_gateway = 0;
1292 memset (&rt, '\0', sizeof (rt));
1293 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1294 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1296 if (kernel_version > KVERSION(2,1,0)) {
1297 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1298 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1301 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1303 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1304 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1306 if ( ! ok_error ( errno ))
1307 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1315 /********************************************************************
1317 * sifproxyarp - Make a proxy ARP entry for the peer.
1320 int sifproxyarp (int unit, u_int32_t his_adr)
1322 struct arpreq arpreq;
1324 if (has_proxy_arp == 0) {
1325 memset (&arpreq, '\0', sizeof(arpreq));
1327 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1328 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1329 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1331 * Get the hardware address of an interface on the same subnet
1332 * as our local address.
1334 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1335 sizeof(proxy_arp_dev))) {
1336 error("Cannot determine ethernet address for proxy ARP");
1339 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1341 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1342 if ( ! ok_error ( errno ))
1343 error("ioctl(SIOCSARP): %m(%d)", errno);
1346 proxy_arp_addr = his_adr;
1353 /********************************************************************
1355 * cifproxyarp - Delete the proxy ARP entry for the peer.
1358 int cifproxyarp (int unit, u_int32_t his_adr)
1360 struct arpreq arpreq;
1362 if (has_proxy_arp) {
1364 memset (&arpreq, '\0', sizeof(arpreq));
1365 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1366 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1367 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1368 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1370 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1371 if ( ! ok_error ( errno ))
1372 warn("ioctl(SIOCDARP): %m(%d)", errno);
1379 /********************************************************************
1381 * get_ether_addr - get the hardware address of an interface on the
1382 * the same subnet as ipaddr.
1385 static int get_ether_addr (u_int32_t ipaddr,
1386 struct sockaddr *hwaddr,
1387 char *name, int namelen)
1389 struct ifreq *ifr, *ifend;
1390 u_int32_t ina, mask;
1393 struct ifreq ifs[MAX_IFS];
1395 ifc.ifc_len = sizeof(ifs);
1397 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1398 if ( ! ok_error ( errno ))
1399 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1403 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1404 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1406 * Scan through looking for an interface with an Internet
1407 * address on the same subnet as `ipaddr'.
1409 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1410 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1411 if (ifr->ifr_addr.sa_family == AF_INET) {
1412 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1413 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1414 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1417 * Check that the interface is up, and not point-to-point
1420 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1423 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1426 * Get its netmask and check that it's on the right subnet.
1428 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1431 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1432 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1433 ip_ntoa(ina), ntohl(mask)));
1435 if (((ipaddr ^ ina) & mask) != 0)
1444 strlcpy(name, ifreq.ifr_name, namelen);
1445 info("found interface %s for proxy arp", name);
1447 * Now get the hardware address.
1449 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1450 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1451 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1457 sizeof (struct sockaddr));
1459 SYSDEBUG ((LOG_DEBUG,
1460 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1461 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1462 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1463 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1464 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1465 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1466 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1467 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1468 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1472 /********************************************************************
1474 * Return user specified netmask, modified by any mask we might determine
1475 * for address `addr' (in network byte order).
1476 * Here we scan through the system's list of interfaces, looking for
1477 * any non-point-to-point interfaces which might appear to be on the same
1478 * network as `addr'. If we find any, we OR in their netmask to the
1479 * user-specified netmask.
1482 u_int32_t GetMask (u_int32_t addr)
1484 u_int32_t mask, nmask, ina;
1485 struct ifreq *ifr, *ifend, ifreq;
1487 struct ifreq ifs[MAX_IFS];
1491 if (IN_CLASSA(addr)) /* determine network mask for address class */
1492 nmask = IN_CLASSA_NET;
1493 else if (IN_CLASSB(addr))
1494 nmask = IN_CLASSB_NET;
1496 nmask = IN_CLASSC_NET;
1498 /* class D nets are disallowed by bad_ip_adrs */
1499 mask = netmask | htonl(nmask);
1501 * Scan through the system's network interfaces.
1503 ifc.ifc_len = sizeof(ifs);
1505 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1506 if ( ! ok_error ( errno ))
1507 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1511 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1512 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1514 * Check the interface's internet address.
1516 if (ifr->ifr_addr.sa_family != AF_INET)
1518 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1519 if (((ntohl(ina) ^ addr) & nmask) != 0)
1522 * Check that the interface is up, and not point-to-point nor loopback.
1524 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1525 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1528 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1531 * Get its netmask and OR it into our mask.
1533 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1535 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1541 /********************************************************************
1543 * Internal routine to decode the version.modification.patch level
1546 static void decode_version (char *buf, int *version,
1547 int *modification, int *patch)
1549 *version = (int) strtoul (buf, &buf, 10);
1555 *modification = (int) strtoul (buf, &buf, 10);
1558 *patch = (int) strtoul (buf, &buf, 10);
1569 /********************************************************************
1571 * Procedure to determine if the PPP line discipline is registered.
1575 ppp_registered(void)
1583 * We used to open the serial device and set it to the ppp line
1584 * discipline here, in order to create a ppp unit. But that is
1585 * not a good idea - the user might have specified a device that
1586 * they can't open (permission, or maybe it doesn't really exist).
1587 * So we grab a pty master/slave pair and use that.
1589 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1590 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1595 * Try to put the device into the PPP discipline.
1597 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1598 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1607 /********************************************************************
1609 * ppp_available - check whether the system has any ppp interfaces
1610 * (in fact we check whether we can do an ioctl on ppp0).
1613 int ppp_available(void)
1618 int my_version, my_modification, my_patch;
1621 "This system lacks kernel support for PPP. This could be because\n"
1622 "the PPP kernel module could not be loaded, or because PPP was not\n"
1623 "included in the kernel configuration. If PPP was included as a\n"
1624 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1625 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1626 "See README.linux file in the ppp distribution for more details.\n";
1628 fd = open("/dev/ppp", O_RDWR);
1630 new_style_driver = 1;
1632 /* XXX should get from driver */
1634 driver_modification = 4;
1641 * Open a socket for doing the ioctl operations.
1643 s = socket(AF_INET, SOCK_DGRAM, 0);
1647 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1648 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1650 * If the device did not exist then attempt to create one by putting the
1651 * current tty into the PPP discipline. If this works then obtain the
1652 * flags for the device again.
1655 if (ppp_registered()) {
1656 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1657 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1661 * Ensure that the hardware address is for PPP and not something else
1664 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1666 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1670 * This is the PPP device. Validate the version of the driver at this
1671 * point to ensure that this program will work with the driver.
1674 char abBuffer [1024];
1676 ifr.ifr_data = abBuffer;
1677 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1679 error("Couldn't read driver version: %m");
1681 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1684 decode_version(abBuffer,
1686 &driver_modification,
1689 * Validate the version of the driver against the version that we used.
1691 decode_version(VERSION,
1696 /* The version numbers must match */
1697 if (driver_version != my_version)
1700 /* The modification levels must be legal */
1701 if (driver_modification < 3) {
1702 if (driver_modification >= 2) {
1703 /* we can cope with 2.2.0 and above */
1712 slprintf(route_buffer, sizeof(route_buffer),
1713 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1714 driver_version, driver_modification, driver_patch);
1716 no_ppp_msg = route_buffer;
1723 /********************************************************************
1725 * Update the wtmp file with the appropriate user name and tty device.
1728 void logwtmp (const char *line, const char *name, const char *host)
1731 struct utmp ut, *utp;
1732 pid_t mypid = getpid();
1734 * Update the signon database for users.
1735 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1737 utmpname(_PATH_UTMP);
1739 while ((utp = getutent()) && (utp->ut_pid != mypid))
1742 /* Is this call really necessary? There is another one after the 'put' */
1746 memcpy(&ut, utp, sizeof(ut));
1748 /* some gettys/telnetds don't initialize utmp... */
1749 memset(&ut, 0, sizeof(ut));
1751 if (ut.ut_id[0] == 0)
1752 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1754 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1755 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1759 ut.ut_type = USER_PROCESS;
1762 /* Insert the host name if one is supplied */
1764 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1766 /* Insert the IP address of the remote system if IP is enabled */
1767 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1768 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1769 sizeof(ut.ut_addr));
1771 /* CL: Makes sure that the logout works */
1772 if (*host == 0 && *name==0)
1778 * Update the wtmp file.
1780 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1782 flock(wtmp, LOCK_EX);
1784 /* we really should check for error on the write for a full disk! */
1785 write (wtmp, (char *)&ut, sizeof(ut));
1788 flock(wtmp, LOCK_UN);
1793 /********************************************************************
1795 * sifvjcomp - config tcp header compression
1798 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1800 u_int x = get_flags(ppp_dev_fd);
1803 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1804 if (! ok_error (errno))
1805 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1810 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1811 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1812 set_flags (ppp_dev_fd, x);
1817 /********************************************************************
1819 * sifup - Config the interface up and enable IP packets to pass.
1826 memset (&ifr, '\0', sizeof (ifr));
1827 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1828 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1829 if (! ok_error (errno))
1830 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1834 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1835 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1836 if (! ok_error (errno))
1837 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1844 /********************************************************************
1846 * sifdown - Config the interface down and disable IP.
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;
1864 ifr.ifr_flags |= IFF_POINTOPOINT;
1865 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1866 if (! ok_error (errno))
1867 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1873 /********************************************************************
1875 * sifaddr - Config the interface IP addresses and netmask.
1878 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1884 memset (&ifr, '\0', sizeof (ifr));
1885 memset (&rt, '\0', sizeof (rt));
1887 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
1888 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
1889 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
1891 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1893 * Set our IP address
1895 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
1896 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
1897 if (errno != EEXIST) {
1898 if (! ok_error (errno))
1899 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
1902 warn("ioctl(SIOCSIFADDR): Address already exists");
1907 * Set the gateway address
1909 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
1910 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
1911 if (! ok_error (errno))
1912 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
1917 * For recent kernels, force the netmask to 255.255.255.255.
1919 if (kernel_version >= KVERSION(2,1,16))
1921 if (net_mask != 0) {
1922 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
1923 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
1924 if (! ok_error (errno))
1925 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
1930 * Add the device route
1932 if (kernel_version < KVERSION(2,1,16)) {
1933 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1934 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1937 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
1938 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
1939 rt.rt_flags = RTF_UP | RTF_HOST;
1941 if (kernel_version > KVERSION(2,1,0)) {
1942 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1943 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
1946 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1947 if (! ok_error (errno))
1948 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
1955 /********************************************************************
1957 * cifaddr - Clear the interface IP addresses, and delete routes
1958 * through the interface if possible.
1961 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
1965 if (kernel_version < KVERSION(2,1,16)) {
1967 * Delete the route through the device
1969 memset (&rt, '\0', sizeof (rt));
1971 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1972 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1975 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
1976 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
1977 rt.rt_flags = RTF_UP | RTF_HOST;
1979 if (kernel_version > KVERSION(2,1,0)) {
1980 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1981 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
1984 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1985 if (still_ppp() && ! ok_error (errno))
1986 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
1994 * get_pty - get a pty master/slave pair and chown the slave side
1995 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
1998 get_pty(master_fdp, slave_fdp, slave_name, uid)
2004 int i, mfd, sfd = -1;
2006 struct termios tios;
2010 * Try the unix98 way first.
2012 mfd = open("/dev/ptmx", O_RDWR);
2015 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2016 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2017 chmod(pty_name, S_IRUSR | S_IWUSR);
2020 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2021 warn("Couldn't unlock pty slave %s: %m", pty_name);
2023 if ((sfd = open(pty_name, O_RDWR)) < 0)
2024 warn("Couldn't open pty slave %s: %m", pty_name);
2027 #endif /* TIOCGPTN */
2030 /* the old way - scan through the pty name space */
2031 for (i = 0; i < 64; ++i) {
2032 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2033 'p' + i / 16, i % 16);
2034 mfd = open(pty_name, O_RDWR, 0);
2037 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2039 fchown(sfd, uid, -1);
2040 fchmod(sfd, S_IRUSR | S_IWUSR);
2051 strlcpy(slave_name, pty_name, 16);
2054 if (tcgetattr(sfd, &tios) == 0) {
2055 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2056 tios.c_cflag |= CS8 | CREAD;
2057 tios.c_iflag = IGNPAR | CLOCAL;
2060 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2061 warn("couldn't set attributes on pty: %m");
2063 warn("couldn't get attributes on pty: %m");
2068 /********************************************************************
2070 * open_loopback - open the device we use for getting packets
2071 * in demand mode. Under Linux, we use a pty master/slave pair.
2074 open_ppp_loopback(void)
2078 if (new_style_driver) {
2079 /* allocate ourselves a ppp unit */
2081 if (ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit) < 0)
2082 fatal("Couldn't create PPP unit: %m");
2083 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2084 set_kdebugflag(kdebugflag);
2089 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2090 fatal("No free pty for loopback");
2091 SYSDEBUG(("using %s for loopback", loop_name));
2093 set_ppp_fd(slave_fd);
2095 flags = fcntl(master_fd, F_GETFL);
2097 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2098 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2100 flags = fcntl(ppp_fd, F_GETFL);
2102 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2103 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2105 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2106 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2108 * Find out which interface we were given.
2110 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2111 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2113 * Enable debug in the driver if requested.
2115 set_kdebugflag (kdebugflag);
2120 /********************************************************************
2122 * restore_loop - reattach the ppp unit to the loopback.
2124 * The kernel ppp driver automatically reattaches the ppp unit to
2125 * the loopback if the serial port is set to a line discipline other
2126 * than ppp, or if it detects a modem hangup. The former will happen
2127 * in disestablish_ppp if the latter hasn't already happened, so we
2128 * shouldn't need to do anything.
2130 * Just to be sure, set the real serial port to the normal discipline.
2136 if (new_style_driver) {
2137 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & SC_LOOP_TRAFFIC);
2140 if (ppp_fd != slave_fd) {
2141 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2142 set_ppp_fd(slave_fd);
2146 /********************************************************************
2148 * sifnpmode - Set the mode for handling packets for a given NP.
2152 sifnpmode(u, proto, mode)
2159 npi.protocol = proto;
2161 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2162 if (! ok_error (errno)) {
2163 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2164 proto, mode, errno);
2165 error("ppp_dev_fd=%d slave_fd=%d\n", ppp_dev_fd, slave_fd);
2173 /********************************************************************
2175 * sipxfaddr - Config the interface IPX networknumber
2178 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2185 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2187 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2189 if (! ok_error (errno))
2190 dbglog("socket(AF_IPX): %m (%d)", errno);
2194 memset (&ifr, '\0', sizeof (ifr));
2195 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2197 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2198 sipx->sipx_family = AF_IPX;
2199 sipx->sipx_port = 0;
2200 sipx->sipx_network = htonl (network);
2201 sipx->sipx_type = IPX_FRAME_ETHERII;
2202 sipx->sipx_action = IPX_CRTITF;
2204 * Set the IPX device
2206 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2208 if (errno != EEXIST) {
2209 if (! ok_error (errno))
2210 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2213 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2222 /********************************************************************
2224 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2225 * are removed and the device is no longer able to pass IPX
2229 int cipxfaddr (int unit)
2236 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2238 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2240 if (! ok_error (errno))
2241 dbglog("socket(AF_IPX): %m (%d)", errno);
2245 memset (&ifr, '\0', sizeof (ifr));
2246 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2248 sipx->sipx_type = IPX_FRAME_ETHERII;
2249 sipx->sipx_action = IPX_DLTITF;
2250 sipx->sipx_family = AF_IPX;
2252 * Set the IPX device
2254 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2255 if (! ok_error (errno))
2256 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2266 * Use the hostname as part of the random number seed.
2275 for (p = hostname; *p != 0; ++p)
2280 /********************************************************************
2282 * sys_check_options - check the options that the user specified
2286 sys_check_options(void)
2290 * Disable the IPX protocol if the support is not present in the kernel.
2292 if (ipxcp_protent.enabled_flag) {
2293 struct stat stat_buf;
2294 if (!path_to_procfs("/net/ipx_interface")
2295 || lstat (route_buffer, &stat_buf) < 0) {
2296 error("IPX support is not present in the kernel\n");
2297 ipxcp_protent.enabled_flag = 0;
2301 if (demand && driver_is_old) {
2302 option_error("demand dialling is not supported by kernel driver "
2303 "version %d.%d.%d", driver_version, driver_modification,