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 #define ok_error(num) ((num)==EIO)
97 static int tty_disc = N_TTY; /* The TTY discipline */
98 static int ppp_disc = N_PPP; /* The PPP discpline */
99 static int initfdflags = -1; /* Initial file descriptor flags for fd */
100 static int ppp_fd = -1; /* fd which is set to PPP discipline */
101 static int sock_fd = -1; /* socket for doing interface ioctls */
102 static int slave_fd = -1;
103 static int master_fd = -1;
105 static int has_proxy_arp = 0;
106 static int driver_version = 0;
107 static int driver_modification = 0;
108 static int driver_patch = 0;
109 static int driver_is_old = 0;
110 static int restore_term = 0; /* 1 => we've munged the terminal */
111 static struct termios inittermios; /* Initial TTY termios */
113 static char loop_name[20];
114 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
116 static int if_is_up; /* Interface has been marked up */
117 static u_int32_t default_route_gateway; /* Gateway for default route added */
118 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
120 static char *lock_file;
122 static struct utsname utsname; /* for the kernel version */
123 static int kernel_version;
124 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
128 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
129 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
130 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
132 /* Prototypes for procedures local to this file. */
133 static int get_flags (void);
134 static void set_flags (int flags);
135 static int translate_speed (int bps);
136 static int baud_rate_of (int speed);
137 static char *path_to_route (void);
138 static void close_route_table (void);
139 static int open_route_table (void);
140 static int read_route_table (struct rtentry *rt);
141 static int defaultroute_exists (struct rtentry *rt);
142 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
144 static void decode_version (char *buf, int *version, int *mod, int *patch);
146 extern u_char inpacket_buf[]; /* borrowed from main.c */
149 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
153 #define SET_SA_FAMILY(addr, family) \
154 memset ((char *) &(addr), '\0', sizeof(addr)); \
155 addr.sa_family = (family);
158 * Determine if the PPP connection should still be present.
164 #define LOCK_PREFIX "/var/lock/LCK.."
167 static void set_ppp_fd (int new_fd)
169 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
173 static int still_ppp(void)
175 if (!hungup || ppp_fd == slave_fd)
178 set_ppp_fd(slave_fd);
184 /********************************************************************
186 * Functions to read and set the flags value in the device driver
189 static int get_flags (void)
193 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0)
195 if ( ok_error (errno) )
201 syslog(LOG_ERR, "ioctl(PPPIOCGFLAGS): %m");
206 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
210 /********************************************************************/
212 static void set_flags (int flags)
214 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
216 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0)
218 if (! ok_error (errno) )
220 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
226 /********************************************************************
228 * sys_init - System-dependent initialization.
233 int osmaj, osmin, ospatch;
235 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
236 setlogmask(LOG_UPTO(LOG_INFO));
239 setlogmask(LOG_UPTO(LOG_DEBUG));
242 /* Get an internet socket for doing socket ioctls. */
243 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
246 if ( ! ok_error ( errno ))
248 syslog(LOG_ERR, "Couldn't create IP socket: %m(%d)", errno);
254 osmaj = osmin = ospatch = 0;
255 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
256 kernel_version = KVERSION(osmaj, osmin, ospatch);
259 /********************************************************************
261 * sys_cleanup - restore any system state we modified before exiting:
262 * mark the interface down, delete default route and/or proxy arp entry.
263 * This should call die() because it's called from die().
266 void sys_cleanup(void)
269 * Take down the device
276 * Delete any routes through the device.
278 if (default_route_gateway != 0)
280 cifdefaultroute(0, 0, default_route_gateway);
285 cifproxyarp(0, proxy_arp_addr);
289 /********************************************************************
291 * sys_close - Clean up in a child process before execing.
301 /********************************************************************
303 * note_debug_level - note a change in the debug level.
306 void note_debug_level (void)
310 SYSDEBUG ((LOG_INFO, "Debug turned ON, Level %d", debug));
311 setlogmask(LOG_UPTO(LOG_DEBUG));
315 setlogmask(LOG_UPTO(LOG_WARNING));
319 /********************************************************************
321 * set_kdebugflag - Define the debugging level for the kernel
324 int set_kdebugflag (int requested_level)
326 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0)
328 if ( ! ok_error (errno) )
330 syslog (LOG_ERR, "ioctl(PPPIOCSDEBUG): %m");
334 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
339 /********************************************************************
341 * establish_ppp - Turn the serial port into a ppp interface.
344 void establish_ppp (int tty_fd)
348 * The current PPP device will be the tty file.
352 * Ensure that the tty device is in exclusive mode.
354 if (ioctl(tty_fd, TIOCEXCL, 0) < 0)
356 if ( ! ok_error ( errno ))
358 syslog (LOG_WARNING, "ioctl(TIOCEXCL): %m");
362 * Demand mode - prime the old ppp device to relinquish the unit.
364 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
366 syslog(LOG_ERR, "ioctl(transfer ppp unit): %m(%d)", errno);
370 * Set the current tty to the PPP discpline
372 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
374 if ( ! ok_error (errno) )
376 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
381 * Find out which interface we were given.
383 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0)
385 if ( ! ok_error (errno))
387 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
392 * Check that we got the same unit again.
398 syslog(LOG_ERR, "transfer_ppp failed: wanted unit %d, got %d",
406 * Enable debug in the driver if requested.
409 set_kdebugflag (kdebugflag);
411 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
412 SC_RCV_EVNP | SC_RCV_ODDP));
414 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
415 driver_version, driver_modification, driver_patch));
417 * Fetch the initial file flags and reset blocking mode on the file.
419 initfdflags = fcntl(ppp_fd, F_GETFL);
421 if (initfdflags == -1 ||
422 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1)
424 if ( ! ok_error (errno))
427 "Couldn't set device to non-blocking mode: %m");
432 /********************************************************************
434 * disestablish_ppp - Restore the serial port to normal operation.
435 * This shouldn't call die() because it's called from die().
438 void disestablish_ppp(int tty_fd)
441 * Attempt to restore the previous tty settings
446 * Restore the previous line discipline
448 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0)
450 if ( ! ok_error (errno))
452 syslog(LOG_ERR, "ioctl(TIOCSETD, N_TTY): %m");
456 if (ioctl(tty_fd, TIOCNXCL, 0) < 0)
458 if ( ! ok_error (errno))
460 syslog (LOG_WARNING, "ioctl(TIOCNXCL): %m(%d)", errno);
464 /* Reset non-blocking mode on fd. */
465 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0)
467 if ( ! ok_error (errno))
470 "Couldn't restore device fd flags: %m");
477 /********************************************************************
479 * clean_check - Fetch the flags for the device and generate
480 * appropriate error messages.
482 void clean_check(void)
489 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0)
492 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP))
495 case SC_RCV_B7_0 | SC_RCV_EVNP:
496 case SC_RCV_B7_0 | SC_RCV_ODDP:
497 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
498 s = "all had bit 7 set to 1";
502 case SC_RCV_B7_1 | SC_RCV_EVNP:
503 case SC_RCV_B7_1 | SC_RCV_ODDP:
504 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
505 s = "all had bit 7 set to 0";
509 s = "all had odd parity";
513 s = "all had even parity";
519 syslog(LOG_WARNING, "Receive serial link is not"
521 syslog(LOG_WARNING, "Problem: %s", s);
529 * List of valid speeds.
533 int speed_int, speed_val;
610 /********************************************************************
612 * Translate from bits/second to a speed_t.
615 static int translate_speed (int bps)
617 struct speed *speedp;
621 for (speedp = speeds; speedp->speed_int; speedp++)
623 if (bps == speedp->speed_int)
625 return speedp->speed_val;
628 syslog(LOG_WARNING, "speed %d not supported", bps);
633 /********************************************************************
635 * Translate from a speed_t to bits/second.
638 static int baud_rate_of (int speed)
640 struct speed *speedp;
644 for (speedp = speeds; speedp->speed_int; speedp++)
646 if (speed == speedp->speed_val)
648 return speedp->speed_int;
655 /********************************************************************
657 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
658 * at the requested speed, etc. If `local' is true, set CLOCAL
659 * regardless of whether the modem option was specified.
662 void set_up_tty(int tty_fd, int local)
668 if (tcgetattr(tty_fd, &tios) < 0)
670 syslog(LOG_ERR, "tcgetattr: %m(%d)", errno);
679 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
680 tios.c_cflag |= CS8 | CREAD | HUPCL;
682 tios.c_iflag = IGNBRK | IGNPAR;
686 tios.c_cc[VTIME] = 0;
690 tios.c_cflag ^= (CLOCAL | HUPCL);
696 tios.c_cflag |= CRTSCTS;
700 tios.c_iflag |= IXON | IXOFF;
701 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
702 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
706 tios.c_cflag &= ~CRTSCTS;
713 speed = translate_speed(inspeed);
716 cfsetospeed (&tios, speed);
717 cfsetispeed (&tios, speed);
720 * We can't proceed if the serial port speed is B0,
721 * since that implies that the serial port is disabled.
725 speed = cfgetospeed(&tios);
728 syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
734 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
736 syslog(LOG_ERR, "tcsetattr: %m");
740 baud_rate = baud_rate_of(speed);
745 * hangup_modem - hang up the modem by clearing DTR.
747 void hangup_modem(int ttyfd)
752 /********************************************************************
754 * setdtr - control the DTR line on the serial port.
755 * This is called from die(), so it shouldn't call die().
758 void setdtr (int tty_fd, int on)
760 int modembits = TIOCM_DTR;
762 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
765 /********************************************************************
767 * restore_tty - restore the terminal to the saved settings.
770 void restore_tty (int tty_fd)
776 * Turn off echoing, because otherwise we can get into
777 * a loop with the tty and the modem echoing to each other.
778 * We presume we are the sole user of this tty device, so
779 * when we close it, it will revert to its defaults anyway.
783 inittermios.c_lflag &= ~(ECHO | ECHONL);
786 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0)
788 if (! ok_error (errno))
790 syslog(LOG_WARNING, "tcsetattr: %m");
796 /********************************************************************
798 * output - Output PPP packet.
801 void output (int unit, unsigned char *p, int len)
805 log_packet(p, len, "sent ", LOG_DEBUG);
808 if (write(ppp_fd, p, len) < 0)
810 if (errno == EWOULDBLOCK || errno == ENOBUFS
811 || errno == ENXIO || errno == EIO || errno == EINTR)
813 syslog(LOG_WARNING, "write: warning: %m (%d)", errno);
817 syslog(LOG_ERR, "write: %m (%d)", errno);
822 /********************************************************************
824 * wait_input - wait until there is data available on ppp_fd,
825 * for the length of time specified by *timo (indefinite
829 void wait_input (struct timeval *timo)
835 FD_SET(ppp_fd, &ready);
837 n = select(ppp_fd + 1, &ready, NULL, &ready, timo);
838 if (n < 0 && errno != EINTR)
840 syslog(LOG_ERR, "select: %m(%d)", errno);
845 /********************************************************************
847 * wait_loop_output - wait until there is data available on the
848 * loopback, for the length of time specified by *timo (indefinite
851 void wait_loop_output(timo)
852 struct timeval *timo;
858 FD_SET(master_fd, &ready);
859 n = select(master_fd + 1, &ready, NULL, &ready, timo);
860 if (n < 0 && errno != EINTR)
862 syslog(LOG_ERR, "select: %m(%d)", errno);
867 /********************************************************************
869 * wait_time - wait for a given length of time or until a
870 * signal is received.
874 struct timeval *timo;
878 n = select(0, NULL, NULL, NULL, timo);
879 if (n < 0 && errno != EINTR) {
880 syslog(LOG_ERR, "select: %m(%d)", errno);
885 /********************************************************************
887 * read_packet - get a PPP packet from the serial device.
890 int read_packet (unsigned char *buf)
894 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
897 if (errno == EWOULDBLOCK)
901 syslog(LOG_ERR, "read: %m(%d)", errno);
907 /********************************************************************
909 * get_loop_output - get outgoing packets from the ppp device,
910 * and detect when we want to bring the real link up.
911 * Return value is 1 if we need to bring up the link, 0 otherwise.
914 get_loop_output(void)
917 int n = read(master_fd, inbuf, sizeof(inbuf));
921 if (loop_chars(inbuf, n))
925 n = read(master_fd, inbuf, sizeof(inbuf));
930 syslog(LOG_ERR, "eof on loopback");
934 if (errno != EWOULDBLOCK)
936 syslog(LOG_ERR, "read from loopback: %m(%d)", errno);
943 /********************************************************************
945 * ppp_send_config - configure the transmit characteristics of
949 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
954 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
956 * Ensure that the link is still up.
961 * Set the MTU and other parameters for the ppp device
963 memset (&ifr, '\0', sizeof (ifr));
964 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
967 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
969 syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m(%d)", errno);
973 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
974 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0)
976 syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
981 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
982 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
987 /********************************************************************
989 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
992 void ppp_set_xaccm (int unit, ext_accm accm)
994 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
995 accm[0], accm[1], accm[2], accm[3]));
997 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
999 if ( ! ok_error (errno))
1001 syslog(LOG_WARNING, "ioctl(set extended ACCM): %m(%d)", errno);
1006 /********************************************************************
1008 * ppp_recv_config - configure the receive-side characteristics of
1009 * the ppp interface.
1012 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1016 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1018 * If we were called because the link has gone down then there is nothing
1019 * which may be done. Just return without incident.
1026 * Set the receiver parameters
1028 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1030 if ( ! ok_error (errno))
1032 syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m(%d)", errno);
1036 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1037 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0)
1039 syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1044 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
1048 /********************************************************************
1050 * ccp_test - ask kernel whether a given compression method
1051 * is acceptable for use.
1054 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1056 struct ppp_option_data data;
1058 memset (&data, '\0', sizeof (data));
1060 data.length = opt_len;
1061 data.transmit = for_transmit;
1063 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1068 return (errno == ENOBUFS)? 0: -1;
1071 /********************************************************************
1073 * ccp_flags_set - inform kernel about the current state of CCP.
1076 void ccp_flags_set (int unit, int isopen, int isup)
1080 int x = get_flags();
1081 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1082 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1087 /********************************************************************
1089 * get_idle_time - return how long the link has been idle.
1092 get_idle_time(u, ip)
1094 struct ppp_idle *ip;
1096 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
1099 /********************************************************************
1101 * ccp_fatal_error - returns 1 if decompression was disabled as a
1102 * result of an error detected after decompression of a packet,
1103 * 0 otherwise. This is necessary because of patent nonsense.
1106 int ccp_fatal_error (int unit)
1108 int x = get_flags();
1110 return x & SC_DC_FERROR;
1114 * path_to_route - determine the path to the proc file system data
1116 #define ROUTE_MAX_COLS 12
1117 FILE *route_fd = (FILE *) 0;
1118 static char route_buffer [512];
1119 static int route_dev_col, route_dest_col, route_gw_col;
1120 static int route_flags_col, route_mask_col;
1121 static int route_num_cols;
1123 static char *path_to_route (void);
1124 static int open_route_table (void);
1125 static void close_route_table (void);
1126 static int read_route_table (struct rtentry *rt);
1128 /********************************************************************
1130 * path_to_procfs - find the path to the proc file system mount point
1133 static int path_to_procfs (void)
1135 struct mntent *mntent;
1138 fp = fopen(MOUNTED, "r");
1140 /* Default the mount location of /proc */
1141 strncpy (route_buffer, "/proc", sizeof (route_buffer)-10);
1145 while ((mntent = getmntent(fp)) != NULL) {
1146 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1148 if (strcmp(mntent->mnt_type, "proc") == 0)
1155 strncpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer)-10);
1156 route_buffer [sizeof (route_buffer)-10] = '\0';
1160 /********************************************************************
1162 * path_to_route - find the path to the route tables in the proc file system
1165 static char *path_to_route (void)
1167 if (!path_to_procfs()) {
1168 syslog (LOG_ERR, "proc file system not mounted");
1171 strcat (route_buffer, "/net/route");
1172 return (route_buffer);
1175 /********************************************************************
1177 * close_route_table - close the interface to the route table
1180 static void close_route_table (void)
1182 if (route_fd != (FILE *) 0) {
1184 route_fd = (FILE *) 0;
1188 /********************************************************************
1190 * open_route_table - open the interface to the route table
1192 static char route_delims[] = " \t\n";
1194 static int open_route_table (void)
1198 close_route_table();
1200 path = path_to_route();
1204 route_fd = fopen (path, "r");
1205 if (route_fd == NULL) {
1206 syslog (LOG_ERR, "can't open %s: %m (%d)", path, errno);
1210 route_dev_col = 0; /* default to usual columns */
1213 route_flags_col = 3;
1217 /* parse header line */
1218 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1219 char *p = route_buffer, *q;
1221 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1223 if ((q = strtok(p, route_delims)) == 0)
1225 if (strcasecmp(q, "iface") == 0)
1226 route_dev_col = col;
1227 else if (strcasecmp(q, "destination") == 0)
1228 route_dest_col = col;
1229 else if (strcasecmp(q, "gateway") == 0)
1231 else if (strcasecmp(q, "flags") == 0)
1232 route_flags_col = col;
1233 else if (strcasecmp(q, "mask") == 0)
1234 route_mask_col = col;
1237 if (used && col >= route_num_cols)
1238 route_num_cols = col + 1;
1246 /********************************************************************
1248 * read_route_table - read the next entry from the route table
1251 static int read_route_table(struct rtentry *rt)
1253 char *cols[ROUTE_MAX_COLS], *p;
1256 memset (rt, '\0', sizeof (struct rtentry));
1258 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1262 for (col = 0; col < route_num_cols; ++col) {
1263 cols[col] = strtok(p, route_delims);
1264 if (cols[col] == NULL)
1265 return 0; /* didn't get enough columns */
1268 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1269 strtoul(cols[route_dest_col], NULL, 16);
1271 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1272 strtoul(cols[route_gw_col], NULL, 16);
1274 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1275 strtoul(cols[route_mask_col], NULL, 16);
1277 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1278 rt->rt_dev = cols[route_dev_col];
1283 /********************************************************************
1285 * defaultroute_exists - determine if there is a default route
1288 static int defaultroute_exists (struct rtentry *rt)
1292 if (!open_route_table())
1295 while (read_route_table(rt) != 0) {
1296 if ((rt->rt_flags & RTF_UP) == 0)
1299 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1305 close_route_table();
1310 * have_route_to - determine if the system has any route to
1311 * a given IP address. `addr' is in network byte order.
1312 * Return value is 1 if yes, 0 if no, -1 if don't know.
1313 * For demand mode to work properly, we have to ignore routes
1314 * through our own interface.
1316 int have_route_to(u_int32_t addr)
1321 if (!open_route_table())
1322 return -1; /* don't know */
1324 while (read_route_table(&rt)) {
1325 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1327 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1328 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1334 close_route_table();
1338 /********************************************************************
1340 * sifdefaultroute - assign a default route through the address given.
1343 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1347 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0)
1349 struct in_addr old_gateway =
1350 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1352 if (old_gateway.s_addr != gateway)
1355 "not replacing existing default route to %s [%s]",
1356 rt.rt_dev, inet_ntoa (old_gateway));
1361 memset (&rt, '\0', sizeof (rt));
1362 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1363 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1365 if (kernel_version > KVERSION(2,1,0)) {
1366 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1367 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1370 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1372 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1373 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
1375 if ( ! ok_error ( errno ))
1377 syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m(%d)", errno);
1382 default_route_gateway = gateway;
1386 /********************************************************************
1388 * cifdefaultroute - delete a default route through the address given.
1391 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1395 default_route_gateway = 0;
1397 memset (&rt, '\0', sizeof (rt));
1398 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1399 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1401 if (kernel_version > KVERSION(2,1,0)) {
1402 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1403 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1406 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1408 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1409 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1413 if ( ! ok_error ( errno ))
1416 "default route ioctl(SIOCDELRT): %m(%d)", errno);
1425 /********************************************************************
1427 * sifproxyarp - Make a proxy ARP entry for the peer.
1430 int sifproxyarp (int unit, u_int32_t his_adr)
1432 struct arpreq arpreq;
1434 if (has_proxy_arp == 0)
1436 memset (&arpreq, '\0', sizeof(arpreq));
1438 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1439 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1440 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1442 * Get the hardware address of an interface on the same subnet
1443 * as our local address.
1445 if (!get_ether_addr(his_adr, &arpreq.arp_ha, arpreq.arp_dev))
1447 syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1451 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0)
1453 if ( ! ok_error ( errno ))
1455 syslog(LOG_ERR, "ioctl(SIOCSARP): %m(%d)", errno);
1461 proxy_arp_addr = his_adr;
1466 /********************************************************************
1468 * cifproxyarp - Delete the proxy ARP entry for the peer.
1471 int cifproxyarp (int unit, u_int32_t his_adr)
1473 struct arpreq arpreq;
1475 if (has_proxy_arp == 1)
1477 memset (&arpreq, '\0', sizeof(arpreq));
1478 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1479 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1480 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1482 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0)
1484 if ( ! ok_error ( errno ))
1486 syslog(LOG_WARNING, "ioctl(SIOCDARP): %m(%d)", errno);
1495 /********************************************************************
1497 * get_ether_addr - get the hardware address of an interface on the
1498 * the same subnet as ipaddr.
1501 static int get_ether_addr (u_int32_t ipaddr,
1502 struct sockaddr *hwaddr,
1505 struct ifreq *ifr, *ifend;
1506 u_int32_t ina, mask;
1509 struct ifreq ifs[MAX_IFS];
1511 ifc.ifc_len = sizeof(ifs);
1513 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1515 if ( ! ok_error ( errno ))
1517 syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1522 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1523 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1525 * Scan through looking for an interface with an Internet
1526 * address on the same subnet as `ipaddr'.
1528 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1529 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1531 if (ifr->ifr_addr.sa_family == AF_INET)
1533 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1534 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1535 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1538 * Check that the interface is up, and not point-to-point
1541 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1546 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1551 * Get its netmask and check that it's on the right subnet.
1553 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1558 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1559 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1560 ip_ntoa(ina), ntohl(mask)));
1562 if (((ipaddr ^ ina) & mask) != 0)
1575 memcpy (name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
1576 syslog(LOG_INFO, "found interface %s for proxy arp", name);
1578 * Now get the hardware address.
1580 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1581 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0)
1583 syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1589 sizeof (struct sockaddr));
1591 SYSDEBUG ((LOG_DEBUG,
1592 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1593 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1594 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1595 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1596 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1597 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1598 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1599 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1600 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1604 /********************************************************************
1606 * Return user specified netmask, modified by any mask we might determine
1607 * for address `addr' (in network byte order).
1608 * Here we scan through the system's list of interfaces, looking for
1609 * any non-point-to-point interfaces which might appear to be on the same
1610 * network as `addr'. If we find any, we OR in their netmask to the
1611 * user-specified netmask.
1614 u_int32_t GetMask (u_int32_t addr)
1616 u_int32_t mask, nmask, ina;
1617 struct ifreq *ifr, *ifend, ifreq;
1619 struct ifreq ifs[MAX_IFS];
1623 if (IN_CLASSA(addr)) /* determine network mask for address class */
1625 nmask = IN_CLASSA_NET;
1629 if (IN_CLASSB(addr))
1631 nmask = IN_CLASSB_NET;
1635 nmask = IN_CLASSC_NET;
1639 /* class D nets are disallowed by bad_ip_adrs */
1640 mask = netmask | htonl(nmask);
1642 * Scan through the system's network interfaces.
1644 ifc.ifc_len = sizeof(ifs);
1646 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1648 if ( ! ok_error ( errno ))
1650 syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1655 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1656 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1659 * Check the interface's internet address.
1661 if (ifr->ifr_addr.sa_family != AF_INET)
1665 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1666 if (((ntohl(ina) ^ addr) & nmask) != 0)
1671 * Check that the interface is up, and not point-to-point nor loopback.
1673 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1674 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1679 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1684 * Get its netmask and OR it into our mask.
1686 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1690 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1696 /********************************************************************
1698 * Internal routine to decode the version.modification.patch level
1701 static void decode_version (char *buf, int *version,
1702 int *modification, int *patch)
1704 *version = (int) strtoul (buf, &buf, 10);
1711 *modification = (int) strtoul (buf, &buf, 10);
1715 *patch = (int) strtoul (buf, &buf, 10);
1727 /********************************************************************
1729 * Procedure to determine if the PPP line discipline is registered.
1733 ppp_registered(void)
1739 local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1742 syslog(LOG_ERR, "Failed to open %s: %m(%d)", devnam, errno);
1746 initfdflags = fcntl(local_fd, F_GETFL);
1747 if (initfdflags == -1)
1749 syslog(LOG_ERR, "Couldn't get device fd flags: %m(%d)", errno);
1754 initfdflags &= ~O_NONBLOCK;
1755 fcntl(local_fd, F_SETFL, initfdflags);
1757 * Read the initial line dicipline and try to put the device into the
1760 if (ioctl(local_fd, TIOCGETD, &init_disc) < 0)
1762 syslog(LOG_ERR, "ioctl(TIOCGETD): %m(%d)", errno);
1767 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0)
1769 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1774 if (ioctl(local_fd, TIOCSETD, &init_disc) < 0)
1776 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1785 /********************************************************************
1787 * ppp_available - check whether the system has any ppp interfaces
1788 * (in fact we check whether we can do an ioctl on ppp0).
1791 int ppp_available(void)
1796 int my_version, my_modification, my_patch;
1797 extern char *no_ppp_msg;
1799 * Open a socket for doing the ioctl operations.
1801 s = socket(AF_INET, SOCK_DGRAM, 0);
1807 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1808 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1810 * If the device did not exist then attempt to create one by putting the
1811 * current tty into the PPP discipline. If this works then obtain the
1812 * flags for the device again.
1816 if (ppp_registered())
1818 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1819 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1823 * Ensure that the hardware address is for PPP and not something else
1827 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1830 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1838 "This system lacks kernel support for PPP. This could be because\n"
1839 "the PPP kernel module is not loaded, or because the kernel is\n"
1840 "not configured for PPP. See the README.linux file in the\n"
1841 "ppp-2.3.6 distribution.\n";
1844 * This is the PPP device. Validate the version of the driver at this
1845 * point to ensure that this program will work with the driver.
1849 char abBuffer [1024];
1851 ifr.ifr_data = abBuffer;
1852 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1854 syslog(LOG_ERR, "Couldn't read driver version: %m");
1856 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1859 decode_version(abBuffer,
1861 &driver_modification,
1864 * Validate the version of the driver against the version that we used.
1866 decode_version(VERSION,
1871 /* The version numbers must match */
1872 if (driver_version != my_version)
1877 /* The modification levels must be legal */
1878 if (driver_modification < 3)
1880 if (driver_modification >= 2) {
1881 /* we can cope with 2.2.0 and above */
1891 sprintf (route_buffer,
1892 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1893 driver_version, driver_modification, driver_patch);
1895 no_ppp_msg = route_buffer;
1902 /********************************************************************
1904 * Update the wtmp file with the appropriate user name and tty device.
1907 void logwtmp (const char *line, const char *name, const char *host)
1910 struct utmp ut, *utp;
1911 pid_t mypid = getpid();
1913 * Update the signon database for users.
1914 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1916 utmpname(_PATH_UTMP);
1918 while ((utp = getutent()) && (utp->ut_pid != mypid))
1921 /* Is this call really necessary? There is another one after the 'put' */
1926 memcpy(&ut, utp, sizeof(ut));
1930 /* some gettys/telnetds don't initialize utmp... */
1931 memset(&ut, 0, sizeof(ut));
1934 if (ut.ut_id[0] == 0)
1936 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1939 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1940 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1944 ut.ut_type = USER_PROCESS;
1947 /* Insert the host name if one is supplied */
1950 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1953 /* Insert the IP address of the remote system if IP is enabled */
1954 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1956 memcpy (&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1957 sizeof(ut.ut_addr));
1960 /* CL: Makes sure that the logout works */
1961 if (*host == 0 && *name==0)
1969 * Update the wtmp file.
1971 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1974 flock(wtmp, LOCK_EX);
1976 /* we really should check for error on the write for a full disk! */
1977 write (wtmp, (char *)&ut, sizeof(ut));
1980 flock(wtmp, LOCK_UN);
1984 /********************************************************************
1985 * Code for locking/unlocking the serial device.
1986 * This code is derived from chat.c.
1990 * lock - create a lock file for the named device
1993 int lock (char *dev)
1997 lock_file = malloc(strlen(dev) + 1);
1998 if (lock_file == NULL)
2000 novm("lock file name");
2002 strcpy (lock_file, dev);
2003 result = mklock (dev, (void *) 0);
2007 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, result);
2016 syslog (LOG_ERR, "Can't create lock file %s", lock_file);
2024 char hdb_lock_buffer[12];
2029 p = strrchr(dev, '/');
2035 lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
2036 if (lock_file == NULL)
2038 novm("lock file name");
2041 strcpy (lock_file, LOCK_PREFIX);
2042 strcat (lock_file, dev);
2044 * Attempt to create the lock file at this point.
2048 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
2053 sprintf (hdb_lock_buffer, "%010d\n", pid);
2054 write (fd, hdb_lock_buffer, 11);
2056 write(fd, &pid, sizeof (pid));
2062 * If the file exists then check to see if the pid is stale
2064 if (errno == EEXIST)
2066 fd = open(lock_file, O_RDONLY, 0);
2069 if (errno == ENOENT) /* This is just a timing problem. */
2076 /* Read the lock file to find out who has the device locked */
2077 n = read (fd, hdb_lock_buffer, 11);
2081 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
2085 /* See the process still exists. */
2089 hdb_lock_buffer[n] = '\0';
2090 sscanf (hdb_lock_buffer, " %d", &pid);
2092 pid = ((int *) hdb_lock_buffer)[0];
2094 if (pid == 0 || pid == getpid()
2095 || (kill(pid, 0) == -1 && errno == ESRCH))
2101 /* If the process does not exist then try to remove the lock */
2102 if (n == 0 && unlink (lock_file) == 0)
2104 syslog (LOG_NOTICE, "Removed stale lock on %s (pid %d)",
2109 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, pid);
2113 syslog(LOG_ERR, "Can't create lock file %s: %m(%d)", lock_file, errno);
2124 /********************************************************************
2126 * unlock - remove our lockfile
2134 (void) rmlock (lock_file, (void *) 0);
2143 /********************************************************************
2145 * sifvjcomp - config tcp header compression
2148 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2150 u_int x = get_flags();
2154 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2156 if (! ok_error (errno))
2158 syslog (LOG_ERR, "ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2164 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2165 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2171 /********************************************************************
2173 * sifup - Config the interface up and enable IP packets to pass.
2180 memset (&ifr, '\0', sizeof (ifr));
2181 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2182 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2184 if (! ok_error (errno))
2186 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2191 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2192 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2194 if (! ok_error (errno))
2196 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2204 /********************************************************************
2206 * sifdown - Config the interface down and disable IP.
2215 memset (&ifr, '\0', sizeof (ifr));
2216 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2217 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2219 if (! ok_error (errno))
2221 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2226 ifr.ifr_flags &= ~IFF_UP;
2227 ifr.ifr_flags |= IFF_POINTOPOINT;
2228 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2230 if (! ok_error (errno))
2232 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2239 /********************************************************************
2241 * sifaddr - Config the interface IP addresses and netmask.
2244 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2250 memset (&ifr, '\0', sizeof (ifr));
2251 memset (&rt, '\0', sizeof (rt));
2253 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2254 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2255 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2257 strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2259 * Set our IP address
2261 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2262 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2264 if (errno != EEXIST)
2266 if (! ok_error (errno))
2268 syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m(%d)", errno);
2273 syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
2278 * Set the gateway address
2280 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2281 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0)
2283 if (! ok_error (errno))
2285 syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2291 * For recent kernels, force the netmask to 255.255.255.255.
2293 if (kernel_version >= KVERSION(2,1,16))
2297 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2298 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0)
2300 if (! ok_error (errno))
2302 syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2308 * Add the device route
2310 if (kernel_version < KVERSION(2,1,16)) {
2311 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2312 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2315 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2316 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2317 rt.rt_flags = RTF_UP | RTF_HOST;
2319 if (kernel_version > KVERSION(2,1,0)) {
2320 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2321 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2324 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
2326 if (! ok_error (errno))
2328 syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m(%d)", errno);
2336 /********************************************************************
2338 * cifaddr - Clear the interface IP addresses, and delete routes
2339 * through the interface if possible.
2342 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2346 if (kernel_version < KVERSION(2,1,16)) {
2348 * Delete the route through the device
2350 memset (&rt, '\0', sizeof (rt));
2352 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2353 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2356 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2357 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2358 rt.rt_flags = RTF_UP | RTF_HOST;
2360 if (kernel_version > KVERSION(2,1,0)) {
2361 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2362 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2365 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
2367 if (still_ppp() && ! ok_error (errno))
2369 syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m(%d)", errno);
2377 /********************************************************************
2379 * open_loopback - open the device we use for getting packets
2380 * in demand mode. Under Linux, we use our existing fd
2381 * to the ppp driver.
2384 open_ppp_loopback(void)
2387 struct termios tios;
2390 for (i = 0; i < 64; ++i) {
2391 sprintf(loop_name, "/dev/pty%c%x", 'p' + i / 16, i % 16);
2392 master_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2396 if (master_fd < 0) {
2397 syslog(LOG_ERR, "No free pty for loopback");
2400 SYSDEBUG((LOG_DEBUG, "using %s for loopback", loop_name));
2402 slave_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2404 syslog(LOG_ERR, "Couldn't open %s for loopback: %m", loop_name);
2408 set_ppp_fd(slave_fd);
2410 if (tcgetattr(ppp_fd, &tios) == 0)
2412 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2413 tios.c_cflag |= CS8 | CREAD;
2414 tios.c_iflag = IGNPAR | CLOCAL;
2417 if (tcsetattr(ppp_fd, TCSAFLUSH, &tios) < 0)
2419 syslog(LOG_WARNING, "couldn't set attributes on loopback: %m(%d)", errno);
2423 flags = fcntl(master_fd, F_GETFL);
2425 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2427 syslog(LOG_WARNING, "couldn't set master loopback to nonblock: %m(%d)", errno);
2430 flags = fcntl(ppp_fd, F_GETFL);
2432 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2434 syslog(LOG_WARNING, "couldn't set slave loopback to nonblock: %m(%d)", errno);
2437 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2439 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
2443 * Find out which interface we were given.
2445 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2447 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
2451 * Enable debug in the driver if requested.
2453 set_kdebugflag (kdebugflag);
2456 /********************************************************************
2458 * restore_loop - reattach the ppp unit to the loopback.
2460 * The kernel ppp driver automatically reattaches the ppp unit to
2461 * the loopback if the serial port is set to a line discipline other
2462 * than ppp, or if it detects a modem hangup. The former will happen
2463 * in disestablish_ppp if the latter hasn't already happened, so we
2464 * shouldn't need to do anything.
2466 * Just to be sure, set the real serial port to the normal discipline.
2472 if (ppp_fd != slave_fd)
2474 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2475 set_ppp_fd(slave_fd);
2479 /********************************************************************
2481 * sifnpmode - Set the mode for handling packets for a given NP.
2485 sifnpmode(u, proto, mode)
2492 npi.protocol = proto;
2494 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0)
2496 if (! ok_error (errno))
2498 syslog(LOG_ERR, "ioctl(PPPIOCSNPMODE, %d, %d): %m(%d)",
2499 proto, mode, errno);
2500 syslog(LOG_ERR, "ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2508 /********************************************************************
2510 * sipxfaddr - Config the interface IPX networknumber
2513 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2520 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2522 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2525 if (! ok_error (errno))
2527 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2533 memset (&ifr, '\0', sizeof (ifr));
2534 strcpy (ifr.ifr_name, ifname);
2536 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2537 sipx->sipx_family = AF_IPX;
2538 sipx->sipx_port = 0;
2539 sipx->sipx_network = htonl (network);
2540 sipx->sipx_type = IPX_FRAME_ETHERII;
2541 sipx->sipx_action = IPX_CRTITF;
2543 * Set the IPX device
2545 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2548 if (errno != EEXIST)
2550 if (! ok_error (errno))
2553 "ioctl(SIOCAIFADDR, CRTITF): %m(%d)", errno);
2558 syslog (LOG_WARNING,
2559 "ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2568 /********************************************************************
2570 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2571 * are removed and the device is no longer able to pass IPX
2575 int cipxfaddr (int unit)
2582 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2584 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2587 if (! ok_error (errno))
2589 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2595 memset (&ifr, '\0', sizeof (ifr));
2596 strcpy (ifr.ifr_name, ifname);
2598 sipx->sipx_type = IPX_FRAME_ETHERII;
2599 sipx->sipx_action = IPX_DLTITF;
2600 sipx->sipx_family = AF_IPX;
2602 * Set the IPX device
2604 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2606 if (! ok_error (errno))
2609 "ioctl(SIOCAIFADDR, IPX_DLTITF): %m(%d)", errno);
2620 * daemon - Detach us from controlling terminal session.
2623 daemon(nochdir, noclose)
2624 int nochdir, noclose;
2628 if ((pid = fork()) < 0)
2631 exit(0); /* parent dies */
2636 fclose(stdin); /* don't need stdin, stdout, stderr */
2644 * Use the hostname as part of the random number seed.
2653 for (p = hostname; *p != 0; ++p)
2658 /********************************************************************
2660 * sys_check_options - check the options that the user specified
2664 sys_check_options(void)
2667 struct stat stat_buf;
2669 * Disable the IPX protocol if the support is not present in the kernel.
2670 * If we disable it then ensure that IP support is enabled.
2672 while (ipxcp_protent.enabled_flag)
2674 if (path_to_procfs())
2676 strcat (route_buffer, "/net/ipx_interface");
2677 if (lstat (route_buffer, &stat_buf) >= 0)
2682 syslog (LOG_ERR, "IPX support is not present in the kernel\n");
2683 ipxcp_protent.enabled_flag = 0;
2684 ipcp_protent.enabled_flag = 1;
2688 if (demand && driver_is_old) {
2689 option_error("demand dialling is not supported by kernel driver version "
2690 "%d.%d.%d", driver_version, driver_modification,