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