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;
106 static fd_set in_fds; /* set of fds that wait_input waits for */
107 static int max_in_fd; /* highest fd set in in_fds */
109 static int has_proxy_arp = 0;
110 static int driver_version = 0;
111 static int driver_modification = 0;
112 static int driver_patch = 0;
113 static int driver_is_old = 0;
114 static int restore_term = 0; /* 1 => we've munged the terminal */
115 static struct termios inittermios; /* Initial TTY termios */
117 static char loop_name[20];
118 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
120 static int if_is_up; /* Interface has been marked up */
121 static u_int32_t default_route_gateway; /* Gateway for default route added */
122 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
123 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
125 static char *lock_file;
127 static struct utsname utsname; /* for the kernel version */
128 static int kernel_version;
129 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
133 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
134 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
135 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
137 /* Prototypes for procedures local to this file. */
138 static int get_flags (void);
139 static void set_flags (int flags);
140 static int translate_speed (int bps);
141 static int baud_rate_of (int speed);
142 static char *path_to_route (void);
143 static void close_route_table (void);
144 static int open_route_table (void);
145 static int read_route_table (struct rtentry *rt);
146 static int defaultroute_exists (struct rtentry *rt);
147 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
148 char *name, int namelen);
149 static void decode_version (char *buf, int *version, int *mod, int *patch);
150 static int set_kdebugflag(int level);
151 static int ppp_registered(void);
153 extern u_char inpacket_buf[]; /* borrowed from main.c */
156 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
160 #define SET_SA_FAMILY(addr, family) \
161 memset ((char *) &(addr), '\0', sizeof(addr)); \
162 addr.sa_family = (family);
165 * Determine if the PPP connection should still be present.
171 #define LOCK_PREFIX "/var/lock/LCK.."
174 static void set_ppp_fd (int new_fd)
176 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
180 static int still_ppp(void)
182 if (!hungup || ppp_fd == slave_fd)
185 set_ppp_fd(slave_fd);
191 /********************************************************************
193 * Functions to read and set the flags value in the device driver
196 static int get_flags (void)
200 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
201 if ( ok_error (errno) )
204 fatal("ioctl(PPPIOCGFLAGS): %m");
207 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
211 /********************************************************************/
213 static void set_flags (int flags)
215 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
217 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
218 if (! ok_error (errno) )
219 fatal("ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
223 /********************************************************************
225 * sys_init - System-dependent initialization.
230 int osmaj, osmin, ospatch;
232 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
233 setlogmask(LOG_UPTO(LOG_INFO));
235 setlogmask(LOG_UPTO(LOG_DEBUG));
237 /* Get an internet socket for doing socket ioctls. */
238 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
240 if ( ! ok_error ( errno ))
241 fatal("Couldn't create IP socket: %m(%d)", errno);
248 osmaj = osmin = ospatch = 0;
249 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
250 kernel_version = KVERSION(osmaj, osmin, ospatch);
253 /********************************************************************
255 * sys_cleanup - restore any system state we modified before exiting:
256 * mark the interface down, delete default route and/or proxy arp entry.
257 * This shouldn't call die() because it's called from die().
260 void sys_cleanup(void)
263 * Take down the device
268 * Delete any routes through the device.
270 if (default_route_gateway != 0)
271 cifdefaultroute(0, 0, default_route_gateway);
274 cifproxyarp(0, proxy_arp_addr);
277 /********************************************************************
279 * sys_close - Clean up in a child process before execing.
293 /********************************************************************
295 * set_kdebugflag - Define the debugging level for the kernel
298 static int set_kdebugflag (int requested_level)
300 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0) {
301 if ( ! ok_error (errno) )
302 error("ioctl(PPPIOCSDEBUG): %m");
305 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
310 /********************************************************************
312 * establish_ppp - Turn the serial port into a ppp interface.
315 int establish_ppp (int tty_fd)
319 * The current PPP device will be the tty file.
323 * Ensure that the tty device is in exclusive mode.
325 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
326 if ( ! ok_error ( errno ))
327 warn("ioctl(TIOCEXCL): %m");
330 * Demand mode - prime the old ppp device to relinquish the unit.
332 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
333 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
335 * Set the current tty to the PPP discpline
337 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0) {
338 if ( ! ok_error (errno) )
339 fatal("ioctl(TIOCSETD): %m(%d)", errno);
342 * Find out which interface we were given.
344 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0) {
345 if ( ! ok_error (errno))
346 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
349 * Check that we got the same unit again.
353 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
358 * Enable debug in the driver if requested.
361 set_kdebugflag (kdebugflag);
363 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
364 SC_RCV_EVNP | SC_RCV_ODDP));
366 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
367 driver_version, driver_modification, driver_patch));
369 * Fetch the initial file flags and reset blocking mode on the file.
371 initfdflags = fcntl(ppp_fd, F_GETFL);
373 if (initfdflags == -1 ||
374 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
375 if ( ! ok_error (errno))
376 warn("Couldn't set device to non-blocking mode: %m");
382 /********************************************************************
384 * disestablish_ppp - Restore the serial port to normal operation.
385 * This shouldn't call die() because it's called from die().
388 void disestablish_ppp(int tty_fd)
391 * Attempt to restore the previous tty settings
395 * Restore the previous line discipline
397 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
398 if ( ! ok_error (errno))
399 error("ioctl(TIOCSETD, N_TTY): %m");
402 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
403 if ( ! ok_error (errno))
404 warn("ioctl(TIOCNXCL): %m(%d)", errno);
407 /* Reset non-blocking mode on fd. */
408 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
409 if ( ! ok_error (errno))
410 warn("Couldn't restore device fd flags: %m");
416 /********************************************************************
418 * clean_check - Fetch the flags for the device and generate
419 * appropriate error messages.
421 void clean_check(void)
427 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
429 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
431 case SC_RCV_B7_0 | SC_RCV_EVNP:
432 case SC_RCV_B7_0 | SC_RCV_ODDP:
433 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
434 s = "all had bit 7 set to 1";
438 case SC_RCV_B7_1 | SC_RCV_EVNP:
439 case SC_RCV_B7_1 | SC_RCV_ODDP:
440 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
441 s = "all had bit 7 set to 0";
445 s = "all had odd parity";
449 s = "all had even parity";
454 warn("Receive serial link is not 8-bit clean:");
455 warn("Problem: %s", s);
463 * List of valid speeds.
467 int speed_int, speed_val;
544 /********************************************************************
546 * Translate from bits/second to a speed_t.
549 static int translate_speed (int bps)
551 struct speed *speedp;
554 for (speedp = speeds; speedp->speed_int; speedp++) {
555 if (bps == speedp->speed_int)
556 return speedp->speed_val;
558 warn("speed %d not supported", bps);
563 /********************************************************************
565 * Translate from a speed_t to bits/second.
568 static int baud_rate_of (int speed)
570 struct speed *speedp;
573 for (speedp = speeds; speedp->speed_int; speedp++) {
574 if (speed == speedp->speed_val)
575 return speedp->speed_int;
581 /********************************************************************
583 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
584 * at the requested speed, etc. If `local' is true, set CLOCAL
585 * regardless of whether the modem option was specified.
588 void set_up_tty(int tty_fd, int local)
594 if (tcgetattr(tty_fd, &tios) < 0) {
595 if (!ok_error(errno))
596 fatal("tcgetattr: %m(%d)", errno);
603 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
604 tios.c_cflag |= CS8 | CREAD | HUPCL;
606 tios.c_iflag = IGNBRK | IGNPAR;
610 tios.c_cc[VTIME] = 0;
613 tios.c_cflag ^= (CLOCAL | HUPCL);
617 tios.c_cflag |= CRTSCTS;
621 tios.c_iflag |= IXON | IXOFF;
622 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
623 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
627 tios.c_cflag &= ~CRTSCTS;
634 speed = translate_speed(inspeed);
636 cfsetospeed (&tios, speed);
637 cfsetispeed (&tios, speed);
640 * We can't proceed if the serial port speed is B0,
641 * since that implies that the serial port is disabled.
644 speed = cfgetospeed(&tios);
646 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
649 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
650 if (!ok_error(errno))
651 fatal("tcsetattr: %m");
653 baud_rate = baud_rate_of(speed);
657 /********************************************************************
659 * setdtr - control the DTR line on the serial port.
660 * This is called from die(), so it shouldn't call die().
663 void setdtr (int tty_fd, int on)
665 int modembits = TIOCM_DTR;
667 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
670 /********************************************************************
672 * restore_tty - restore the terminal to the saved settings.
675 void restore_tty (int tty_fd)
680 * Turn off echoing, because otherwise we can get into
681 * a loop with the tty and the modem echoing to each other.
682 * We presume we are the sole user of this tty device, so
683 * when we close it, it will revert to its defaults anyway.
686 inittermios.c_lflag &= ~(ECHO | ECHONL);
688 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
689 if (! ok_error (errno))
690 warn("tcsetattr: %m");
695 /********************************************************************
697 * output - Output PPP packet.
700 void output (int unit, unsigned char *p, int len)
703 dbglog("sent %P", p, len);
705 if (write(ppp_fd, p, len) < 0) {
706 if (errno == EWOULDBLOCK || errno == ENOBUFS
707 || errno == ENXIO || errno == EIO || errno == EINTR)
708 warn("write: warning: %m (%d)", errno);
710 error("write: %m (%d)", errno);
714 /********************************************************************
716 * wait_input - wait until there is data available,
717 * for the length of time specified by *timo (indefinite
721 void wait_input(struct timeval *timo)
727 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
728 if (n < 0 && errno != EINTR)
729 fatal("select: %m(%d)", errno);
733 * add_fd - add an fd to the set that wait_input waits for.
743 * remove_fd - remove an fd from the set that wait_input waits for.
745 void remove_fd(int fd)
751 /********************************************************************
753 * wait_loop_output - wait until there is data available on the
754 * loopback, for the length of time specified by *timo (indefinite
757 void wait_loop_output(timo)
758 struct timeval *timo;
764 FD_SET(master_fd, &ready);
765 n = select(master_fd + 1, &ready, NULL, &ready, timo);
766 if (n < 0 && errno != EINTR)
767 fatal("select: %m(%d)", errno);
770 /********************************************************************
772 * wait_time - wait for a given length of time or until a
773 * signal is received.
777 struct timeval *timo;
781 n = select(0, NULL, NULL, NULL, timo);
782 if (n < 0 && errno != EINTR)
783 fatal("select: %m(%d)", errno);
787 /********************************************************************
789 * read_packet - get a PPP packet from the serial device.
792 int read_packet (unsigned char *buf)
796 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
798 if (errno == EWOULDBLOCK || errno == EIO)
800 fatal("read: %m(%d)", errno);
805 /********************************************************************
807 * get_loop_output - get outgoing packets from the ppp device,
808 * and detect when we want to bring the real link up.
809 * Return value is 1 if we need to bring up the link, 0 otherwise.
812 get_loop_output(void)
815 int n = read(master_fd, inbuf, sizeof(inbuf));
818 if (loop_chars(inbuf, n))
820 n = read(master_fd, inbuf, sizeof(inbuf));
824 fatal("eof on loopback");
826 if (errno != EWOULDBLOCK)
827 fatal("read from loopback: %m(%d)", errno);
832 /********************************************************************
834 * ppp_send_config - configure the transmit characteristics of
838 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
843 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
845 * Ensure that the link is still up.
850 * Set the MTU and other parameters for the ppp device
852 memset (&ifr, '\0', sizeof (ifr));
853 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
856 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
857 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
859 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
860 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
861 if (!ok_error(errno))
862 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
867 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
868 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
869 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
873 /********************************************************************
875 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
878 void ppp_set_xaccm (int unit, ext_accm accm)
880 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
881 accm[0], accm[1], accm[2], accm[3]));
883 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
884 if ( ! ok_error (errno))
885 warn("ioctl(set extended ACCM): %m(%d)", errno);
889 /********************************************************************
891 * ppp_recv_config - configure the receive-side characteristics of
895 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
899 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
901 * If we were called because the link has gone down then there is nothing
902 * which may be done. Just return without incident.
907 * Set the receiver parameters
909 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
910 if ( ! ok_error (errno))
911 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
914 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
915 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
916 if (!ok_error(errno))
917 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
921 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
925 /********************************************************************
927 * ccp_test - ask kernel whether a given compression method
928 * is acceptable for use.
931 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
933 struct ppp_option_data data;
935 memset (&data, '\0', sizeof (data));
937 data.length = opt_len;
938 data.transmit = for_transmit;
940 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
943 return (errno == ENOBUFS)? 0: -1;
946 /********************************************************************
948 * ccp_flags_set - inform kernel about the current state of CCP.
951 void ccp_flags_set (int unit, int isopen, int isup)
955 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
956 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
961 /********************************************************************
963 * get_idle_time - return how long the link has been idle.
970 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
973 /********************************************************************
975 * get_ppp_stats - return statistics for the link.
978 get_ppp_stats(u, stats)
980 struct pppd_stats *stats;
982 struct ifpppstatsreq req;
984 memset (&req, 0, sizeof (req));
986 req.stats_ptr = (caddr_t) &req.stats;
987 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
988 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
989 error("Couldn't get PPP statistics: %m");
992 stats->bytes_in = req.stats.p.ppp_ibytes;
993 stats->bytes_out = req.stats.p.ppp_obytes;
997 /********************************************************************
999 * ccp_fatal_error - returns 1 if decompression was disabled as a
1000 * result of an error detected after decompression of a packet,
1001 * 0 otherwise. This is necessary because of patent nonsense.
1004 int ccp_fatal_error (int unit)
1006 int x = get_flags();
1008 return x & SC_DC_FERROR;
1012 * path_to_route - determine the path to the proc file system data
1014 #define ROUTE_MAX_COLS 12
1015 FILE *route_fd = (FILE *) 0;
1016 static char route_buffer [512];
1017 static int route_dev_col, route_dest_col, route_gw_col;
1018 static int route_flags_col, route_mask_col;
1019 static int route_num_cols;
1021 static char *path_to_route (void);
1022 static int open_route_table (void);
1023 static void close_route_table (void);
1024 static int read_route_table (struct rtentry *rt);
1026 /********************************************************************
1028 * path_to_procfs - find the path to the proc file system mount point
1031 static int path_to_procfs (void)
1033 struct mntent *mntent;
1036 fp = fopen(MOUNTED, "r");
1038 /* Default the mount location of /proc */
1039 strlcpy (route_buffer, "/proc", sizeof (route_buffer));
1043 while ((mntent = getmntent(fp)) != NULL) {
1044 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1046 if (strcmp(mntent->mnt_type, "proc") == 0)
1053 strlcpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer));
1057 /********************************************************************
1059 * path_to_route - find the path to the route tables in the proc file system
1062 static char *path_to_route (void)
1064 if (!path_to_procfs()) {
1065 error("proc file system not mounted");
1068 strlcat (route_buffer, "/net/route", sizeof(route_buffer));
1069 return (route_buffer);
1072 /********************************************************************
1074 * close_route_table - close the interface to the route table
1077 static void close_route_table (void)
1079 if (route_fd != (FILE *) 0) {
1081 route_fd = (FILE *) 0;
1085 /********************************************************************
1087 * open_route_table - open the interface to the route table
1089 static char route_delims[] = " \t\n";
1091 static int open_route_table (void)
1095 close_route_table();
1097 path = path_to_route();
1101 route_fd = fopen (path, "r");
1102 if (route_fd == NULL) {
1103 error("can't open %s: %m (%d)", path, errno);
1107 route_dev_col = 0; /* default to usual columns */
1110 route_flags_col = 3;
1114 /* parse header line */
1115 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1116 char *p = route_buffer, *q;
1118 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1120 if ((q = strtok(p, route_delims)) == 0)
1122 if (strcasecmp(q, "iface") == 0)
1123 route_dev_col = col;
1124 else if (strcasecmp(q, "destination") == 0)
1125 route_dest_col = col;
1126 else if (strcasecmp(q, "gateway") == 0)
1128 else if (strcasecmp(q, "flags") == 0)
1129 route_flags_col = col;
1130 else if (strcasecmp(q, "mask") == 0)
1131 route_mask_col = col;
1134 if (used && col >= route_num_cols)
1135 route_num_cols = col + 1;
1143 /********************************************************************
1145 * read_route_table - read the next entry from the route table
1148 static int read_route_table(struct rtentry *rt)
1150 char *cols[ROUTE_MAX_COLS], *p;
1153 memset (rt, '\0', sizeof (struct rtentry));
1155 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1159 for (col = 0; col < route_num_cols; ++col) {
1160 cols[col] = strtok(p, route_delims);
1161 if (cols[col] == NULL)
1162 return 0; /* didn't get enough columns */
1165 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1166 strtoul(cols[route_dest_col], NULL, 16);
1168 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1169 strtoul(cols[route_gw_col], NULL, 16);
1171 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1172 strtoul(cols[route_mask_col], NULL, 16);
1174 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1175 rt->rt_dev = cols[route_dev_col];
1180 /********************************************************************
1182 * defaultroute_exists - determine if there is a default route
1185 static int defaultroute_exists (struct rtentry *rt)
1189 if (!open_route_table())
1192 while (read_route_table(rt) != 0) {
1193 if ((rt->rt_flags & RTF_UP) == 0)
1196 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1202 close_route_table();
1207 * have_route_to - determine if the system has any route to
1208 * a given IP address. `addr' is in network byte order.
1209 * Return value is 1 if yes, 0 if no, -1 if don't know.
1210 * For demand mode to work properly, we have to ignore routes
1211 * through our own interface.
1213 int have_route_to(u_int32_t addr)
1218 if (!open_route_table())
1219 return -1; /* don't know */
1221 while (read_route_table(&rt)) {
1222 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1224 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1225 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1231 close_route_table();
1235 /********************************************************************
1237 * sifdefaultroute - assign a default route through the address given.
1240 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1244 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1245 struct in_addr old_gateway =
1246 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1248 if (old_gateway.s_addr != gateway)
1249 error("not replacing existing default route to %s [%I]",
1250 rt.rt_dev, old_gateway);
1254 memset (&rt, '\0', sizeof (rt));
1255 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1256 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1258 if (kernel_version > KVERSION(2,1,0)) {
1259 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1260 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1263 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1265 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1266 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1267 if ( ! ok_error ( errno ))
1268 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1272 default_route_gateway = gateway;
1276 /********************************************************************
1278 * cifdefaultroute - delete a default route through the address given.
1281 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1285 default_route_gateway = 0;
1287 memset (&rt, '\0', sizeof (rt));
1288 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1289 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1291 if (kernel_version > KVERSION(2,1,0)) {
1292 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1293 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1296 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1298 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1299 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1301 if ( ! ok_error ( errno ))
1302 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1310 /********************************************************************
1312 * sifproxyarp - Make a proxy ARP entry for the peer.
1315 int sifproxyarp (int unit, u_int32_t his_adr)
1317 struct arpreq arpreq;
1319 if (has_proxy_arp == 0) {
1320 memset (&arpreq, '\0', sizeof(arpreq));
1322 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1323 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1324 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1326 * Get the hardware address of an interface on the same subnet
1327 * as our local address.
1329 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1330 sizeof(proxy_arp_dev))) {
1331 error("Cannot determine ethernet address for proxy ARP");
1334 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1336 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1337 if ( ! ok_error ( errno ))
1338 error("ioctl(SIOCSARP): %m(%d)", errno);
1341 proxy_arp_addr = his_adr;
1348 /********************************************************************
1350 * cifproxyarp - Delete the proxy ARP entry for the peer.
1353 int cifproxyarp (int unit, u_int32_t his_adr)
1355 struct arpreq arpreq;
1357 if (has_proxy_arp) {
1359 memset (&arpreq, '\0', sizeof(arpreq));
1360 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1361 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1362 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1363 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1365 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1366 if ( ! ok_error ( errno ))
1367 warn("ioctl(SIOCDARP): %m(%d)", errno);
1374 /********************************************************************
1376 * get_ether_addr - get the hardware address of an interface on the
1377 * the same subnet as ipaddr.
1380 static int get_ether_addr (u_int32_t ipaddr,
1381 struct sockaddr *hwaddr,
1382 char *name, int namelen)
1384 struct ifreq *ifr, *ifend;
1385 u_int32_t ina, mask;
1388 struct ifreq ifs[MAX_IFS];
1390 ifc.ifc_len = sizeof(ifs);
1392 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1393 if ( ! ok_error ( errno ))
1394 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1398 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1399 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1401 * Scan through looking for an interface with an Internet
1402 * address on the same subnet as `ipaddr'.
1404 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1405 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1406 if (ifr->ifr_addr.sa_family == AF_INET) {
1407 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1408 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1409 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1412 * Check that the interface is up, and not point-to-point
1415 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1418 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1421 * Get its netmask and check that it's on the right subnet.
1423 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1426 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1427 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1428 ip_ntoa(ina), ntohl(mask)));
1430 if (((ipaddr ^ ina) & mask) != 0)
1439 strlcpy(name, ifreq.ifr_name, namelen);
1440 info("found interface %s for proxy arp", name);
1442 * Now get the hardware address.
1444 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1445 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1446 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1452 sizeof (struct sockaddr));
1454 SYSDEBUG ((LOG_DEBUG,
1455 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1456 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1457 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1458 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1459 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1460 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1461 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1462 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1463 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1467 /********************************************************************
1469 * Return user specified netmask, modified by any mask we might determine
1470 * for address `addr' (in network byte order).
1471 * Here we scan through the system's list of interfaces, looking for
1472 * any non-point-to-point interfaces which might appear to be on the same
1473 * network as `addr'. If we find any, we OR in their netmask to the
1474 * user-specified netmask.
1477 u_int32_t GetMask (u_int32_t addr)
1479 u_int32_t mask, nmask, ina;
1480 struct ifreq *ifr, *ifend, ifreq;
1482 struct ifreq ifs[MAX_IFS];
1486 if (IN_CLASSA(addr)) /* determine network mask for address class */
1487 nmask = IN_CLASSA_NET;
1488 else if (IN_CLASSB(addr))
1489 nmask = IN_CLASSB_NET;
1491 nmask = IN_CLASSC_NET;
1493 /* class D nets are disallowed by bad_ip_adrs */
1494 mask = netmask | htonl(nmask);
1496 * Scan through the system's network interfaces.
1498 ifc.ifc_len = sizeof(ifs);
1500 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1501 if ( ! ok_error ( errno ))
1502 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1506 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1507 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1509 * Check the interface's internet address.
1511 if (ifr->ifr_addr.sa_family != AF_INET)
1513 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1514 if (((ntohl(ina) ^ addr) & nmask) != 0)
1517 * Check that the interface is up, and not point-to-point nor loopback.
1519 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1520 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1523 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1526 * Get its netmask and OR it into our mask.
1528 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1530 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1536 /********************************************************************
1538 * Internal routine to decode the version.modification.patch level
1541 static void decode_version (char *buf, int *version,
1542 int *modification, int *patch)
1544 *version = (int) strtoul (buf, &buf, 10);
1550 *modification = (int) strtoul (buf, &buf, 10);
1553 *patch = (int) strtoul (buf, &buf, 10);
1564 /********************************************************************
1566 * Procedure to determine if the PPP line discipline is registered.
1570 ppp_registered(void)
1577 if (devnam[0] == 0) {
1578 /* running with notty or pty option */
1580 if (!get_pty(&mfd, &local_fd, slave, 0))
1583 local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1585 error("Failed to open %s: %m(%d)", devnam, errno);
1591 * Read the initial line discipline and try to put the device into the
1594 if (ioctl(local_fd, TIOCGETD, &init_disc) < 0) {
1595 error("ioctl(TIOCGETD): %m(%d)", errno);
1596 } else if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1597 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1598 } else if (ioctl(local_fd, TIOCSETD, &init_disc) < 0) {
1599 error("ioctl(TIOCSETD(%d)): %m(%d)", init_disc, errno);
1609 /********************************************************************
1611 * ppp_available - check whether the system has any ppp interfaces
1612 * (in fact we check whether we can do an ioctl on ppp0).
1615 int ppp_available(void)
1620 int my_version, my_modification, my_patch;
1621 extern char *no_ppp_msg;
1623 * Open a socket for doing the ioctl operations.
1625 s = socket(AF_INET, SOCK_DGRAM, 0);
1629 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1630 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1632 * If the device did not exist then attempt to create one by putting the
1633 * current tty into the PPP discipline. If this works then obtain the
1634 * flags for the device again.
1637 if (ppp_registered()) {
1638 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1639 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1643 * Ensure that the hardware address is for PPP and not something else
1646 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1648 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1653 "This system lacks kernel support for PPP. This could be because\n"
1654 "the PPP kernel module is not loaded, or because the kernel is\n"
1655 "not configured for PPP. See the README.linux file in the\n"
1656 "ppp-2.3.7 distribution.\n";
1659 * This is the PPP device. Validate the version of the driver at this
1660 * point to ensure that this program will work with the driver.
1663 char abBuffer [1024];
1665 ifr.ifr_data = abBuffer;
1666 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1668 error("Couldn't read driver version: %m");
1670 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1673 decode_version(abBuffer,
1675 &driver_modification,
1678 * Validate the version of the driver against the version that we used.
1680 decode_version(VERSION,
1685 /* The version numbers must match */
1686 if (driver_version != my_version)
1689 /* The modification levels must be legal */
1690 if (driver_modification < 3) {
1691 if (driver_modification >= 2) {
1692 /* we can cope with 2.2.0 and above */
1701 slprintf(route_buffer, sizeof(route_buffer),
1702 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1703 driver_version, driver_modification, driver_patch);
1705 no_ppp_msg = route_buffer;
1712 /********************************************************************
1714 * Update the wtmp file with the appropriate user name and tty device.
1717 void logwtmp (const char *line, const char *name, const char *host)
1720 struct utmp ut, *utp;
1721 pid_t mypid = getpid();
1723 * Update the signon database for users.
1724 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1726 utmpname(_PATH_UTMP);
1728 while ((utp = getutent()) && (utp->ut_pid != mypid))
1731 /* Is this call really necessary? There is another one after the 'put' */
1735 memcpy(&ut, utp, sizeof(ut));
1737 /* some gettys/telnetds don't initialize utmp... */
1738 memset(&ut, 0, sizeof(ut));
1740 if (ut.ut_id[0] == 0)
1741 strlcpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1743 strlcpy(ut.ut_user, name, sizeof(ut.ut_user));
1744 strlcpy(ut.ut_line, line, sizeof(ut.ut_line));
1748 ut.ut_type = USER_PROCESS;
1751 /* Insert the host name if one is supplied */
1753 strlcpy (ut.ut_host, host, sizeof(ut.ut_host));
1755 /* Insert the IP address of the remote system if IP is enabled */
1756 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1757 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1758 sizeof(ut.ut_addr));
1760 /* CL: Makes sure that the logout works */
1761 if (*host == 0 && *name==0)
1767 * Update the wtmp file.
1769 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1771 flock(wtmp, LOCK_EX);
1773 /* we really should check for error on the write for a full disk! */
1774 write (wtmp, (char *)&ut, sizeof(ut));
1777 flock(wtmp, LOCK_UN);
1781 /********************************************************************
1782 * Code for locking/unlocking the serial device.
1783 * This code is derived from chat.c.
1787 * lock - create a lock file for the named device
1790 int lock (char *dev)
1794 lock_file = strdup(dev);
1795 if (lock_file == NULL)
1796 novm("lock file name");
1797 result = mklock (dev, (void *) 0);
1800 notice("Device %s is locked by pid %d", dev, result);
1807 error("Can't create lock file %s", lock_file);
1815 char hdb_lock_buffer[12];
1821 p = strrchr(dev, '/');
1825 l = strlen(LOCK_PREFIX) + strlen(dev) + 1;
1826 lock_file = malloc(l);
1827 if (lock_file == NULL)
1828 novm("lock file name");
1830 slprintf(lock_file, l, "%s%s", LOCK_PREFIX, dev);
1832 * Attempt to create the lock file at this point.
1835 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1839 slprintf(hdb_lock_buffer, sizeof(hdb_lock_buffer), "%010d\n", pid);
1840 write (fd, hdb_lock_buffer, 11);
1842 write(fd, &pid, sizeof (pid));
1848 * If the file exists then check to see if the pid is stale
1850 if (errno == EEXIST) {
1851 fd = open(lock_file, O_RDONLY, 0);
1853 if (errno == ENOENT) /* This is just a timing problem. */
1858 /* Read the lock file to find out who has the device locked */
1859 n = read (fd, hdb_lock_buffer, 11);
1862 error("Can't read pid from lock file %s", lock_file);
1866 /* See the process still exists. */
1869 hdb_lock_buffer[n] = '\0';
1870 sscanf (hdb_lock_buffer, " %d", &pid);
1872 pid = ((int *) hdb_lock_buffer)[0];
1874 if (pid == 0 || pid == getpid()
1875 || (kill(pid, 0) == -1 && errno == ESRCH))
1879 /* If the process does not exist then try to remove the lock */
1880 if (n == 0 && unlink (lock_file) == 0) {
1881 notice("Removed stale lock on %s (pid %d)",
1886 notice("Device %s is locked by pid %d", dev, pid);
1890 error("Can't create lock file %s: %m(%d)", lock_file, errno);
1901 /********************************************************************
1903 * unlock - remove our lockfile
1910 (void) rmlock (lock_file, (void *) 0);
1919 /********************************************************************
1921 * sifvjcomp - config tcp header compression
1924 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1926 u_int x = get_flags();
1929 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1930 if (! ok_error (errno))
1931 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1936 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1937 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1943 /********************************************************************
1945 * sifup - Config the interface up and enable IP packets to pass.
1952 memset (&ifr, '\0', sizeof (ifr));
1953 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1954 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1955 if (! ok_error (errno))
1956 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1960 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1961 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1962 if (! ok_error (errno))
1963 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1970 /********************************************************************
1972 * sifdown - Config the interface down and disable IP.
1981 memset (&ifr, '\0', sizeof (ifr));
1982 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1983 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1984 if (! ok_error (errno))
1985 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1989 ifr.ifr_flags &= ~IFF_UP;
1990 ifr.ifr_flags |= IFF_POINTOPOINT;
1991 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1992 if (! ok_error (errno))
1993 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1999 /********************************************************************
2001 * sifaddr - Config the interface IP addresses and netmask.
2004 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2010 memset (&ifr, '\0', sizeof (ifr));
2011 memset (&rt, '\0', sizeof (rt));
2013 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2014 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2015 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2017 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2019 * Set our IP address
2021 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2022 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2023 if (errno != EEXIST) {
2024 if (! ok_error (errno))
2025 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2028 warn("ioctl(SIOCSIFADDR): Address already exists");
2033 * Set the gateway address
2035 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2036 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2037 if (! ok_error (errno))
2038 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2043 * For recent kernels, force the netmask to 255.255.255.255.
2045 if (kernel_version >= KVERSION(2,1,16))
2047 if (net_mask != 0) {
2048 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2049 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2050 if (! ok_error (errno))
2051 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2056 * Add the device route
2058 if (kernel_version < KVERSION(2,1,16)) {
2059 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2060 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2063 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2064 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2065 rt.rt_flags = RTF_UP | RTF_HOST;
2067 if (kernel_version > KVERSION(2,1,0)) {
2068 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2069 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2072 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2073 if (! ok_error (errno))
2074 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2081 /********************************************************************
2083 * cifaddr - Clear the interface IP addresses, and delete routes
2084 * through the interface if possible.
2087 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2091 if (kernel_version < KVERSION(2,1,16)) {
2093 * Delete the route through the device
2095 memset (&rt, '\0', sizeof (rt));
2097 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2098 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2101 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2102 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2103 rt.rt_flags = RTF_UP | RTF_HOST;
2105 if (kernel_version > KVERSION(2,1,0)) {
2106 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2107 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2110 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2111 if (still_ppp() && ! ok_error (errno))
2112 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2120 * get_pty - get a pty master/slave pair and chown the slave side
2121 * to the uid given. Assumes slave_name points to >= 12 bytes of space.
2124 get_pty(master_fdp, slave_fdp, slave_name, uid)
2132 struct termios tios;
2135 for (i = 0; i < 64; ++i) {
2136 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2137 'p' + i / 16, i % 16);
2138 mfd = open(pty_name, O_RDWR, 0);
2141 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2150 strlcpy(slave_name, pty_name, 12);
2153 fchown(sfd, uid, -1);
2154 fchmod(sfd, S_IRUSR | S_IWUSR);
2155 if (tcgetattr(sfd, &tios) == 0) {
2156 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2157 tios.c_cflag |= CS8 | CREAD;
2158 tios.c_iflag = IGNPAR | CLOCAL;
2161 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2162 warn("couldn't set attributes on pty: %m");
2164 warn("couldn't get attributes on pty: %m");
2169 /********************************************************************
2171 * open_loopback - open the device we use for getting packets
2172 * in demand mode. Under Linux, we use a pty master/slave pair.
2175 open_ppp_loopback(void)
2179 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2180 fatal("No free pty for loopback");
2181 SYSDEBUG(("using %s for loopback", loop_name));
2183 set_ppp_fd(slave_fd);
2185 flags = fcntl(master_fd, F_GETFL);
2187 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2188 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2190 flags = fcntl(ppp_fd, F_GETFL);
2192 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2193 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2195 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2196 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2198 * Find out which interface we were given.
2200 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2201 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2203 * Enable debug in the driver if requested.
2205 set_kdebugflag (kdebugflag);
2210 /********************************************************************
2212 * restore_loop - reattach the ppp unit to the loopback.
2214 * The kernel ppp driver automatically reattaches the ppp unit to
2215 * the loopback if the serial port is set to a line discipline other
2216 * than ppp, or if it detects a modem hangup. The former will happen
2217 * in disestablish_ppp if the latter hasn't already happened, so we
2218 * shouldn't need to do anything.
2220 * Just to be sure, set the real serial port to the normal discipline.
2226 if (ppp_fd != slave_fd) {
2227 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2228 set_ppp_fd(slave_fd);
2232 /********************************************************************
2234 * sifnpmode - Set the mode for handling packets for a given NP.
2238 sifnpmode(u, proto, mode)
2245 npi.protocol = proto;
2247 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2248 if (! ok_error (errno)) {
2249 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2250 proto, mode, errno);
2251 error("ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2259 /********************************************************************
2261 * sipxfaddr - Config the interface IPX networknumber
2264 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2271 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2273 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2275 if (! ok_error (errno))
2276 dbglog("socket(AF_IPX): %m (%d)", errno);
2280 memset (&ifr, '\0', sizeof (ifr));
2281 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2283 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2284 sipx->sipx_family = AF_IPX;
2285 sipx->sipx_port = 0;
2286 sipx->sipx_network = htonl (network);
2287 sipx->sipx_type = IPX_FRAME_ETHERII;
2288 sipx->sipx_action = IPX_CRTITF;
2290 * Set the IPX device
2292 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2294 if (errno != EEXIST) {
2295 if (! ok_error (errno))
2296 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2299 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2308 /********************************************************************
2310 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2311 * are removed and the device is no longer able to pass IPX
2315 int cipxfaddr (int unit)
2322 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2324 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2326 if (! ok_error (errno))
2327 dbglog("socket(AF_IPX): %m (%d)", errno);
2331 memset (&ifr, '\0', sizeof (ifr));
2332 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2334 sipx->sipx_type = IPX_FRAME_ETHERII;
2335 sipx->sipx_action = IPX_DLTITF;
2336 sipx->sipx_family = AF_IPX;
2338 * Set the IPX device
2340 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2341 if (! ok_error (errno))
2342 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2352 * daemon - Detach us from controlling terminal session.
2355 daemon(nochdir, noclose)
2356 int nochdir, noclose;
2360 if ((pid = fork()) < 0)
2363 exit(0); /* parent dies */
2368 fclose(stdin); /* don't need stdin, stdout, stderr */
2376 * Use the hostname as part of the random number seed.
2385 for (p = hostname; *p != 0; ++p)
2390 /********************************************************************
2392 * sys_check_options - check the options that the user specified
2396 sys_check_options(void)
2399 struct stat stat_buf;
2401 * Disable the IPX protocol if the support is not present in the kernel.
2402 * If we disable it then ensure that IP support is enabled.
2404 while (ipxcp_protent.enabled_flag) {
2405 if (path_to_procfs()) {
2406 strlcat (route_buffer, "/net/ipx_interface", sizeof(route_buffer));
2407 if (lstat (route_buffer, &stat_buf) >= 0)
2410 error("IPX support is not present in the kernel\n");
2411 ipxcp_protent.enabled_flag = 0;
2412 ipcp_protent.enabled_flag = 1;
2416 if (demand && driver_is_old) {
2417 option_error("demand dialling is not supported by kernel driver "
2418 "version %d.%d.%d", driver_version, driver_modification,