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>
41 /* This is in netdevice.h. However, this compile will fail miserably if
42 you attempt to include netdevice.h because it has so many references
43 to __memcpy functions which it should not attempt to do. So, since I
44 really don't use it, but it must be defined, define it now. */
47 #define MAX_ADDR_LEN 7
50 #include <linux/version.h>
52 #include <linux/ppp_defs.h>
53 #include <net/if_arp.h>
54 #include <linux/if_ppp.h>
55 #include <net/route.h>
56 #include <linux/if_ether.h>
57 #include <netinet/in.h>
63 #ifndef RTF_DEFAULT /* Normally in <linux/route.h> from <net/route.h> */
72 #include <sys/locks.h>
75 #define ok_error(num) ((num)==EIO)
77 static int tty_disc = N_TTY; /* The TTY discipline */
78 static int ppp_disc = N_PPP; /* The PPP discpline */
79 static int initfdflags = -1; /* Initial file descriptor flags for fd */
80 static int ppp_fd = -1; /* fd which is set to PPP discipline */
81 static int sock_fd = -1; /* socket for doing interface ioctls */
82 static int slave_fd = -1;
83 static int master_fd = -1;
85 static int has_proxy_arp = 0;
86 static int driver_version = 0;
87 static int driver_modification = 0;
88 static int driver_patch = 0;
89 static int driver_is_old = 0;
90 static int restore_term = 0; /* 1 => we've munged the terminal */
91 static struct termios inittermios; /* Initial TTY termios */
93 static char loop_name[20];
94 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
96 static int if_is_up; /* Interface has been marked up */
97 static u_int32_t default_route_gateway; /* Gateway for default route added */
98 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
100 static char *lock_file;
104 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
105 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
106 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
108 /* Prototypes for procedures local to this file. */
109 static int get_flags (void);
110 static void set_flags (int flags);
111 static int translate_speed (int bps);
112 static int baud_rate_of (int speed);
113 static char *path_to_route (void);
114 static void close_route_table (void);
115 static int open_route_table (void);
116 static int read_route_table (struct rtentry *rt);
117 static int defaultroute_exists (struct rtentry *rt);
118 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
120 static void decode_version (char *buf, int *version, int *mod, int *patch);
122 extern u_char inpacket_buf[]; /* borrowed from main.c */
125 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
129 #define SET_SA_FAMILY(addr, family) \
130 memset ((char *) &(addr), '\0', sizeof(addr)); \
131 addr.sa_family = (family);
134 * Determine if the PPP connection should still be present.
138 #define still_ppp() (hungup == 0)
141 #define LOCK_PREFIX "/var/lock/LCK.."
144 /********************************************************************
146 * Functions to read and set the flags value in the device driver
149 static void set_ppp_fd (int new_fd)
151 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", ppp_fd));
155 /********************************************************************
157 * Functions to read and set the flags value in the device driver
160 static int get_flags (void)
164 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0)
166 if ( ok_error (errno) )
172 syslog(LOG_ERR, "ioctl(PPPIOCGFLAGS): %m");
177 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
181 /********************************************************************/
183 static void set_flags (int flags)
185 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
187 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0)
189 if (! ok_error (errno) )
191 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
197 /********************************************************************
199 * sys_init - System-dependent initialization.
204 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
205 setlogmask(LOG_UPTO(LOG_INFO));
208 setlogmask(LOG_UPTO(LOG_DEBUG));
211 /* Get an internet socket for doing socket ioctls. */
212 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
215 if ( ! ok_error ( errno ))
217 syslog(LOG_ERR, "Couldn't create IP socket: %m(%d)", errno);
223 /********************************************************************
225 * sys_cleanup - restore any system state we modified before exiting:
226 * mark the interface down, delete default route and/or proxy arp entry.
227 * This should call die() because it's called from die().
230 void sys_cleanup(void)
234 * Take down the device
241 * Delete any routes through the device.
243 if (default_route_gateway != 0)
245 cifdefaultroute(0, 0, default_route_gateway);
250 cifproxyarp(0, proxy_arp_addr);
254 /********************************************************************
256 * sys_close - Clean up in a child process before execing.
266 /********************************************************************
268 * note_debug_level - note a change in the debug level.
271 void note_debug_level (void)
275 SYSDEBUG ((LOG_INFO, "Debug turned ON, Level %d", debug));
276 setlogmask(LOG_UPTO(LOG_DEBUG));
280 setlogmask(LOG_UPTO(LOG_WARNING));
284 /********************************************************************
286 * set_kdebugflag - Define the debugging level for the kernel
289 int set_kdebugflag (int requested_level)
291 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0)
293 if ( ! ok_error (errno) )
295 syslog (LOG_ERR, "ioctl(PPPIOCSDEBUG): %m");
299 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
304 /********************************************************************
306 * establish_ppp - Turn the serial port into a ppp interface.
309 void establish_ppp (int tty_fd)
313 * The current PPP device will be the tty file.
317 * Ensure that the tty device is in exclusive mode.
319 if (ioctl(tty_fd, TIOCEXCL, 0) < 0)
321 if ( ! ok_error ( errno ))
323 syslog (LOG_WARNING, "ioctl(TIOCEXCL): %m");
327 * Demand mode - prime the old ppp device to relinquish the unit.
329 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
331 syslog(LOG_ERR, "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)
339 if ( ! ok_error (errno) )
341 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
346 * Find out which interface we were given.
348 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0)
350 if ( ! ok_error (errno))
352 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
357 * Check that we got the same unit again.
363 syslog(LOG_ERR, "transfer_ppp failed: wanted unit %d, got %d",
371 * Enable debug in the driver if requested.
374 set_kdebugflag (kdebugflag);
376 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
377 SC_RCV_EVNP | SC_RCV_ODDP));
379 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
380 driver_version, driver_modification, driver_patch));
382 * Fetch the initial file flags and reset blocking mode on the file.
384 initfdflags = fcntl(ppp_fd, F_GETFL);
386 if (initfdflags == -1 ||
387 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1)
389 if ( ! ok_error (errno))
392 "Couldn't set device to non-blocking mode: %m");
397 /********************************************************************
399 * disestablish_ppp - Restore the serial port to normal operation.
400 * This shouldn't call die() because it's called from die().
403 void disestablish_ppp(int tty_fd)
409 * Attempt to restore the previous tty settings
414 * Restore the previous line discipline
416 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0)
418 if ( ! ok_error (errno))
420 syslog(LOG_ERR, "ioctl(TIOCSETD, N_TTY): %m");
424 if (ioctl(tty_fd, TIOCNXCL, 0) < 0)
426 if ( ! ok_error (errno))
428 syslog (LOG_WARNING, "ioctl(TIOCNXCL): %m(%d)", errno);
432 /* Reset non-blocking mode on fd. */
433 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0)
435 if ( ! ok_error (errno))
438 "Couldn't restore device fd flags: %m");
445 /********************************************************************
447 * clean_check - Fetch the flags for the device and generate
448 * appropriate error messages.
450 void clean_check(void)
457 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0)
460 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP))
463 case SC_RCV_B7_0 | SC_RCV_EVNP:
464 case SC_RCV_B7_0 | SC_RCV_ODDP:
465 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
466 s = "all had bit 7 set to 1";
470 case SC_RCV_B7_1 | SC_RCV_EVNP:
471 case SC_RCV_B7_1 | SC_RCV_ODDP:
472 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
473 s = "all had bit 7 set to 0";
477 s = "all had odd parity";
481 s = "all had even parity";
487 syslog(LOG_WARNING, "Receive serial link is not"
489 syslog(LOG_WARNING, "Problem: %s", s);
497 * List of valid speeds.
501 int speed_int, speed_val;
572 /********************************************************************
574 * Translate from bits/second to a speed_t.
577 static int translate_speed (int bps)
579 struct speed *speedp;
583 for (speedp = speeds; speedp->speed_int; speedp++)
585 if (bps == speedp->speed_int)
587 return speedp->speed_val;
590 syslog(LOG_WARNING, "speed %d not supported", bps);
595 /********************************************************************
597 * Translate from a speed_t to bits/second.
600 static int baud_rate_of (int speed)
602 struct speed *speedp;
606 for (speedp = speeds; speedp->speed_int; speedp++)
608 if (speed == speedp->speed_val)
610 return speedp->speed_int;
617 /********************************************************************
619 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
620 * at the requested speed, etc. If `local' is true, set CLOCAL
621 * regardless of whether the modem option was specified.
624 void set_up_tty (int tty_fd, int local)
629 if (tcgetattr(tty_fd, &tios) < 0)
631 syslog(LOG_ERR, "tcgetattr: %m(%d)", errno);
640 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
641 tios.c_cflag |= CS8 | CREAD | HUPCL;
643 tios.c_iflag = IGNBRK | IGNPAR;
647 tios.c_cc[VTIME] = 0;
651 tios.c_cflag ^= (CLOCAL | HUPCL);
657 tios.c_cflag |= CRTSCTS;
661 tios.c_iflag |= IXON | IXOFF;
662 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
663 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
667 tios.c_cflag &= ~CRTSCTS;
674 speed = translate_speed(inspeed);
677 cfsetospeed (&tios, speed);
678 cfsetispeed (&tios, speed);
681 * We can't proceed if the serial port speed is B0,
682 * since that implies that the serial port is disabled.
686 speed = cfgetospeed(&tios);
689 syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
695 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
697 syslog(LOG_ERR, "tcsetattr: %m");
701 baud_rate = baud_rate_of(speed);
705 /********************************************************************
707 * setdtr - control the DTR line on the serial port.
708 * This is called from die(), so it shouldn't call die().
711 void setdtr (int tty_fd, int on)
713 int modembits = TIOCM_DTR;
715 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
718 /********************************************************************
720 * restore_tty - restore the terminal to the saved settings.
723 void restore_tty (int tty_fd)
729 * Turn off echoing, because otherwise we can get into
730 * a loop with the tty and the modem echoing to each other.
731 * We presume we are the sole user of this tty device, so
732 * when we close it, it will revert to its defaults anyway.
736 inittermios.c_lflag &= ~(ECHO | ECHONL);
739 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0)
741 if (! ok_error (errno))
743 syslog(LOG_WARNING, "tcsetattr: %m");
749 /********************************************************************
751 * output - Output PPP packet.
754 void output (int unit, unsigned char *p, int len)
758 log_packet(p, len, "sent ", LOG_DEBUG);
761 if (write(ppp_fd, p, len) < 0)
763 if (errno == EWOULDBLOCK || errno == ENOBUFS
764 || errno == ENXIO || errno == EIO)
766 syslog(LOG_WARNING, "write: warning: %m(%d)", errno);
770 syslog(LOG_ERR, "write: %m(%d)", errno);
776 /********************************************************************
778 * wait_input - wait until there is data available on ppp_fd,
779 * for the length of time specified by *timo (indefinite
783 void wait_input (struct timeval *timo)
789 FD_SET(ppp_fd, &ready);
791 n = select(ppp_fd + 1, &ready, NULL, &ready, timo);
792 if (n < 0 && errno != EINTR)
794 syslog(LOG_ERR, "select: %m(%d)", errno);
799 /********************************************************************
801 * wait_loop_output - wait until there is data available on the
802 * loopback, for the length of time specified by *timo (indefinite
805 void wait_loop_output(timo)
806 struct timeval *timo;
812 FD_SET(master_fd, &ready);
813 n = select(master_fd + 1, &ready, NULL, &ready, timo);
814 if (n < 0 && errno != EINTR)
816 syslog(LOG_ERR, "select: %m(%d)", errno);
821 /********************************************************************
823 * wait_time - wait for a given length of time or until a
824 * signal is received.
828 struct timeval *timo;
832 n = select(0, NULL, NULL, NULL, timo);
833 if (n < 0 && errno != EINTR) {
834 syslog(LOG_ERR, "select: %m(%d)", errno);
839 /********************************************************************
841 * read_packet - get a PPP packet from the serial device.
844 int read_packet (unsigned char *buf)
848 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
851 if (errno == EWOULDBLOCK)
855 syslog(LOG_ERR, "read: %m(%d)", errno);
861 /********************************************************************
863 * get_loop_output - get outgoing packets from the ppp device,
864 * and detect when we want to bring the real link up.
865 * Return value is 1 if we need to bring up the link, 0 otherwise.
868 get_loop_output(void)
871 int n = read(master_fd, inbuf, sizeof(inbuf));
875 if (loop_chars(inbuf, n))
879 n = read(master_fd, inbuf, sizeof(inbuf));
884 syslog(LOG_ERR, "eof on loopback");
888 if (errno != EWOULDBLOCK)
890 syslog(LOG_ERR, "read from loopback: %m(%d)", errno);
897 /********************************************************************
899 * ppp_send_config - configure the transmit characteristics of
903 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
908 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
910 * Ensure that the link is still up.
915 * Set the MTU and other parameters for the ppp device
917 memset (&ifr, '\0', sizeof (ifr));
918 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
921 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
923 syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m(%d)", errno);
927 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
928 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0)
930 syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
935 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
936 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
941 /********************************************************************
943 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
946 void ppp_set_xaccm (int unit, ext_accm accm)
948 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
949 accm[0], accm[1], accm[2], accm[3]));
951 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
953 if ( ! ok_error (errno))
955 syslog(LOG_WARNING, "ioctl(set extended ACCM): %m(%d)", errno);
960 /********************************************************************
962 * ppp_recv_config - configure the receive-side characteristics of
966 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
970 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
972 * If we were called because the link has gone down then there is nothing
973 * which may be done. Just return without incident.
980 * Set the receiver parameters
982 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
984 if ( ! ok_error (errno))
986 syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m(%d)", errno);
990 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
991 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0)
993 syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
998 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
1002 /********************************************************************
1004 * ccp_test - ask kernel whether a given compression method
1005 * is acceptable for use.
1008 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1010 struct ppp_option_data data;
1012 memset (&data, '\0', sizeof (data));
1014 data.length = opt_len;
1015 data.transmit = for_transmit;
1017 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1022 return (errno == ENOBUFS)? 0: -1;
1025 /********************************************************************
1027 * ccp_flags_set - inform kernel about the current state of CCP.
1030 void ccp_flags_set (int unit, int isopen, int isup)
1034 int x = get_flags();
1035 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1036 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1041 /********************************************************************
1043 * get_idle_time - return how long the link has been idle.
1046 get_idle_time(u, ip)
1048 struct ppp_idle *ip;
1050 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
1053 /********************************************************************
1055 * ccp_fatal_error - returns 1 if decompression was disabled as a
1056 * result of an error detected after decompression of a packet,
1057 * 0 otherwise. This is necessary because of patent nonsense.
1060 int ccp_fatal_error (int unit)
1062 int x = get_flags();
1064 return x & SC_DC_FERROR;
1068 * path_to_route - determine the path to the proc file system data
1071 FILE *route_fd = (FILE *) 0;
1072 static char route_buffer [512];
1074 static char *path_to_route (void);
1075 static int open_route_table (void);
1076 static void close_route_table (void);
1077 static int read_route_table (struct rtentry *rt);
1079 /********************************************************************
1081 * path_to_procfs - find the path to the proc file system mount point
1084 static int path_to_procfs (void)
1086 struct mntent *mntent;
1089 fp = fopen (MOUNTED, "r");
1092 mntent = getmntent (fp);
1093 while (mntent != (struct mntent *) 0)
1095 if (strcmp (mntent->mnt_type, MNTTYPE_IGNORE) != 0)
1097 if (strcmp (mntent->mnt_type, "proc") == 0)
1099 strncpy (route_buffer, mntent->mnt_dir,
1100 sizeof (route_buffer)-10);
1101 route_buffer [sizeof (route_buffer)-10] = '\0';
1106 mntent = getmntent (fp);
1113 /********************************************************************
1115 * path_to_route - find the path to the route tables in the proc file system
1118 static char *path_to_route (void)
1120 if (! path_to_procfs())
1122 syslog (LOG_ERR, "proc file system not mounted");
1125 strcat (route_buffer, "/net/route");
1126 return (route_buffer);
1129 /********************************************************************
1131 * close_route_table - close the interface to the route table
1134 static void close_route_table (void)
1136 if (route_fd != (FILE *) 0)
1139 route_fd = (FILE *) 0;
1143 /********************************************************************
1145 * open_route_table - open the interface to the route table
1148 static int open_route_table (void)
1152 close_route_table();
1154 path = path_to_route();
1160 route_fd = fopen (path, "r");
1161 if (route_fd == (FILE *) 0)
1163 syslog (LOG_ERR, "can not open %s: %m(%d)", path, errno);
1169 /********************************************************************
1171 * read_route_table - read the next entry from the route table
1174 static int read_route_table (struct rtentry *rt)
1176 static char delims[] = " \t\n";
1177 char *dev_ptr, *ptr, *dst_ptr, *gw_ptr, *flag_ptr;
1179 memset (rt, '\0', sizeof (struct rtentry));
1183 if (fgets (route_buffer, sizeof (route_buffer), route_fd) ==
1189 dev_ptr = strtok (route_buffer, delims); /* interface name */
1190 dst_ptr = strtok (NULL, delims); /* destination address */
1191 gw_ptr = strtok (NULL, delims); /* gateway */
1192 flag_ptr = strtok (NULL, delims); /* flags */
1194 if (flag_ptr == (char *) 0) /* assume that we failed, somewhere. */
1199 /* Discard that stupid header line which should never
1200 * have been there in the first place !! */
1201 if (isxdigit (*dst_ptr) && isxdigit (*gw_ptr) && isxdigit (*flag_ptr))
1207 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1208 strtoul (dst_ptr, NULL, 16);
1210 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1211 strtoul (gw_ptr, NULL, 16);
1213 rt->rt_flags = (short) strtoul (flag_ptr, NULL, 16);
1214 rt->rt_dev = dev_ptr;
1219 /********************************************************************
1221 * defaultroute_exists - determine if there is a default route
1224 static int defaultroute_exists (struct rtentry *rt)
1228 if (!open_route_table())
1233 while (read_route_table(rt) != 0)
1235 if ((rt->rt_flags & RTF_UP) == 0)
1240 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L)
1247 close_route_table();
1251 /********************************************************************
1253 * sifdefaultroute - assign a default route through the address given.
1256 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1260 if (defaultroute_exists(&rt))
1262 struct in_addr old_gateway =
1263 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1265 if (old_gateway.s_addr != gateway)
1268 "not replacing existing default route to %s [%s]",
1270 inet_ntoa (old_gateway));
1275 memset (&rt, '\0', sizeof (rt));
1276 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1277 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1279 #if LINUX_VERSION_CODE > 0x020100
1280 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1281 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1284 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1286 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1287 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
1289 if ( ! ok_error ( errno ))
1291 syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m(%d)", errno);
1296 default_route_gateway = gateway;
1300 /********************************************************************
1302 * cifdefaultroute - delete a default route through the address given.
1305 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1309 default_route_gateway = 0;
1311 memset (&rt, '\0', sizeof (rt));
1312 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1313 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1315 #if LINUX_VERSION_CODE > 0x020100
1316 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1317 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1320 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1322 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1323 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1327 if ( ! ok_error ( errno ))
1330 "default route ioctl(SIOCDELRT): %m(%d)", errno);
1339 /********************************************************************
1341 * sifproxyarp - Make a proxy ARP entry for the peer.
1344 int sifproxyarp (int unit, u_int32_t his_adr)
1346 struct arpreq arpreq;
1348 if (has_proxy_arp == 0)
1350 memset (&arpreq, '\0', sizeof(arpreq));
1352 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1353 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1354 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1356 * Get the hardware address of an interface on the same subnet
1357 * as our local address.
1359 if (!get_ether_addr(his_adr, &arpreq.arp_ha, arpreq.arp_dev))
1361 syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1365 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0)
1367 if ( ! ok_error ( errno ))
1369 syslog(LOG_ERR, "ioctl(SIOCSARP): %m(%d)", errno);
1375 proxy_arp_addr = his_adr;
1380 /********************************************************************
1382 * cifproxyarp - Delete the proxy ARP entry for the peer.
1385 int cifproxyarp (int unit, u_int32_t his_adr)
1387 struct arpreq arpreq;
1389 if (has_proxy_arp == 1)
1391 memset (&arpreq, '\0', sizeof(arpreq));
1392 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1393 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1394 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1396 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0)
1398 if ( ! ok_error ( errno ))
1400 syslog(LOG_WARNING, "ioctl(SIOCDARP): %m(%d)", errno);
1409 /********************************************************************
1411 * get_ether_addr - get the hardware address of an interface on the
1412 * the same subnet as ipaddr.
1415 static int get_ether_addr (u_int32_t ipaddr,
1416 struct sockaddr *hwaddr,
1419 struct ifreq *ifr, *ifend, *ifp;
1421 u_int32_t ina, mask;
1424 struct ifreq ifs[MAX_IFS];
1426 ifc.ifc_len = sizeof(ifs);
1428 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1430 if ( ! ok_error ( errno ))
1432 syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1437 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1438 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1440 * Scan through looking for an interface with an Internet
1441 * address on the same subnet as `ipaddr'.
1443 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1444 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1446 if (ifr->ifr_addr.sa_family == AF_INET)
1448 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1449 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1450 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1453 * Check that the interface is up, and not point-to-point
1456 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1461 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1466 * Get its netmask and check that it's on the right subnet.
1468 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1473 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1474 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1475 ip_ntoa(ina), ntohl(mask)));
1477 if (((ipaddr ^ ina) & mask) != 0)
1490 memcpy (name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
1491 syslog(LOG_INFO, "found interface %s for proxy arp", name);
1493 * Now get the hardware address.
1495 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1496 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0)
1498 syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1504 sizeof (struct sockaddr));
1506 SYSDEBUG ((LOG_DEBUG,
1507 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1508 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1509 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1510 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1511 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1512 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1513 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1514 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1515 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1519 /********************************************************************
1521 * Return user specified netmask, modified by any mask we might determine
1522 * for address `addr' (in network byte order).
1523 * Here we scan through the system's list of interfaces, looking for
1524 * any non-point-to-point interfaces which might appear to be on the same
1525 * network as `addr'. If we find any, we OR in their netmask to the
1526 * user-specified netmask.
1529 u_int32_t GetMask (u_int32_t addr)
1531 u_int32_t mask, nmask, ina;
1532 struct ifreq *ifr, *ifend, ifreq;
1534 struct ifreq ifs[MAX_IFS];
1538 if (IN_CLASSA(addr)) /* determine network mask for address class */
1540 nmask = IN_CLASSA_NET;
1544 if (IN_CLASSB(addr))
1546 nmask = IN_CLASSB_NET;
1550 nmask = IN_CLASSC_NET;
1554 /* class D nets are disallowed by bad_ip_adrs */
1555 mask = netmask | htonl(nmask);
1557 * Scan through the system's network interfaces.
1559 ifc.ifc_len = sizeof(ifs);
1561 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1563 if ( ! ok_error ( errno ))
1565 syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1570 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1571 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1574 * Check the interface's internet address.
1576 if (ifr->ifr_addr.sa_family != AF_INET)
1580 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1581 if (((ntohl(ina) ^ addr) & nmask) != 0)
1586 * Check that the interface is up, and not point-to-point nor loopback.
1588 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1589 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1594 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1599 * Get its netmask and OR it into our mask.
1601 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1605 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1611 /********************************************************************
1613 * Internal routine to decode the version.modification.patch level
1616 static void decode_version (char *buf, int *version,
1617 int *modification, int *patch)
1619 *version = (int) strtoul (buf, &buf, 10);
1626 *modification = (int) strtoul (buf, &buf, 10);
1630 *patch = (int) strtoul (buf, &buf, 10);
1642 /********************************************************************
1644 * Procedure to determine if the PPP line dicipline is registered.
1648 ppp_registered(void)
1654 local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1657 syslog(LOG_ERR, "Failed to open %s: %m(%d)", devnam, errno);
1661 initfdflags = fcntl(local_fd, F_GETFL);
1662 if (initfdflags == -1)
1664 syslog(LOG_ERR, "Couldn't get device fd flags: %m(%d)", errno);
1669 initfdflags &= ~O_NONBLOCK;
1670 fcntl(local_fd, F_SETFL, initfdflags);
1672 * Read the initial line dicipline and try to put the device into the
1675 if (ioctl(local_fd, TIOCGETD, &init_disc) < 0)
1677 syslog(LOG_ERR, "ioctl(TIOCGETD): %m(%d)", errno);
1682 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0)
1684 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1689 if (ioctl(local_fd, TIOCSETD, &init_disc) < 0)
1691 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1700 /********************************************************************
1702 * ppp_available - check whether the system has any ppp interfaces
1703 * (in fact we check whether we can do an ioctl on ppp0).
1706 int ppp_available(void)
1711 int my_version, my_modification, my_patch;
1712 extern char *no_ppp_msg;
1714 * Open a socket for doing the ioctl operations.
1716 s = socket(AF_INET, SOCK_DGRAM, 0);
1722 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1723 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1725 * If the device did not exist then attempt to create one by putting the
1726 * current tty into the PPP discipline. If this works then obtain the
1727 * flags for the device again.
1731 if (ppp_registered())
1733 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1734 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1738 * Ensure that the hardware address is for PPP and not something else
1742 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1745 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1753 "This system lacks kernel support for PPP. This could be because\n"
1754 "the PPP kernel module is not loaded, or because the kernel is\n"
1755 "not configured for PPP. See the README.linux file in the\n"
1756 "ppp-2.3.1 distribution.\n";
1759 * This is the PPP device. Validate the version of the driver at this
1760 * point to ensure that this program will work with the driver.
1764 char abBuffer [1024];
1766 ifr.ifr_data = abBuffer;
1767 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1772 decode_version (abBuffer,
1774 &driver_modification,
1781 driver_modification =
1785 * Validate the version of the driver against the version that we used.
1787 decode_version (PPP_VERSION,
1792 /* The version numbers must match */
1793 if (driver_version != my_version)
1798 /* The modification levels must be legal */
1799 if (driver_modification < my_modification)
1801 if (driver_modification >= 2) {
1802 /* we can cope with 2.2.0 and above */
1812 sprintf (route_buffer,
1813 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1814 driver_version, driver_modification, driver_patch);
1816 no_ppp_msg = route_buffer;
1822 /********************************************************************
1824 * Update the wtmp file with the appropriate user name and tty device.
1827 void logwtmp (const char *line, const char *name, const char *host)
1830 struct utmp ut, *utp;
1831 pid_t mypid = getpid();
1833 * Update the signon database for users.
1834 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1836 utmpname(_PATH_UTMP);
1838 while ((utp = getutent()) && (utp->ut_pid != mypid))
1841 /* Is this call really necessary? There is another one after the 'put' */
1846 memcpy(&ut, utp, sizeof(ut));
1850 /* some gettys/telnetds don't initialize utmp... */
1851 memset(&ut, 0, sizeof(ut));
1854 if (ut.ut_id[0] == 0)
1856 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1859 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1860 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1864 ut.ut_type = USER_PROCESS;
1867 /* Insert the host name if one is supplied */
1870 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1873 /* Insert the IP address of the remote system if IP is enabled */
1874 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1876 memcpy (&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1877 sizeof(ut.ut_addr));
1880 /* CL: Makes sure that the logout works */
1881 if (*host == 0 && *name==0)
1889 * Update the wtmp file.
1891 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1894 flock(wtmp, LOCK_EX);
1896 /* we really should check for error on the write for a full disk! */
1897 write (wtmp, (char *)&ut, sizeof(ut));
1900 flock(wtmp, LOCK_UN);
1904 /********************************************************************
1905 * Code for locking/unlocking the serial device.
1906 * This code is derived from chat.c.
1910 * lock - create a lock file for the named device
1913 int lock (char *dev)
1917 lock_file = malloc(strlen(dev) + 1);
1918 if (lock_file == NULL)
1920 novm("lock file name");
1922 strcpy (lock_file, dev);
1923 result = mklock (dev, (void *) 0);
1927 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, result);
1936 syslog (LOG_ERR, "Can't create lock file %s", lock_file);
1944 char hdb_lock_buffer[12];
1949 p = strrchr(dev, '/');
1955 lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
1956 if (lock_file == NULL)
1958 novm("lock file name");
1961 strcpy (lock_file, LOCK_PREFIX);
1962 strcat (lock_file, dev);
1964 * Attempt to create the lock file at this point.
1968 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1973 sprintf (hdb_lock_buffer, "%010d\n", pid);
1974 write (fd, hdb_lock_buffer, 11);
1976 write(fd, &pid, sizeof (pid));
1982 * If the file exists then check to see if the pid is stale
1984 if (errno == EEXIST)
1986 fd = open(lock_file, O_RDONLY, 0);
1989 if (errno == ENOENT) /* This is just a timing problem. */
1996 /* Read the lock file to find out who has the device locked */
1997 n = read (fd, hdb_lock_buffer, 11);
2001 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
2005 /* See the process still exists. */
2009 hdb_lock_buffer[n] = '\0';
2010 sscanf (hdb_lock_buffer, " %d", &pid);
2012 pid = ((int *) hdb_lock_buffer)[0];
2014 if (pid == 0 || pid == getpid()
2015 || (kill(pid, 0) == -1 && errno == ESRCH))
2021 /* If the process does not exist then try to remove the lock */
2022 if (n == 0 && unlink (lock_file) == 0)
2024 syslog (LOG_NOTICE, "Removed stale lock on %s (pid %d)",
2029 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, pid);
2033 syslog(LOG_ERR, "Can't create lock file %s: %m(%d)", lock_file, errno);
2044 /********************************************************************
2046 * unlock - remove our lockfile
2054 (void) rmlock (lock_file, (void *) 0);
2063 /********************************************************************
2065 * sifvjcomp - config tcp header compression
2068 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2070 u_int x = get_flags();
2074 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2076 if (! ok_error (errno))
2078 syslog (LOG_ERR, "ioctl(PPPIOCSFLAGS): %m(%d)", errno);
2084 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2085 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2091 /********************************************************************
2093 * sifup - Config the interface up and enable IP packets to pass.
2100 memset (&ifr, '\0', sizeof (ifr));
2101 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2102 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2104 if (! ok_error (errno))
2106 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2111 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2112 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2114 if (! ok_error (errno))
2116 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2124 /********************************************************************
2126 * sifdown - Config the interface down and disable IP.
2135 memset (&ifr, '\0', sizeof (ifr));
2136 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2137 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2139 if (! ok_error (errno))
2141 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2146 ifr.ifr_flags &= ~IFF_UP;
2147 ifr.ifr_flags |= IFF_POINTOPOINT;
2148 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2150 if (! ok_error (errno))
2152 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2159 /********************************************************************
2161 * sifaddr - Config the interface IP addresses and netmask.
2164 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2170 memset (&ifr, '\0', sizeof (ifr));
2171 memset (&rt, '\0', sizeof (rt));
2173 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2174 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2175 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2177 strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2179 * Set our IP address
2181 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2182 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2184 if (errno != EEXIST)
2186 if (! ok_error (errno))
2188 syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m(%d)", errno);
2193 syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
2198 * Set the gateway address
2200 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2201 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0)
2203 if (! ok_error (errno))
2205 syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2214 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2215 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0)
2217 if (! ok_error (errno))
2219 syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2225 * Add the device route
2227 #if LINUX_VERSION_CODE < 0x020100+16 /* 2.1.16 */
2228 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2229 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2232 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2233 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2234 rt.rt_flags = RTF_UP | RTF_HOST;
2236 #if LINUX_VERSION_CODE > 0x020100
2237 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2238 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2241 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
2243 if (! ok_error (errno))
2245 syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m(%d)", errno);
2253 /********************************************************************
2255 * cifaddr - Clear the interface IP addresses, and delete routes
2256 * through the interface if possible.
2259 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2261 #if LINUX_VERSION_CODE < 0x020100+16 /* 2.1.16 */
2264 * Delete the route through the device
2266 memset (&rt, '\0', sizeof (rt));
2268 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2269 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2272 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2273 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2274 rt.rt_flags = RTF_UP | RTF_HOST;
2276 #if LINUX_VERSION_CODE > 0x020100
2277 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2278 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2281 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
2283 if (still_ppp() && ! ok_error (errno))
2285 syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m(%d)", errno);
2293 /********************************************************************
2295 * open_loopback - open the device we use for getting packets
2296 * in demand mode. Under Linux, we use our existing fd
2297 * to the ppp driver.
2300 open_ppp_loopback(void)
2303 struct termios tios;
2306 for (i = 0; i < 64; ++i) {
2307 sprintf(loop_name, "/dev/pty%c%x", 'p' + i / 16, i % 16);
2308 master_fd = open(loop_name, O_RDWR, 0);
2312 if (master_fd < 0) {
2313 syslog(LOG_ERR, "No free pty for loopback");
2316 SYSDEBUG((LOG_DEBUG, "using %s for loopback", loop_name));
2318 slave_fd = open(loop_name, O_RDWR, 0);
2320 syslog(LOG_ERR, "Couldn't open %s for loopback: %m", loop_name);
2324 set_ppp_fd(slave_fd);
2326 if (tcgetattr(ppp_fd, &tios) == 0)
2328 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2329 tios.c_cflag |= CS8 | CREAD;
2330 tios.c_iflag = IGNPAR | CLOCAL;
2333 if (tcsetattr(ppp_fd, TCSAFLUSH, &tios) < 0)
2335 syslog(LOG_WARNING, "couldn't set attributes on loopback: %m(%d)", errno);
2339 flags = fcntl(master_fd, F_GETFL);
2341 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2343 syslog(LOG_WARNING, "couldn't set master loopback to nonblock: %m(%d)", errno);
2346 flags = fcntl(ppp_fd, F_GETFL);
2348 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2350 syslog(LOG_WARNING, "couldn't set slave loopback to nonblock: %m(%d)", errno);
2353 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2355 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
2359 * Find out which interface we were given.
2361 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2363 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
2367 * Enable debug in the driver if requested.
2369 set_kdebugflag (kdebugflag);
2372 /********************************************************************
2374 * restore_loop - reattach the ppp unit to the loopback.
2376 * The kernel ppp driver automatically reattaches the ppp unit to
2377 * the loopback if the serial port is set to a line discipline other
2378 * than ppp, or if it detects a modem hangup. The former will happen
2379 * in disestablish_ppp if the latter hasn't already happened, so we
2380 * shouldn't need to do anything.
2382 * Just to be sure, set the real serial port to the normal discipline.
2388 if (ppp_fd != slave_fd)
2390 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2391 set_ppp_fd(slave_fd);
2395 /********************************************************************
2397 * sifnpmode - Set the mode for handling packets for a given NP.
2401 sifnpmode(u, proto, mode)
2408 npi.protocol = proto;
2410 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0)
2412 if (! ok_error (errno))
2414 syslog(LOG_ERR, "ioctl(PPPIOCSNPMODE, %d, %d): %m(%d)",
2415 proto, mode, errno);
2416 syslog(LOG_ERR, "ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2424 #include <linux/ipx.h>
2426 /********************************************************************
2428 * sipxfaddr - Config the interface IPX networknumber
2431 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2437 struct sockaddr_ipx ipx_addr;
2439 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2441 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2444 if (! ok_error (errno))
2446 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2452 memset (&ifr, '\0', sizeof (ifr));
2453 strcpy (ifr.ifr_name, ifname);
2455 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2456 sipx->sipx_family = AF_IPX;
2457 sipx->sipx_port = 0;
2458 sipx->sipx_network = htonl (network);
2459 sipx->sipx_type = IPX_FRAME_ETHERII;
2460 sipx->sipx_action = IPX_CRTITF;
2462 * Set the IPX device
2464 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2467 if (errno != EEXIST)
2469 if (! ok_error (errno))
2472 "ioctl(SIOCAIFADDR, CRTITF): %m(%d)", errno);
2477 syslog (LOG_WARNING,
2478 "ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2487 /********************************************************************
2489 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2490 * are removed and the device is no longer able to pass IPX
2494 int cipxfaddr (int unit)
2500 struct sockaddr_ipx ipx_addr;
2502 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2504 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2507 if (! ok_error (errno))
2509 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2515 memset (&ifr, '\0', sizeof (ifr));
2516 strcpy (ifr.ifr_name, ifname);
2518 sipx->sipx_type = IPX_FRAME_ETHERII;
2519 sipx->sipx_action = IPX_DLTITF;
2520 sipx->sipx_family = AF_IPX;
2522 * Set the IPX device
2524 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2526 if (! ok_error (errno))
2529 "ioctl(SIOCAIFADDR, IPX_DLTITF): %m(%d)", errno);
2540 * daemon - Detach us from controlling terminal session.
2543 daemon(nochdir, noclose)
2544 int nochdir, noclose;
2548 if ((pid = fork()) < 0)
2551 exit(0); /* parent dies */
2556 fclose(stdin); /* don't need stdin, stdout, stderr */
2563 /********************************************************************
2565 * sys_check_options - check the options that the user specified
2569 sys_check_options(void)
2572 struct stat stat_buf;
2574 * Disable the IPX protocol if the support is not present in the kernel.
2575 * If we disable it then ensure that IP support is enabled.
2577 while (ipxcp_protent.enabled_flag)
2579 if (path_to_procfs())
2581 strcat (route_buffer, "/net/ipx_interface");
2582 if (lstat (route_buffer, &stat_buf) >= 0)
2587 syslog (LOG_ERR, "IPX support is not present in the kernel\n");
2588 ipxcp_protent.enabled_flag = 0;
2589 ipcp_protent.enabled_flag = 1;
2593 if (demand && driver_is_old) {
2594 option_error("demand dialling is not supported by kernel driver version "
2595 "%d.%d.%d", driver_version, driver_modification,