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