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