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