pppd/sys-linux.c

   1 /*
   2  * sys-linux.c - System-dependent procedures for setting up
   3  * PPP interfaces on Linux systems
   4  *
   5  * Copyright (c) 1989 Carnegie Mellon University.
   6  * All rights reserved.
   7  *
   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.
  19  */
  20
  21 #include <sys/ioctl.h>
  22 #include <sys/types.h>
  23 #include <sys/socket.h>
  24 #include <sys/time.h>
  25 #include <sys/errno.h>
  26 #include <sys/file.h>
  27 #include <sys/stat.h>
  28 #include <sys/utsname.h>
  29 #include <sys/sysmacros.h>
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <syslog.h>
  34 #include <string.h>
  35 #include <time.h>
  36 #include <memory.h>
  37 #include <utmp.h>
  38 #include <mntent.h>
  39 #include <signal.h>
  40 #include <fcntl.h>
  41 #include <ctype.h>
  42 #include <termios.h>
  43 #include <unistd.h>
  44
  45 /* This is in netdevice.h. However, this compile will fail miserably if
  46    you attempt to include netdevice.h because it has so many references
  47    to __memcpy functions which it should not attempt to do. So, since I
  48    really don't use it, but it must be defined, define it now. */
  49
  50 #ifndef MAX_ADDR_LEN
  51 #define MAX_ADDR_LEN 7
  52 #endif
  53
  54 #if __GLIBC__ >= 2
  55 #include <asm/types.h>          /* glibc 2 conflicts with linux/types.h */
  56 #include <net/if.h>
  57 #include <net/if_arp.h>
  58 #include <net/route.h>
  59 #include <netinet/if_ether.h>
  60 #else
  61 #include <linux/types.h>
  62 #include <linux/if.h>
  63 #include <linux/if_arp.h>
  64 #include <linux/route.h>
  65 #include <linux/if_ether.h>
  66 #endif
  67 #include <netinet/in.h>
  68 #include <arpa/inet.h>
  69
  70 #include <linux/ppp_defs.h>
  71 #include <linux/if_ppp.h>
  72
  73 #include "pppd.h"
  74 #include "fsm.h"
  75 #include "ipcp.h"
  76
  77 #ifdef IPX_CHANGE
  78 #include "ipxcp.h"
  79 #if __GLIBC__ >= 2 && \
  80     !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
  81 #include <netipx/ipx.h>
  82 #else
  83 #include <linux/ipx.h>
  84 #endif
  85 #endif /* IPX_CHANGE */
  86
  87 #ifdef PPP_FILTER
  88 #include <net/bpf.h>
  89 #include <linux/filter.h>
  90 #endif /* PPP_FILTER */
  91
  92 #ifdef LOCKLIB
  93 #include <sys/locks.h>
  94 #endif
  95
  96 #ifdef INET6
  97 #ifndef _LINUX_IN6_H
  98 /*
  99  *    This is in linux/include/net/ipv6.h.
 100  */
 101
 102 struct in6_ifreq {
 103     struct in6_addr ifr6_addr;
 104     __u32 ifr6_prefixlen;
 105     unsigned int ifr6_ifindex;
 106 };
 107 #endif
 108
 109 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do {                 \
 110         memset(&sin6.s6_addr, 0, sizeof(struct in6_addr));      \
 111         sin6.s6_addr16[0] = htons(0xfe80);                      \
 112         eui64_copy(eui64, sin6.s6_addr32[2]);                   \
 113         } while (0)
 114
 115 #endif /* INET6 */
 116
 117 /* We can get an EIO error on an ioctl if the modem has hung up */
 118 #define ok_error(num) ((num)==EIO)
 119
 120 static int tty_disc = N_TTY;    /* The TTY discipline */
 121 static int ppp_disc = N_PPP;    /* The PPP discpline */
 122 static int initfdflags = -1;    /* Initial file descriptor flags for fd */
 123 static int ppp_fd = -1;         /* fd which is set to PPP discipline */
 124 static int sock_fd = -1;        /* socket for doing interface ioctls */
 125 static int slave_fd = -1;
 126 static int master_fd = -1;
 127 #ifdef INET6
 128 static int sock6_fd = -1;
 129 #endif /* INET6 */
 130 static int ppp_dev_fd = -1;     /* fd for /dev/ppp (new style driver) */
 131 static int chindex;             /* channel index (new style driver) */
 132
 133 static fd_set in_fds;           /* set of fds that wait_input waits for */
 134 static int max_in_fd;           /* highest fd set in in_fds */
 135
 136 static int has_proxy_arp       = 0;
 137 static int driver_version      = 0;
 138 static int driver_modification = 0;
 139 static int driver_patch        = 0;
 140 static int driver_is_old       = 0;
 141 static int restore_term        = 0;     /* 1 => we've munged the terminal */
 142 static struct termios inittermios;      /* Initial TTY termios */
 143
 144 static int new_style_driver = 0;
 145
 146 static char loop_name[20];
 147 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
 148
 149 static int      if_is_up;       /* Interface has been marked up */
 150 static u_int32_t default_route_gateway; /* Gateway for default route added */
 151 static u_int32_t proxy_arp_addr;        /* Addr for proxy arp entry added */
 152 static char proxy_arp_dev[16];          /* Device for proxy arp entry */
 153 static u_int32_t our_old_addr;          /* for detecting address changes */
 154 static int      dynaddr_set;            /* 1 if ip_dynaddr set */
 155 static int      looped;                 /* 1 if using loop */
 156 static int      link_mtu;               /* mtu for the link (not bundle) */
 157
 158 static struct utsname utsname;  /* for the kernel version */
 159 static int kernel_version;
 160 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
 161
 162 #define MAX_IFS         100
 163
 164 #define FLAGS_GOOD (IFF_UP          | IFF_BROADCAST)
 165 #define FLAGS_MASK (IFF_UP          | IFF_BROADCAST | \
 166                     IFF_POINTOPOINT | IFF_LOOPBACK  | IFF_NOARP)
 167
 168 #define SIN_ADDR(x)     (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
 169
 170 /* Prototypes for procedures local to this file. */
 171 static int get_flags (int fd);
 172 static void set_flags (int fd, int flags);
 173 static int translate_speed (int bps);
 174 static int baud_rate_of (int speed);
 175 static void close_route_table (void);
 176 static int open_route_table (void);
 177 static int read_route_table (struct rtentry *rt);
 178 static int defaultroute_exists (struct rtentry *rt);
 179 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
 180                            char *name, int namelen);
 181 static void decode_version (char *buf, int *version, int *mod, int *patch);
 182 static int set_kdebugflag(int level);
 183 static int ppp_registered(void);
 184 static int make_ppp_unit(void);
 185 static void restore_loop(void); /* Transfer ppp unit back to loopback */
 186
 187 extern u_char   inpacket_buf[]; /* borrowed from main.c */
 188
 189 /*
 190  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
 191  * if it exists.
 192  */
 193
 194 #define SET_SA_FAMILY(addr, family)                     \
 195     memset ((char *) &(addr), '\0', sizeof(addr));      \
 196     addr.sa_family = (family);
 197
 198 /*
 199  * Determine if the PPP connection should still be present.
 200  */
 201
 202 extern int hungup;
 203
 204 /* new_fd is the fd of a tty */
 205 static void set_ppp_fd (int new_fd)
 206 {
 207         SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
 208         ppp_fd = new_fd;
 209         if (!new_style_driver)
 210                 ppp_dev_fd = new_fd;
 211 }
 212
 213 static int still_ppp(void)
 214 {
 215         if (new_style_driver)
 216                 return !hungup && ppp_fd >= 0;
 217         if (!hungup || ppp_fd == slave_fd)
 218                 return 1;
 219         if (slave_fd >= 0) {
 220                 set_ppp_fd(slave_fd);
 221                 return 1;
 222         }
 223         return 0;
 224 }
 225
 226 /********************************************************************
 227  *
 228  * Functions to read and set the flags value in the device driver
 229  */
 230
 231 static int get_flags (int fd)
 232 {
 233     int flags;
 234
 235     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
 236         if ( ok_error (errno) )
 237             flags = 0;
 238         else
 239             fatal("ioctl(PPPIOCGFLAGS): %m");
 240     }
 241
 242     SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
 243     return flags;
 244 }
 245
 246 /********************************************************************/
 247
 248 static void set_flags (int fd, int flags)
 249 {
 250     SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
 251
 252     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
 253         if (! ok_error (errno) )
 254             fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
 255     }
 256 }
 257
 258 /********************************************************************
 259  *
 260  * sys_init - System-dependent initialization.
 261  */
 262
 263 void sys_init(void)
 264 {
 265     int flags;
 266
 267     if (new_style_driver) {
 268         ppp_dev_fd = open("/dev/ppp", O_RDWR);
 269         if (ppp_dev_fd < 0)
 270             fatal("Couldn't open /dev/ppp: %m");
 271         flags = fcntl(ppp_dev_fd, F_GETFL);
 272         if (flags == -1
 273             || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
 274             warn("Couldn't set /dev/ppp to nonblock: %m");
 275     }
 276
 277     /* Get an internet socket for doing socket ioctls. */
 278     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 279     if (sock_fd < 0)
 280         fatal("Couldn't create IP socket: %m(%d)", errno);
 281
 282 #ifdef INET6
 283     sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
 284     if (sock6_fd < 0)
 285         sock6_fd = -errno;      /* save errno for later */
 286 #endif
 287
 288     FD_ZERO(&in_fds);
 289     max_in_fd = 0;
 290 }
 291
 292 /********************************************************************
 293  *
 294  * sys_cleanup - restore any system state we modified before exiting:
 295  * mark the interface down, delete default route and/or proxy arp entry.
 296  * This shouldn't call die() because it's called from die().
 297  */
 298
 299 void sys_cleanup(void)
 300 {
 301 /*
 302  * Take down the device
 303  */
 304     if (if_is_up) {
 305         if_is_up = 0;
 306         sifdown(0);
 307     }
 308 /*
 309  * Delete any routes through the device.
 310  */
 311     if (default_route_gateway != 0)
 312         cifdefaultroute(0, 0, default_route_gateway);
 313
 314     if (has_proxy_arp)
 315         cifproxyarp(0, proxy_arp_addr);
 316 }
 317
 318 /********************************************************************
 319  *
 320  * sys_close - Clean up in a child process before execing.
 321  */
 322 void
 323 sys_close(void)
 324 {
 325     if (new_style_driver)
 326         close(ppp_dev_fd);
 327     if (sock_fd >= 0)
 328         close(sock_fd);
 329     if (slave_fd >= 0)
 330         close(slave_fd);
 331     if (master_fd >= 0)
 332         close(master_fd);
 333     closelog();
 334 }
 335
 336 /********************************************************************
 337  *
 338  * set_kdebugflag - Define the debugging level for the kernel
 339  */
 340
 341 static int set_kdebugflag (int requested_level)
 342 {
 343     if (new_style_driver && ifunit < 0)
 344         return 1;
 345     if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
 346         if ( ! ok_error (errno) )
 347             error("ioctl(PPPIOCSDEBUG): %m");
 348         return (0);
 349     }
 350     SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
 351                 requested_level));
 352     return (1);
 353 }
 354
 355 /********************************************************************
 356  *
 357  * tty_establish_ppp - Turn the serial port into a ppp interface.
 358  */
 359
 360 int tty_establish_ppp (int tty_fd)
 361 {
 362     int x;
 363     int fd = -1;
 364
 365 /*
 366  * Ensure that the tty device is in exclusive mode.
 367  */
 368     if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
 369         if ( ! ok_error ( errno ))
 370             warn("Couldn't make tty exclusive: %m");
 371     }
 372 /*
 373  * Demand mode - prime the old ppp device to relinquish the unit.
 374  */
 375     if (!new_style_driver && looped
 376         && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
 377         error("ioctl(transfer ppp unit): %m");
 378         return -1;
 379     }
 380 /*
 381  * Set the current tty to the PPP discpline
 382  */
 383
 384 #ifndef N_SYNC_PPP
 385 #define N_SYNC_PPP 14
 386 #endif
 387     ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
 388     if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
 389         if ( ! ok_error (errno) ) {
 390             error("Couldn't set tty to PPP discipline: %m");
 391             return -1;
 392         }
 393     }
 394
 395     if (new_style_driver) {
 396         /* Open another instance of /dev/ppp and connect the channel to it */
 397         int flags;
 398
 399         if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
 400             error("Couldn't get channel number: %m");
 401             goto err;
 402         }
 403         dbglog("using channel %d", chindex);
 404         fd = open("/dev/ppp", O_RDWR);
 405         if (fd < 0) {
 406             error("Couldn't reopen /dev/ppp: %m");
 407             goto err;
 408         }
 409         if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
 410             error("Couldn't attach to channel %d: %m", chindex);
 411             goto err_close;
 412         }
 413         flags = fcntl(fd, F_GETFL);
 414         if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
 415             warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
 416         set_ppp_fd(fd);
 417
 418         if (!looped)
 419             ifunit = -1;
 420         if (!looped && !multilink) {
 421             /*
 422              * Create a new PPP unit.
 423              */
 424             if (make_ppp_unit() < 0)
 425                 goto err_close;
 426         }
 427
 428         if (looped)
 429             set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
 430
 431         if (!multilink) {
 432             add_fd(ppp_dev_fd);
 433             if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
 434                 error("Couldn't attach to PPP unit %d: %m", ifunit);
 435                 goto err_close;
 436             }
 437         }
 438
 439     } else {
 440         /*
 441          * Old-style driver: find out which interface we were given.
 442          */
 443         set_ppp_fd (tty_fd);
 444         if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
 445             if (ok_error (errno))
 446                 goto err;
 447             fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
 448         }
 449         /* Check that we got the same unit again. */
 450         if (looped && x != ifunit)
 451             fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
 452         ifunit = x;
 453
 454         /*
 455          * Fetch the initial file flags and reset blocking mode on the file.
 456          */
 457         initfdflags = fcntl(tty_fd, F_GETFL);
 458         if (initfdflags == -1 ||
 459             fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
 460             if ( ! ok_error (errno))
 461                 warn("Couldn't set device to non-blocking mode: %m");
 462         }
 463     }
 464
 465     looped = 0;
 466
 467     /*
 468      * Enable debug in the driver if requested.
 469      */
 470     if (!looped)
 471         set_kdebugflag (kdebugflag);
 472
 473 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
 474 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
 475                  | SC_LOG_FLUSH)
 476
 477     set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
 478                        | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
 479
 480     SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
 481             driver_version, driver_modification, driver_patch));
 482
 483     return ppp_fd;
 484
 485  err_close:
 486     close(fd);
 487  err:
 488     if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
 489         warn("Couldn't reset tty to normal line discipline: %m");
 490     return -1;
 491 }
 492
 493 /********************************************************************
 494  *
 495  * tty_disestablish_ppp - Restore the serial port to normal operation,
 496  * and reconnect the ppp unit to the loopback if in demand mode.
 497  * This shouldn't call die() because it's called from die().
 498  */
 499
 500 void tty_disestablish_ppp(int tty_fd)
 501 {
 502     if (demand)
 503         restore_loop();
 504     if (!hungup) {
 505 /*
 506  * Flush the tty output buffer so that the TIOCSETD doesn't hang.
 507  */
 508         if (tcflush(tty_fd, TCIOFLUSH) < 0)
 509             warn("tcflush failed: %m");
 510 /*
 511  * Restore the previous line discipline
 512  */
 513         if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
 514             if ( ! ok_error (errno))
 515                 error("ioctl(TIOCSETD, N_TTY): %m");
 516         }
 517
 518         if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
 519             if ( ! ok_error (errno))
 520                 warn("ioctl(TIOCNXCL): %m(%d)", errno);
 521         }
 522
 523         /* Reset non-blocking mode on fd. */
 524         if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
 525             if ( ! ok_error (errno))
 526                 warn("Couldn't restore device fd flags: %m");
 527         }
 528     }
 529     initfdflags = -1;
 530
 531     if (new_style_driver) {
 532         close(ppp_fd);
 533         ppp_fd = -1;
 534         if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
 535             error("Couldn't release PPP unit: %m");
 536         if (!multilink)
 537             remove_fd(ppp_dev_fd);
 538     }
 539 }
 540
 541 /*
 542  * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
 543  * Assumes new_style_driver.
 544  */
 545 static int make_ppp_unit()
 546 {
 547         int x;
 548
 549         ifunit = req_unit;
 550         x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
 551         if (x < 0 && req_unit >= 0 && errno == EEXIST) {
 552                 warn("Couldn't allocate PPP unit %d as it is already in use");
 553                 ifunit = -1;
 554                 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
 555         }
 556         if (x < 0)
 557                 error("Couldn't create new ppp unit: %m");
 558         return x;
 559 }
 560
 561 /*
 562  * cfg_bundle - configure the existing bundle.
 563  * Used in demand mode.
 564  */
 565 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
 566 {
 567         int flags;
 568
 569         if (!new_style_driver)
 570                 return;
 571
 572         /* set the mrru, mtu and flags */
 573         if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
 574                 error("Couldn't set MRRU: %m");
 575         flags = get_flags(ppp_dev_fd);
 576         flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
 577         flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
 578                 | (mrru? SC_MULTILINK: 0);
 579
 580         set_flags(ppp_dev_fd, flags);
 581
 582         /* connect up the channel */
 583         if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
 584                 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
 585         add_fd(ppp_dev_fd);
 586 }
 587
 588 /*
 589  * make_new_bundle - create a new PPP unit (i.e. a bundle)
 590  * and connect our channel to it.  This should only get called
 591  * if `multilink' was set at the time establish_ppp was called.
 592  * In demand mode this uses our existing bundle instead of making
 593  * a new one.
 594  */
 595 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
 596 {
 597         if (!new_style_driver)
 598                 return;
 599
 600         /* make us a ppp unit */
 601         if (make_ppp_unit() < 0)
 602                 die(1);
 603
 604         /* set the mrru and flags */
 605         cfg_bundle(mrru, mtru, rssn, tssn);
 606 }
 607
 608 /*
 609  * bundle_attach - attach our link to a given PPP unit.
 610  * We assume the unit is controlled by another pppd.
 611  */
 612 int bundle_attach(int ifnum)
 613 {
 614         if (!new_style_driver)
 615                 return -1;
 616
 617         if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
 618                 if (errno == ENXIO)
 619                         return 0;       /* doesn't still exist */
 620                 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
 621         }
 622         if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
 623                 fatal("Couldn't connect to interface unit %d: %m", ifnum);
 624         set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
 625
 626         ifunit = ifnum;
 627         return 1;
 628 }
 629
 630 /********************************************************************
 631  *
 632  * clean_check - Fetch the flags for the device and generate
 633  * appropriate error messages.
 634  */
 635 void clean_check(void)
 636 {
 637     int x;
 638     char *s;
 639
 640     if (still_ppp()) {
 641         if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
 642             s = NULL;
 643             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
 644             case SC_RCV_B7_0:
 645                 s = "all had bit 7 set to 1";
 646                 break;
 647
 648             case SC_RCV_B7_1:
 649                 s = "all had bit 7 set to 0";
 650                 break;
 651
 652             case SC_RCV_EVNP:
 653                 s = "all had odd parity";
 654                 break;
 655
 656             case SC_RCV_ODDP:
 657                 s = "all had even parity";
 658                 break;
 659             }
 660
 661             if (s != NULL) {
 662                 warn("Receive serial link is not 8-bit clean:");
 663                 warn("Problem: %s", s);
 664             }
 665         }
 666     }
 667 }
 668
 669
 670 /*
 671  * List of valid speeds.
 672  */
 673
 674 struct speed {
 675     int speed_int, speed_val;
 676 } speeds[] = {
 677 #ifdef B50
 678     { 50, B50 },
 679 #endif
 680 #ifdef B75
 681     { 75, B75 },
 682 #endif
 683 #ifdef B110
 684     { 110, B110 },
 685 #endif
 686 #ifdef B134
 687     { 134, B134 },
 688 #endif
 689 #ifdef B150
 690     { 150, B150 },
 691 #endif
 692 #ifdef B200
 693     { 200, B200 },
 694 #endif
 695 #ifdef B300
 696     { 300, B300 },
 697 #endif
 698 #ifdef B600
 699     { 600, B600 },
 700 #endif
 701 #ifdef B1200
 702     { 1200, B1200 },
 703 #endif
 704 #ifdef B1800
 705     { 1800, B1800 },
 706 #endif
 707 #ifdef B2000
 708     { 2000, B2000 },
 709 #endif
 710 #ifdef B2400
 711     { 2400, B2400 },
 712 #endif
 713 #ifdef B3600
 714     { 3600, B3600 },
 715 #endif
 716 #ifdef B4800
 717     { 4800, B4800 },
 718 #endif
 719 #ifdef B7200
 720     { 7200, B7200 },
 721 #endif
 722 #ifdef B9600
 723     { 9600, B9600 },
 724 #endif
 725 #ifdef B19200
 726     { 19200, B19200 },
 727 #endif
 728 #ifdef B38400
 729     { 38400, B38400 },
 730 #endif
 731 #ifdef B57600
 732     { 57600, B57600 },
 733 #endif
 734 #ifdef B76800
 735     { 76800, B76800 },
 736 #endif
 737 #ifdef B115200
 738     { 115200, B115200 },
 739 #endif
 740 #ifdef EXTA
 741     { 19200, EXTA },
 742 #endif
 743 #ifdef EXTB
 744     { 38400, EXTB },
 745 #endif
 746 #ifdef B230400
 747     { 230400, B230400 },
 748 #endif
 749 #ifdef B460800
 750     { 460800, B460800 },
 751 #endif
 752 #ifdef B921600
 753     { 921600, B921600 },
 754 #endif
 755     { 0, 0 }
 756 };
 757
 758 /********************************************************************
 759  *
 760  * Translate from bits/second to a speed_t.
 761  */
 762
 763 static int translate_speed (int bps)
 764 {
 765     struct speed *speedp;
 766
 767     if (bps != 0) {
 768         for (speedp = speeds; speedp->speed_int; speedp++) {
 769             if (bps == speedp->speed_int)
 770                 return speedp->speed_val;
 771         }
 772         warn("speed %d not supported", bps);
 773     }
 774     return 0;
 775 }
 776
 777 /********************************************************************
 778  *
 779  * Translate from a speed_t to bits/second.
 780  */
 781
 782 static int baud_rate_of (int speed)
 783 {
 784     struct speed *speedp;
 785
 786     if (speed != 0) {
 787         for (speedp = speeds; speedp->speed_int; speedp++) {
 788             if (speed == speedp->speed_val)
 789                 return speedp->speed_int;
 790         }
 791     }
 792     return 0;
 793 }
 794
 795 /********************************************************************
 796  *
 797  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
 798  * at the requested speed, etc.  If `local' is true, set CLOCAL
 799  * regardless of whether the modem option was specified.
 800  */
 801
 802 void set_up_tty(int tty_fd, int local)
 803 {
 804     int speed;
 805     struct termios tios;
 806
 807     setdtr(tty_fd, 1);
 808     if (tcgetattr(tty_fd, &tios) < 0) {
 809         if (!ok_error(errno))
 810             fatal("tcgetattr: %m(%d)", errno);
 811         return;
 812     }
 813
 814     if (!restore_term)
 815         inittermios = tios;
 816
 817     tios.c_cflag     &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
 818     tios.c_cflag     |= CS8 | CREAD | HUPCL;
 819
 820     tios.c_iflag      = IGNBRK | IGNPAR;
 821     tios.c_oflag      = 0;
 822     tios.c_lflag      = 0;
 823     tios.c_cc[VMIN]   = 1;
 824     tios.c_cc[VTIME]  = 0;
 825
 826     if (local || !modem)
 827         tios.c_cflag ^= (CLOCAL | HUPCL);
 828
 829     switch (crtscts) {
 830     case 1:
 831         tios.c_cflag |= CRTSCTS;
 832         break;
 833
 834     case -2:
 835         tios.c_iflag     |= IXON | IXOFF;
 836         tios.c_cc[VSTOP]  = 0x13;       /* DC3 = XOFF = ^S */
 837         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
 838         break;
 839
 840     case -1:
 841         tios.c_cflag &= ~CRTSCTS;
 842         break;
 843
 844     default:
 845         break;
 846     }
 847
 848     speed = translate_speed(inspeed);
 849     if (speed) {
 850         cfsetospeed (&tios, speed);
 851         cfsetispeed (&tios, speed);
 852     }
 853 /*
 854  * We can't proceed if the serial port speed is B0,
 855  * since that implies that the serial port is disabled.
 856  */
 857     else {
 858         speed = cfgetospeed(&tios);
 859         if (speed == B0)
 860             fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
 861     }
 862
 863     if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
 864         if (!ok_error(errno))
 865             fatal("tcsetattr: %m");
 866
 867     baud_rate    = baud_rate_of(speed);
 868     restore_term = 1;
 869 }
 870
 871 /********************************************************************
 872  *
 873  * setdtr - control the DTR line on the serial port.
 874  * This is called from die(), so it shouldn't call die().
 875  */
 876
 877 void setdtr (int tty_fd, int on)
 878 {
 879     int modembits = TIOCM_DTR;
 880
 881     ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
 882 }
 883
 884 /********************************************************************
 885  *
 886  * restore_tty - restore the terminal to the saved settings.
 887  */
 888
 889 void restore_tty (int tty_fd)
 890 {
 891     if (restore_term) {
 892         restore_term = 0;
 893 /*
 894  * Turn off echoing, because otherwise we can get into
 895  * a loop with the tty and the modem echoing to each other.
 896  * We presume we are the sole user of this tty device, so
 897  * when we close it, it will revert to its defaults anyway.
 898  */
 899         if (!default_device)
 900             inittermios.c_lflag &= ~(ECHO | ECHONL);
 901
 902         if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
 903             if (! ok_error (errno))
 904                 warn("tcsetattr: %m");
 905         }
 906     }
 907 }
 908
 909 /********************************************************************
 910  *
 911  * output - Output PPP packet.
 912  */
 913
 914 void output (int unit, unsigned char *p, int len)
 915 {
 916     int fd = ppp_fd;
 917     int proto;
 918
 919     if (debug)
 920         dbglog("sent %P", p, len);
 921
 922     if (len < PPP_HDRLEN)
 923         return;
 924     if (new_style_driver) {
 925         p += 2;
 926         len -= 2;
 927         proto = (p[0] << 8) + p[1];
 928         if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
 929             fd = ppp_dev_fd;
 930     }
 931     if (write(fd, p, len) < 0) {
 932         if (errno == EWOULDBLOCK || errno == ENOBUFS
 933             || errno == ENXIO || errno == EIO || errno == EINTR)
 934             warn("write: warning: %m (%d)", errno);
 935         else
 936             error("write: %m (%d)", errno);
 937     }
 938 }
 939
 940 /********************************************************************
 941  *
 942  * wait_input - wait until there is data available,
 943  * for the length of time specified by *timo (indefinite
 944  * if timo is NULL).
 945  */
 946
 947 void wait_input(struct timeval *timo)
 948 {
 949     fd_set ready, exc;
 950     int n;
 951
 952     ready = in_fds;
 953     exc = in_fds;
 954     n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
 955     if (n < 0 && errno != EINTR)
 956         fatal("select: %m(%d)", errno);
 957 }
 958
 959 /*
 960  * add_fd - add an fd to the set that wait_input waits for.
 961  */
 962 void add_fd(int fd)
 963 {
 964     FD_SET(fd, &in_fds);
 965     if (fd > max_in_fd)
 966         max_in_fd = fd;
 967 }
 968
 969 /*
 970  * remove_fd - remove an fd from the set that wait_input waits for.
 971  */
 972 void remove_fd(int fd)
 973 {
 974     FD_CLR(fd, &in_fds);
 975 }
 976
 977
 978 /********************************************************************
 979  *
 980  * read_packet - get a PPP packet from the serial device.
 981  */
 982
 983 int read_packet (unsigned char *buf)
 984 {
 985     int len, nr;
 986
 987     len = PPP_MRU + PPP_HDRLEN;
 988     if (new_style_driver) {
 989         *buf++ = PPP_ALLSTATIONS;
 990         *buf++ = PPP_UI;
 991         len -= 2;
 992     }
 993     nr = -1;
 994     if (ppp_fd >= 0) {
 995         nr = read(ppp_fd, buf, len);
 996         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
 997             error("read: %m");
 998         if (nr < 0 && errno == ENXIO)
 999             return 0;
1000     }
1001     if (nr < 0 && new_style_driver && ifunit >= 0) {
1002         /* N.B. we read ppp_fd first since LCP packets come in there. */
1003         nr = read(ppp_dev_fd, buf, len);
1004         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1005             error("read /dev/ppp: %m");
1006         if (nr < 0 && errno == ENXIO)
1007             return 0;
1008     }
1009     return (new_style_driver && nr > 0)? nr+2: nr;
1010 }
1011
1012 /********************************************************************
1013  *
1014  * get_loop_output - get outgoing packets from the ppp device,
1015  * and detect when we want to bring the real link up.
1016  * Return value is 1 if we need to bring up the link, 0 otherwise.
1017  */
1018 int
1019 get_loop_output(void)
1020 {
1021     int rv = 0;
1022     int n;
1023
1024     if (new_style_driver) {
1025         while ((n = read_packet(inpacket_buf)) > 0)
1026             if (loop_frame(inpacket_buf, n))
1027                 rv = 1;
1028         return rv;
1029     }
1030
1031     while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1032         if (loop_chars(inbuf, n))
1033             rv = 1;
1034
1035     if (n == 0)
1036         fatal("eof on loopback");
1037
1038     if (errno != EWOULDBLOCK)
1039         fatal("read from loopback: %m(%d)", errno);
1040
1041     return rv;
1042 }
1043
1044 /*
1045  * netif_set_mtu - set the MTU on the PPP network interface.
1046  */
1047 void
1048 netif_set_mtu(int unit, int mtu)
1049 {
1050     struct ifreq ifr;
1051
1052     SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1053
1054     memset (&ifr, '\0', sizeof (ifr));
1055     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1056     ifr.ifr_mtu = mtu;
1057
1058     if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1059         fatal("ioctl(SIOCSIFMTU): %m");
1060 }
1061
1062 /********************************************************************
1063  *
1064  * tty_send_config - configure the transmit characteristics of
1065  * the ppp interface.
1066  */
1067
1068 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1069 {
1070     u_int x;
1071
1072 /*
1073  * Set the asyncmap and other parameters for the ppp device
1074  */
1075     if (!still_ppp())
1076         return;
1077     link_mtu = mtu;
1078     SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1079     if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1080         if (!ok_error(errno))
1081             fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1082         return;
1083     }
1084
1085     x = get_flags(ppp_fd);
1086     x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1087     x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
1088     x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1089     set_flags(ppp_fd, x);
1090 }
1091
1092 /********************************************************************
1093  *
1094  * tty_set_xaccm - set the extended transmit ACCM for the interface.
1095  */
1096
1097 void tty_set_xaccm (ext_accm accm)
1098 {
1099     SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1100                 accm[0], accm[1], accm[2], accm[3]));
1101
1102     if (!still_ppp())
1103         return;
1104     if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1105         if ( ! ok_error (errno))
1106             warn("ioctl(set extended ACCM): %m(%d)", errno);
1107     }
1108 }
1109
1110 /********************************************************************
1111  *
1112  * tty_recv_config - configure the receive-side characteristics of
1113  * the ppp interface.
1114  */
1115
1116 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1117 {
1118     SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1119 /*
1120  * If we were called because the link has gone down then there is nothing
1121  * which may be done. Just return without incident.
1122  */
1123     if (!still_ppp())
1124         return;
1125 /*
1126  * Set the receiver parameters
1127  */
1128     if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1129         if ( ! ok_error (errno))
1130             error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1131     }
1132     if (new_style_driver && ifunit >= 0
1133         && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1134         error("Couldn't set MRU in generic PPP layer: %m");
1135
1136     SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1137     if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1138         if (!ok_error(errno))
1139             error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1140     }
1141 }
1142
1143 /********************************************************************
1144  *
1145  * ccp_test - ask kernel whether a given compression method
1146  * is acceptable for use.
1147  */
1148
1149 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1150 {
1151     struct ppp_option_data data;
1152
1153     memset (&data, '\0', sizeof (data));
1154     data.ptr      = opt_ptr;
1155     data.length   = opt_len;
1156     data.transmit = for_transmit;
1157
1158     if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1159         return 1;
1160
1161     return (errno == ENOBUFS)? 0: -1;
1162 }
1163
1164 /********************************************************************
1165  *
1166  * ccp_flags_set - inform kernel about the current state of CCP.
1167  */
1168
1169 void ccp_flags_set (int unit, int isopen, int isup)
1170 {
1171     if (still_ppp()) {
1172         int x = get_flags(ppp_dev_fd);
1173         x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1174         x = isup?   x | SC_CCP_UP   : x &~ SC_CCP_UP;
1175         set_flags (ppp_dev_fd, x);
1176     }
1177 }
1178
1179 #ifdef PPP_FILTER
1180 /*
1181  * set_filters - set the active and pass filters in the kernel driver.
1182  */
1183 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1184 {
1185         struct sock_fprog fp;
1186
1187         fp.len = pass->bf_len;
1188         fp.filter = (struct sock_filter *) pass->bf_insns;
1189         if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1190                 if (errno == ENOTTY)
1191                         warn("kernel does not support PPP filtering");
1192                 else
1193                         error("Couldn't set pass-filter in kernel: %m");
1194                 return 0;
1195         }
1196         fp.len = active->bf_len;
1197         fp.filter = (struct sock_filter *) active->bf_insns;
1198         if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1199                 error("Couldn't set active-filter in kernel: %m");
1200                 return 0;
1201         }
1202         return 1;
1203 }
1204 #endif /* PPP_FILTER */
1205
1206 /********************************************************************
1207  *
1208  * get_idle_time - return how long the link has been idle.
1209  */
1210 int
1211 get_idle_time(u, ip)
1212     int u;
1213     struct ppp_idle *ip;
1214 {
1215     return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1216 }
1217
1218 /********************************************************************
1219  *
1220  * get_ppp_stats - return statistics for the link.
1221  */
1222 int
1223 get_ppp_stats(u, stats)
1224     int u;
1225     struct pppd_stats *stats;
1226 {
1227     struct ifpppstatsreq req;
1228
1229     memset (&req, 0, sizeof (req));
1230
1231     req.stats_ptr = (caddr_t) &req.stats;
1232     strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1233     if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1234         error("Couldn't get PPP statistics: %m");
1235         return 0;
1236     }
1237     stats->bytes_in = req.stats.p.ppp_ibytes;
1238     stats->bytes_out = req.stats.p.ppp_obytes;
1239     return 1;
1240 }
1241
1242 /********************************************************************
1243  *
1244  * ccp_fatal_error - returns 1 if decompression was disabled as a
1245  * result of an error detected after decompression of a packet,
1246  * 0 otherwise.  This is necessary because of patent nonsense.
1247  */
1248
1249 int ccp_fatal_error (int unit)
1250 {
1251     int x = get_flags(ppp_dev_fd);
1252
1253     return x & SC_DC_FERROR;
1254 }
1255
1256 /********************************************************************
1257  *
1258  * path_to_procfs - find the path to the proc file system mount point
1259  */
1260 static char proc_path[MAXPATHLEN];
1261 static int proc_path_len;
1262
1263 static char *path_to_procfs(const char *tail)
1264 {
1265     struct mntent *mntent;
1266     FILE *fp;
1267
1268     if (proc_path_len == 0) {
1269         /* Default the mount location of /proc */
1270         strlcpy (proc_path, "/proc", sizeof(proc_path));
1271         proc_path_len = 5;
1272         fp = fopen(MOUNTED, "r");
1273         if (fp != NULL) {
1274             while ((mntent = getmntent(fp)) != NULL) {
1275                 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1276                     continue;
1277                 if (strcmp(mntent->mnt_type, "proc") == 0) {
1278                     strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1279                     proc_path_len = strlen(proc_path);
1280                     break;
1281                 }
1282             }
1283             fclose (fp);
1284         }
1285     }
1286
1287     strlcpy(proc_path + proc_path_len, tail,
1288             sizeof(proc_path) - proc_path_len);
1289     return proc_path;
1290 }
1291
1292 /*
1293  * /proc/net/route parsing stuff.
1294  */
1295 #define ROUTE_MAX_COLS  12
1296 FILE *route_fd = (FILE *) 0;
1297 static char route_buffer[512];
1298 static int route_dev_col, route_dest_col, route_gw_col;
1299 static int route_flags_col, route_mask_col;
1300 static int route_num_cols;
1301
1302 static int open_route_table (void);
1303 static void close_route_table (void);
1304 static int read_route_table (struct rtentry *rt);
1305
1306 /********************************************************************
1307  *
1308  * close_route_table - close the interface to the route table
1309  */
1310
1311 static void close_route_table (void)
1312 {
1313     if (route_fd != (FILE *) 0) {
1314         fclose (route_fd);
1315         route_fd = (FILE *) 0;
1316     }
1317 }
1318
1319 /********************************************************************
1320  *
1321  * open_route_table - open the interface to the route table
1322  */
1323 static char route_delims[] = " \t\n";
1324
1325 static int open_route_table (void)
1326 {
1327     char *path;
1328
1329     close_route_table();
1330
1331     path = path_to_procfs("/net/route");
1332     route_fd = fopen (path, "r");
1333     if (route_fd == NULL) {
1334         error("can't open routing table %s: %m", path);
1335         return 0;
1336     }
1337
1338     route_dev_col = 0;          /* default to usual columns */
1339     route_dest_col = 1;
1340     route_gw_col = 2;
1341     route_flags_col = 3;
1342     route_mask_col = 7;
1343     route_num_cols = 8;
1344
1345     /* parse header line */
1346     if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1347         char *p = route_buffer, *q;
1348         int col;
1349         for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1350             int used = 1;
1351             if ((q = strtok(p, route_delims)) == 0)
1352                 break;
1353             if (strcasecmp(q, "iface") == 0)
1354                 route_dev_col = col;
1355             else if (strcasecmp(q, "destination") == 0)
1356                 route_dest_col = col;
1357             else if (strcasecmp(q, "gateway") == 0)
1358                 route_gw_col = col;
1359             else if (strcasecmp(q, "flags") == 0)
1360                 route_flags_col = col;
1361             else if (strcasecmp(q, "mask") == 0)
1362                 route_mask_col = col;
1363             else
1364                 used = 0;
1365             if (used && col >= route_num_cols)
1366                 route_num_cols = col + 1;
1367             p = NULL;
1368         }
1369     }
1370
1371     return 1;
1372 }
1373
1374 /********************************************************************
1375  *
1376  * read_route_table - read the next entry from the route table
1377  */
1378
1379 static int read_route_table(struct rtentry *rt)
1380 {
1381     char *cols[ROUTE_MAX_COLS], *p;
1382     int col;
1383
1384     memset (rt, '\0', sizeof (struct rtentry));
1385
1386     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1387         return 0;
1388
1389     p = route_buffer;
1390     for (col = 0; col < route_num_cols; ++col) {
1391         cols[col] = strtok(p, route_delims);
1392         if (cols[col] == NULL)
1393             return 0;           /* didn't get enough columns */
1394         p = NULL;
1395     }
1396
1397     SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1398     SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1399     SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1400
1401     rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1402     rt->rt_dev   = cols[route_dev_col];
1403
1404     return 1;
1405 }
1406
1407 /********************************************************************
1408  *
1409  * defaultroute_exists - determine if there is a default route
1410  */
1411
1412 static int defaultroute_exists (struct rtentry *rt)
1413 {
1414     int result = 0;
1415
1416     if (!open_route_table())
1417         return 0;
1418
1419     while (read_route_table(rt) != 0) {
1420         if ((rt->rt_flags & RTF_UP) == 0)
1421             continue;
1422
1423         if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1424             continue;
1425         if (SIN_ADDR(rt->rt_dst) == 0L) {
1426             result = 1;
1427             break;
1428         }
1429     }
1430
1431     close_route_table();
1432     return result;
1433 }
1434
1435 /*
1436  * have_route_to - determine if the system has any route to
1437  * a given IP address.  `addr' is in network byte order.
1438  * Return value is 1 if yes, 0 if no, -1 if don't know.
1439  * For demand mode to work properly, we have to ignore routes
1440  * through our own interface.
1441  */
1442 int have_route_to(u_int32_t addr)
1443 {
1444     struct rtentry rt;
1445     int result = 0;
1446
1447     if (!open_route_table())
1448         return -1;              /* don't know */
1449
1450     while (read_route_table(&rt)) {
1451         if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1452             continue;
1453         if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1454             result = 1;
1455             break;
1456         }
1457     }
1458
1459     close_route_table();
1460     return result;
1461 }
1462
1463 /********************************************************************
1464  *
1465  * sifdefaultroute - assign a default route through the address given.
1466  */
1467
1468 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1469 {
1470     struct rtentry rt;
1471
1472     if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1473         u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1474
1475         if (old_gateway != gateway)
1476             error("not replacing existing default route to %s [%I]",
1477                   rt.rt_dev, old_gateway);
1478         return 0;
1479     }
1480
1481     memset (&rt, '\0', sizeof (rt));
1482     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1483     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1484
1485     if (kernel_version > KVERSION(2,1,0)) {
1486         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1487         SIN_ADDR(rt.rt_genmask) = 0L;
1488     }
1489
1490     SIN_ADDR(rt.rt_gateway) = gateway;
1491
1492     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1493     if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1494         if ( ! ok_error ( errno ))
1495             error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1496         return 0;
1497     }
1498
1499     default_route_gateway = gateway;
1500     return 1;
1501 }
1502
1503 /********************************************************************
1504  *
1505  * cifdefaultroute - delete a default route through the address given.
1506  */
1507
1508 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1509 {
1510     struct rtentry rt;
1511
1512     default_route_gateway = 0;
1513
1514     memset (&rt, '\0', sizeof (rt));
1515     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1516     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1517
1518     if (kernel_version > KVERSION(2,1,0)) {
1519         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1520         SIN_ADDR(rt.rt_genmask) = 0L;
1521     }
1522
1523     SIN_ADDR(rt.rt_gateway) = gateway;
1524
1525     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1526     if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1527         if (still_ppp()) {
1528             if ( ! ok_error ( errno ))
1529                 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1530             return 0;
1531         }
1532     }
1533
1534     return 1;
1535 }
1536
1537 /********************************************************************
1538  *
1539  * sifproxyarp - Make a proxy ARP entry for the peer.
1540  */
1541
1542 int sifproxyarp (int unit, u_int32_t his_adr)
1543 {
1544     struct arpreq arpreq;
1545     char *forw_path;
1546
1547     if (has_proxy_arp == 0) {
1548         memset (&arpreq, '\0', sizeof(arpreq));
1549
1550         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1551         SIN_ADDR(arpreq.arp_pa) = his_adr;
1552         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1553 /*
1554  * Get the hardware address of an interface on the same subnet
1555  * as our local address.
1556  */
1557         if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1558                             sizeof(proxy_arp_dev))) {
1559             error("Cannot determine ethernet address for proxy ARP");
1560             return 0;
1561         }
1562         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1563
1564         if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1565             if ( ! ok_error ( errno ))
1566                 error("ioctl(SIOCSARP): %m(%d)", errno);
1567             return 0;
1568         }
1569         proxy_arp_addr = his_adr;
1570         has_proxy_arp = 1;
1571
1572         if (tune_kernel) {
1573             forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1574             if (forw_path != 0) {
1575                 int fd = open(forw_path, O_WRONLY);
1576                 if (fd >= 0) {
1577                     if (write(fd, "1", 1) != 1)
1578                         error("Couldn't enable IP forwarding: %m");
1579                     close(fd);
1580                 }
1581             }
1582         }
1583     }
1584
1585     return 1;
1586 }
1587
1588 /********************************************************************
1589  *
1590  * cifproxyarp - Delete the proxy ARP entry for the peer.
1591  */
1592
1593 int cifproxyarp (int unit, u_int32_t his_adr)
1594 {
1595     struct arpreq arpreq;
1596
1597     if (has_proxy_arp) {
1598         has_proxy_arp = 0;
1599         memset (&arpreq, '\0', sizeof(arpreq));
1600         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1601         SIN_ADDR(arpreq.arp_pa) = his_adr;
1602         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1603         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1604
1605         if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1606             if ( ! ok_error ( errno ))
1607                 warn("ioctl(SIOCDARP): %m(%d)", errno);
1608             return 0;
1609         }
1610     }
1611     return 1;
1612 }
1613
1614 /********************************************************************
1615  *
1616  * get_ether_addr - get the hardware address of an interface on the
1617  * the same subnet as ipaddr.
1618  */
1619
1620 static int get_ether_addr (u_int32_t ipaddr,
1621                            struct sockaddr *hwaddr,
1622                            char *name, int namelen)
1623 {
1624     struct ifreq *ifr, *ifend;
1625     u_int32_t ina, mask;
1626     char *aliasp;
1627     struct ifreq ifreq;
1628     struct ifconf ifc;
1629     struct ifreq ifs[MAX_IFS];
1630
1631     ifc.ifc_len = sizeof(ifs);
1632     ifc.ifc_req = ifs;
1633     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1634         if ( ! ok_error ( errno ))
1635             error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1636         return 0;
1637     }
1638
1639     SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1640                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1641 /*
1642  * Scan through looking for an interface with an Internet
1643  * address on the same subnet as `ipaddr'.
1644  */
1645     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1646     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1647         if (ifr->ifr_addr.sa_family == AF_INET) {
1648             ina = SIN_ADDR(ifr->ifr_addr);
1649             strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1650             SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1651                         ifreq.ifr_name));
1652 /*
1653  * Check that the interface is up, and not point-to-point
1654  * nor loopback.
1655  */
1656             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1657                 continue;
1658
1659             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1660                 continue;
1661 /*
1662  * Get its netmask and check that it's on the right subnet.
1663  */
1664             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1665                 continue;
1666
1667             mask = SIN_ADDR(ifreq.ifr_addr);
1668             SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1669                         ip_ntoa(ina), ntohl(mask)));
1670
1671             if (((ipaddr ^ ina) & mask) != 0)
1672                 continue;
1673             break;
1674         }
1675     }
1676
1677     if (ifr >= ifend)
1678         return 0;
1679
1680     strlcpy(name, ifreq.ifr_name, namelen);
1681
1682     /* trim off the :1 in eth0:1 */
1683     aliasp = strchr(name, ':');
1684     if (aliasp != 0)
1685         *aliasp = 0;
1686
1687     info("found interface %s for proxy arp", name);
1688 /*
1689  * Now get the hardware address.
1690  */
1691     memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1692     if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1693         error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1694         return 0;
1695     }
1696
1697     memcpy (hwaddr,
1698             &ifreq.ifr_hwaddr,
1699             sizeof (struct sockaddr));
1700
1701     SYSDEBUG ((LOG_DEBUG,
1702            "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1703                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1704                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1705                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1706                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1707                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1708                 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1709                 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1710                 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1711     return 1;
1712 }
1713
1714 /*
1715  * get_if_hwaddr - get the hardware address for the specified
1716  * network interface device.
1717  */
1718 int
1719 get_if_hwaddr(u_char *addr, char *name)
1720 {
1721         struct ifreq ifreq;
1722         int ret, sock_fd;
1723
1724         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1725         if (sock_fd < 0)
1726                 return 0;
1727         memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1728         strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1729         ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1730         close(sock_fd);
1731         if (ret >= 0)
1732                 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1733         return ret;
1734 }
1735
1736 /*
1737  * get_first_ethernet - return the name of the first ethernet-style
1738  * interface on this system.
1739  */
1740 char *
1741 get_first_ethernet()
1742 {
1743         return "eth0";
1744 }
1745
1746 /********************************************************************
1747  *
1748  * Return user specified netmask, modified by any mask we might determine
1749  * for address `addr' (in network byte order).
1750  * Here we scan through the system's list of interfaces, looking for
1751  * any non-point-to-point interfaces which might appear to be on the same
1752  * network as `addr'.  If we find any, we OR in their netmask to the
1753  * user-specified netmask.
1754  */
1755
1756 u_int32_t GetMask (u_int32_t addr)
1757 {
1758     u_int32_t mask, nmask, ina;
1759     struct ifreq *ifr, *ifend, ifreq;
1760     struct ifconf ifc;
1761     struct ifreq ifs[MAX_IFS];
1762
1763     addr = ntohl(addr);
1764
1765     if (IN_CLASSA(addr))        /* determine network mask for address class */
1766         nmask = IN_CLASSA_NET;
1767     else if (IN_CLASSB(addr))
1768             nmask = IN_CLASSB_NET;
1769     else
1770             nmask = IN_CLASSC_NET;
1771
1772     /* class D nets are disallowed by bad_ip_adrs */
1773     mask = netmask | htonl(nmask);
1774 /*
1775  * Scan through the system's network interfaces.
1776  */
1777     ifc.ifc_len = sizeof(ifs);
1778     ifc.ifc_req = ifs;
1779     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1780         if ( ! ok_error ( errno ))
1781             warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1782         return mask;
1783     }
1784
1785     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1786     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1787 /*
1788  * Check the interface's internet address.
1789  */
1790         if (ifr->ifr_addr.sa_family != AF_INET)
1791             continue;
1792         ina = SIN_ADDR(ifr->ifr_addr);
1793         if (((ntohl(ina) ^ addr) & nmask) != 0)
1794             continue;
1795 /*
1796  * Check that the interface is up, and not point-to-point nor loopback.
1797  */
1798         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1799         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1800             continue;
1801
1802         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1803             continue;
1804 /*
1805  * Get its netmask and OR it into our mask.
1806  */
1807         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1808             continue;
1809         mask |= SIN_ADDR(ifreq.ifr_addr);
1810         break;
1811     }
1812     return mask;
1813 }
1814
1815 /********************************************************************
1816  *
1817  * Internal routine to decode the version.modification.patch level
1818  */
1819
1820 static void decode_version (char *buf, int *version,
1821                             int *modification, int *patch)
1822 {
1823     char *endp;
1824
1825     *version      = (int) strtoul (buf, &endp, 10);
1826     *modification = 0;
1827     *patch        = 0;
1828
1829     if (endp != buf && *endp == '.') {
1830         buf = endp + 1;
1831         *modification = (int) strtoul (buf, &endp, 10);
1832         if (endp != buf && *endp == '.') {
1833             buf = endp + 1;
1834             *patch = (int) strtoul (buf, &buf, 10);
1835         }
1836     }
1837 }
1838
1839 /********************************************************************
1840  *
1841  * Procedure to determine if the PPP line discipline is registered.
1842  */
1843
1844 static int
1845 ppp_registered(void)
1846 {
1847     int local_fd;
1848     int mfd = -1;
1849     int ret = 0;
1850     char slave[16];
1851
1852     /*
1853      * We used to open the serial device and set it to the ppp line
1854      * discipline here, in order to create a ppp unit.  But that is
1855      * not a good idea - the user might have specified a device that
1856      * they can't open (permission, or maybe it doesn't really exist).
1857      * So we grab a pty master/slave pair and use that.
1858      */
1859     if (!get_pty(&mfd, &local_fd, slave, 0)) {
1860         no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1861         return 0;
1862     }
1863
1864     /*
1865      * Try to put the device into the PPP discipline.
1866      */
1867     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1868         error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1869     } else
1870         ret = 1;
1871
1872     close(local_fd);
1873     close(mfd);
1874     return ret;
1875 }
1876
1877 /********************************************************************
1878  *
1879  * ppp_available - check whether the system has any ppp interfaces
1880  * (in fact we check whether we can do an ioctl on ppp0).
1881  */
1882
1883 int ppp_available(void)
1884 {
1885     int s, ok, fd;
1886     struct ifreq ifr;
1887     int    size;
1888     int    my_version, my_modification, my_patch;
1889     int osmaj, osmin, ospatch;
1890
1891     no_ppp_msg =
1892         "This system lacks kernel support for PPP.  This could be because\n"
1893         "the PPP kernel module could not be loaded, or because PPP was not\n"
1894         "included in the kernel configuration.  If PPP was included as a\n"
1895         "module, try `/sbin/modprobe -v ppp'.  If that fails, check that\n"
1896         "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1897         "See README.linux file in the ppp distribution for more details.\n";
1898
1899     /* get the kernel version now, since we are called before sys_init */
1900     uname(&utsname);
1901     osmaj = osmin = ospatch = 0;
1902     sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1903     kernel_version = KVERSION(osmaj, osmin, ospatch);
1904
1905     fd = open("/dev/ppp", O_RDWR);
1906 #if 0
1907     if (fd < 0 && errno == ENOENT) {
1908         /* try making it and see if that helps. */
1909         if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1910                   makedev(108, 0)) >= 0) {
1911             fd = open("/dev/ppp", O_RDWR);
1912             if (fd >= 0)
1913                 info("Created /dev/ppp device node");
1914             else
1915                 unlink("/dev/ppp");     /* didn't work, undo the mknod */
1916         } else if (errno == EEXIST) {
1917             fd = open("/dev/ppp", O_RDWR);
1918         }
1919     }
1920 #endif /* 0 */
1921     if (fd >= 0) {
1922         new_style_driver = 1;
1923
1924         /* XXX should get from driver */
1925         driver_version = 2;
1926         driver_modification = 4;
1927         driver_patch = 0;
1928         close(fd);
1929         return 1;
1930     }
1931     if (kernel_version >= KVERSION(2,3,13)) {
1932         if (errno == ENOENT)
1933             no_ppp_msg =
1934                 "pppd is unable to open the /dev/ppp device.\n"
1935                 "You need to create the /dev/ppp device node by\n"
1936                 "executing the following command as root:\n"
1937                 "       mknod /dev/ppp c 108 0\n";
1938         return 0;
1939     }
1940
1941 /*
1942  * Open a socket for doing the ioctl operations.
1943  */
1944     s = socket(AF_INET, SOCK_DGRAM, 0);
1945     if (s < 0)
1946         return 0;
1947
1948     strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1949     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1950 /*
1951  * If the device did not exist then attempt to create one by putting the
1952  * current tty into the PPP discipline. If this works then obtain the
1953  * flags for the device again.
1954  */
1955     if (!ok) {
1956         if (ppp_registered()) {
1957             strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1958             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1959         }
1960     }
1961 /*
1962  * Ensure that the hardware address is for PPP and not something else
1963  */
1964     if (ok)
1965         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1966
1967     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1968         ok = 0;
1969
1970 /*
1971  *  This is the PPP device. Validate the version of the driver at this
1972  *  point to ensure that this program will work with the driver.
1973  */
1974     if (ok) {
1975         char   abBuffer [1024];
1976
1977         ifr.ifr_data = abBuffer;
1978         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1979         if (size < 0) {
1980             error("Couldn't read driver version: %m");
1981             ok = 0;
1982             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1983
1984         } else {
1985             decode_version(abBuffer,
1986                            &driver_version,
1987                            &driver_modification,
1988                            &driver_patch);
1989 /*
1990  * Validate the version of the driver against the version that we used.
1991  */
1992             decode_version(VERSION,
1993                            &my_version,
1994                            &my_modification,
1995                            &my_patch);
1996
1997             /* The version numbers must match */
1998             if (driver_version != my_version)
1999                 ok = 0;
2000
2001             /* The modification levels must be legal */
2002             if (driver_modification < 3) {
2003                 if (driver_modification >= 2) {
2004                     /* we can cope with 2.2.0 and above */
2005                     driver_is_old = 1;
2006                 } else {
2007                     ok = 0;
2008                 }
2009             }
2010
2011             close (s);
2012             if (!ok) {
2013                 slprintf(route_buffer, sizeof(route_buffer),
2014                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
2015                          driver_version, driver_modification, driver_patch);
2016
2017                 no_ppp_msg = route_buffer;
2018             }
2019         }
2020     }
2021     return ok;
2022 }
2023
2024 /********************************************************************
2025  *
2026  * Update the wtmp file with the appropriate user name and tty device.
2027  */
2028
2029 void logwtmp (const char *line, const char *name, const char *host)
2030 {
2031     struct utmp ut, *utp;
2032     pid_t  mypid = getpid();
2033 #if __GLIBC__ < 2
2034     int    wtmp;
2035 #endif
2036
2037 /*
2038  * Update the signon database for users.
2039  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2040  */
2041     utmpname(_PATH_UTMP);
2042     setutent();
2043     while ((utp = getutent()) && (utp->ut_pid != mypid))
2044         /* nothing */;
2045
2046     /* Is this call really necessary? There is another one after the 'put' */
2047     endutent();
2048
2049     if (utp)
2050         memcpy(&ut, utp, sizeof(ut));
2051     else
2052         /* some gettys/telnetds don't initialize utmp... */
2053         memset(&ut, 0, sizeof(ut));
2054
2055     if (ut.ut_id[0] == 0)
2056         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2057
2058     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2059     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2060
2061     time(&ut.ut_time);
2062
2063     ut.ut_type = USER_PROCESS;
2064     ut.ut_pid  = mypid;
2065
2066     /* Insert the host name if one is supplied */
2067     if (*host)
2068         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2069
2070     /* Insert the IP address of the remote system if IP is enabled */
2071     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2072         memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2073                  sizeof(ut.ut_addr));
2074
2075     /* CL: Makes sure that the logout works */
2076     if (*host == 0 && *name==0)
2077         ut.ut_host[0]=0;
2078
2079     pututline(&ut);
2080     endutent();
2081 /*
2082  * Update the wtmp file.
2083  */
2084 #if __GLIBC__ >= 2
2085     updwtmp(_PATH_WTMP, &ut);
2086 #else
2087     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2088     if (wtmp >= 0) {
2089         flock(wtmp, LOCK_EX);
2090
2091         if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2092             warn("error writing %s: %m", _PATH_WTMP);
2093
2094         flock(wtmp, LOCK_UN);
2095
2096         close (wtmp);
2097     }
2098 #endif
2099 }
2100
2101
2102 /********************************************************************
2103  *
2104  * sifvjcomp - config tcp header compression
2105  */
2106
2107 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2108 {
2109     u_int x = get_flags(ppp_dev_fd);
2110
2111     if (vjcomp) {
2112         if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2113             if (! ok_error (errno))
2114                 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2115             vjcomp = 0;
2116         }
2117     }
2118
2119     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
2120     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2121     set_flags (ppp_dev_fd, x);
2122
2123     return 1;
2124 }
2125
2126 /********************************************************************
2127  *
2128  * sifup - Config the interface up and enable IP packets to pass.
2129  */
2130
2131 int sifup(int u)
2132 {
2133     struct ifreq ifr;
2134
2135     memset (&ifr, '\0', sizeof (ifr));
2136     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2137     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2138         if (! ok_error (errno))
2139             error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2140         return 0;
2141     }
2142
2143     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2144     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2145         if (! ok_error (errno))
2146             error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2147         return 0;
2148     }
2149     if_is_up++;
2150
2151     return 1;
2152 }
2153
2154 /********************************************************************
2155  *
2156  * sifdown - Disable the indicated protocol and config the interface
2157  *           down if there are no remaining protocols.
2158  */
2159
2160 int sifdown (int u)
2161 {
2162     struct ifreq ifr;
2163
2164     if (if_is_up && --if_is_up > 0)
2165         return 1;
2166
2167     memset (&ifr, '\0', sizeof (ifr));
2168     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2169     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2170         if (! ok_error (errno))
2171             error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2172         return 0;
2173     }
2174
2175     ifr.ifr_flags &= ~IFF_UP;
2176     ifr.ifr_flags |= IFF_POINTOPOINT;
2177     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2178         if (! ok_error (errno))
2179             error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2180         return 0;
2181     }
2182     return 1;
2183 }
2184
2185 /********************************************************************
2186  *
2187  * sifaddr - Config the interface IP addresses and netmask.
2188  */
2189
2190 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2191              u_int32_t net_mask)
2192 {
2193     struct ifreq   ifr;
2194     struct rtentry rt;
2195
2196     memset (&ifr, '\0', sizeof (ifr));
2197     memset (&rt,  '\0', sizeof (rt));
2198
2199     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET);
2200     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2201     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2202
2203     strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2204 /*
2205  *  Set our IP address
2206  */
2207     SIN_ADDR(ifr.ifr_addr) = our_adr;
2208     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2209         if (errno != EEXIST) {
2210             if (! ok_error (errno))
2211                 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2212         }
2213         else {
2214             warn("ioctl(SIOCSIFADDR): Address already exists");
2215         }
2216         return (0);
2217     }
2218 /*
2219  *  Set the gateway address
2220  */
2221     SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2222     if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2223         if (! ok_error (errno))
2224             error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2225         return (0);
2226     }
2227 /*
2228  *  Set the netmask.
2229  *  For recent kernels, force the netmask to 255.255.255.255.
2230  */
2231     if (kernel_version >= KVERSION(2,1,16))
2232         net_mask = ~0L;
2233     if (net_mask != 0) {
2234         SIN_ADDR(ifr.ifr_netmask) = net_mask;
2235         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2236             if (! ok_error (errno))
2237                 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2238             return (0);
2239         }
2240     }
2241 /*
2242  *  Add the device route
2243  */
2244     if (kernel_version < KVERSION(2,1,16)) {
2245         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2246         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2247         rt.rt_dev = ifname;
2248
2249         SIN_ADDR(rt.rt_gateway) = 0L;
2250         SIN_ADDR(rt.rt_dst)     = his_adr;
2251         rt.rt_flags = RTF_UP | RTF_HOST;
2252
2253         if (kernel_version > KVERSION(2,1,0)) {
2254             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2255             SIN_ADDR(rt.rt_genmask) = -1L;
2256         }
2257
2258         if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2259             if (! ok_error (errno))
2260                 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2261             return (0);
2262         }
2263     }
2264
2265     /* set ip_dynaddr in demand mode if address changes */
2266     if (demand && tune_kernel && !dynaddr_set
2267         && our_old_addr && our_old_addr != our_adr) {
2268         /* set ip_dynaddr if possible */
2269         char *path;
2270         int fd;
2271
2272         path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2273         if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2274             if (write(fd, "1", 1) != 1)
2275                 error("Couldn't enable dynamic IP addressing: %m");
2276             close(fd);
2277         }
2278         dynaddr_set = 1;        /* only 1 attempt */
2279     }
2280     our_old_addr = 0;
2281
2282     return 1;
2283 }
2284
2285 /********************************************************************
2286  *
2287  * cifaddr - Clear the interface IP addresses, and delete routes
2288  * through the interface if possible.
2289  */
2290
2291 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2292 {
2293     struct ifreq ifr;
2294
2295     if (kernel_version < KVERSION(2,1,16)) {
2296 /*
2297  *  Delete the route through the device
2298  */
2299         struct rtentry rt;
2300         memset (&rt, '\0', sizeof (rt));
2301
2302         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2303         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2304         rt.rt_dev = ifname;
2305
2306         SIN_ADDR(rt.rt_gateway) = 0;
2307         SIN_ADDR(rt.rt_dst)     = his_adr;
2308         rt.rt_flags = RTF_UP | RTF_HOST;
2309
2310         if (kernel_version > KVERSION(2,1,0)) {
2311             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2312             SIN_ADDR(rt.rt_genmask) = -1L;
2313         }
2314
2315         if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2316             if (still_ppp() && ! ok_error (errno))
2317                 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2318             return (0);
2319         }
2320     }
2321
2322     /* This way it is possible to have an IPX-only or IPv6-only interface */
2323     memset(&ifr, 0, sizeof(ifr));
2324     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2325     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2326
2327     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2328         if (! ok_error (errno)) {
2329             error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2330             return 0;
2331         }
2332     }
2333
2334     our_old_addr = our_adr;
2335
2336     return 1;
2337 }
2338
2339 #ifdef INET6
2340 /********************************************************************
2341  *
2342  * sif6addr - Config the interface with an IPv6 link-local address
2343  */
2344 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2345 {
2346     struct in6_ifreq ifr6;
2347     struct ifreq ifr;
2348     struct in6_rtmsg rt6;
2349
2350     if (sock6_fd < 0) {
2351         errno = -sock6_fd;
2352         error("IPv6 socket creation failed: %m");
2353         return 0;
2354     }
2355     memset(&ifr, 0, sizeof (ifr));
2356     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2357     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2358         error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2359         return 0;
2360     }
2361
2362     /* Local interface */
2363     memset(&ifr6, 0, sizeof(ifr6));
2364     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2365     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2366     ifr6.ifr6_prefixlen = 10;
2367
2368     if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2369         error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2370         return 0;
2371     }
2372
2373     /* Route to remote host */
2374     memset(&rt6, 0, sizeof(rt6));
2375     IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2376     rt6.rtmsg_flags = RTF_UP;
2377     rt6.rtmsg_dst_len = 10;
2378     rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2379     rt6.rtmsg_metric = 1;
2380
2381     if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2382         error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2383         return 0;
2384     }
2385
2386     return 1;
2387 }
2388
2389
2390 /********************************************************************
2391  *
2392  * cif6addr - Remove IPv6 address from interface
2393  */
2394 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2395 {
2396     struct ifreq ifr;
2397     struct in6_ifreq ifr6;
2398
2399     if (sock6_fd < 0) {
2400         errno = -sock6_fd;
2401         error("IPv6 socket creation failed: %m");
2402         return 0;
2403     }
2404     memset(&ifr, 0, sizeof(ifr));
2405     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2406     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2407         error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2408         return 0;
2409     }
2410
2411     memset(&ifr6, 0, sizeof(ifr6));
2412     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2413     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2414     ifr6.ifr6_prefixlen = 10;
2415
2416     if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2417         if (errno != EADDRNOTAVAIL) {
2418             if (! ok_error (errno))
2419                 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2420         }
2421         else {
2422             warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2423         }
2424         return (0);
2425     }
2426     return 1;
2427 }
2428 #endif /* INET6 */
2429
2430 /*
2431  * get_pty - get a pty master/slave pair and chown the slave side
2432  * to the uid given.  Assumes slave_name points to >= 16 bytes of space.
2433  */
2434 int
2435 get_pty(master_fdp, slave_fdp, slave_name, uid)
2436     int *master_fdp;
2437     int *slave_fdp;
2438     char *slave_name;
2439     int uid;
2440 {
2441     int i, mfd, sfd = -1;
2442     char pty_name[16];
2443     struct termios tios;
2444
2445 #ifdef TIOCGPTN
2446     /*
2447      * Try the unix98 way first.
2448      */
2449     mfd = open("/dev/ptmx", O_RDWR);
2450     if (mfd >= 0) {
2451         int ptn;
2452         if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2453             slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2454             chmod(pty_name, S_IRUSR | S_IWUSR);
2455 #ifdef TIOCSPTLCK
2456             ptn = 0;
2457             if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2458                 warn("Couldn't unlock pty slave %s: %m", pty_name);
2459 #endif
2460             if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2461                 warn("Couldn't open pty slave %s: %m", pty_name);
2462         }
2463     }
2464 #endif /* TIOCGPTN */
2465
2466     if (sfd < 0) {
2467         /* the old way - scan through the pty name space */
2468         for (i = 0; i < 64; ++i) {
2469             slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2470                      'p' + i / 16, i % 16);
2471             mfd = open(pty_name, O_RDWR, 0);
2472             if (mfd >= 0) {
2473                 pty_name[5] = 't';
2474                 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2475                 if (sfd >= 0) {
2476                     fchown(sfd, uid, -1);
2477                     fchmod(sfd, S_IRUSR | S_IWUSR);
2478                     break;
2479                 }
2480                 close(mfd);
2481             }
2482         }
2483     }
2484
2485     if (sfd < 0)
2486         return 0;
2487
2488     strlcpy(slave_name, pty_name, 16);
2489     *master_fdp = mfd;
2490     *slave_fdp = sfd;
2491     if (tcgetattr(sfd, &tios) == 0) {
2492         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2493         tios.c_cflag |= CS8 | CREAD | CLOCAL;
2494         tios.c_iflag  = IGNPAR;
2495         tios.c_oflag  = 0;
2496         tios.c_lflag  = 0;
2497         if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2498             warn("couldn't set attributes on pty: %m");
2499     } else
2500         warn("couldn't get attributes on pty: %m");
2501
2502     return 1;
2503 }
2504
2505 /********************************************************************
2506  *
2507  * open_loopback - open the device we use for getting packets
2508  * in demand mode.  Under Linux, we use a pty master/slave pair.
2509  */
2510 int
2511 open_ppp_loopback(void)
2512 {
2513     int flags;
2514
2515     looped = 1;
2516     if (new_style_driver) {
2517         /* allocate ourselves a ppp unit */
2518         if (make_ppp_unit() < 0)
2519             die(1);
2520         set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2521         set_kdebugflag(kdebugflag);
2522         ppp_fd = -1;
2523         return ppp_dev_fd;
2524     }
2525
2526     if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2527         fatal("No free pty for loopback");
2528     SYSDEBUG(("using %s for loopback", loop_name));
2529
2530     set_ppp_fd(slave_fd);
2531
2532     flags = fcntl(master_fd, F_GETFL);
2533     if (flags == -1 ||
2534         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2535         warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2536
2537     flags = fcntl(ppp_fd, F_GETFL);
2538     if (flags == -1 ||
2539         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2540         warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2541
2542     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2543         fatal("ioctl(TIOCSETD): %m(%d)", errno);
2544 /*
2545  * Find out which interface we were given.
2546  */
2547     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2548         fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2549 /*
2550  * Enable debug in the driver if requested.
2551  */
2552     set_kdebugflag (kdebugflag);
2553
2554     return master_fd;
2555 }
2556
2557 /********************************************************************
2558  *
2559  * restore_loop - reattach the ppp unit to the loopback.
2560  *
2561  * The kernel ppp driver automatically reattaches the ppp unit to
2562  * the loopback if the serial port is set to a line discipline other
2563  * than ppp, or if it detects a modem hangup.  The former will happen
2564  * in disestablish_ppp if the latter hasn't already happened, so we
2565  * shouldn't need to do anything.
2566  *
2567  * Just to be sure, set the real serial port to the normal discipline.
2568  */
2569
2570 static void
2571 restore_loop(void)
2572 {
2573     looped = 1;
2574     if (new_style_driver) {
2575         set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2576         return;
2577     }
2578     if (ppp_fd != slave_fd) {
2579         (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2580         set_ppp_fd(slave_fd);
2581     }
2582 }
2583
2584 /********************************************************************
2585  *
2586  * sifnpmode - Set the mode for handling packets for a given NP.
2587  */
2588
2589 int
2590 sifnpmode(u, proto, mode)
2591     int u;
2592     int proto;
2593     enum NPmode mode;
2594 {
2595     struct npioctl npi;
2596
2597     npi.protocol = proto;
2598     npi.mode     = mode;
2599     if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2600         if (! ok_error (errno))
2601             error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2602                    proto, mode, errno);
2603         return 0;
2604     }
2605     return 1;
2606 }
2607
2608 \f
2609 /********************************************************************
2610  *
2611  * sipxfaddr - Config the interface IPX networknumber
2612  */
2613
2614 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2615 {
2616     int    result = 1;
2617
2618 #ifdef IPX_CHANGE
2619     int    skfd;
2620     struct ifreq         ifr;
2621     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2622
2623     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2624     if (skfd < 0) {
2625         if (! ok_error (errno))
2626             dbglog("socket(AF_IPX): %m (%d)", errno);
2627         result = 0;
2628     }
2629     else {
2630         memset (&ifr, '\0', sizeof (ifr));
2631         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2632
2633         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2634         sipx->sipx_family  = AF_IPX;
2635         sipx->sipx_port    = 0;
2636         sipx->sipx_network = htonl (network);
2637         sipx->sipx_type    = IPX_FRAME_ETHERII;
2638         sipx->sipx_action  = IPX_CRTITF;
2639 /*
2640  *  Set the IPX device
2641  */
2642         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2643             result = 0;
2644             if (errno != EEXIST) {
2645                 if (! ok_error (errno))
2646                     dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2647             }
2648             else {
2649                 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2650             }
2651         }
2652         close (skfd);
2653     }
2654 #endif
2655     return result;
2656 }
2657
2658 /********************************************************************
2659  *
2660  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2661  *             are removed and the device is no longer able to pass IPX
2662  *             frames.
2663  */
2664
2665 int cipxfaddr (int unit)
2666 {
2667     int    result = 1;
2668
2669 #ifdef IPX_CHANGE
2670     int    skfd;
2671     struct ifreq         ifr;
2672     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2673
2674     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2675     if (skfd < 0) {
2676         if (! ok_error (errno))
2677             dbglog("socket(AF_IPX): %m (%d)", errno);
2678         result = 0;
2679     }
2680     else {
2681         memset (&ifr, '\0', sizeof (ifr));
2682         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2683
2684         sipx->sipx_type    = IPX_FRAME_ETHERII;
2685         sipx->sipx_action  = IPX_DLTITF;
2686         sipx->sipx_family  = AF_IPX;
2687 /*
2688  *  Set the IPX device
2689  */
2690         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2691             if (! ok_error (errno))
2692                 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2693             result = 0;
2694         }
2695         close (skfd);
2696     }
2697 #endif
2698     return result;
2699 }
2700
2701 /*
2702  * Use the hostname as part of the random number seed.
2703  */
2704 int
2705 get_host_seed()
2706 {
2707     int h;
2708     char *p = hostname;
2709
2710     h = 407;
2711     for (p = hostname; *p != 0; ++p)
2712         h = h * 37 + *p;
2713     return h;
2714 }
2715
2716 /********************************************************************
2717  *
2718  * sys_check_options - check the options that the user specified
2719  */
2720
2721 int
2722 sys_check_options(void)
2723 {
2724 #ifdef IPX_CHANGE
2725 /*
2726  * Disable the IPX protocol if the support is not present in the kernel.
2727  */
2728     char *path;
2729
2730     if (ipxcp_protent.enabled_flag) {
2731         struct stat stat_buf;
2732         if ((path = path_to_procfs("/net/ipx_interface")) == 0
2733             || lstat(path, &stat_buf) < 0) {
2734             error("IPX support is not present in the kernel\n");
2735             ipxcp_protent.enabled_flag = 0;
2736         }
2737     }
2738 #endif
2739     if (demand && driver_is_old) {
2740         option_error("demand dialling is not supported by kernel driver "
2741                      "version %d.%d.%d", driver_version, driver_modification,
2742                      driver_patch);
2743         return 0;
2744     }
2745     if (multilink && !new_style_driver) {
2746         warn("Warning: multilink is not supported by the kernel driver");
2747         multilink = 0;
2748     }
2749     return 1;
2750 }