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