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) 1994-2004 Paul Mackerras. All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. The name(s) of the authors of this software must not be used to
  15  *    endorse or promote products derived from this software without
  16  *    prior written permission.
  17  *
  18  * 3. Redistributions of any form whatsoever must retain the following
  19  *    acknowledgment:
  20  *    "This product includes software developed by Paul Mackerras
  21  *     <paulus@samba.org>".
  22  *
  23  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  24  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  25  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  26  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  27  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  28  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  29  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  30  *
  31  * Derived from main.c and pppd.h, which are:
  32  *
  33  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  *
  39  * 1. Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  *
  42  * 2. Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in
  44  *    the documentation and/or other materials provided with the
  45  *    distribution.
  46  *
  47  * 3. The name "Carnegie Mellon University" must not be used to
  48  *    endorse or promote products derived from this software without
  49  *    prior written permission. For permission or any legal
  50  *    details, please contact
  51  *      Office of Technology Transfer
  52  *      Carnegie Mellon University
  53  *      5000 Forbes Avenue
  54  *      Pittsburgh, PA  15213-3890
  55  *      (412) 268-4387, fax: (412) 268-7395
  56  *      tech-transfer@andrew.cmu.edu
  57  *
  58  * 4. Redistributions of any form whatsoever must retain the following
  59  *    acknowledgment:
  60  *    "This product includes software developed by Computing Services
  61  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
  62  *
  63  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
  64  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  65  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
  66  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  67  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  68  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  69  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  70  */
  71
  72 #include <sys/ioctl.h>
  73 #include <sys/types.h>
  74 #include <sys/socket.h>
  75 #include <sys/time.h>
  76 #include <sys/file.h>
  77 #include <sys/stat.h>
  78 #include <sys/utsname.h>
  79 #include <sys/sysmacros.h>
  80
  81 #include <errno.h>
  82 #include <stdio.h>
  83 #include <stdlib.h>
  84 #include <syslog.h>
  85 #include <string.h>
  86 #include <time.h>
  87 #include <memory.h>
  88 #include <utmp.h>
  89 #include <mntent.h>
  90 #include <signal.h>
  91 #include <fcntl.h>
  92 #include <ctype.h>
  93 #include <termios.h>
  94 #include <unistd.h>
  95
  96 /* This is in netdevice.h. However, this compile will fail miserably if
  97    you attempt to include netdevice.h because it has so many references
  98    to __memcpy functions which it should not attempt to do. So, since I
  99    really don't use it, but it must be defined, define it now. */
 100
 101 #ifndef MAX_ADDR_LEN
 102 #define MAX_ADDR_LEN 7
 103 #endif
 104
 105 #if !defined(__GLIBC__) || __GLIBC__ >= 2
 106 #include <asm/types.h>          /* glibc 2 conflicts with linux/types.h */
 107 #include <asm/ioctls.h>
 108 #include <net/if.h>
 109 #include <net/if_arp.h>
 110 #include <net/route.h>
 111 #include <netinet/if_ether.h>
 112 #else
 113 #include <linux/types.h>
 114 #include <linux/if.h>
 115 #include <linux/if_arp.h>
 116 #include <linux/route.h>
 117 #include <linux/if_ether.h>
 118 #endif
 119 #include <netinet/in.h>
 120 #include <arpa/inet.h>
 121
 122 #include <linux/ppp_defs.h>
 123 #include <linux/if_ppp.h>
 124
 125 #ifdef INET6
 126 #include <linux/netlink.h>
 127 #include <linux/rtnetlink.h>
 128 #include <linux/if_addr.h>
 129 /* glibc versions prior to 2.24 do not define SOL_NETLINK */
 130 #ifndef SOL_NETLINK
 131 #define SOL_NETLINK 270
 132 #endif
 133 /* linux kernel versions prior to 4.3 do not define/support NETLINK_CAP_ACK */
 134 #ifndef NETLINK_CAP_ACK
 135 #define NETLINK_CAP_ACK 10
 136 #endif
 137 #endif
 138
 139 #include "pppd.h"
 140 #include "fsm.h"
 141 #include "ipcp.h"
 142
 143 #ifdef IPX_CHANGE
 144 #include "ipxcp.h"
 145 #if __GLIBC__ >= 2 && \
 146     !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
 147 #include <netipx/ipx.h>
 148 #else
 149 #include <linux/ipx.h>
 150 #endif
 151 #endif /* IPX_CHANGE */
 152
 153 #ifdef PPP_FILTER
 154 #include <pcap-bpf.h>
 155 #include <linux/filter.h>
 156 #endif /* PPP_FILTER */
 157
 158 #ifdef LOCKLIB
 159 #include <sys/locks.h>
 160 #endif
 161
 162 #ifndef BOTHER
 163 #define BOTHER 0010000
 164 #endif
 165 struct termios2 {
 166         unsigned int c_iflag;
 167         unsigned int c_oflag;
 168         unsigned int c_cflag;
 169         unsigned int c_lflag;
 170         unsigned char c_line;
 171         unsigned char c_cc[19];
 172         unsigned int c_ispeed;
 173         unsigned int c_ospeed;
 174 };
 175
 176 #ifdef INET6
 177 #ifndef _LINUX_IN6_H
 178 /*
 179  *    This is in linux/include/net/ipv6.h.
 180  */
 181
 182 struct in6_ifreq {
 183     struct in6_addr ifr6_addr;
 184     __u32 ifr6_prefixlen;
 185     unsigned int ifr6_ifindex;
 186 };
 187 #endif
 188
 189 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do {                 \
 190         memset(&(sin6).s6_addr, 0, sizeof(struct in6_addr));    \
 191         (sin6).s6_addr16[0] = htons(0xfe80);                    \
 192         eui64_copy(eui64, (sin6).s6_addr32[2]);                 \
 193         } while (0)
 194
 195 static const eui64_t nulleui64;
 196 #endif /* INET6 */
 197
 198 /* We can get an EIO error on an ioctl if the modem has hung up */
 199 #define ok_error(num) ((num)==EIO)
 200
 201 static int tty_disc = N_TTY;    /* The TTY discipline */
 202 static int ppp_disc = N_PPP;    /* The PPP discpline */
 203 static int initfdflags = -1;    /* Initial file descriptor flags for fd */
 204 static int ppp_fd = -1;         /* fd which is set to PPP discipline */
 205 static int sock_fd = -1;        /* socket for doing interface ioctls */
 206 static int slave_fd = -1;       /* pty for old-style demand mode, slave */
 207 static int master_fd = -1;      /* pty for old-style demand mode, master */
 208 #ifdef INET6
 209 static int sock6_fd = -1;
 210 #endif /* INET6 */
 211
 212 /*
 213  * For the old-style kernel driver, this is the same as ppp_fd.
 214  * For the new-style driver, it is the fd of an instance of /dev/ppp
 215  * which is attached to the ppp unit and is used for controlling it.
 216  */
 217 int ppp_dev_fd = -1;            /* fd for /dev/ppp (new style driver) */
 218
 219 static int chindex;             /* channel index (new style driver) */
 220
 221 static fd_set in_fds;           /* set of fds that wait_input waits for */
 222 static int max_in_fd;           /* highest fd set in in_fds */
 223
 224 static int has_proxy_arp       = 0;
 225 static int driver_version      = 0;
 226 static int driver_modification = 0;
 227 static int driver_patch        = 0;
 228 static int driver_is_old       = 0;
 229 static int restore_term        = 0;     /* 1 => we've munged the terminal */
 230 static struct termios inittermios;      /* Initial TTY termios */
 231
 232 int new_style_driver = 0;
 233
 234 static char loop_name[20];
 235 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
 236
 237 static int      if_is_up;       /* Interface has been marked up */
 238 static int      if6_is_up;      /* Interface has been marked up for IPv6, to help differentiate */
 239 static int      have_default_route;     /* Gateway for default route added */
 240 static int      have_default_route6;    /* Gateway for default IPv6 route added */
 241 static struct   rtentry old_def_rt;     /* Old default route */
 242 static int      default_rt_repl_rest;   /* replace and restore old default rt */
 243 static u_int32_t proxy_arp_addr;        /* Addr for proxy arp entry added */
 244 static char proxy_arp_dev[16];          /* Device for proxy arp entry */
 245 static u_int32_t our_old_addr;          /* for detecting address changes */
 246 static int      dynaddr_set;            /* 1 if ip_dynaddr set */
 247 static int      looped;                 /* 1 if using loop */
 248 static int      link_mtu;               /* mtu for the link (not bundle) */
 249
 250 static struct utsname utsname;  /* for the kernel version */
 251 static int kernel_version;
 252 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
 253
 254 #define MAX_IFS         100
 255
 256 #define FLAGS_GOOD (IFF_UP          | IFF_BROADCAST)
 257 #define FLAGS_MASK (IFF_UP          | IFF_BROADCAST | \
 258                     IFF_POINTOPOINT | IFF_LOOPBACK  | IFF_NOARP)
 259
 260 #define SIN_ADDR(x)     (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
 261
 262 /* Prototypes for procedures local to this file. */
 263 static int modify_flags(int fd, int clear_bits, int set_bits);
 264 static int translate_speed (int bps);
 265 static int baud_rate_of (int speed);
 266 static void close_route_table (void);
 267 static int open_route_table (void);
 268 static int read_route_table (struct rtentry *rt);
 269 static int defaultroute_exists (struct rtentry *rt, int metric);
 270 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric);
 271 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
 272                            char *name, int namelen);
 273 static void decode_version (char *buf, int *version, int *mod, int *patch);
 274 static int set_kdebugflag(int level);
 275 static int ppp_registered(void);
 276 static int make_ppp_unit(void);
 277 static int setifstate (int u, int state);
 278
 279 extern u_char   inpacket_buf[]; /* borrowed from main.c */
 280
 281 extern int dfl_route_metric;
 282
 283 /*
 284  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
 285  * if it exists.
 286  */
 287
 288 #define SET_SA_FAMILY(addr, family)                     \
 289     memset ((char *) &(addr), '\0', sizeof(addr));      \
 290     addr.sa_family = (family);
 291
 292 /*
 293  * Determine if the PPP connection should still be present.
 294  */
 295
 296 extern int hungup;
 297
 298 /* new_fd is the fd of a tty */
 299 static void set_ppp_fd (int new_fd)
 300 {
 301         ppp_fd = new_fd;
 302         if (!new_style_driver)
 303                 ppp_dev_fd = new_fd;
 304 }
 305
 306 static int still_ppp(void)
 307 {
 308         if (new_style_driver)
 309                 return !hungup && ppp_fd >= 0;
 310         if (!hungup || ppp_fd == slave_fd)
 311                 return 1;
 312         if (slave_fd >= 0) {
 313                 set_ppp_fd(slave_fd);
 314                 return 1;
 315         }
 316         return 0;
 317 }
 318
 319 /*
 320  * modify_flags - set and clear flag bits controlling the kernel
 321  * PPP driver.
 322  */
 323 static int modify_flags(int fd, int clear_bits, int set_bits)
 324 {
 325         int flags;
 326
 327         if (ioctl(fd, PPPIOCGFLAGS, &flags) == -1)
 328                 goto err;
 329         flags = (flags & ~clear_bits) | set_bits;
 330         if (ioctl(fd, PPPIOCSFLAGS, &flags) == -1)
 331                 goto err;
 332
 333         return 0;
 334
 335  err:
 336         if (errno != EIO)
 337                 error("Failed to set PPP kernel option flags: %m");
 338         return -1;
 339 }
 340
 341 /********************************************************************
 342  *
 343  * sys_init - System-dependent initialization.
 344  */
 345
 346 void sys_init(void)
 347 {
 348     /* Get an internet socket for doing socket ioctls. */
 349     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 350     if (sock_fd < 0)
 351         fatal("Couldn't create IP socket: %m(%d)", errno);
 352
 353 #ifdef INET6
 354     sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
 355     if (sock6_fd < 0)
 356         sock6_fd = -errno;      /* save errno for later */
 357 #endif
 358
 359     FD_ZERO(&in_fds);
 360     max_in_fd = 0;
 361 }
 362
 363 /********************************************************************
 364  *
 365  * sys_cleanup - restore any system state we modified before exiting:
 366  * mark the interface down, delete default route and/or proxy arp entry.
 367  * This shouldn't call die() because it's called from die().
 368  */
 369
 370 void sys_cleanup(void)
 371 {
 372 /*
 373  * Take down the device
 374  */
 375     if (if_is_up) {
 376         if_is_up = 0;
 377         sifdown(0);
 378     }
 379     if (if6_is_up)
 380         sif6down(0);
 381
 382 /*
 383  * Delete any routes through the device.
 384  */
 385     if (have_default_route)
 386         cifdefaultroute(0, 0, 0);
 387 #ifdef INET6
 388     if (have_default_route6)
 389         cif6defaultroute(0, nulleui64, nulleui64);
 390 #endif
 391
 392     if (has_proxy_arp)
 393         cifproxyarp(0, proxy_arp_addr);
 394 }
 395
 396 /********************************************************************
 397  *
 398  * sys_close - Clean up in a child process before execing.
 399  */
 400 void
 401 sys_close(void)
 402 {
 403     if (new_style_driver && ppp_dev_fd >= 0)
 404         close(ppp_dev_fd);
 405     if (sock_fd >= 0)
 406         close(sock_fd);
 407 #ifdef INET6
 408     if (sock6_fd >= 0)
 409         close(sock6_fd);
 410 #endif
 411     if (slave_fd >= 0)
 412         close(slave_fd);
 413     if (master_fd >= 0)
 414         close(master_fd);
 415 }
 416
 417 /********************************************************************
 418  *
 419  * set_kdebugflag - Define the debugging level for the kernel
 420  */
 421
 422 static int set_kdebugflag (int requested_level)
 423 {
 424     if (ppp_dev_fd < 0)
 425         return 1;
 426     if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
 427         if ( ! ok_error (errno) )
 428             error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
 429         return (0);
 430     }
 431     return (1);
 432 }
 433
 434 /********************************************************************
 435  *
 436  * tty_establish_ppp - Turn the serial port into a ppp interface.
 437  */
 438
 439 int tty_establish_ppp (int tty_fd)
 440 {
 441     int ret_fd;
 442
 443 /*
 444  * Ensure that the tty device is in exclusive mode.
 445  */
 446     if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
 447         if ( ! ok_error ( errno ))
 448             warn("Couldn't make tty exclusive: %m");
 449     }
 450 /*
 451  * Demand mode - prime the old ppp device to relinquish the unit.
 452  */
 453     if (!new_style_driver && looped
 454         && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
 455         error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
 456         return -1;
 457     }
 458 /*
 459  * Set the current tty to the PPP discpline
 460  */
 461
 462 #ifndef N_SYNC_PPP
 463 #define N_SYNC_PPP 14
 464 #endif
 465     ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
 466     if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
 467         if ( ! ok_error (errno) ) {
 468             error("Couldn't set tty to PPP discipline: %m");
 469             return -1;
 470         }
 471     }
 472
 473     ret_fd = generic_establish_ppp(tty_fd);
 474
 475 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
 476 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
 477                  | SC_LOG_FLUSH)
 478
 479     if (ret_fd >= 0) {
 480         modify_flags(ppp_fd, SC_RCVB | SC_LOGB,
 481                      (kdebugflag * SC_DEBUG) & SC_LOGB);
 482     } else {
 483         if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
 484             warn("Couldn't reset tty to normal line discipline: %m");
 485     }
 486
 487     return ret_fd;
 488 }
 489
 490 /********************************************************************
 491  *
 492  * generic_establish_ppp - Turn the fd into a ppp interface.
 493  */
 494 int generic_establish_ppp (int fd)
 495 {
 496     int x;
 497
 498     if (new_style_driver) {
 499         int flags;
 500
 501         /* If a ppp_fd is already open, close it first */
 502         if (ppp_fd >= 0) {
 503             close(ppp_fd);
 504             remove_fd(ppp_fd);
 505             ppp_fd = -1;
 506         }
 507
 508         /* Open an instance of /dev/ppp and connect the channel to it */
 509         if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
 510             error("Couldn't get channel number: %m");
 511             goto err;
 512         }
 513         dbglog("using channel %d", chindex);
 514         fd = open("/dev/ppp", O_RDWR);
 515         if (fd < 0) {
 516             error("Couldn't reopen /dev/ppp: %m");
 517             goto err;
 518         }
 519         (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
 520         if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
 521             error("Couldn't attach to channel %d: %m", chindex);
 522             goto err_close;
 523         }
 524         flags = fcntl(fd, F_GETFL);
 525         if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
 526             warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
 527         set_ppp_fd(fd);
 528
 529         if (!looped)
 530             ifunit = -1;
 531         if (!looped && !multilink) {
 532             /*
 533              * Create a new PPP unit.
 534              */
 535             if (make_ppp_unit() < 0)
 536                 goto err_close;
 537         }
 538
 539         if (looped)
 540             modify_flags(ppp_dev_fd, SC_LOOP_TRAFFIC, 0);
 541
 542         if (!multilink) {
 543             add_fd(ppp_dev_fd);
 544             if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
 545                 error("Couldn't attach to PPP unit %d: %m", ifunit);
 546                 goto err_close;
 547             }
 548         }
 549
 550     } else {
 551         /*
 552          * Old-style driver: find out which interface we were given.
 553          */
 554         set_ppp_fd (fd);
 555         if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
 556             if (ok_error (errno))
 557                 goto err;
 558             fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
 559         }
 560         /* Check that we got the same unit again. */
 561         if (looped && x != ifunit)
 562             fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
 563         ifunit = x;
 564
 565         /*
 566          * Fetch the initial file flags and reset blocking mode on the file.
 567          */
 568         initfdflags = fcntl(fd, F_GETFL);
 569         if (initfdflags == -1 ||
 570             fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
 571             if ( ! ok_error (errno))
 572                 warn("Couldn't set device to non-blocking mode: %m");
 573         }
 574     }
 575
 576     /*
 577      * Enable debug in the driver if requested.
 578      */
 579     if (!looped)
 580         set_kdebugflag (kdebugflag);
 581
 582     looped = 0;
 583
 584     return ppp_fd;
 585
 586  err_close:
 587     close(fd);
 588  err:
 589     return -1;
 590 }
 591
 592 /********************************************************************
 593  *
 594  * tty_disestablish_ppp - Restore the serial port to normal operation.
 595  * This shouldn't call die() because it's called from die().
 596  */
 597
 598 void tty_disestablish_ppp(int tty_fd)
 599 {
 600     if (!hungup) {
 601 /*
 602  * Flush the tty output buffer so that the TIOCSETD doesn't hang.
 603  */
 604         if (tcflush(tty_fd, TCIOFLUSH) < 0)
 605         {
 606             warn("tcflush failed: %m");
 607             goto flushfailed;
 608         }
 609 /*
 610  * Restore the previous line discipline
 611  */
 612         if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
 613             if ( ! ok_error (errno))
 614                 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
 615         }
 616
 617         if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
 618             if ( ! ok_error (errno))
 619                 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
 620         }
 621
 622         /* Reset non-blocking mode on fd. */
 623         if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
 624             if ( ! ok_error (errno))
 625                 warn("Couldn't restore device fd flags: %m");
 626         }
 627     }
 628 flushfailed:
 629     initfdflags = -1;
 630
 631     generic_disestablish_ppp(tty_fd);
 632 }
 633
 634 /********************************************************************
 635  *
 636  * generic_disestablish_ppp - Restore device components to normal
 637  * operation, and reconnect the ppp unit to the loopback if in demand
 638  * mode.  This shouldn't call die() because it's called from die().
 639  */
 640 void generic_disestablish_ppp(int dev_fd)
 641 {
 642     if (new_style_driver) {
 643         close(ppp_fd);
 644         ppp_fd = -1;
 645         if (demand) {
 646             modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
 647             looped = 1;
 648         } else if (!doing_multilink && ppp_dev_fd >= 0) {
 649             close(ppp_dev_fd);
 650             remove_fd(ppp_dev_fd);
 651             ppp_dev_fd = -1;
 652         }
 653     } else {
 654         /* old-style driver */
 655         if (demand)
 656             set_ppp_fd(slave_fd);
 657         else
 658             ppp_dev_fd = -1;
 659     }
 660 }
 661
 662 /*
 663  * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
 664  * Assumes new_style_driver.
 665  */
 666 static int make_ppp_unit(void)
 667 {
 668         int x, flags;
 669
 670         if (ppp_dev_fd >= 0) {
 671                 dbglog("in make_ppp_unit, already had /dev/ppp open?");
 672                 close(ppp_dev_fd);
 673         }
 674         ppp_dev_fd = open("/dev/ppp", O_RDWR);
 675         if (ppp_dev_fd < 0)
 676                 fatal("Couldn't open /dev/ppp: %m");
 677         flags = fcntl(ppp_dev_fd, F_GETFL);
 678         if (flags == -1
 679             || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
 680                 warn("Couldn't set /dev/ppp to nonblock: %m");
 681
 682         ifunit = req_unit;
 683         x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
 684         if (x < 0 && req_unit >= 0 && errno == EEXIST) {
 685                 warn("Couldn't allocate PPP unit %d as it is already in use", req_unit);
 686                 ifunit = -1;
 687                 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
 688         }
 689         if (x < 0)
 690                 error("Couldn't create new ppp unit: %m");
 691
 692         if (x == 0 && req_ifname[0] != '\0') {
 693                 struct ifreq ifr;
 694                 char t[MAXIFNAMELEN];
 695                 memset(&ifr, 0, sizeof(struct ifreq));
 696                 slprintf(t, sizeof(t), "%s%d", PPP_DRV_NAME, ifunit);
 697                 strlcpy(ifr.ifr_name, t, IF_NAMESIZE);
 698                 strlcpy(ifr.ifr_newname, req_ifname, IF_NAMESIZE);
 699                 x = ioctl(sock_fd, SIOCSIFNAME, &ifr);
 700                 if (x < 0)
 701                     error("Couldn't rename interface %s to %s: %m", t, req_ifname);
 702                 else
 703                     info("Renamed interface %s to %s", t, req_ifname);
 704         }
 705
 706         return x;
 707 }
 708
 709 /*
 710  * cfg_bundle - configure the existing bundle.
 711  * Used in demand mode.
 712  */
 713 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
 714 {
 715         if (!new_style_driver)
 716                 return;
 717
 718         /* set the mrru, mtu and flags */
 719         if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
 720                 error("Couldn't set MRRU: %m");
 721
 722         modify_flags(ppp_dev_fd, SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ|SC_MULTILINK,
 723                      ((rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
 724                       | (mrru? SC_MULTILINK: 0)));
 725
 726         /* connect up the channel */
 727         if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
 728                 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
 729         add_fd(ppp_dev_fd);
 730 }
 731
 732 /*
 733  * make_new_bundle - create a new PPP unit (i.e. a bundle)
 734  * and connect our channel to it.  This should only get called
 735  * if `multilink' was set at the time establish_ppp was called.
 736  * In demand mode this uses our existing bundle instead of making
 737  * a new one.
 738  */
 739 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
 740 {
 741         if (!new_style_driver)
 742                 return;
 743
 744         /* make us a ppp unit */
 745         if (make_ppp_unit() < 0)
 746                 die(1);
 747
 748         /* set the mrru and flags */
 749         cfg_bundle(mrru, mtru, rssn, tssn);
 750 }
 751
 752 /*
 753  * bundle_attach - attach our link to a given PPP unit.
 754  * We assume the unit is controlled by another pppd.
 755  */
 756 int bundle_attach(int ifnum)
 757 {
 758         int master_fd;
 759
 760         if (!new_style_driver)
 761                 return -1;
 762
 763         master_fd = open("/dev/ppp", O_RDWR);
 764         if (master_fd < 0)
 765                 fatal("Couldn't open /dev/ppp: %m");
 766         if (ioctl(master_fd, PPPIOCATTACH, &ifnum) < 0) {
 767                 if (errno == ENXIO) {
 768                         close(master_fd);
 769                         return 0;       /* doesn't still exist */
 770                 }
 771                 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
 772         }
 773         if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
 774                 fatal("Couldn't connect to interface unit %d: %m", ifnum);
 775         modify_flags(master_fd, 0, SC_MULTILINK);
 776         close(master_fd);
 777
 778         ifunit = ifnum;
 779         return 1;
 780 }
 781
 782 /*
 783  * destroy_bundle - tell the driver to destroy our bundle.
 784  */
 785 void destroy_bundle(void)
 786 {
 787         if (ppp_dev_fd >= 0) {
 788                 close(ppp_dev_fd);
 789                 remove_fd(ppp_dev_fd);
 790                 ppp_dev_fd = -1;
 791         }
 792 }
 793
 794 /********************************************************************
 795  *
 796  * clean_check - Fetch the flags for the device and generate
 797  * appropriate error messages.
 798  */
 799 void clean_check(void)
 800 {
 801     int x;
 802     char *s;
 803
 804     if (still_ppp()) {
 805         if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
 806             s = NULL;
 807             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
 808             case SC_RCV_B7_0:
 809                 s = "all had bit 7 set to 1";
 810                 break;
 811
 812             case SC_RCV_B7_1:
 813                 s = "all had bit 7 set to 0";
 814                 break;
 815
 816             case SC_RCV_EVNP:
 817                 s = "all had odd parity";
 818                 break;
 819
 820             case SC_RCV_ODDP:
 821                 s = "all had even parity";
 822                 break;
 823             }
 824
 825             if (s != NULL) {
 826                 warn("Receive serial link is not 8-bit clean:");
 827                 warn("Problem: %s", s);
 828             }
 829         }
 830     }
 831 }
 832
 833
 834 /*
 835  * List of valid speeds.
 836  */
 837
 838 struct speed {
 839     int speed_int, speed_val;
 840 } speeds[] = {
 841 #ifdef B50
 842     { 50, B50 },
 843 #endif
 844 #ifdef B75
 845     { 75, B75 },
 846 #endif
 847 #ifdef B110
 848     { 110, B110 },
 849 #endif
 850 #ifdef B134
 851     { 134, B134 },
 852 #endif
 853 #ifdef B150
 854     { 150, B150 },
 855 #endif
 856 #ifdef B200
 857     { 200, B200 },
 858 #endif
 859 #ifdef B300
 860     { 300, B300 },
 861 #endif
 862 #ifdef B600
 863     { 600, B600 },
 864 #endif
 865 #ifdef B1200
 866     { 1200, B1200 },
 867 #endif
 868 #ifdef B1800
 869     { 1800, B1800 },
 870 #endif
 871 #ifdef B2000
 872     { 2000, B2000 },
 873 #endif
 874 #ifdef B2400
 875     { 2400, B2400 },
 876 #endif
 877 #ifdef B3600
 878     { 3600, B3600 },
 879 #endif
 880 #ifdef B4800
 881     { 4800, B4800 },
 882 #endif
 883 #ifdef B7200
 884     { 7200, B7200 },
 885 #endif
 886 #ifdef B9600
 887     { 9600, B9600 },
 888 #endif
 889 #ifdef B19200
 890     { 19200, B19200 },
 891 #endif
 892 #ifdef B38400
 893     { 38400, B38400 },
 894 #endif
 895 #ifdef B57600
 896     { 57600, B57600 },
 897 #endif
 898 #ifdef B76800
 899     { 76800, B76800 },
 900 #endif
 901 #ifdef B115200
 902     { 115200, B115200 },
 903 #endif
 904 #ifdef EXTA
 905     { 19200, EXTA },
 906 #endif
 907 #ifdef EXTB
 908     { 38400, EXTB },
 909 #endif
 910 #ifdef B230400
 911     { 230400, B230400 },
 912 #endif
 913 #ifdef B460800
 914     { 460800, B460800 },
 915 #endif
 916 #ifdef B500000
 917     { 500000, B500000 },
 918 #endif
 919 #ifdef B576000
 920     { 576000, B576000 },
 921 #endif
 922 #ifdef B921600
 923     { 921600, B921600 },
 924 #endif
 925 #ifdef B1000000
 926     { 1000000, B1000000 },
 927 #endif
 928 #ifdef B1152000
 929     { 1152000, B1152000 },
 930 #endif
 931 #ifdef B1500000
 932     { 1500000, B1500000 },
 933 #endif
 934 #ifdef B2000000
 935     { 2000000, B2000000 },
 936 #endif
 937 #ifdef B2500000
 938     { 2500000, B2500000 },
 939 #endif
 940 #ifdef B3000000
 941     { 3000000, B3000000 },
 942 #endif
 943 #ifdef B3500000
 944     { 3500000, B3500000 },
 945 #endif
 946 #ifdef B4000000
 947     { 4000000, B4000000 },
 948 #endif
 949     { 0, 0 }
 950 };
 951
 952 /********************************************************************
 953  *
 954  * Translate from bits/second to a speed_t.
 955  */
 956
 957 static int translate_speed (int bps)
 958 {
 959     struct speed *speedp;
 960
 961     if (bps != 0) {
 962         for (speedp = speeds; speedp->speed_int; speedp++) {
 963             if (bps == speedp->speed_int)
 964                 return speedp->speed_val;
 965         }
 966     }
 967     return 0;
 968 }
 969
 970 /********************************************************************
 971  *
 972  * Translate from a speed_t to bits/second.
 973  */
 974
 975 static int baud_rate_of (int speed)
 976 {
 977     struct speed *speedp;
 978
 979     if (speed != 0) {
 980         for (speedp = speeds; speedp->speed_int; speedp++) {
 981             if (speed == speedp->speed_val)
 982                 return speedp->speed_int;
 983         }
 984     }
 985     return 0;
 986 }
 987
 988 /********************************************************************
 989  *
 990  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
 991  * at the requested speed, etc.  If `local' is true, set CLOCAL
 992  * regardless of whether the modem option was specified.
 993  */
 994
 995 void set_up_tty(int tty_fd, int local)
 996 {
 997     int speed;
 998     struct termios tios;
 999
1000     setdtr(tty_fd, 1);
1001     if (tcgetattr(tty_fd, &tios) < 0) {
1002         if (!ok_error(errno))
1003             fatal("tcgetattr: %m (line %d)", __LINE__);
1004         return;
1005     }
1006
1007     if (!restore_term)
1008         inittermios = tios;
1009
1010     tios.c_cflag     &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1011     tios.c_cflag     |= CS8 | CREAD | HUPCL;
1012
1013     tios.c_iflag      = IGNBRK | IGNPAR;
1014     tios.c_oflag      = 0;
1015     tios.c_lflag      = 0;
1016     tios.c_cc[VMIN]   = 1;
1017     tios.c_cc[VTIME]  = 0;
1018
1019     if (local || !modem)
1020         tios.c_cflag ^= (CLOCAL | HUPCL);
1021
1022     switch (crtscts) {
1023     case 1:
1024         tios.c_cflag |= CRTSCTS;
1025         break;
1026
1027     case -2:
1028         tios.c_iflag     |= IXON | IXOFF;
1029         tios.c_cc[VSTOP]  = 0x13;       /* DC3 = XOFF = ^S */
1030         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
1031         break;
1032
1033     case -1:
1034         tios.c_cflag &= ~CRTSCTS;
1035         break;
1036
1037     default:
1038         break;
1039     }
1040
1041     if (stop_bits >= 2)
1042         tios.c_cflag |= CSTOPB;
1043
1044     if (inspeed) {
1045         speed = translate_speed(inspeed);
1046         if (speed) {
1047             cfsetospeed (&tios, speed);
1048             cfsetispeed (&tios, speed);
1049             speed = cfgetospeed(&tios);
1050         }
1051         baud_rate = baud_rate_of(speed);
1052     }
1053     else {
1054         speed = cfgetospeed(&tios);
1055         baud_rate = baud_rate_of(speed);
1056     }
1057
1058     while (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0 && !ok_error(errno))
1059         if (errno != EINTR)
1060             fatal("tcsetattr: %m (line %d)", __LINE__);
1061     restore_term = 1;
1062
1063 /* Most Linux architectures and drivers support arbitrary baud rate values via BOTHER */
1064 #ifdef TCGETS2
1065     if (!baud_rate) {
1066         struct termios2 tios2;
1067         if (ioctl(tty_fd, TCGETS2, &tios2) == 0) {
1068             if (inspeed) {
1069                 tios2.c_cflag &= ~CBAUD;
1070                 tios2.c_cflag |= BOTHER;
1071                 tios2.c_ispeed = inspeed;
1072                 tios2.c_ospeed = inspeed;
1073 #ifdef TCSETS2
1074                 if (ioctl(tty_fd, TCSETS2, &tios2) == 0)
1075                     baud_rate = inspeed;
1076 #endif
1077             } else {
1078                 if ((tios2.c_cflag & CBAUD) == BOTHER && tios2.c_ospeed)
1079                     baud_rate = tios2.c_ospeed;
1080             }
1081         }
1082     }
1083 #endif
1084
1085 /*
1086  * We can't proceed if the serial port baud rate is unknown,
1087  * since that implies that the serial port is disabled.
1088  */
1089     if (!baud_rate) {
1090         if (inspeed)
1091             fatal("speed %d not supported", inspeed);
1092         else
1093             fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1094     }
1095 }
1096
1097 /********************************************************************
1098  *
1099  * setdtr - control the DTR line on the serial port.
1100  * This is called from die(), so it shouldn't call die().
1101  */
1102
1103 void setdtr (int tty_fd, int on)
1104 {
1105     int modembits = TIOCM_DTR;
1106
1107     ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
1108 }
1109
1110 /********************************************************************
1111  *
1112  * restore_tty - restore the terminal to the saved settings.
1113  */
1114
1115 void restore_tty (int tty_fd)
1116 {
1117     if (restore_term) {
1118         restore_term = 0;
1119 /*
1120  * Turn off echoing, because otherwise we can get into
1121  * a loop with the tty and the modem echoing to each other.
1122  * We presume we are the sole user of this tty device, so
1123  * when we close it, it will revert to its defaults anyway.
1124  */
1125         if (!default_device)
1126             inittermios.c_lflag &= ~(ECHO | ECHONL);
1127
1128         if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
1129             if (! ok_error (errno))
1130                 warn("tcsetattr: %m (line %d)", __LINE__);
1131         }
1132     }
1133 }
1134
1135 /********************************************************************
1136  *
1137  * output - Output PPP packet.
1138  */
1139
1140 void output (int unit, unsigned char *p, int len)
1141 {
1142     int fd = ppp_fd;
1143     int proto;
1144
1145     dump_packet("sent", p, len);
1146     if (snoop_send_hook) snoop_send_hook(p, len);
1147
1148     if (len < PPP_HDRLEN)
1149         return;
1150     if (new_style_driver) {
1151         p += 2;
1152         len -= 2;
1153         proto = (p[0] << 8) + p[1];
1154         if (ppp_dev_fd >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
1155             fd = ppp_dev_fd;
1156     }
1157     if (write(fd, p, len) < 0) {
1158         if (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOBUFS
1159             || errno == ENXIO || errno == EIO || errno == EINTR)
1160             warn("write: warning: %m (%d)", errno);
1161         else
1162             error("write: %m (%d)", errno);
1163     }
1164 }
1165
1166 /********************************************************************
1167  *
1168  * wait_input - wait until there is data available,
1169  * for the length of time specified by *timo (indefinite
1170  * if timo is NULL).
1171  */
1172
1173 void wait_input(struct timeval *timo)
1174 {
1175     fd_set ready, exc;
1176     int n;
1177
1178     ready = in_fds;
1179     exc = in_fds;
1180     n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
1181     if (n < 0 && errno != EINTR)
1182         fatal("select: %m");
1183 }
1184
1185 /*
1186  * add_fd - add an fd to the set that wait_input waits for.
1187  */
1188 void add_fd(int fd)
1189 {
1190     if (fd >= FD_SETSIZE)
1191         fatal("internal error: file descriptor too large (%d)", fd);
1192     FD_SET(fd, &in_fds);
1193     if (fd > max_in_fd)
1194         max_in_fd = fd;
1195 }
1196
1197 /*
1198  * remove_fd - remove an fd from the set that wait_input waits for.
1199  */
1200 void remove_fd(int fd)
1201 {
1202     FD_CLR(fd, &in_fds);
1203 }
1204
1205
1206 /********************************************************************
1207  *
1208  * read_packet - get a PPP packet from the serial device.
1209  */
1210
1211 int read_packet (unsigned char *buf)
1212 {
1213     int len, nr;
1214
1215     len = PPP_MRU + PPP_HDRLEN;
1216     if (new_style_driver) {
1217         *buf++ = PPP_ALLSTATIONS;
1218         *buf++ = PPP_UI;
1219         len -= 2;
1220     }
1221     nr = -1;
1222     if (ppp_fd >= 0) {
1223         nr = read(ppp_fd, buf, len);
1224         if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1225             && errno != EIO && errno != EINTR)
1226             error("read: %m");
1227         if (nr < 0 && errno == ENXIO)
1228             return 0;
1229     }
1230     if (nr < 0 && new_style_driver && ppp_dev_fd >= 0 && !bundle_eof) {
1231         /* N.B. we read ppp_fd first since LCP packets come in there. */
1232         nr = read(ppp_dev_fd, buf, len);
1233         if (nr < 0 && errno != EWOULDBLOCK && errno != EAGAIN
1234             && errno != EIO && errno != EINTR)
1235             error("read /dev/ppp: %m");
1236         if (nr < 0 && errno == ENXIO)
1237             nr = 0;
1238         if (nr == 0 && doing_multilink) {
1239             remove_fd(ppp_dev_fd);
1240             bundle_eof = 1;
1241         }
1242     }
1243     if (new_style_driver && ppp_fd < 0 && ppp_dev_fd < 0)
1244         nr = 0;
1245     return (new_style_driver && nr > 0)? nr+2: nr;
1246 }
1247
1248 /********************************************************************
1249  *
1250  * get_loop_output - get outgoing packets from the ppp device,
1251  * and detect when we want to bring the real link up.
1252  * Return value is 1 if we need to bring up the link, 0 otherwise.
1253  */
1254 int
1255 get_loop_output(void)
1256 {
1257     int rv = 0;
1258     int n;
1259
1260     if (new_style_driver) {
1261         while ((n = read_packet(inpacket_buf)) > 0)
1262             if (loop_frame(inpacket_buf, n))
1263                 rv = 1;
1264         return rv;
1265     }
1266
1267     while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1268         if (loop_chars(inbuf, n))
1269             rv = 1;
1270
1271     if (n == 0)
1272         fatal("eof on loopback");
1273
1274     if (errno != EWOULDBLOCK && errno != EAGAIN)
1275         fatal("read from loopback: %m(%d)", errno);
1276
1277     return rv;
1278 }
1279
1280 /*
1281  * netif_set_mtu - set the MTU on the PPP network interface.
1282  */
1283 void
1284 netif_set_mtu(int unit, int mtu)
1285 {
1286     struct ifreq ifr;
1287
1288     memset (&ifr, '\0', sizeof (ifr));
1289     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1290     ifr.ifr_mtu = mtu;
1291
1292     if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1293         error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1294 }
1295
1296 /*
1297  * netif_get_mtu - get the MTU on the PPP network interface.
1298  */
1299 int
1300 netif_get_mtu(int unit)
1301 {
1302     struct ifreq ifr;
1303
1304     memset (&ifr, '\0', sizeof (ifr));
1305     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1306
1307     if (ifunit >= 0 && ioctl(sock_fd, SIOCGIFMTU, (caddr_t) &ifr) < 0) {
1308         error("ioctl(SIOCGIFMTU): %m (line %d)", __LINE__);
1309         return 0;
1310     }
1311     return ifr.ifr_mtu;
1312 }
1313
1314 /********************************************************************
1315  *
1316  * tty_send_config - configure the transmit characteristics of
1317  * the ppp interface.
1318  */
1319
1320 void tty_send_config(int mtu, u_int32_t asyncmap, int pcomp, int accomp)
1321 {
1322         int x;
1323
1324         if (!still_ppp())
1325                 return;
1326         link_mtu = mtu;
1327         if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1328                 if (errno != EIO && errno != ENOTTY)
1329                         error("Couldn't set transmit async character map: %m");
1330                 ++error_count;
1331                 return;
1332         }
1333
1334         x = (pcomp? SC_COMP_PROT: 0) | (accomp? SC_COMP_AC: 0)
1335             | (sync_serial? SC_SYNC: 0);
1336         modify_flags(ppp_fd, SC_COMP_PROT|SC_COMP_AC|SC_SYNC, x);
1337 }
1338
1339 /********************************************************************
1340  *
1341  * tty_set_xaccm - set the extended transmit ACCM for the interface.
1342  */
1343
1344 void tty_set_xaccm (ext_accm accm)
1345 {
1346     if (!still_ppp())
1347         return;
1348     if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1349         if ( ! ok_error (errno))
1350             warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1351     }
1352 }
1353
1354 /********************************************************************
1355  *
1356  * tty_recv_config - configure the receive-side characteristics of
1357  * the ppp interface.
1358  */
1359
1360 void tty_recv_config(int mru, u_int32_t asyncmap, int pcomp, int accomp)
1361 {
1362 /*
1363  * If we were called because the link has gone down then there is nothing
1364  * which may be done. Just return without incident.
1365  */
1366         if (!still_ppp())
1367                 return;
1368 /*
1369  * Set the receiver parameters
1370  */
1371         if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1372                 if (errno != EIO && errno != ENOTTY)
1373                         error("Couldn't set channel receive MRU: %m");
1374         }
1375         if (new_style_driver && ppp_dev_fd >= 0
1376             && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1377                 error("Couldn't set MRU in generic PPP layer: %m");
1378
1379         if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1380                 if (errno != EIO && errno != ENOTTY)
1381                         error("Couldn't set channel receive asyncmap: %m");
1382         }
1383 }
1384
1385 /********************************************************************
1386  *
1387  * ccp_test - ask kernel whether a given compression method
1388  * is acceptable for use.
1389  */
1390
1391 int
1392 ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1393 {
1394     struct ppp_option_data data;
1395
1396     memset (&data, '\0', sizeof (data));
1397     data.ptr      = opt_ptr;
1398     data.length   = opt_len;
1399     data.transmit = for_transmit;
1400
1401     if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1402         return 1;
1403
1404     return (errno == ENOBUFS)? 0: -1;
1405 }
1406
1407 /********************************************************************
1408  *
1409  * ccp_flags_set - inform kernel about the current state of CCP.
1410  */
1411
1412 void ccp_flags_set (int unit, int isopen, int isup)
1413 {
1414         int x;
1415
1416         x = (isopen? SC_CCP_OPEN: 0) | (isup? SC_CCP_UP: 0);
1417         if (still_ppp() && ppp_dev_fd >= 0)
1418                 modify_flags(ppp_dev_fd, SC_CCP_OPEN|SC_CCP_UP, x);
1419 }
1420
1421 #ifdef PPP_FILTER
1422 /*
1423  * set_filters - set the active and pass filters in the kernel driver.
1424  */
1425 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1426 {
1427         struct sock_fprog fp;
1428
1429         fp.len = pass->bf_len;
1430         fp.filter = (struct sock_filter *) pass->bf_insns;
1431         if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1432                 if (errno == ENOTTY)
1433                         warn("kernel does not support PPP filtering");
1434                 else
1435                         error("Couldn't set pass-filter in kernel: %m");
1436                 return 0;
1437         }
1438         fp.len = active->bf_len;
1439         fp.filter = (struct sock_filter *) active->bf_insns;
1440         if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1441                 error("Couldn't set active-filter in kernel: %m");
1442                 return 0;
1443         }
1444         return 1;
1445 }
1446 #endif /* PPP_FILTER */
1447
1448 /********************************************************************
1449  *
1450  * get_idle_time - return how long the link has been idle.
1451  */
1452 int
1453 get_idle_time(int u, struct ppp_idle *ip)
1454 {
1455     return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1456 }
1457
1458 /********************************************************************
1459  *
1460  * get_ppp_stats - return statistics for the link.
1461  */
1462 int
1463 get_ppp_stats(int u, struct pppd_stats *stats)
1464 {
1465     struct ifpppstatsreq req;
1466
1467     memset (&req, 0, sizeof (req));
1468
1469     req.stats_ptr = (caddr_t) &req.stats;
1470     strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1471     if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1472         error("Couldn't get PPP statistics: %m");
1473         return 0;
1474     }
1475     stats->bytes_in = req.stats.p.ppp_ibytes;
1476     stats->bytes_out = req.stats.p.ppp_obytes;
1477     stats->pkts_in = req.stats.p.ppp_ipackets;
1478     stats->pkts_out = req.stats.p.ppp_opackets;
1479     return 1;
1480 }
1481
1482 /********************************************************************
1483  *
1484  * ccp_fatal_error - returns 1 if decompression was disabled as a
1485  * result of an error detected after decompression of a packet,
1486  * 0 otherwise.  This is necessary because of patent nonsense.
1487  */
1488
1489 int ccp_fatal_error (int unit)
1490 {
1491         int flags;
1492
1493         if (ioctl(ppp_dev_fd, PPPIOCGFLAGS, &flags) < 0) {
1494                 error("Couldn't read compression error flags: %m");
1495                 flags = 0;
1496         }
1497         return flags & SC_DC_FERROR;
1498 }
1499
1500 /********************************************************************
1501  *
1502  * path_to_procfs - find the path to the proc file system mount point
1503  */
1504 static char proc_path[MAXPATHLEN];
1505 static int proc_path_len;
1506
1507 static char *path_to_procfs(const char *tail)
1508 {
1509     struct mntent *mntent;
1510     FILE *fp;
1511
1512     if (proc_path_len == 0) {
1513         /* Default the mount location of /proc */
1514         strlcpy (proc_path, "/proc", sizeof(proc_path));
1515         proc_path_len = 5;
1516         fp = fopen(MOUNTED, "r");
1517         if (fp != NULL) {
1518             while ((mntent = getmntent(fp)) != NULL) {
1519                 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1520                     continue;
1521                 if (strcmp(mntent->mnt_type, "proc") == 0) {
1522                     strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1523                     proc_path_len = strlen(proc_path);
1524                     break;
1525                 }
1526             }
1527             fclose (fp);
1528         }
1529     }
1530
1531     strlcpy(proc_path + proc_path_len, tail,
1532             sizeof(proc_path) - proc_path_len);
1533     return proc_path;
1534 }
1535
1536 /*
1537  * /proc/net/route parsing stuff.
1538  */
1539 #define ROUTE_MAX_COLS  12
1540 FILE *route_fd = (FILE *) 0;
1541 static char route_buffer[512];
1542 static int route_dev_col, route_dest_col, route_gw_col;
1543 static int route_flags_col, route_metric_col, route_mask_col;
1544 static int route_num_cols;
1545
1546 static int open_route_table (void);
1547 static void close_route_table (void);
1548 static int read_route_table (struct rtentry *rt);
1549
1550 /********************************************************************
1551  *
1552  * close_route_table - close the interface to the route table
1553  */
1554
1555 static void close_route_table (void)
1556 {
1557     if (route_fd != (FILE *) 0) {
1558         fclose (route_fd);
1559         route_fd = (FILE *) 0;
1560     }
1561 }
1562
1563 /********************************************************************
1564  *
1565  * open_route_table - open the interface to the route table
1566  */
1567 static char route_delims[] = " \t\n";
1568
1569 static int open_route_table (void)
1570 {
1571     char *path;
1572
1573     close_route_table();
1574
1575     path = path_to_procfs("/net/route");
1576     route_fd = fopen (path, "r");
1577     if (route_fd == NULL) {
1578         error("can't open routing table %s: %m", path);
1579         return 0;
1580     }
1581
1582     route_dev_col = 0;          /* default to usual columns */
1583     route_dest_col = 1;
1584     route_gw_col = 2;
1585     route_flags_col = 3;
1586     route_metric_col = 6;
1587     route_mask_col = 7;
1588     route_num_cols = 8;
1589
1590     /* parse header line */
1591     if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1592         char *p = route_buffer, *q;
1593         int col;
1594         for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1595             int used = 1;
1596             if ((q = strtok(p, route_delims)) == 0)
1597                 break;
1598             if (strcasecmp(q, "iface") == 0)
1599                 route_dev_col = col;
1600             else if (strcasecmp(q, "destination") == 0)
1601                 route_dest_col = col;
1602             else if (strcasecmp(q, "gateway") == 0)
1603                 route_gw_col = col;
1604             else if (strcasecmp(q, "flags") == 0)
1605                 route_flags_col = col;
1606             else if (strcasecmp(q, "mask") == 0)
1607                 route_mask_col = col;
1608             else
1609                 used = 0;
1610             if (used && col >= route_num_cols)
1611                 route_num_cols = col + 1;
1612             p = NULL;
1613         }
1614     }
1615
1616     return 1;
1617 }
1618
1619 /********************************************************************
1620  *
1621  * read_route_table - read the next entry from the route table
1622  */
1623
1624 static int read_route_table(struct rtentry *rt)
1625 {
1626     char *cols[ROUTE_MAX_COLS], *p;
1627     int col;
1628
1629     memset (rt, '\0', sizeof (struct rtentry));
1630
1631     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1632         return 0;
1633
1634     p = route_buffer;
1635     for (col = 0; col < route_num_cols; ++col) {
1636         cols[col] = strtok(p, route_delims);
1637         if (cols[col] == NULL)
1638             return 0;           /* didn't get enough columns */
1639         p = NULL;
1640     }
1641
1642     SET_SA_FAMILY (rt->rt_dst,     AF_INET);
1643     SET_SA_FAMILY (rt->rt_gateway, AF_INET);
1644
1645     SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1646     SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1647     SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1648
1649     rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1650     rt->rt_metric = (short) strtoul(cols[route_metric_col], NULL, 10);
1651     rt->rt_dev   = cols[route_dev_col];
1652
1653     return 1;
1654 }
1655
1656 /********************************************************************
1657  *
1658  * defaultroute_exists - determine if there is a default route
1659  * with the given metric (or negative for any)
1660  */
1661
1662 static int defaultroute_exists (struct rtentry *rt, int metric)
1663 {
1664     int result = 0;
1665
1666     if (!open_route_table())
1667         return 0;
1668
1669     while (read_route_table(rt) != 0) {
1670         if ((rt->rt_flags & RTF_UP) == 0)
1671             continue;
1672
1673         if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1674             continue;
1675         if (SIN_ADDR(rt->rt_dst) == 0L && (metric < 0
1676                                            || rt->rt_metric == metric)) {
1677             result = 1;
1678             break;
1679         }
1680     }
1681
1682     close_route_table();
1683     return result;
1684 }
1685
1686 /*
1687  * have_route_to - determine if the system has any route to
1688  * a given IP address.  `addr' is in network byte order.
1689  * Return value is 1 if yes, 0 if no, -1 if don't know.
1690  * For demand mode to work properly, we have to ignore routes
1691  * through our own interface.
1692  */
1693 int have_route_to(u_int32_t addr)
1694 {
1695     struct rtentry rt;
1696     int result = 0;
1697
1698     if (!open_route_table())
1699         return -1;              /* don't know */
1700
1701     while (read_route_table(&rt)) {
1702         if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1703             continue;
1704         if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1705             result = 1;
1706             break;
1707         }
1708     }
1709
1710     close_route_table();
1711     return result;
1712 }
1713
1714 /********************************************************************
1715  *
1716  * sifdefaultroute - assign a default route through the address given.
1717  *
1718  * If the global default_rt_repl_rest flag is set, then this function
1719  * already replaced the original system defaultroute with some other
1720  * route and it should just replace the current defaultroute with
1721  * another one, without saving the current route. Use: demand mode,
1722  * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1723  * and then changes the temporary addresses to the addresses for the real
1724  * ppp connection when it has come up.
1725  */
1726
1727 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
1728 {
1729     struct rtentry rt, tmp_rt;
1730     struct rtentry *del_rt = NULL;
1731
1732     if (default_rt_repl_rest) {
1733         /* We have already replaced the original defaultroute, if we
1734          * are called again, we will delete the current default route
1735          * and set the new default route in this function.
1736          * - this is normally only the case the doing demand: */
1737         if (defaultroute_exists(&tmp_rt, -1))
1738             del_rt = &tmp_rt;
1739     } else if (defaultroute_exists(&old_def_rt, -1           ) &&
1740                             strcmp( old_def_rt.rt_dev, ifname) != 0) {
1741         /*
1742          * We did not yet replace an existing default route, let's
1743          * check if we should save and replace a default route:
1744          */
1745         u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
1746
1747         if (old_gateway != gateway) {
1748             if (!replace) {
1749                 error("not replacing default route to %s [%I]",
1750                         old_def_rt.rt_dev, old_gateway);
1751                 return 0;
1752             } else {
1753                 /* we need to copy rt_dev because we need it permanent too: */
1754                 char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
1755                 strcpy(tmp_dev, old_def_rt.rt_dev);
1756                 old_def_rt.rt_dev = tmp_dev;
1757
1758                 notice("replacing old default route to %s [%I]",
1759                         old_def_rt.rt_dev, old_gateway);
1760                 default_rt_repl_rest = 1;
1761                 del_rt = &old_def_rt;
1762             }
1763         }
1764     }
1765
1766     memset (&rt, 0, sizeof (rt));
1767     SET_SA_FAMILY (rt.rt_dst, AF_INET);
1768
1769     rt.rt_dev = ifname;
1770     rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1771
1772     if (kernel_version > KVERSION(2,1,0)) {
1773         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1774         SIN_ADDR(rt.rt_genmask) = 0L;
1775     }
1776
1777     rt.rt_flags = RTF_UP;
1778     if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1779         if ( ! ok_error ( errno ))
1780             error("default route ioctl(SIOCADDRT): %m");
1781         return 0;
1782     }
1783     if (default_rt_repl_rest && del_rt)
1784         if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
1785             if ( ! ok_error ( errno ))
1786                 error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
1787             return 0;
1788         }
1789
1790     have_default_route = 1;
1791     return 1;
1792 }
1793
1794 /********************************************************************
1795  *
1796  * cifdefaultroute - delete a default route through the address given.
1797  */
1798
1799 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1800 {
1801     struct rtentry rt;
1802
1803     have_default_route = 0;
1804
1805     memset (&rt, '\0', sizeof (rt));
1806     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1807     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1808
1809     rt.rt_dev = ifname;
1810
1811     rt.rt_dev = ifname;
1812     rt.rt_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1813
1814     if (kernel_version > KVERSION(2,1,0)) {
1815         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1816         SIN_ADDR(rt.rt_genmask) = 0L;
1817     }
1818
1819     rt.rt_flags = RTF_UP;
1820     if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1821         if (still_ppp()) {
1822             if ( ! ok_error ( errno ))
1823                 error("default route ioctl(SIOCDELRT): %m");
1824             return 0;
1825         }
1826     }
1827     if (default_rt_repl_rest) {
1828         notice("restoring old default route to %s [%I]",
1829                         old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
1830         if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
1831             if ( ! ok_error ( errno ))
1832                 error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
1833             return 0;
1834         }
1835         default_rt_repl_rest = 0;
1836     }
1837
1838     return 1;
1839 }
1840
1841 #ifdef INET6
1842 /*
1843  * /proc/net/ipv6_route parsing stuff.
1844  */
1845 static int route_dest_plen_col;
1846 static int open_route6_table (void);
1847 static int read_route6_table (struct in6_rtmsg *rt);
1848
1849 /********************************************************************
1850  *
1851  * open_route6_table - open the interface to the route table
1852  */
1853 static int open_route6_table (void)
1854 {
1855     char *path;
1856
1857     close_route_table();
1858
1859     path = path_to_procfs("/net/ipv6_route");
1860     route_fd = fopen (path, "r");
1861     if (route_fd == NULL) {
1862         error("can't open routing table %s: %m", path);
1863         return 0;
1864     }
1865
1866     /* default to usual columns */
1867     route_dest_col = 0;
1868     route_dest_plen_col = 1;
1869     route_gw_col = 4;
1870     route_metric_col = 5;
1871     route_flags_col = 8;
1872     route_dev_col = 9;
1873     route_num_cols = 10;
1874
1875     return 1;
1876 }
1877
1878 /********************************************************************
1879  *
1880  * read_route6_table - read the next entry from the route table
1881  */
1882
1883 static void hex_to_in6_addr(struct in6_addr *addr, const char *s)
1884 {
1885     char hex8[9];
1886     unsigned i;
1887     uint32_t v;
1888
1889     hex8[8] = 0;
1890     for (i = 0; i < 4; i++) {
1891         memcpy(hex8, s + 8*i, 8);
1892         v = strtoul(hex8, NULL, 16);
1893         addr->s6_addr32[i] = v;
1894     }
1895 }
1896
1897 static int read_route6_table(struct in6_rtmsg *rt)
1898 {
1899     char *cols[ROUTE_MAX_COLS], *p;
1900     int col;
1901
1902     memset (rt, '\0', sizeof (struct in6_rtmsg));
1903
1904     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1905         return 0;
1906
1907     p = route_buffer;
1908     for (col = 0; col < route_num_cols; ++col) {
1909         cols[col] = strtok(p, route_delims);
1910         if (cols[col] == NULL)
1911             return 0;           /* didn't get enough columns */
1912         p = NULL;
1913     }
1914
1915     hex_to_in6_addr(&rt->rtmsg_dst, cols[route_dest_col]);
1916     rt->rtmsg_dst_len = strtoul(cols[route_dest_plen_col], NULL, 16);
1917     hex_to_in6_addr(&rt->rtmsg_gateway, cols[route_gw_col]);
1918
1919     rt->rtmsg_metric = strtoul(cols[route_metric_col], NULL, 16);
1920     rt->rtmsg_flags = strtoul(cols[route_flags_col], NULL, 16);
1921     rt->rtmsg_ifindex = if_nametoindex(cols[route_dev_col]);
1922
1923     return 1;
1924 }
1925
1926 /********************************************************************
1927  *
1928  * defaultroute6_exists - determine if there is a default route
1929  */
1930
1931 static int defaultroute6_exists (struct in6_rtmsg *rt, int metric)
1932 {
1933     int result = 0;
1934
1935     if (!open_route6_table())
1936         return 0;
1937
1938     while (read_route6_table(rt) != 0) {
1939         if ((rt->rtmsg_flags & RTF_UP) == 0)
1940             continue;
1941
1942         if (rt->rtmsg_dst_len != 0)
1943             continue;
1944         if (rt->rtmsg_dst.s6_addr32[0] == 0L
1945          && rt->rtmsg_dst.s6_addr32[1] == 0L
1946          && rt->rtmsg_dst.s6_addr32[2] == 0L
1947          && rt->rtmsg_dst.s6_addr32[3] == 0L
1948          && (metric < 0 || rt->rtmsg_metric == metric)) {
1949             result = 1;
1950             break;
1951         }
1952     }
1953
1954     close_route_table();
1955     return result;
1956 }
1957
1958 /********************************************************************
1959  *
1960  * sif6defaultroute - assign a default route through the address given.
1961  *
1962  * If the global default_rt_repl_rest flag is set, then this function
1963  * already replaced the original system defaultroute with some other
1964  * route and it should just replace the current defaultroute with
1965  * another one, without saving the current route. Use: demand mode,
1966  * when pppd sets first a defaultroute it it's temporary ppp0 addresses
1967  * and then changes the temporary addresses to the addresses for the real
1968  * ppp connection when it has come up.
1969  */
1970
1971 int sif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
1972 {
1973     struct in6_rtmsg rt;
1974     char buf[IF_NAMESIZE];
1975
1976     if (defaultroute6_exists(&rt, dfl_route_metric) &&
1977             rt.rtmsg_ifindex != if_nametoindex(ifname)) {
1978         if (rt.rtmsg_flags & RTF_GATEWAY)
1979             error("not replacing existing default route via gateway");
1980         else
1981             error("not replacing existing default route through %s",
1982                   if_indextoname(rt.rtmsg_ifindex, buf));
1983         return 0;
1984     }
1985
1986     memset (&rt, 0, sizeof (rt));
1987
1988     rt.rtmsg_ifindex = if_nametoindex(ifname);
1989     rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
1990     rt.rtmsg_dst_len = 0;
1991
1992     rt.rtmsg_flags = RTF_UP;
1993     if (ioctl(sock6_fd, SIOCADDRT, &rt) < 0) {
1994         if ( ! ok_error ( errno ))
1995             error("default route ioctl(SIOCADDRT): %m");
1996         return 0;
1997     }
1998
1999     have_default_route6 = 1;
2000     return 1;
2001 }
2002
2003 /********************************************************************
2004  *
2005  * cif6defaultroute - delete a default route through the address given.
2006  */
2007
2008 int cif6defaultroute (int unit, eui64_t ouraddr, eui64_t gateway)
2009 {
2010     struct in6_rtmsg rt;
2011
2012     have_default_route6 = 0;
2013
2014     memset (&rt, '\0', sizeof (rt));
2015
2016     rt.rtmsg_ifindex = if_nametoindex(ifname);
2017     rt.rtmsg_metric = dfl_route_metric + 1; /* +1 for binary compatibility */
2018     rt.rtmsg_dst_len = 0;
2019
2020     rt.rtmsg_flags = RTF_UP;
2021     if (ioctl(sock6_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2022         if (still_ppp()) {
2023             if ( ! ok_error ( errno ))
2024                 error("default route ioctl(SIOCDELRT): %m");
2025             return 0;
2026         }
2027     }
2028
2029     return 1;
2030 }
2031 #endif /* INET6 */
2032
2033 /********************************************************************
2034  *
2035  * sifproxyarp - Make a proxy ARP entry for the peer.
2036  */
2037
2038 int sifproxyarp (int unit, u_int32_t his_adr)
2039 {
2040     struct arpreq arpreq;
2041     char *forw_path;
2042
2043     if (has_proxy_arp == 0) {
2044         memset (&arpreq, '\0', sizeof(arpreq));
2045
2046         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2047         SIN_ADDR(arpreq.arp_pa) = his_adr;
2048         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2049 /*
2050  * Get the hardware address of an interface on the same subnet
2051  * as our local address.
2052  */
2053         if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
2054                             sizeof(proxy_arp_dev))) {
2055             error("Cannot determine ethernet address for proxy ARP");
2056             return 0;
2057         }
2058         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2059
2060         if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
2061             if ( ! ok_error ( errno ))
2062                 error("ioctl(SIOCSARP): %m");
2063             return 0;
2064         }
2065         proxy_arp_addr = his_adr;
2066         has_proxy_arp = 1;
2067
2068         if (tune_kernel) {
2069             forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
2070             if (forw_path != 0) {
2071                 int fd = open(forw_path, O_WRONLY);
2072                 if (fd >= 0) {
2073                     if (write(fd, "1", 1) != 1)
2074                         error("Couldn't enable IP forwarding: %m");
2075                     close(fd);
2076                 }
2077             }
2078         }
2079     }
2080
2081     return 1;
2082 }
2083
2084 /********************************************************************
2085  *
2086  * cifproxyarp - Delete the proxy ARP entry for the peer.
2087  */
2088
2089 int cifproxyarp (int unit, u_int32_t his_adr)
2090 {
2091     struct arpreq arpreq;
2092
2093     if (has_proxy_arp) {
2094         has_proxy_arp = 0;
2095         memset (&arpreq, '\0', sizeof(arpreq));
2096         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
2097         SIN_ADDR(arpreq.arp_pa) = his_adr;
2098         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2099         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
2100
2101         if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2102             if ( ! ok_error ( errno ))
2103                 warn("ioctl(SIOCDARP): %m");
2104             return 0;
2105         }
2106     }
2107     return 1;
2108 }
2109
2110 /********************************************************************
2111  *
2112  * get_ether_addr - get the hardware address of an interface on the
2113  * the same subnet as ipaddr.
2114  */
2115
2116 static int get_ether_addr (u_int32_t ipaddr,
2117                            struct sockaddr *hwaddr,
2118                            char *name, int namelen)
2119 {
2120     struct ifreq *ifr, *ifend;
2121     u_int32_t ina, mask;
2122     char *aliasp;
2123     struct ifreq ifreq, bestifreq;
2124     struct ifconf ifc;
2125     struct ifreq ifs[MAX_IFS];
2126
2127     u_int32_t bestmask=0;
2128     int found_interface = 0;
2129
2130     ifc.ifc_len = sizeof(ifs);
2131     ifc.ifc_req = ifs;
2132     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2133         if ( ! ok_error ( errno ))
2134             error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2135         return 0;
2136     }
2137
2138 /*
2139  * Scan through looking for an interface with an Internet
2140  * address on the same subnet as `ipaddr'.
2141  */
2142     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
2143     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2144         if (ifr->ifr_addr.sa_family == AF_INET) {
2145             ina = SIN_ADDR(ifr->ifr_addr);
2146             strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2147 /*
2148  * Check that the interface is up, and not point-to-point
2149  * nor loopback.
2150  */
2151             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2152                 continue;
2153
2154             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2155                 continue;
2156 /*
2157  * Get its netmask and check that it's on the right subnet.
2158  */
2159             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2160                 continue;
2161
2162             mask = SIN_ADDR(ifreq.ifr_addr);
2163
2164             if (((ipaddr ^ ina) & mask) != 0)
2165                 continue; /* no match */
2166             /* matched */
2167             if (mask >= bestmask) {
2168                 /* Compare using >= instead of > -- it is possible for
2169                    an interface to have a netmask of 0.0.0.0 */
2170                 found_interface = 1;
2171                 bestifreq = ifreq;
2172                 bestmask = mask;
2173             }
2174         }
2175     }
2176
2177     if (!found_interface) return 0;
2178
2179     strlcpy(name, bestifreq.ifr_name, namelen);
2180
2181     /* trim off the :1 in eth0:1 */
2182     aliasp = strchr(name, ':');
2183     if (aliasp != 0)
2184         *aliasp = 0;
2185
2186     info("found interface %s for proxy arp", name);
2187 /*
2188  * Now get the hardware address.
2189  */
2190     memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
2191     if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
2192         error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
2193         return 0;
2194     }
2195
2196     memcpy (hwaddr,
2197             &bestifreq.ifr_hwaddr,
2198             sizeof (struct sockaddr));
2199
2200     return 1;
2201 }
2202
2203 /*
2204  * get_if_hwaddr - get the hardware address for the specified
2205  * network interface device.
2206  */
2207 int
2208 get_if_hwaddr(u_char *addr, char *name)
2209 {
2210         struct ifreq ifreq;
2211         int ret, sock_fd;
2212
2213         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2214         if (sock_fd < 0)
2215                 return -1;
2216         memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2217         strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
2218         ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2219         close(sock_fd);
2220         if (ret >= 0)
2221                 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2222         return ret;
2223 }
2224
2225 /*
2226  * get_first_ether_hwaddr - get the hardware address for the first
2227  * ethernet-style interface on this system.
2228  */
2229 int
2230 get_first_ether_hwaddr(u_char *addr)
2231 {
2232         struct if_nameindex *if_ni, *i;
2233         struct ifreq ifreq;
2234         int ret, sock_fd;
2235
2236         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
2237         if (sock_fd < 0)
2238                 return -1;
2239
2240         if_ni = if_nameindex();
2241         if (!if_ni) {
2242                 close(sock_fd);
2243                 return -1;
2244         }
2245
2246         ret = -1;
2247
2248         for (i = if_ni; !(i->if_index == 0 && i->if_name == NULL); i++) {
2249                 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
2250                 strlcpy(ifreq.ifr_name, i->if_name, sizeof(ifreq.ifr_name));
2251                 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
2252                 if (ret >= 0 && ifreq.ifr_hwaddr.sa_family == ARPHRD_ETHER) {
2253                         memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
2254                         break;
2255                 }
2256                 ret = -1;
2257         }
2258
2259         if_freenameindex(if_ni);
2260         close(sock_fd);
2261
2262         return ret;
2263 }
2264
2265 /********************************************************************
2266  *
2267  * Return user specified netmask, modified by any mask we might determine
2268  * for address `addr' (in network byte order).
2269  * Here we scan through the system's list of interfaces, looking for
2270  * any non-point-to-point interfaces which might appear to be on the same
2271  * network as `addr'.  If we find any, we OR in their netmask to the
2272  * user-specified netmask.
2273  */
2274
2275 u_int32_t GetMask (u_int32_t addr)
2276 {
2277     u_int32_t mask, nmask, ina;
2278     struct ifreq *ifr, *ifend, ifreq;
2279     struct ifconf ifc;
2280     struct ifreq ifs[MAX_IFS];
2281
2282     addr = ntohl(addr);
2283
2284     if (IN_CLASSA(addr))        /* determine network mask for address class */
2285         nmask = IN_CLASSA_NET;
2286     else if (IN_CLASSB(addr))
2287             nmask = IN_CLASSB_NET;
2288     else
2289             nmask = IN_CLASSC_NET;
2290
2291     /* class D nets are disallowed by bad_ip_adrs */
2292     mask = netmask | htonl(nmask);
2293 /*
2294  * Scan through the system's network interfaces.
2295  */
2296     ifc.ifc_len = sizeof(ifs);
2297     ifc.ifc_req = ifs;
2298     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
2299         if ( ! ok_error ( errno ))
2300             warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
2301         return mask;
2302     }
2303
2304     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2305     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
2306 /*
2307  * Check the interface's internet address.
2308  */
2309         if (ifr->ifr_addr.sa_family != AF_INET)
2310             continue;
2311         ina = SIN_ADDR(ifr->ifr_addr);
2312         if (((ntohl(ina) ^ addr) & nmask) != 0)
2313             continue;
2314 /*
2315  * Check that the interface is up, and not point-to-point nor loopback.
2316  */
2317         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2318         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
2319             continue;
2320
2321         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
2322             continue;
2323 /*
2324  * Get its netmask and OR it into our mask.
2325  */
2326         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
2327             continue;
2328         mask |= SIN_ADDR(ifreq.ifr_addr);
2329         break;
2330     }
2331     return mask;
2332 }
2333
2334 /********************************************************************
2335  *
2336  * Internal routine to decode the version.modification.patch level
2337  */
2338
2339 static void decode_version (char *buf, int *version,
2340                             int *modification, int *patch)
2341 {
2342     char *endp;
2343
2344     *version      = (int) strtoul (buf, &endp, 10);
2345     *modification = 0;
2346     *patch        = 0;
2347
2348     if (endp != buf && *endp == '.') {
2349         buf = endp + 1;
2350         *modification = (int) strtoul (buf, &endp, 10);
2351         if (endp != buf && *endp == '.') {
2352             buf = endp + 1;
2353             *patch = (int) strtoul (buf, &buf, 10);
2354         }
2355     }
2356 }
2357
2358 /********************************************************************
2359  *
2360  * Procedure to determine if the PPP line discipline is registered.
2361  */
2362
2363 static int
2364 ppp_registered(void)
2365 {
2366     int local_fd;
2367     int mfd = -1;
2368     int ret = 0;
2369     char slave[16];
2370
2371     /*
2372      * We used to open the serial device and set it to the ppp line
2373      * discipline here, in order to create a ppp unit.  But that is
2374      * not a good idea - the user might have specified a device that
2375      * they can't open (permission, or maybe it doesn't really exist).
2376      * So we grab a pty master/slave pair and use that.
2377      */
2378     if (!get_pty(&mfd, &local_fd, slave, 0)) {
2379         no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
2380         return 0;
2381     }
2382
2383     /*
2384      * Try to put the device into the PPP discipline.
2385      */
2386     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
2387         error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
2388     } else
2389         ret = 1;
2390
2391     close(local_fd);
2392     close(mfd);
2393     return ret;
2394 }
2395
2396 /********************************************************************
2397  *
2398  * ppp_available - check whether the system has any ppp interfaces
2399  * (in fact we check whether we can do an ioctl on ppp0).
2400  */
2401
2402 int ppp_available(void)
2403 {
2404     int s, ok, fd;
2405     struct ifreq ifr;
2406     int    size;
2407     int    my_version, my_modification, my_patch;
2408     int osmaj, osmin, ospatch;
2409
2410     /* get the kernel version now, since we are called before sys_init */
2411     uname(&utsname);
2412     osmaj = osmin = ospatch = 0;
2413     sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
2414     kernel_version = KVERSION(osmaj, osmin, ospatch);
2415
2416     fd = open("/dev/ppp", O_RDWR);
2417     if (fd >= 0) {
2418         new_style_driver = 1;
2419
2420         /* XXX should get from driver */
2421         driver_version = 2;
2422         driver_modification = 4;
2423         driver_patch = 0;
2424         close(fd);
2425         return 1;
2426     }
2427
2428     if (kernel_version >= KVERSION(2,3,13)) {
2429         error("Couldn't open the /dev/ppp device: %m");
2430         if (errno == ENOENT)
2431             no_ppp_msg =
2432                 "You need to create the /dev/ppp device node by\n"
2433                 "executing the following command as root:\n"
2434                 "       mknod /dev/ppp c 108 0\n";
2435         else if (errno == ENODEV || errno == ENXIO)
2436             no_ppp_msg =
2437                 "Please load the ppp_generic kernel module.\n";
2438         return 0;
2439     }
2440
2441     /* we are running on a really really old kernel */
2442     no_ppp_msg =
2443         "This system lacks kernel support for PPP.  This could be because\n"
2444         "the PPP kernel module could not be loaded, or because PPP was not\n"
2445         "included in the kernel configuration.  If PPP was included as a\n"
2446         "module, try `/sbin/modprobe -v ppp'.  If that fails, check that\n"
2447         "ppp.o exists in /lib/modules/`uname -r`/net.\n"
2448         "See README.linux file in the ppp distribution for more details.\n";
2449
2450 /*
2451  * Open a socket for doing the ioctl operations.
2452  */
2453     s = socket(AF_INET, SOCK_DGRAM, 0);
2454     if (s < 0)
2455         return 0;
2456
2457     strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2458     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2459 /*
2460  * If the device did not exist then attempt to create one by putting the
2461  * current tty into the PPP discipline. If this works then obtain the
2462  * flags for the device again.
2463  */
2464     if (!ok) {
2465         if (ppp_registered()) {
2466             strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2467             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2468         }
2469     }
2470 /*
2471  * Ensure that the hardware address is for PPP and not something else
2472  */
2473     if (ok)
2474         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2475
2476     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2477         ok = 0;
2478
2479 /*
2480  *  This is the PPP device. Validate the version of the driver at this
2481  *  point to ensure that this program will work with the driver.
2482  */
2483     if (ok) {
2484         char   abBuffer [1024];
2485
2486         ifr.ifr_data = abBuffer;
2487         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2488         if (size < 0) {
2489             error("Couldn't read driver version: %m");
2490             ok = 0;
2491             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2492
2493         } else {
2494             decode_version(abBuffer,
2495                            &driver_version,
2496                            &driver_modification,
2497                            &driver_patch);
2498 /*
2499  * Validate the version of the driver against the version that we used.
2500  */
2501             decode_version(VERSION,
2502                            &my_version,
2503                            &my_modification,
2504                            &my_patch);
2505
2506             /* The version numbers must match */
2507             if (driver_version != my_version)
2508                 ok = 0;
2509
2510             /* The modification levels must be legal */
2511             if (driver_modification < 3) {
2512                 if (driver_modification >= 2) {
2513                     /* we can cope with 2.2.0 and above */
2514                     driver_is_old = 1;
2515                 } else {
2516                     ok = 0;
2517                 }
2518             }
2519
2520             if (!ok) {
2521                 slprintf(route_buffer, sizeof(route_buffer),
2522                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
2523                          driver_version, driver_modification, driver_patch);
2524
2525                 no_ppp_msg = route_buffer;
2526             }
2527         }
2528     }
2529     close(s);
2530     return ok;
2531 }
2532
2533 #ifndef HAVE_LOGWTMP
2534 /********************************************************************
2535  *
2536  * Update the wtmp file with the appropriate user name and tty device.
2537  */
2538
2539 void logwtmp (const char *line, const char *name, const char *host)
2540 {
2541     struct utmp ut, *utp;
2542     pid_t  mypid = getpid();
2543 #if __GLIBC__ < 2
2544     int    wtmp;
2545 #endif
2546
2547 /*
2548  * Update the signon database for users.
2549  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2550  */
2551     utmpname(_PATH_UTMP);
2552     setutent();
2553     while ((utp = getutent()) && (utp->ut_pid != mypid))
2554         /* nothing */;
2555
2556     if (utp)
2557         memcpy(&ut, utp, sizeof(ut));
2558     else
2559         /* some gettys/telnetds don't initialize utmp... */
2560         memset(&ut, 0, sizeof(ut));
2561
2562     if (ut.ut_id[0] == 0)
2563         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2564
2565     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2566     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2567
2568     time(&ut.ut_time);
2569
2570     ut.ut_type = USER_PROCESS;
2571     ut.ut_pid  = mypid;
2572
2573     /* Insert the host name if one is supplied */
2574     if (*host)
2575         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2576
2577     /* Insert the IP address of the remote system if IP is enabled */
2578     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2579         memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2580                  sizeof(ut.ut_addr));
2581
2582     /* CL: Makes sure that the logout works */
2583     if (*host == 0 && *name==0)
2584         ut.ut_host[0]=0;
2585
2586     pututline(&ut);
2587     endutent();
2588 /*
2589  * Update the wtmp file.
2590  */
2591 #if __GLIBC__ >= 2
2592     updwtmp(_PATH_WTMP, &ut);
2593 #else
2594     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2595     if (wtmp >= 0) {
2596         flock(wtmp, LOCK_EX);
2597
2598         if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2599             warn("error writing %s: %m", _PATH_WTMP);
2600
2601         flock(wtmp, LOCK_UN);
2602
2603         close (wtmp);
2604     }
2605 #endif
2606 }
2607 #endif /* HAVE_LOGWTMP */
2608
2609 /********************************************************************
2610  *
2611  * sifvjcomp - config tcp header compression
2612  */
2613
2614 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2615 {
2616         u_int x;
2617
2618         if (vjcomp) {
2619                 if (ioctl(ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2620                         error("Couldn't set up TCP header compression: %m");
2621                         vjcomp = 0;
2622                 }
2623         }
2624
2625         x = (vjcomp? SC_COMP_TCP: 0) | (cidcomp? 0: SC_NO_TCP_CCID);
2626         modify_flags(ppp_dev_fd, SC_COMP_TCP|SC_NO_TCP_CCID, x);
2627
2628         return 1;
2629 }
2630
2631 /********************************************************************
2632  *
2633  * sifup - Config the interface up and enable IP packets to pass.
2634  */
2635
2636 int sifup(int u)
2637 {
2638     int ret;
2639
2640     if ((ret = setifstate(u, 1)))
2641         if_is_up++;
2642
2643     return ret;
2644 }
2645
2646 /********************************************************************
2647  *
2648  * sifdown - Disable the indicated protocol and config the interface
2649  *           down if there are no remaining protocols.
2650  */
2651
2652 int sifdown (int u)
2653 {
2654     if (if_is_up && --if_is_up > 0)
2655         return 1;
2656
2657 #ifdef INET6
2658     if (if6_is_up)
2659         return 1;
2660 #endif /* INET6 */
2661
2662     return setifstate(u, 0);
2663 }
2664
2665 #ifdef INET6
2666 /********************************************************************
2667  *
2668  * sif6up - Config the interface up for IPv6
2669  */
2670
2671 int sif6up(int u)
2672 {
2673     int ret;
2674
2675     if ((ret = setifstate(u, 1)))
2676         if6_is_up = 1;
2677
2678     return ret;
2679 }
2680
2681 /********************************************************************
2682  *
2683  * sif6down - Disable the IPv6CP protocol and config the interface
2684  *            down if there are no remaining protocols.
2685  */
2686
2687 int sif6down (int u)
2688 {
2689     if6_is_up = 0;
2690
2691     if (if_is_up)
2692         return 1;
2693
2694     return setifstate(u, 0);
2695 }
2696 #endif /* INET6 */
2697
2698 /********************************************************************
2699  *
2700  * setifstate - Config the interface up or down
2701  */
2702
2703 static int setifstate (int u, int state)
2704 {
2705     struct ifreq ifr;
2706
2707     memset (&ifr, '\0', sizeof (ifr));
2708     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2709     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2710         if (! ok_error (errno))
2711             error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2712         return 0;
2713     }
2714
2715     if (state)
2716         ifr.ifr_flags |= IFF_UP;
2717     else
2718         ifr.ifr_flags &= ~IFF_UP;
2719     ifr.ifr_flags |= IFF_POINTOPOINT;
2720     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2721         if (! ok_error (errno))
2722             error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2723         return 0;
2724     }
2725     return 1;
2726 }
2727
2728 /********************************************************************
2729  *
2730  * sifaddr - Config the interface IP addresses and netmask.
2731  */
2732
2733 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2734              u_int32_t net_mask)
2735 {
2736     struct ifreq   ifr;
2737     struct rtentry rt;
2738
2739     memset (&ifr, '\0', sizeof (ifr));
2740     memset (&rt,  '\0', sizeof (rt));
2741
2742     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET);
2743     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2744     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2745
2746     strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2747 /*
2748  *  Set our IP address
2749  */
2750     SIN_ADDR(ifr.ifr_addr) = our_adr;
2751     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2752         if (errno != EEXIST) {
2753             if (! ok_error (errno))
2754                 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2755         }
2756         else {
2757             warn("ioctl(SIOCSIFADDR): Address already exists");
2758         }
2759         return (0);
2760     }
2761 /*
2762  *  Set the gateway address
2763  */
2764     if (his_adr != 0) {
2765         SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2766         if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2767             if (! ok_error (errno))
2768                 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2769             return (0);
2770         }
2771     }
2772 /*
2773  *  Set the netmask.
2774  *  For recent kernels, force the netmask to 255.255.255.255.
2775  */
2776     if (kernel_version >= KVERSION(2,1,16))
2777         net_mask = ~0L;
2778     if (net_mask != 0) {
2779         SIN_ADDR(ifr.ifr_netmask) = net_mask;
2780         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2781             if (! ok_error (errno))
2782                 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2783             return (0);
2784         }
2785     }
2786 /*
2787  *  Add the device route
2788  */
2789     if (kernel_version < KVERSION(2,1,16)) {
2790         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2791         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2792         rt.rt_dev = ifname;
2793
2794         SIN_ADDR(rt.rt_gateway) = 0L;
2795         SIN_ADDR(rt.rt_dst)     = his_adr;
2796         rt.rt_flags = RTF_UP | RTF_HOST;
2797
2798         if (kernel_version > KVERSION(2,1,0)) {
2799             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2800             SIN_ADDR(rt.rt_genmask) = -1L;
2801         }
2802
2803         if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2804             if (! ok_error (errno))
2805                 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2806             return (0);
2807         }
2808     }
2809
2810     /* set ip_dynaddr in demand mode if address changes */
2811     if (demand && tune_kernel && !dynaddr_set
2812         && our_old_addr && our_old_addr != our_adr) {
2813         /* set ip_dynaddr if possible */
2814         char *path;
2815         int fd;
2816
2817         path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2818         if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2819             if (write(fd, "1", 1) != 1)
2820                 error("Couldn't enable dynamic IP addressing: %m");
2821             close(fd);
2822         }
2823         dynaddr_set = 1;        /* only 1 attempt */
2824     }
2825     our_old_addr = 0;
2826
2827     return 1;
2828 }
2829
2830 /********************************************************************
2831  *
2832  * cifaddr - Clear the interface IP addresses, and delete routes
2833  * through the interface if possible.
2834  */
2835
2836 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2837 {
2838     struct ifreq ifr;
2839
2840     if (kernel_version < KVERSION(2,1,16)) {
2841 /*
2842  *  Delete the route through the device
2843  */
2844         struct rtentry rt;
2845         memset (&rt, '\0', sizeof (rt));
2846
2847         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2848         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2849         rt.rt_dev = ifname;
2850
2851         SIN_ADDR(rt.rt_gateway) = 0;
2852         SIN_ADDR(rt.rt_dst)     = his_adr;
2853         rt.rt_flags = RTF_UP | RTF_HOST;
2854
2855         if (kernel_version > KVERSION(2,1,0)) {
2856             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2857             SIN_ADDR(rt.rt_genmask) = -1L;
2858         }
2859
2860         if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2861             if (still_ppp() && ! ok_error (errno))
2862                 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2863             return (0);
2864         }
2865     }
2866
2867     /* This way it is possible to have an IPX-only or IPv6-only interface */
2868     memset(&ifr, 0, sizeof(ifr));
2869     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2870     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2871
2872     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2873         if (! ok_error (errno)) {
2874             error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2875             return 0;
2876         }
2877     }
2878
2879     our_old_addr = our_adr;
2880
2881     return 1;
2882 }
2883
2884 #ifdef INET6
2885 /********************************************************************
2886  *
2887  * sif6addr_rtnetlink - Config the interface with both IPv6 link-local addresses via rtnetlink
2888  */
2889 static int sif6addr_rtnetlink(unsigned int iface, eui64_t our_eui64, eui64_t his_eui64)
2890 {
2891     struct {
2892         struct nlmsghdr nlh;
2893         struct ifaddrmsg ifa;
2894         struct {
2895             struct rtattr rta;
2896             struct in6_addr addr;
2897         } addrs[2];
2898     } nlreq;
2899     struct {
2900         struct nlmsghdr nlh;
2901         struct nlmsgerr nlerr;
2902     } nlresp;
2903     struct sockaddr_nl nladdr;
2904     struct iovec iov;
2905     struct msghdr msg;
2906     ssize_t nlresplen;
2907     int one;
2908     int fd;
2909
2910     fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
2911     if (fd < 0) {
2912         error("sif6addr_rtnetlink: socket(NETLINK_ROUTE): %m (line %d)", __LINE__);
2913         return 0;
2914     }
2915
2916     /*
2917      * Tell kernel to not send to us payload of acknowledgment error message.
2918      * NETLINK_CAP_ACK option is supported since Linux kernel version 4.3 and
2919      * older kernel versions always send full payload in acknowledgment netlink
2920      * message. We ignore payload of this message as we need only error code,
2921      * to check if our set remote peer address request succeeded or failed.
2922      * So ignore return value from the following setsockopt() call as setting
2923      * option NETLINK_CAP_ACK means for us just a kernel hint / optimization.
2924      */
2925     one = 1;
2926     setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &one, sizeof(one));
2927
2928     memset(&nladdr, 0, sizeof(nladdr));
2929     nladdr.nl_family = AF_NETLINK;
2930
2931     if (bind(fd, (struct sockaddr *)&nladdr, sizeof(nladdr)) < 0) {
2932         error("sif6addr_rtnetlink: bind(AF_NETLINK): %m (line %d)", __LINE__);
2933         close(fd);
2934         return 0;
2935     }
2936
2937     memset(&nlreq, 0, sizeof(nlreq));
2938     nlreq.nlh.nlmsg_len = sizeof(nlreq);
2939     nlreq.nlh.nlmsg_type = RTM_NEWADDR;
2940     nlreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE;
2941     nlreq.ifa.ifa_family = AF_INET6;
2942     nlreq.ifa.ifa_prefixlen = 128;
2943     nlreq.ifa.ifa_flags = IFA_F_NODAD | IFA_F_PERMANENT;
2944     nlreq.ifa.ifa_scope = RT_SCOPE_LINK;
2945     nlreq.ifa.ifa_index = iface;
2946     nlreq.addrs[0].rta.rta_len = sizeof(nlreq.addrs[0]);
2947     nlreq.addrs[0].rta.rta_type = IFA_LOCAL;
2948     IN6_LLADDR_FROM_EUI64(nlreq.addrs[0].addr, our_eui64);
2949     nlreq.addrs[1].rta.rta_len = sizeof(nlreq.addrs[1]);
2950     nlreq.addrs[1].rta.rta_type = IFA_ADDRESS;
2951     IN6_LLADDR_FROM_EUI64(nlreq.addrs[1].addr, his_eui64);
2952
2953     memset(&nladdr, 0, sizeof(nladdr));
2954     nladdr.nl_family = AF_NETLINK;
2955
2956     memset(&iov, 0, sizeof(iov));
2957     iov.iov_base = &nlreq;
2958     iov.iov_len = sizeof(nlreq);
2959
2960     memset(&msg, 0, sizeof(msg));
2961     msg.msg_name = &nladdr;
2962     msg.msg_namelen = sizeof(nladdr);
2963     msg.msg_iov = &iov;
2964     msg.msg_iovlen = 1;
2965
2966     if (sendmsg(fd, &msg, 0) < 0) {
2967         error("sif6addr_rtnetlink: sendmsg(RTM_NEWADDR/NLM_F_CREATE): %m (line %d)", __LINE__);
2968         close(fd);
2969         return 0;
2970     }
2971
2972     memset(&iov, 0, sizeof(iov));
2973     iov.iov_base = &nlresp;
2974     iov.iov_len = sizeof(nlresp);
2975
2976     memset(&msg, 0, sizeof(msg));
2977     msg.msg_name = &nladdr;
2978     msg.msg_namelen = sizeof(nladdr);
2979     msg.msg_iov = &iov;
2980     msg.msg_iovlen = 1;
2981
2982     nlresplen = recvmsg(fd, &msg, 0);
2983
2984     if (nlresplen < 0) {
2985         error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): %m (line %d)", __LINE__);
2986         close(fd);
2987         return 0;
2988     }
2989
2990     close(fd);
2991
2992     if (nladdr.nl_family != AF_NETLINK) {
2993         error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not a netlink packet (line %d)", __LINE__);
2994         return 0;
2995     }
2996
2997     if ((size_t)nlresplen != sizeof(nlresp) || nlresp.nlh.nlmsg_len < sizeof(nlresp)) {
2998         error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Acknowledgment netlink packet too short (line %d)", __LINE__);
2999         return 0;
3000     }
3001
3002     /* acknowledgment packet for NLM_F_ACK is NLMSG_ERROR */
3003     if (nlresp.nlh.nlmsg_type != NLMSG_ERROR) {
3004         error("sif6addr_rtnetlink: recvmsg(NLM_F_ACK): Not an acknowledgment netlink packet (line %d)", __LINE__);
3005         return 0;
3006     }
3007
3008     /* error == 0 indicates success, negative value is errno code */
3009     if (nlresp.nlerr.error != 0) {
3010         error("sif6addr_rtnetlink: %s (line %d)", strerror(-nlresp.nlerr.error), __LINE__);
3011         return 0;
3012     }
3013
3014     return 1;
3015 }
3016
3017 /********************************************************************
3018  *
3019  * sif6addr - Config the interface with an IPv6 link-local address
3020  */
3021 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3022 {
3023     struct in6_ifreq ifr6;
3024     struct ifreq ifr;
3025     struct in6_rtmsg rt6;
3026
3027     if (sock6_fd < 0) {
3028         errno = -sock6_fd;
3029         error("IPv6 socket creation failed: %m");
3030         return 0;
3031     }
3032     memset(&ifr, 0, sizeof (ifr));
3033     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3034     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3035         error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3036         return 0;
3037     }
3038
3039     if (kernel_version >= KVERSION(2,1,16)) {
3040         /* Set both local address and remote peer address (with route for it) via rtnetlink */
3041         return sif6addr_rtnetlink(ifr.ifr_ifindex, our_eui64, his_eui64);
3042     } else {
3043         /* Local interface */
3044         memset(&ifr6, 0, sizeof(ifr6));
3045         IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3046         ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3047         ifr6.ifr6_prefixlen = 128;
3048
3049         if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
3050             error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
3051             return 0;
3052         }
3053
3054         /*
3055          * Linux kernel does not provide AF_INET6 ioctl SIOCSIFDSTADDR for
3056          * setting remote peer host address, so set only route to remote host.
3057          */
3058
3059         /* Route to remote host */
3060         memset(&rt6, 0, sizeof(rt6));
3061         IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
3062         rt6.rtmsg_flags = RTF_UP;
3063         rt6.rtmsg_dst_len = 128;
3064         rt6.rtmsg_ifindex = ifr.ifr_ifindex;
3065         rt6.rtmsg_metric = 1;
3066
3067         if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
3068             error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
3069             return 0;
3070         }
3071     }
3072
3073     return 1;
3074 }
3075
3076
3077 /********************************************************************
3078  *
3079  * cif6addr - Remove IPv6 address from interface
3080  */
3081 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
3082 {
3083     struct ifreq ifr;
3084     struct in6_ifreq ifr6;
3085
3086     if (sock6_fd < 0) {
3087         errno = -sock6_fd;
3088         error("IPv6 socket creation failed: %m");
3089         return 0;
3090     }
3091     memset(&ifr, 0, sizeof(ifr));
3092     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3093     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
3094         error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
3095         return 0;
3096     }
3097
3098     memset(&ifr6, 0, sizeof(ifr6));
3099     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
3100     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
3101     ifr6.ifr6_prefixlen = 128;
3102
3103     if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
3104         if (errno != EADDRNOTAVAIL) {
3105             if (! ok_error (errno))
3106                 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
3107         }
3108         else {
3109             warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
3110         }
3111         return (0);
3112     }
3113     return 1;
3114 }
3115 #endif /* INET6 */
3116
3117 /*
3118  * get_pty - get a pty master/slave pair and chown the slave side
3119  * to the uid given.  Assumes slave_name points to >= 16 bytes of space.
3120  */
3121 int
3122 get_pty(int *master_fdp, int *slave_fdp, char *slave_name, int uid)
3123 {
3124     int i, mfd, sfd = -1;
3125     char pty_name[16];
3126     struct termios tios;
3127
3128 #ifdef TIOCGPTN
3129     /*
3130      * Try the unix98 way first.
3131      */
3132     mfd = open("/dev/ptmx", O_RDWR);
3133     if (mfd >= 0) {
3134         int ptn;
3135         if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
3136             slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
3137             chmod(pty_name, S_IRUSR | S_IWUSR);
3138 #ifdef TIOCSPTLCK
3139             ptn = 0;
3140             if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
3141                 warn("Couldn't unlock pty slave %s: %m", pty_name);
3142 #endif
3143             if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
3144             {
3145                 warn("Couldn't open pty slave %s: %m", pty_name);
3146                 close(mfd);
3147             }
3148         }
3149     }
3150 #endif /* TIOCGPTN */
3151
3152     if (sfd < 0) {
3153         /* the old way - scan through the pty name space */
3154         for (i = 0; i < 64; ++i) {
3155             slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
3156                      'p' + i / 16, i % 16);
3157             mfd = open(pty_name, O_RDWR, 0);
3158             if (mfd >= 0) {
3159                 pty_name[5] = 't';
3160                 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
3161                 if (sfd >= 0) {
3162                     fchown(sfd, uid, -1);
3163                     fchmod(sfd, S_IRUSR | S_IWUSR);
3164                     break;
3165                 }
3166                 close(mfd);
3167             }
3168         }
3169     }
3170
3171     if (sfd < 0)
3172         return 0;
3173
3174     strlcpy(slave_name, pty_name, 16);
3175     *master_fdp = mfd;
3176     *slave_fdp = sfd;
3177     if (tcgetattr(sfd, &tios) == 0) {
3178         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
3179         tios.c_cflag |= CS8 | CREAD | CLOCAL;
3180         tios.c_iflag  = IGNPAR;
3181         tios.c_oflag  = 0;
3182         tios.c_lflag  = 0;
3183         if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
3184             warn("couldn't set attributes on pty: %m");
3185     } else
3186         warn("couldn't get attributes on pty: %m");
3187
3188     return 1;
3189 }
3190
3191 /********************************************************************
3192  *
3193  * open_loopback - open the device we use for getting packets
3194  * in demand mode.  Under Linux, we use a pty master/slave pair.
3195  */
3196 int
3197 open_ppp_loopback(void)
3198 {
3199     int flags;
3200
3201     looped = 1;
3202     if (new_style_driver) {
3203         /* allocate ourselves a ppp unit */
3204         if (make_ppp_unit() < 0)
3205             die(1);
3206         modify_flags(ppp_dev_fd, 0, SC_LOOP_TRAFFIC);
3207         set_kdebugflag(kdebugflag);
3208         ppp_fd = -1;
3209         return ppp_dev_fd;
3210     }
3211
3212     if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
3213         fatal("No free pty for loopback");
3214
3215     set_ppp_fd(slave_fd);
3216
3217     flags = fcntl(master_fd, F_GETFL);
3218     if (flags == -1 ||
3219         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3220         warn("couldn't set master loopback to nonblock: %m");
3221
3222     flags = fcntl(ppp_fd, F_GETFL);
3223     if (flags == -1 ||
3224         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
3225         warn("couldn't set slave loopback to nonblock: %m");
3226
3227     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
3228         fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
3229 /*
3230  * Find out which interface we were given.
3231  */
3232     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
3233         fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
3234 /*
3235  * Enable debug in the driver if requested.
3236  */
3237     set_kdebugflag (kdebugflag);
3238
3239     return master_fd;
3240 }
3241
3242 /********************************************************************
3243  *
3244  * sifnpmode - Set the mode for handling packets for a given NP.
3245  */
3246
3247 int
3248 sifnpmode(int u, int proto, enum NPmode mode)
3249 {
3250     struct npioctl npi;
3251
3252     npi.protocol = proto;
3253     npi.mode     = mode;
3254     if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
3255         if (! ok_error (errno))
3256             error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
3257         return 0;
3258     }
3259     return 1;
3260 }
3261
3262 \f
3263 /********************************************************************
3264  *
3265  * sipxfaddr - Config the interface IPX networknumber
3266  */
3267
3268 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
3269 {
3270     int    result = 1;
3271
3272 #ifdef IPX_CHANGE
3273     int    skfd;
3274     struct ifreq         ifr;
3275     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3276
3277     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3278     if (skfd < 0) {
3279         if (! ok_error (errno))
3280             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3281         result = 0;
3282     }
3283     else {
3284         memset (&ifr, '\0', sizeof (ifr));
3285         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3286
3287         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
3288         sipx->sipx_family  = AF_IPX;
3289         sipx->sipx_port    = 0;
3290         sipx->sipx_network = htonl (network);
3291         sipx->sipx_type    = IPX_FRAME_ETHERII;
3292         sipx->sipx_action  = IPX_CRTITF;
3293 /*
3294  *  Set the IPX device
3295  */
3296         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3297             result = 0;
3298             if (errno != EEXIST) {
3299                 if (! ok_error (errno))
3300                     dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
3301             }
3302             else {
3303                 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
3304             }
3305         }
3306         close (skfd);
3307     }
3308 #endif
3309     return result;
3310 }
3311
3312 /********************************************************************
3313  *
3314  * cipxfaddr - Clear the information for the IPX network. The IPX routes
3315  *             are removed and the device is no longer able to pass IPX
3316  *             frames.
3317  */
3318
3319 int cipxfaddr (int unit)
3320 {
3321     int    result = 1;
3322
3323 #ifdef IPX_CHANGE
3324     int    skfd;
3325     struct ifreq         ifr;
3326     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
3327
3328     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
3329     if (skfd < 0) {
3330         if (! ok_error (errno))
3331             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
3332         result = 0;
3333     }
3334     else {
3335         memset (&ifr, '\0', sizeof (ifr));
3336         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
3337
3338         sipx->sipx_type    = IPX_FRAME_ETHERII;
3339         sipx->sipx_action  = IPX_DLTITF;
3340         sipx->sipx_family  = AF_IPX;
3341 /*
3342  *  Set the IPX device
3343  */
3344         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
3345             if (! ok_error (errno))
3346                 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
3347             result = 0;
3348         }
3349         close (skfd);
3350     }
3351 #endif
3352     return result;
3353 }
3354
3355 /*
3356  * Use the hostname as part of the random number seed.
3357  */
3358 int
3359 get_host_seed(void)
3360 {
3361     int h;
3362     char *p = hostname;
3363
3364     h = 407;
3365     for (p = hostname; *p != 0; ++p)
3366         h = h * 37 + *p;
3367     return h;
3368 }
3369
3370 /********************************************************************
3371  *
3372  * sys_check_options - check the options that the user specified
3373  */
3374
3375 int
3376 sys_check_options(void)
3377 {
3378 #ifdef IPX_CHANGE
3379 /*
3380  * Disable the IPX protocol if the support is not present in the kernel.
3381  */
3382     char *path;
3383
3384     if (ipxcp_protent.enabled_flag) {
3385         struct stat stat_buf;
3386         if (  ((path = path_to_procfs("/net/ipx/interface")) == NULL
3387             && (path = path_to_procfs("/net/ipx_interface")) == NULL)
3388             || lstat(path, &stat_buf) < 0) {
3389             error("IPX support is not present in the kernel\n");
3390             ipxcp_protent.enabled_flag = 0;
3391         }
3392     }
3393 #endif
3394     if (demand && driver_is_old) {
3395         option_error("demand dialling is not supported by kernel driver "
3396                      "version %d.%d.%d", driver_version, driver_modification,
3397                      driver_patch);
3398         return 0;
3399     }
3400     if (multilink && !new_style_driver) {
3401         warn("Warning: multilink is not supported by the kernel driver");
3402         multilink = 0;
3403     }
3404     return 1;
3405 }
3406
3407 /********************************************************************
3408  *
3409  * get_time - Get current time, monotonic if possible.
3410  */
3411 int
3412 get_time(struct timeval *tv)
3413 {
3414 /* Old glibc (< 2.3.4) does define CLOCK_MONOTONIC, but kernel may have it.
3415  * Runtime checking makes it safe. */
3416 #ifndef CLOCK_MONOTONIC
3417 #define CLOCK_MONOTONIC 1
3418 #endif
3419     static int monotonic = -1;
3420     struct timespec ts;
3421     int ret;
3422
3423     if (monotonic) {
3424         ret = clock_gettime(CLOCK_MONOTONIC, &ts);
3425         if (ret == 0) {
3426             monotonic = 1;
3427             if (tv) {
3428                 tv->tv_sec = ts.tv_sec;
3429                 tv->tv_usec = ts.tv_nsec / 1000;
3430             }
3431             return ret;
3432         } else if (monotonic > 0)
3433             return ret;
3434
3435         monotonic = 0;
3436         warn("Couldn't use monotonic clock source: %m");
3437     }
3438
3439     return gettimeofday(tv, NULL);
3440 }