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