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