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) 1989 Carnegie Mellon University.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms are permitted
   9  * provided that the above copyright notice and this paragraph are
  10  * duplicated in all such forms and that any documentation,
  11  * advertising materials, and other materials related to such
  12  * distribution and use acknowledge that the software was developed
  13  * by Carnegie Mellon University.  The name of the
  14  * University may not be used to endorse or promote products derived
  15  * from this software without specific prior written permission.
  16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19  */
  20
  21 #include <sys/ioctl.h>
  22 #include <sys/types.h>
  23 #include <sys/socket.h>
  24 #include <sys/time.h>
  25 #include <sys/errno.h>
  26 #include <sys/file.h>
  27 #include <sys/stat.h>
  28 #include <sys/utsname.h>
  29 #include <sys/sysmacros.h>
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <syslog.h>
  34 #include <string.h>
  35 #include <time.h>
  36 #include <memory.h>
  37 #include <utmp.h>
  38 #include <mntent.h>
  39 #include <signal.h>
  40 #include <fcntl.h>
  41 #include <ctype.h>
  42 #include <termios.h>
  43 #include <unistd.h>
  44
  45 /* This is in netdevice.h. However, this compile will fail miserably if
  46    you attempt to include netdevice.h because it has so many references
  47    to __memcpy functions which it should not attempt to do. So, since I
  48    really don't use it, but it must be defined, define it now. */
  49
  50 #ifndef MAX_ADDR_LEN
  51 #define MAX_ADDR_LEN 7
  52 #endif
  53
  54 #if __GLIBC__ >= 2
  55 #include <asm/types.h>          /* glibc 2 conflicts with linux/types.h */
  56 #include <net/if.h>
  57 #include <net/if_arp.h>
  58 #include <net/route.h>
  59 #include <netinet/if_ether.h>
  60 #else
  61 #include <linux/types.h>
  62 #include <linux/if.h>
  63 #include <linux/if_arp.h>
  64 #include <linux/route.h>
  65 #include <linux/if_ether.h>
  66 #endif
  67 #include <netinet/in.h>
  68 #include <arpa/inet.h>
  69
  70 #include <linux/ppp_defs.h>
  71 #include <linux/if_ppp.h>
  72
  73 #include "pppd.h"
  74 #include "fsm.h"
  75 #include "ipcp.h"
  76 #include "patchlevel.h"
  77
  78 #ifdef IPX_CHANGE
  79 #include "ipxcp.h"
  80 #if __GLIBC__ >= 2 && \
  81     !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
  82 #include <netipx/ipx.h>
  83 #else
  84 #include <linux/ipx.h>
  85 #endif
  86 #endif /* IPX_CHANGE */
  87
  88 #ifdef LOCKLIB
  89 #include <sys/locks.h>
  90 #endif
  91
  92 #ifdef INET6
  93 #ifndef _LINUX_IN6_H
  94 /*
  95  *    This is in linux/include/net/ipv6.h.
  96  */
  97
  98 struct in6_ifreq {
  99     struct in6_addr ifr6_addr;
 100     __u32 ifr6_prefixlen;
 101     unsigned int ifr6_ifindex;
 102 };
 103 #endif
 104
 105 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do {                 \
 106         memset(&sin6.s6_addr, 0, sizeof(struct in6_addr));      \
 107         sin6.s6_addr16[0] = htons(0xfe80);                      \
 108         eui64_copy(eui64, sin6.s6_addr32[2]);                   \
 109         } while (0)
 110
 111 #endif /* INET6 */
 112
 113 /* We can get an EIO error on an ioctl if the modem has hung up */
 114 #define ok_error(num) ((num)==EIO)
 115
 116 static int tty_disc = N_TTY;    /* The TTY discipline */
 117 static int ppp_disc = N_PPP;    /* The PPP discpline */
 118 static int initfdflags = -1;    /* Initial file descriptor flags for fd */
 119 static int ppp_fd = -1;         /* fd which is set to PPP discipline */
 120 static int sock_fd = -1;        /* socket for doing interface ioctls */
 121 static int slave_fd = -1;
 122 static int master_fd = -1;
 123 #ifdef INET6
 124 static int sock6_fd = -1;
 125 #endif /* INET6 */
 126 static int ppp_dev_fd = -1;     /* fd for /dev/ppp (new style driver) */
 127 static int chindex;             /* channel index (new style driver) */
 128
 129 static fd_set in_fds;           /* set of fds that wait_input waits for */
 130 static int max_in_fd;           /* highest fd set in in_fds */
 131
 132 static int has_proxy_arp       = 0;
 133 static int driver_version      = 0;
 134 static int driver_modification = 0;
 135 static int driver_patch        = 0;
 136 static int driver_is_old       = 0;
 137 static int restore_term        = 0;     /* 1 => we've munged the terminal */
 138 static struct termios inittermios;      /* Initial TTY termios */
 139
 140 static int new_style_driver = 0;
 141
 142 static char loop_name[20];
 143 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
 144
 145 static int      if_is_up;       /* Interface has been marked up */
 146 static u_int32_t default_route_gateway; /* Gateway for default route added */
 147 static u_int32_t proxy_arp_addr;        /* Addr for proxy arp entry added */
 148 static char proxy_arp_dev[16];          /* Device for proxy arp entry */
 149 static u_int32_t our_old_addr;          /* for detecting address changes */
 150 static int      dynaddr_set;            /* 1 if ip_dynaddr set */
 151 static int      looped;                 /* 1 if using loop */
 152
 153 static struct utsname utsname;  /* for the kernel version */
 154 static int kernel_version;
 155 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
 156
 157 #define MAX_IFS         100
 158
 159 #define FLAGS_GOOD (IFF_UP          | IFF_BROADCAST)
 160 #define FLAGS_MASK (IFF_UP          | IFF_BROADCAST | \
 161                     IFF_POINTOPOINT | IFF_LOOPBACK  | IFF_NOARP)
 162
 163 #define SIN_ADDR(x)     (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
 164
 165 /* Prototypes for procedures local to this file. */
 166 static int get_flags (int fd);
 167 static void set_flags (int fd, int flags);
 168 static int translate_speed (int bps);
 169 static int baud_rate_of (int speed);
 170 static void close_route_table (void);
 171 static int open_route_table (void);
 172 static int read_route_table (struct rtentry *rt);
 173 static int defaultroute_exists (struct rtentry *rt);
 174 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
 175                            char *name, int namelen);
 176 static void decode_version (char *buf, int *version, int *mod, int *patch);
 177 static int set_kdebugflag(int level);
 178 static int ppp_registered(void);
 179
 180 extern u_char   inpacket_buf[]; /* borrowed from main.c */
 181
 182 /*
 183  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
 184  * if it exists.
 185  */
 186
 187 #define SET_SA_FAMILY(addr, family)                     \
 188     memset ((char *) &(addr), '\0', sizeof(addr));      \
 189     addr.sa_family = (family);
 190
 191 /*
 192  * Determine if the PPP connection should still be present.
 193  */
 194
 195 extern int hungup;
 196
 197 /* new_fd is the fd of a tty */
 198 static void set_ppp_fd (int new_fd)
 199 {
 200         SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
 201         ppp_fd = new_fd;
 202         if (!new_style_driver)
 203                 ppp_dev_fd = new_fd;
 204 }
 205
 206 static int still_ppp(void)
 207 {
 208         if (new_style_driver)
 209                 return !hungup && ppp_fd >= 0;
 210         if (!hungup || ppp_fd == slave_fd)
 211                 return 1;
 212         if (slave_fd >= 0) {
 213                 set_ppp_fd(slave_fd);
 214                 return 1;
 215         }
 216         return 0;
 217 }
 218
 219 /********************************************************************
 220  *
 221  * Functions to read and set the flags value in the device driver
 222  */
 223
 224 static int get_flags (int fd)
 225 {
 226     int flags;
 227
 228     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
 229         if ( ok_error (errno) )
 230             flags = 0;
 231         else
 232             fatal("ioctl(PPPIOCGFLAGS): %m");
 233     }
 234
 235     SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
 236     return flags;
 237 }
 238
 239 /********************************************************************/
 240
 241 static void set_flags (int fd, int flags)
 242 {
 243     SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
 244
 245     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
 246         if (! ok_error (errno) )
 247             fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
 248     }
 249 }
 250
 251 /********************************************************************
 252  *
 253  * sys_init - System-dependent initialization.
 254  */
 255
 256 void sys_init(void)
 257 {
 258     int flags;
 259
 260     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
 261     setlogmask(LOG_UPTO(LOG_INFO));
 262     if (debug)
 263         setlogmask(LOG_UPTO(LOG_DEBUG));
 264
 265     if (new_style_driver) {
 266         ppp_dev_fd = open("/dev/ppp", O_RDWR);
 267         if (ppp_dev_fd < 0)
 268             fatal("Couldn't open /dev/ppp: %m");
 269         flags = fcntl(ppp_dev_fd, F_GETFL);
 270         if (flags == -1
 271             || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
 272             warn("Couldn't set /dev/ppp to nonblock: %m");
 273     }
 274
 275     /* Get an internet socket for doing socket ioctls. */
 276     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
 277     if (sock_fd < 0)
 278         fatal("Couldn't create IP socket: %m(%d)", errno);
 279
 280 #ifdef INET6
 281     sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
 282     if (sock6_fd < 0)
 283         fatal("Couldn't create IPv6 socket: %m(%d)", errno);
 284 #endif
 285
 286     FD_ZERO(&in_fds);
 287     max_in_fd = 0;
 288 }
 289
 290 /********************************************************************
 291  *
 292  * sys_cleanup - restore any system state we modified before exiting:
 293  * mark the interface down, delete default route and/or proxy arp entry.
 294  * This shouldn't call die() because it's called from die().
 295  */
 296
 297 void sys_cleanup(void)
 298 {
 299 /*
 300  * Take down the device
 301  */
 302     if (if_is_up) {
 303         if_is_up = 0;
 304         sifdown(0);
 305     }
 306 /*
 307  * Delete any routes through the device.
 308  */
 309     if (default_route_gateway != 0)
 310         cifdefaultroute(0, 0, default_route_gateway);
 311
 312     if (has_proxy_arp)
 313         cifproxyarp(0, proxy_arp_addr);
 314 }
 315
 316 /********************************************************************
 317  *
 318  * sys_close - Clean up in a child process before execing.
 319  */
 320 void
 321 sys_close(void)
 322 {
 323     if (new_style_driver)
 324         close(ppp_dev_fd);
 325     if (sock_fd >= 0)
 326         close(sock_fd);
 327     if (slave_fd >= 0)
 328         close(slave_fd);
 329     if (master_fd >= 0)
 330         close(master_fd);
 331     closelog();
 332 }
 333
 334 /********************************************************************
 335  *
 336  * set_kdebugflag - Define the debugging level for the kernel
 337  */
 338
 339 static int set_kdebugflag (int requested_level)
 340 {
 341     if (new_style_driver && ifunit < 0)
 342         return 1;
 343     if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
 344         if ( ! ok_error (errno) )
 345             error("ioctl(PPPIOCSDEBUG): %m");
 346         return (0);
 347     }
 348     SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
 349                 requested_level));
 350     return (1);
 351 }
 352
 353 /********************************************************************
 354  *
 355  * establish_ppp - Turn the serial port into a ppp interface.
 356  */
 357
 358 int establish_ppp (int tty_fd)
 359 {
 360     int x;
 361     int fd = -1;
 362
 363 /*
 364  * Ensure that the tty device is in exclusive mode.
 365  */
 366     if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
 367         if ( ! ok_error ( errno ))
 368             warn("Couldn't make tty exclusive: %m");
 369     }
 370 /*
 371  * Demand mode - prime the old ppp device to relinquish the unit.
 372  */
 373     if (!new_style_driver && looped
 374         && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
 375         error("ioctl(transfer ppp unit): %m");
 376         return -1;
 377     }
 378 /*
 379  * Set the current tty to the PPP discpline
 380  */
 381
 382 #ifndef N_SYNC_PPP
 383 #define N_SYNC_PPP 14
 384 #endif
 385     ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
 386     if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
 387         if ( ! ok_error (errno) ) {
 388             error("Couldn't set tty to PPP discipline: %m");
 389             return -1;
 390         }
 391     }
 392
 393     if (new_style_driver) {
 394         /* Open another instance of /dev/ppp and connect the channel to it */
 395         int flags;
 396
 397         if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
 398             error("Couldn't get channel number: %m");
 399             goto err;
 400         }
 401         dbglog("using channel %d", chindex);
 402         fd = open("/dev/ppp", O_RDWR);
 403         if (fd < 0) {
 404             error("Couldn't reopen /dev/ppp: %m");
 405             goto err;
 406         }
 407         if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
 408             error("Couldn't attach to channel %d: %m", chindex);
 409             goto err_close;
 410         }
 411         flags = fcntl(fd, F_GETFL);
 412         if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
 413             warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
 414         set_ppp_fd(fd);
 415
 416         ifunit = -1;
 417         if (!looped && !multilink) {
 418             /*
 419              * Create a new PPP unit.
 420              */
 421             ifunit = req_unit;
 422             x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
 423             if (x < 0 && req_unit >= 0 && errno == EEXIST) {
 424                 warn("Couldn't allocate PPP unit %d as it is already in use");
 425                 ifunit = -1;
 426                 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
 427             }
 428             if (x < 0) {
 429                 error("Couldn't create new ppp unit: %m");
 430                 goto err_close;
 431             }
 432         }
 433
 434         if (looped)
 435             set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
 436
 437         if (!multilink) {
 438             add_fd(ppp_dev_fd);
 439             if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
 440                 error("Couldn't attach to PPP unit %d: %m", ifunit);
 441                 goto err_close;
 442             }
 443         }
 444
 445     } else {
 446         /*
 447          * Old-style driver: find out which interface we were given.
 448          */
 449         set_ppp_fd (tty_fd);
 450         if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
 451             if ( ! ok_error (errno))
 452                 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
 453         }
 454         /* Check that we got the same unit again. */
 455         if (looped && x != ifunit)
 456             fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
 457         ifunit = x;
 458
 459         /*
 460          * Fetch the initial file flags and reset blocking mode on the file.
 461          */
 462         initfdflags = fcntl(tty_fd, F_GETFL);
 463         if (initfdflags == -1 ||
 464             fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
 465             if ( ! ok_error (errno))
 466                 warn("Couldn't set device to non-blocking mode: %m");
 467         }
 468     }
 469
 470     looped = 0;
 471
 472     /*
 473      * Enable debug in the driver if requested.
 474      */
 475     if (!looped)
 476         set_kdebugflag (kdebugflag);
 477
 478     set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
 479                                             SC_RCV_EVNP | SC_RCV_ODDP));
 480
 481     SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
 482             driver_version, driver_modification, driver_patch));
 483
 484     return ppp_fd;
 485
 486  err_close:
 487     close(fd);
 488  err:
 489     if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
 490         warn("Couldn't reset tty to normal line discipline: %m");
 491     return -1;
 492 }
 493
 494 /********************************************************************
 495  *
 496  * disestablish_ppp - Restore the serial port to normal operation.
 497  * This shouldn't call die() because it's called from die().
 498  */
 499
 500 void disestablish_ppp(int tty_fd)
 501 {
 502     if (!hungup) {
 503 /*
 504  * Flush the tty output buffer so that the TIOCSETD doesn't hang.
 505  */
 506         if (tcflush(tty_fd, TCIOFLUSH) < 0)
 507             warn("tcflush failed: %m");
 508 /*
 509  * Restore the previous line discipline
 510  */
 511         if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
 512             if ( ! ok_error (errno))
 513                 error("ioctl(TIOCSETD, N_TTY): %m");
 514         }
 515
 516         if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
 517             if ( ! ok_error (errno))
 518                 warn("ioctl(TIOCNXCL): %m(%d)", errno);
 519         }
 520
 521         /* Reset non-blocking mode on fd. */
 522         if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
 523             if ( ! ok_error (errno))
 524                 warn("Couldn't restore device fd flags: %m");
 525         }
 526     }
 527     initfdflags = -1;
 528
 529     if (new_style_driver) {
 530         close(ppp_fd);
 531         ppp_fd = -1;
 532         if (!looped && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
 533             error("Couldn't release PPP unit: %m");
 534         if (!multilink)
 535             remove_fd(ppp_dev_fd);
 536     }
 537 }
 538
 539 /*
 540  * bundle_attach - attach our link to a given PPP unit.
 541  */
 542 int bundle_attach(int ifnum)
 543 {
 544     int mrru = 1500;
 545
 546     if (!new_style_driver)
 547         return -1;
 548
 549     if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
 550         error("Couldn't attach to interface unit %d: %m\n", ifnum);
 551         return -1;
 552     }
 553     set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
 554     if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
 555         error("Couldn't set interface MRRU: %m");
 556
 557     if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0) {
 558         error("Couldn't connect to interface unit %d: %m", ifnum);
 559         return -1;
 560     }
 561
 562     dbglog("bundle_attach succeeded");
 563     return 0;
 564 }
 565
 566 /********************************************************************
 567  *
 568  * clean_check - Fetch the flags for the device and generate
 569  * appropriate error messages.
 570  */
 571 void clean_check(void)
 572 {
 573     int x;
 574     char *s;
 575
 576     if (still_ppp()) {
 577         if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
 578             s = NULL;
 579             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
 580             case SC_RCV_B7_0:
 581                 s = "all had bit 7 set to 1";
 582                 break;
 583
 584             case SC_RCV_B7_1:
 585                 s = "all had bit 7 set to 0";
 586                 break;
 587
 588             case SC_RCV_EVNP:
 589                 s = "all had odd parity";
 590                 break;
 591
 592             case SC_RCV_ODDP:
 593                 s = "all had even parity";
 594                 break;
 595             }
 596
 597             if (s != NULL) {
 598                 warn("Receive serial link is not 8-bit clean:");
 599                 warn("Problem: %s", s);
 600             }
 601         }
 602     }
 603 }
 604
 605
 606 /*
 607  * List of valid speeds.
 608  */
 609
 610 struct speed {
 611     int speed_int, speed_val;
 612 } speeds[] = {
 613 #ifdef B50
 614     { 50, B50 },
 615 #endif
 616 #ifdef B75
 617     { 75, B75 },
 618 #endif
 619 #ifdef B110
 620     { 110, B110 },
 621 #endif
 622 #ifdef B134
 623     { 134, B134 },
 624 #endif
 625 #ifdef B150
 626     { 150, B150 },
 627 #endif
 628 #ifdef B200
 629     { 200, B200 },
 630 #endif
 631 #ifdef B300
 632     { 300, B300 },
 633 #endif
 634 #ifdef B600
 635     { 600, B600 },
 636 #endif
 637 #ifdef B1200
 638     { 1200, B1200 },
 639 #endif
 640 #ifdef B1800
 641     { 1800, B1800 },
 642 #endif
 643 #ifdef B2000
 644     { 2000, B2000 },
 645 #endif
 646 #ifdef B2400
 647     { 2400, B2400 },
 648 #endif
 649 #ifdef B3600
 650     { 3600, B3600 },
 651 #endif
 652 #ifdef B4800
 653     { 4800, B4800 },
 654 #endif
 655 #ifdef B7200
 656     { 7200, B7200 },
 657 #endif
 658 #ifdef B9600
 659     { 9600, B9600 },
 660 #endif
 661 #ifdef B19200
 662     { 19200, B19200 },
 663 #endif
 664 #ifdef B38400
 665     { 38400, B38400 },
 666 #endif
 667 #ifdef B57600
 668     { 57600, B57600 },
 669 #endif
 670 #ifdef B115200
 671     { 115200, B115200 },
 672 #endif
 673 #ifdef EXTA
 674     { 19200, EXTA },
 675 #endif
 676 #ifdef EXTB
 677     { 38400, EXTB },
 678 #endif
 679 #ifdef B230400
 680     { 230400, B230400 },
 681 #endif
 682 #ifdef B460800
 683     { 460800, B460800 },
 684 #endif
 685     { 0, 0 }
 686 };
 687
 688 /********************************************************************
 689  *
 690  * Translate from bits/second to a speed_t.
 691  */
 692
 693 static int translate_speed (int bps)
 694 {
 695     struct speed *speedp;
 696
 697     if (bps != 0) {
 698         for (speedp = speeds; speedp->speed_int; speedp++) {
 699             if (bps == speedp->speed_int)
 700                 return speedp->speed_val;
 701         }
 702         warn("speed %d not supported", bps);
 703     }
 704     return 0;
 705 }
 706
 707 /********************************************************************
 708  *
 709  * Translate from a speed_t to bits/second.
 710  */
 711
 712 static int baud_rate_of (int speed)
 713 {
 714     struct speed *speedp;
 715
 716     if (speed != 0) {
 717         for (speedp = speeds; speedp->speed_int; speedp++) {
 718             if (speed == speedp->speed_val)
 719                 return speedp->speed_int;
 720         }
 721     }
 722     return 0;
 723 }
 724
 725 /********************************************************************
 726  *
 727  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
 728  * at the requested speed, etc.  If `local' is true, set CLOCAL
 729  * regardless of whether the modem option was specified.
 730  */
 731
 732 void set_up_tty(int tty_fd, int local)
 733 {
 734     int speed;
 735     struct termios tios;
 736
 737     setdtr(tty_fd, 1);
 738     if (tcgetattr(tty_fd, &tios) < 0) {
 739         if (!ok_error(errno))
 740             fatal("tcgetattr: %m(%d)", errno);
 741         return;
 742     }
 743
 744     if (!restore_term)
 745         inittermios = tios;
 746
 747     tios.c_cflag     &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
 748     tios.c_cflag     |= CS8 | CREAD | HUPCL;
 749
 750     tios.c_iflag      = IGNBRK | IGNPAR;
 751     tios.c_oflag      = 0;
 752     tios.c_lflag      = 0;
 753     tios.c_cc[VMIN]   = 1;
 754     tios.c_cc[VTIME]  = 0;
 755
 756     if (local || !modem)
 757         tios.c_cflag ^= (CLOCAL | HUPCL);
 758
 759     switch (crtscts) {
 760     case 1:
 761         tios.c_cflag |= CRTSCTS;
 762         break;
 763
 764     case -2:
 765         tios.c_iflag     |= IXON | IXOFF;
 766         tios.c_cc[VSTOP]  = 0x13;       /* DC3 = XOFF = ^S */
 767         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
 768         break;
 769
 770     case -1:
 771         tios.c_cflag &= ~CRTSCTS;
 772         break;
 773
 774     default:
 775         break;
 776     }
 777
 778     speed = translate_speed(inspeed);
 779     if (speed) {
 780         cfsetospeed (&tios, speed);
 781         cfsetispeed (&tios, speed);
 782     }
 783 /*
 784  * We can't proceed if the serial port speed is B0,
 785  * since that implies that the serial port is disabled.
 786  */
 787     else {
 788         speed = cfgetospeed(&tios);
 789         if (speed == B0)
 790             fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
 791     }
 792
 793     if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
 794         if (!ok_error(errno))
 795             fatal("tcsetattr: %m");
 796
 797     baud_rate    = baud_rate_of(speed);
 798     restore_term = 1;
 799 }
 800
 801 /********************************************************************
 802  *
 803  * setdtr - control the DTR line on the serial port.
 804  * This is called from die(), so it shouldn't call die().
 805  */
 806
 807 void setdtr (int tty_fd, int on)
 808 {
 809     int modembits = TIOCM_DTR;
 810
 811     ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
 812 }
 813
 814 /********************************************************************
 815  *
 816  * restore_tty - restore the terminal to the saved settings.
 817  */
 818
 819 void restore_tty (int tty_fd)
 820 {
 821     if (restore_term) {
 822         restore_term = 0;
 823 /*
 824  * Turn off echoing, because otherwise we can get into
 825  * a loop with the tty and the modem echoing to each other.
 826  * We presume we are the sole user of this tty device, so
 827  * when we close it, it will revert to its defaults anyway.
 828  */
 829         if (!default_device)
 830             inittermios.c_lflag &= ~(ECHO | ECHONL);
 831
 832         if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
 833             if (! ok_error (errno))
 834                 warn("tcsetattr: %m");
 835         }
 836     }
 837 }
 838
 839 /********************************************************************
 840  *
 841  * output - Output PPP packet.
 842  */
 843
 844 void output (int unit, unsigned char *p, int len)
 845 {
 846     int fd = ppp_fd;
 847     int proto;
 848
 849     if (debug)
 850         dbglog("sent %P", p, len);
 851
 852     if (len < PPP_HDRLEN)
 853         return;
 854     if (new_style_driver) {
 855         p += 2;
 856         len -= 2;
 857         proto = (p[0] << 8) + p[1];
 858         if (!multilink && proto != PPP_LCP)
 859             fd = ppp_dev_fd;
 860     }
 861     if (write(fd, p, len) < 0) {
 862         if (errno == EWOULDBLOCK || errno == ENOBUFS
 863             || errno == ENXIO || errno == EIO || errno == EINTR)
 864             warn("write: warning: %m (%d)", errno);
 865         else
 866             error("write: %m (%d)", errno);
 867     }
 868 }
 869
 870 /********************************************************************
 871  *
 872  * wait_input - wait until there is data available,
 873  * for the length of time specified by *timo (indefinite
 874  * if timo is NULL).
 875  */
 876
 877 void wait_input(struct timeval *timo)
 878 {
 879     fd_set ready, exc;
 880     int n;
 881
 882     ready = in_fds;
 883     exc = in_fds;
 884     n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
 885     if (n < 0 && errno != EINTR)
 886         fatal("select: %m(%d)", errno);
 887 }
 888
 889 /*
 890  * add_fd - add an fd to the set that wait_input waits for.
 891  */
 892 void add_fd(int fd)
 893 {
 894     FD_SET(fd, &in_fds);
 895     if (fd > max_in_fd)
 896         max_in_fd = fd;
 897 }
 898
 899 /*
 900  * remove_fd - remove an fd from the set that wait_input waits for.
 901  */
 902 void remove_fd(int fd)
 903 {
 904     FD_CLR(fd, &in_fds);
 905 }
 906
 907
 908 /********************************************************************
 909  *
 910  * read_packet - get a PPP packet from the serial device.
 911  */
 912
 913 int read_packet (unsigned char *buf)
 914 {
 915     int len, nr;
 916
 917     len = PPP_MRU + PPP_HDRLEN;
 918     if (new_style_driver) {
 919         *buf++ = PPP_ALLSTATIONS;
 920         *buf++ = PPP_UI;
 921         len -= 2;
 922     }
 923     nr = -1;
 924     if (ppp_fd >= 0) {
 925         nr = read(ppp_fd, buf, len);
 926         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
 927             error("read: %m");
 928     }
 929     if (nr < 0 && new_style_driver && !multilink) {
 930         /* N.B. we read ppp_fd first since LCP packets come in there. */
 931         nr = read(ppp_dev_fd, buf, len);
 932         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
 933             error("read /dev/ppp: %m");
 934     }
 935     return (new_style_driver && nr > 0)? nr+2: nr;
 936 }
 937
 938 /********************************************************************
 939  *
 940  * get_loop_output - get outgoing packets from the ppp device,
 941  * and detect when we want to bring the real link up.
 942  * Return value is 1 if we need to bring up the link, 0 otherwise.
 943  */
 944 int
 945 get_loop_output(void)
 946 {
 947     int rv = 0;
 948     int n;
 949
 950     if (new_style_driver) {
 951         while ((n = read_packet(inpacket_buf)) > 0)
 952             if (loop_frame(inpacket_buf, n))
 953                 rv = 1;
 954         return rv;
 955     }
 956
 957     while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
 958         if (loop_chars(inbuf, n))
 959             rv = 1;
 960
 961     if (n == 0)
 962         fatal("eof on loopback");
 963
 964     if (errno != EWOULDBLOCK)
 965         fatal("read from loopback: %m(%d)", errno);
 966
 967     return rv;
 968 }
 969
 970 /********************************************************************
 971  *
 972  * ppp_send_config - configure the transmit characteristics of
 973  * the ppp interface.
 974  */
 975
 976 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
 977 {
 978     u_int x;
 979     struct ifreq ifr;
 980
 981     SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
 982 /*
 983  * Set the MTU and other parameters for the ppp device
 984  */
 985     memset (&ifr, '\0', sizeof (ifr));
 986     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
 987     ifr.ifr_mtu = mtu;
 988
 989     if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
 990         fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
 991
 992     if (!still_ppp())
 993         return;
 994     SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
 995     if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
 996         if (!ok_error(errno))
 997             fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
 998         return;
 999     }
1000
1001     x = get_flags(ppp_fd);
1002     x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1003     x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
1004     x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1005     set_flags(ppp_fd, x);
1006 }
1007
1008 /********************************************************************
1009  *
1010  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1011  */
1012
1013 void ppp_set_xaccm (int unit, ext_accm accm)
1014 {
1015     SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1016                 accm[0], accm[1], accm[2], accm[3]));
1017
1018     if (!still_ppp())
1019         return;
1020     if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1021         if ( ! ok_error (errno))
1022             warn("ioctl(set extended ACCM): %m(%d)", errno);
1023     }
1024 }
1025
1026 /********************************************************************
1027  *
1028  * ppp_recv_config - configure the receive-side characteristics of
1029  * the ppp interface.
1030  */
1031
1032 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1033 {
1034     SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1035 /*
1036  * If we were called because the link has gone down then there is nothing
1037  * which may be done. Just return without incident.
1038  */
1039     if (!still_ppp())
1040         return;
1041 /*
1042  * Set the receiver parameters
1043  */
1044     if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1045         if ( ! ok_error (errno))
1046             error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1047     }
1048     if (new_style_driver && ifunit >= 0
1049         && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1050         error("Couldn't set MRU in generic PPP layer: %m");
1051
1052     SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1053     if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1054         if (!ok_error(errno))
1055             error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1056     }
1057 }
1058
1059 /********************************************************************
1060  *
1061  * ccp_test - ask kernel whether a given compression method
1062  * is acceptable for use.
1063  */
1064
1065 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1066 {
1067     struct ppp_option_data data;
1068
1069     memset (&data, '\0', sizeof (data));
1070     data.ptr      = opt_ptr;
1071     data.length   = opt_len;
1072     data.transmit = for_transmit;
1073
1074     if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1075         return 1;
1076
1077     return (errno == ENOBUFS)? 0: -1;
1078 }
1079
1080 /********************************************************************
1081  *
1082  * ccp_flags_set - inform kernel about the current state of CCP.
1083  */
1084
1085 void ccp_flags_set (int unit, int isopen, int isup)
1086 {
1087     if (still_ppp()) {
1088         int x = get_flags(ppp_dev_fd);
1089         x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1090         x = isup?   x | SC_CCP_UP   : x &~ SC_CCP_UP;
1091         set_flags (ppp_dev_fd, x);
1092     }
1093 }
1094
1095 /********************************************************************
1096  *
1097  * get_idle_time - return how long the link has been idle.
1098  */
1099 int
1100 get_idle_time(u, ip)
1101     int u;
1102     struct ppp_idle *ip;
1103 {
1104     return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1105 }
1106
1107 /********************************************************************
1108  *
1109  * get_ppp_stats - return statistics for the link.
1110  */
1111 int
1112 get_ppp_stats(u, stats)
1113     int u;
1114     struct pppd_stats *stats;
1115 {
1116     struct ifpppstatsreq req;
1117
1118     memset (&req, 0, sizeof (req));
1119
1120     req.stats_ptr = (caddr_t) &req.stats;
1121     strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1122     if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1123         error("Couldn't get PPP statistics: %m");
1124         return 0;
1125     }
1126     stats->bytes_in = req.stats.p.ppp_ibytes;
1127     stats->bytes_out = req.stats.p.ppp_obytes;
1128     return 1;
1129 }
1130
1131 /********************************************************************
1132  *
1133  * ccp_fatal_error - returns 1 if decompression was disabled as a
1134  * result of an error detected after decompression of a packet,
1135  * 0 otherwise.  This is necessary because of patent nonsense.
1136  */
1137
1138 int ccp_fatal_error (int unit)
1139 {
1140     int x = get_flags(ppp_dev_fd);
1141
1142     return x & SC_DC_FERROR;
1143 }
1144
1145 /********************************************************************
1146  *
1147  * path_to_procfs - find the path to the proc file system mount point
1148  */
1149 static char proc_path[MAXPATHLEN];
1150 static int proc_path_len;
1151
1152 static char *path_to_procfs(const char *tail)
1153 {
1154     struct mntent *mntent;
1155     FILE *fp;
1156
1157     if (proc_path_len == 0) {
1158         /* Default the mount location of /proc */
1159         strlcpy (proc_path, "/proc", sizeof(proc_path));
1160         proc_path_len = 5;
1161         fp = fopen(MOUNTED, "r");
1162         if (fp != NULL) {
1163             while ((mntent = getmntent(fp)) != NULL) {
1164                 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1165                     continue;
1166                 if (strcmp(mntent->mnt_type, "proc") == 0) {
1167                     strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1168                     proc_path_len = strlen(proc_path);
1169                     break;
1170                 }
1171             }
1172             fclose (fp);
1173         }
1174     }
1175
1176     strlcpy(proc_path + proc_path_len, tail,
1177             sizeof(proc_path) - proc_path_len);
1178     return proc_path;
1179 }
1180
1181 /*
1182  * /proc/net/route parsing stuff.
1183  */
1184 #define ROUTE_MAX_COLS  12
1185 FILE *route_fd = (FILE *) 0;
1186 static char route_buffer[512];
1187 static int route_dev_col, route_dest_col, route_gw_col;
1188 static int route_flags_col, route_mask_col;
1189 static int route_num_cols;
1190
1191 static int open_route_table (void);
1192 static void close_route_table (void);
1193 static int read_route_table (struct rtentry *rt);
1194
1195 /********************************************************************
1196  *
1197  * close_route_table - close the interface to the route table
1198  */
1199
1200 static void close_route_table (void)
1201 {
1202     if (route_fd != (FILE *) 0) {
1203         fclose (route_fd);
1204         route_fd = (FILE *) 0;
1205     }
1206 }
1207
1208 /********************************************************************
1209  *
1210  * open_route_table - open the interface to the route table
1211  */
1212 static char route_delims[] = " \t\n";
1213
1214 static int open_route_table (void)
1215 {
1216     char *path;
1217
1218     close_route_table();
1219
1220     path = path_to_procfs("/net/route");
1221     route_fd = fopen (path, "r");
1222     if (route_fd == NULL) {
1223         error("can't open routing table %s: %m", path);
1224         return 0;
1225     }
1226
1227     route_dev_col = 0;          /* default to usual columns */
1228     route_dest_col = 1;
1229     route_gw_col = 2;
1230     route_flags_col = 3;
1231     route_mask_col = 7;
1232     route_num_cols = 8;
1233
1234     /* parse header line */
1235     if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1236         char *p = route_buffer, *q;
1237         int col;
1238         for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1239             int used = 1;
1240             if ((q = strtok(p, route_delims)) == 0)
1241                 break;
1242             if (strcasecmp(q, "iface") == 0)
1243                 route_dev_col = col;
1244             else if (strcasecmp(q, "destination") == 0)
1245                 route_dest_col = col;
1246             else if (strcasecmp(q, "gateway") == 0)
1247                 route_gw_col = col;
1248             else if (strcasecmp(q, "flags") == 0)
1249                 route_flags_col = col;
1250             else if (strcasecmp(q, "mask") == 0)
1251                 route_mask_col = col;
1252             else
1253                 used = 0;
1254             if (used && col >= route_num_cols)
1255                 route_num_cols = col + 1;
1256             p = NULL;
1257         }
1258     }
1259
1260     return 1;
1261 }
1262
1263 /********************************************************************
1264  *
1265  * read_route_table - read the next entry from the route table
1266  */
1267
1268 static int read_route_table(struct rtentry *rt)
1269 {
1270     char *cols[ROUTE_MAX_COLS], *p;
1271     int col;
1272
1273     memset (rt, '\0', sizeof (struct rtentry));
1274
1275     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1276         return 0;
1277
1278     p = route_buffer;
1279     for (col = 0; col < route_num_cols; ++col) {
1280         cols[col] = strtok(p, route_delims);
1281         if (cols[col] == NULL)
1282             return 0;           /* didn't get enough columns */
1283         p = NULL;
1284     }
1285
1286     SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1287     SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1288     SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1289
1290     rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1291     rt->rt_dev   = cols[route_dev_col];
1292
1293     return 1;
1294 }
1295
1296 /********************************************************************
1297  *
1298  * defaultroute_exists - determine if there is a default route
1299  */
1300
1301 static int defaultroute_exists (struct rtentry *rt)
1302 {
1303     int result = 0;
1304
1305     if (!open_route_table())
1306         return 0;
1307
1308     while (read_route_table(rt) != 0) {
1309         if ((rt->rt_flags & RTF_UP) == 0)
1310             continue;
1311
1312         if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1313             continue;
1314         if (SIN_ADDR(rt->rt_dst) == 0L) {
1315             result = 1;
1316             break;
1317         }
1318     }
1319
1320     close_route_table();
1321     return result;
1322 }
1323
1324 /*
1325  * have_route_to - determine if the system has any route to
1326  * a given IP address.  `addr' is in network byte order.
1327  * Return value is 1 if yes, 0 if no, -1 if don't know.
1328  * For demand mode to work properly, we have to ignore routes
1329  * through our own interface.
1330  */
1331 int have_route_to(u_int32_t addr)
1332 {
1333     struct rtentry rt;
1334     int result = 0;
1335
1336     if (!open_route_table())
1337         return -1;              /* don't know */
1338
1339     while (read_route_table(&rt)) {
1340         if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1341             continue;
1342         if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1343             result = 1;
1344             break;
1345         }
1346     }
1347
1348     close_route_table();
1349     return result;
1350 }
1351
1352 /********************************************************************
1353  *
1354  * sifdefaultroute - assign a default route through the address given.
1355  */
1356
1357 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1358 {
1359     struct rtentry rt;
1360
1361     if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1362         u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1363
1364         if (old_gateway != gateway)
1365             error("not replacing existing default route to %s [%I]",
1366                   rt.rt_dev, old_gateway);
1367         return 0;
1368     }
1369
1370     memset (&rt, '\0', sizeof (rt));
1371     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1372     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1373
1374     if (kernel_version > KVERSION(2,1,0)) {
1375         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1376         SIN_ADDR(rt.rt_genmask) = 0L;
1377     }
1378
1379     SIN_ADDR(rt.rt_gateway) = gateway;
1380
1381     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1382     if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1383         if ( ! ok_error ( errno ))
1384             error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1385         return 0;
1386     }
1387
1388     default_route_gateway = gateway;
1389     return 1;
1390 }
1391
1392 /********************************************************************
1393  *
1394  * cifdefaultroute - delete a default route through the address given.
1395  */
1396
1397 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1398 {
1399     struct rtentry rt;
1400
1401     default_route_gateway = 0;
1402
1403     memset (&rt, '\0', sizeof (rt));
1404     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1405     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1406
1407     if (kernel_version > KVERSION(2,1,0)) {
1408         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1409         SIN_ADDR(rt.rt_genmask) = 0L;
1410     }
1411
1412     SIN_ADDR(rt.rt_gateway) = gateway;
1413
1414     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1415     if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1416         if (still_ppp()) {
1417             if ( ! ok_error ( errno ))
1418                 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1419             return 0;
1420         }
1421     }
1422
1423     return 1;
1424 }
1425
1426 /********************************************************************
1427  *
1428  * sifproxyarp - Make a proxy ARP entry for the peer.
1429  */
1430
1431 int sifproxyarp (int unit, u_int32_t his_adr)
1432 {
1433     struct arpreq arpreq;
1434     char *forw_path;
1435
1436     if (has_proxy_arp == 0) {
1437         memset (&arpreq, '\0', sizeof(arpreq));
1438
1439         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1440         SIN_ADDR(arpreq.arp_pa) = his_adr;
1441         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1442 /*
1443  * Get the hardware address of an interface on the same subnet
1444  * as our local address.
1445  */
1446         if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1447                             sizeof(proxy_arp_dev))) {
1448             error("Cannot determine ethernet address for proxy ARP");
1449             return 0;
1450         }
1451         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1452
1453         if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1454             if ( ! ok_error ( errno ))
1455                 error("ioctl(SIOCSARP): %m(%d)", errno);
1456             return 0;
1457         }
1458         proxy_arp_addr = his_adr;
1459         has_proxy_arp = 1;
1460
1461         if (tune_kernel) {
1462             forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1463             if (forw_path != 0) {
1464                 int fd = open(forw_path, O_WRONLY);
1465                 if (fd >= 0) {
1466                     if (write(fd, "1", 1) != 1)
1467                         error("Couldn't enable IP forwarding: %m");
1468                     close(fd);
1469                 }
1470             }
1471         }
1472     }
1473
1474     return 1;
1475 }
1476
1477 /********************************************************************
1478  *
1479  * cifproxyarp - Delete the proxy ARP entry for the peer.
1480  */
1481
1482 int cifproxyarp (int unit, u_int32_t his_adr)
1483 {
1484     struct arpreq arpreq;
1485
1486     if (has_proxy_arp) {
1487         has_proxy_arp = 0;
1488         memset (&arpreq, '\0', sizeof(arpreq));
1489         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1490         SIN_ADDR(arpreq.arp_pa) = his_adr;
1491         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1492         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1493
1494         if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1495             if ( ! ok_error ( errno ))
1496                 warn("ioctl(SIOCDARP): %m(%d)", errno);
1497             return 0;
1498         }
1499     }
1500     return 1;
1501 }
1502
1503 /********************************************************************
1504  *
1505  * get_ether_addr - get the hardware address of an interface on the
1506  * the same subnet as ipaddr.
1507  */
1508
1509 static int get_ether_addr (u_int32_t ipaddr,
1510                            struct sockaddr *hwaddr,
1511                            char *name, int namelen)
1512 {
1513     struct ifreq *ifr, *ifend;
1514     u_int32_t ina, mask;
1515     char *aliasp;
1516     struct ifreq ifreq;
1517     struct ifconf ifc;
1518     struct ifreq ifs[MAX_IFS];
1519
1520     ifc.ifc_len = sizeof(ifs);
1521     ifc.ifc_req = ifs;
1522     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1523         if ( ! ok_error ( errno ))
1524             error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1525         return 0;
1526     }
1527
1528     SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1529                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1530 /*
1531  * Scan through looking for an interface with an Internet
1532  * address on the same subnet as `ipaddr'.
1533  */
1534     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1535     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1536         if (ifr->ifr_addr.sa_family == AF_INET) {
1537             ina = SIN_ADDR(ifr->ifr_addr);
1538             strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1539             SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1540                         ifreq.ifr_name));
1541 /*
1542  * Check that the interface is up, and not point-to-point
1543  * nor loopback.
1544  */
1545             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1546                 continue;
1547
1548             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1549                 continue;
1550 /*
1551  * Get its netmask and check that it's on the right subnet.
1552  */
1553             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1554                 continue;
1555
1556             mask = SIN_ADDR(ifreq.ifr_addr);
1557             SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1558                         ip_ntoa(ina), ntohl(mask)));
1559
1560             if (((ipaddr ^ ina) & mask) != 0)
1561                 continue;
1562             break;
1563         }
1564     }
1565
1566     if (ifr >= ifend)
1567         return 0;
1568
1569     strlcpy(name, ifreq.ifr_name, namelen);
1570
1571     /* trim off the :1 in eth0:1 */
1572     aliasp = strchr(name, ':');
1573     if (aliasp != 0)
1574         *aliasp = 0;
1575
1576     info("found interface %s for proxy arp", name);
1577 /*
1578  * Now get the hardware address.
1579  */
1580     memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1581     if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1582         error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1583         return 0;
1584     }
1585
1586     memcpy (hwaddr,
1587             &ifreq.ifr_hwaddr,
1588             sizeof (struct sockaddr));
1589
1590     SYSDEBUG ((LOG_DEBUG,
1591            "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1592                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1593                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1594                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1595                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1596                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1597                 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1598                 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1599                 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1600     return 1;
1601 }
1602
1603 /********************************************************************
1604  *
1605  * Return user specified netmask, modified by any mask we might determine
1606  * for address `addr' (in network byte order).
1607  * Here we scan through the system's list of interfaces, looking for
1608  * any non-point-to-point interfaces which might appear to be on the same
1609  * network as `addr'.  If we find any, we OR in their netmask to the
1610  * user-specified netmask.
1611  */
1612
1613 u_int32_t GetMask (u_int32_t addr)
1614 {
1615     u_int32_t mask, nmask, ina;
1616     struct ifreq *ifr, *ifend, ifreq;
1617     struct ifconf ifc;
1618     struct ifreq ifs[MAX_IFS];
1619
1620     addr = ntohl(addr);
1621
1622     if (IN_CLASSA(addr))        /* determine network mask for address class */
1623         nmask = IN_CLASSA_NET;
1624     else if (IN_CLASSB(addr))
1625             nmask = IN_CLASSB_NET;
1626     else
1627             nmask = IN_CLASSC_NET;
1628
1629     /* class D nets are disallowed by bad_ip_adrs */
1630     mask = netmask | htonl(nmask);
1631 /*
1632  * Scan through the system's network interfaces.
1633  */
1634     ifc.ifc_len = sizeof(ifs);
1635     ifc.ifc_req = ifs;
1636     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1637         if ( ! ok_error ( errno ))
1638             warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1639         return mask;
1640     }
1641
1642     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1643     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1644 /*
1645  * Check the interface's internet address.
1646  */
1647         if (ifr->ifr_addr.sa_family != AF_INET)
1648             continue;
1649         ina = SIN_ADDR(ifr->ifr_addr);
1650         if (((ntohl(ina) ^ addr) & nmask) != 0)
1651             continue;
1652 /*
1653  * Check that the interface is up, and not point-to-point nor loopback.
1654  */
1655         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1656         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1657             continue;
1658
1659         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1660             continue;
1661 /*
1662  * Get its netmask and OR it into our mask.
1663  */
1664         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1665             continue;
1666         mask |= SIN_ADDR(ifreq.ifr_addr);
1667         break;
1668     }
1669     return mask;
1670 }
1671
1672 /********************************************************************
1673  *
1674  * Internal routine to decode the version.modification.patch level
1675  */
1676
1677 static void decode_version (char *buf, int *version,
1678                             int *modification, int *patch)
1679 {
1680     *version      = (int) strtoul (buf, &buf, 10);
1681     *modification = 0;
1682     *patch        = 0;
1683
1684     if (*buf == '.') {
1685         ++buf;
1686         *modification = (int) strtoul (buf, &buf, 10);
1687         if (*buf == '.') {
1688             ++buf;
1689             *patch = (int) strtoul (buf, &buf, 10);
1690         }
1691     }
1692
1693     if (*buf != '\0') {
1694         *version      =
1695         *modification =
1696         *patch        = 0;
1697     }
1698 }
1699
1700 /********************************************************************
1701  *
1702  * Procedure to determine if the PPP line discipline is registered.
1703  */
1704
1705 static int
1706 ppp_registered(void)
1707 {
1708     int local_fd;
1709     int mfd = -1;
1710     int ret = 0;
1711     char slave[16];
1712
1713     /*
1714      * We used to open the serial device and set it to the ppp line
1715      * discipline here, in order to create a ppp unit.  But that is
1716      * not a good idea - the user might have specified a device that
1717      * they can't open (permission, or maybe it doesn't really exist).
1718      * So we grab a pty master/slave pair and use that.
1719      */
1720     if (!get_pty(&mfd, &local_fd, slave, 0)) {
1721         no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1722         return 0;
1723     }
1724
1725     /*
1726      * Try to put the device into the PPP discipline.
1727      */
1728     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1729         error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1730     } else
1731         ret = 1;
1732
1733     close(local_fd);
1734     close(mfd);
1735     return ret;
1736 }
1737
1738 /********************************************************************
1739  *
1740  * ppp_available - check whether the system has any ppp interfaces
1741  * (in fact we check whether we can do an ioctl on ppp0).
1742  */
1743
1744 int ppp_available(void)
1745 {
1746     int s, ok, fd;
1747     struct ifreq ifr;
1748     int    size;
1749     int    my_version, my_modification, my_patch;
1750     int osmaj, osmin, ospatch;
1751
1752     no_ppp_msg =
1753         "This system lacks kernel support for PPP.  This could be because\n"
1754         "the PPP kernel module could not be loaded, or because PPP was not\n"
1755         "included in the kernel configuration.  If PPP was included as a\n"
1756         "module, try `/sbin/modprobe -v ppp'.  If that fails, check that\n"
1757         "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1758         "See README.linux file in the ppp distribution for more details.\n";
1759
1760     /* get the kernel version now, since we are called before sys_init */
1761     uname(&utsname);
1762     osmaj = osmin = ospatch = 0;
1763     sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1764     kernel_version = KVERSION(osmaj, osmin, ospatch);
1765
1766     if (kernel_version >= KVERSION(2,3,13)) {
1767         fd = open("/dev/ppp", O_RDWR);
1768 #if 0
1769         if (fd < 0 && errno == ENOENT) {
1770             /* try making it and see if that helps. */
1771             if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1772                       makedev(108, 0)) >= 0) {
1773                 fd = open("/dev/ppp", O_RDWR);
1774                 if (fd >= 0)
1775                     info("Created /dev/ppp device node");
1776                 else
1777                     unlink("/dev/ppp"); /* didn't work, undo the mknod */
1778             } else if (errno == EEXIST) {
1779                 fd = open("/dev/ppp", O_RDWR);
1780             }
1781         }
1782 #endif /* 0 */
1783         if (fd >= 0) {
1784             new_style_driver = 1;
1785
1786             /* XXX should get from driver */
1787             driver_version = 2;
1788             driver_modification = 4;
1789             driver_patch = 0;
1790             close(fd);
1791             return 1;
1792         }
1793         return 0;
1794     }
1795
1796 /*
1797  * Open a socket for doing the ioctl operations.
1798  */
1799     s = socket(AF_INET, SOCK_DGRAM, 0);
1800     if (s < 0)
1801         return 0;
1802
1803     strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1804     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1805 /*
1806  * If the device did not exist then attempt to create one by putting the
1807  * current tty into the PPP discipline. If this works then obtain the
1808  * flags for the device again.
1809  */
1810     if (!ok) {
1811         if (ppp_registered()) {
1812             strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1813             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1814         }
1815     }
1816 /*
1817  * Ensure that the hardware address is for PPP and not something else
1818  */
1819     if (ok)
1820         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1821
1822     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1823         ok = 0;
1824
1825 /*
1826  *  This is the PPP device. Validate the version of the driver at this
1827  *  point to ensure that this program will work with the driver.
1828  */
1829     if (ok) {
1830         char   abBuffer [1024];
1831
1832         ifr.ifr_data = abBuffer;
1833         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1834         if (size < 0) {
1835             error("Couldn't read driver version: %m");
1836             ok = 0;
1837             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1838
1839         } else {
1840             decode_version(abBuffer,
1841                            &driver_version,
1842                            &driver_modification,
1843                            &driver_patch);
1844 /*
1845  * Validate the version of the driver against the version that we used.
1846  */
1847             decode_version(VERSION,
1848                            &my_version,
1849                            &my_modification,
1850                            &my_patch);
1851
1852             /* The version numbers must match */
1853             if (driver_version != my_version)
1854                 ok = 0;
1855
1856             /* The modification levels must be legal */
1857             if (driver_modification < 3) {
1858                 if (driver_modification >= 2) {
1859                     /* we can cope with 2.2.0 and above */
1860                     driver_is_old = 1;
1861                 } else {
1862                     ok = 0;
1863                 }
1864             }
1865
1866             close (s);
1867             if (!ok) {
1868                 slprintf(route_buffer, sizeof(route_buffer),
1869                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
1870                          driver_version, driver_modification, driver_patch);
1871
1872                 no_ppp_msg = route_buffer;
1873             }
1874         }
1875     }
1876     return ok;
1877 }
1878
1879 /********************************************************************
1880  *
1881  * Update the wtmp file with the appropriate user name and tty device.
1882  */
1883
1884 void logwtmp (const char *line, const char *name, const char *host)
1885 {
1886     struct utmp ut, *utp;
1887     pid_t  mypid = getpid();
1888 #if __GLIBC__ < 2
1889     int    wtmp;
1890 #endif
1891
1892 /*
1893  * Update the signon database for users.
1894  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1895  */
1896     utmpname(_PATH_UTMP);
1897     setutent();
1898     while ((utp = getutent()) && (utp->ut_pid != mypid))
1899         /* nothing */;
1900
1901     /* Is this call really necessary? There is another one after the 'put' */
1902     endutent();
1903
1904     if (utp)
1905         memcpy(&ut, utp, sizeof(ut));
1906     else
1907         /* some gettys/telnetds don't initialize utmp... */
1908         memset(&ut, 0, sizeof(ut));
1909
1910     if (ut.ut_id[0] == 0)
1911         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1912
1913     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1914     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1915
1916     time(&ut.ut_time);
1917
1918     ut.ut_type = USER_PROCESS;
1919     ut.ut_pid  = mypid;
1920
1921     /* Insert the host name if one is supplied */
1922     if (*host)
1923         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1924
1925     /* Insert the IP address of the remote system if IP is enabled */
1926     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1927         memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1928                  sizeof(ut.ut_addr));
1929
1930     /* CL: Makes sure that the logout works */
1931     if (*host == 0 && *name==0)
1932         ut.ut_host[0]=0;
1933
1934     pututline(&ut);
1935     endutent();
1936 /*
1937  * Update the wtmp file.
1938  */
1939 #if __GLIBC__ >= 2
1940     updwtmp(_PATH_WTMP, &ut);
1941 #else
1942     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1943     if (wtmp >= 0) {
1944         flock(wtmp, LOCK_EX);
1945
1946         if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1947             warn("error writing %s: %m", _PATH_WTMP);
1948
1949         flock(wtmp, LOCK_UN);
1950
1951         close (wtmp);
1952     }
1953 #endif
1954 }
1955
1956
1957 /********************************************************************
1958  *
1959  * sifvjcomp - config tcp header compression
1960  */
1961
1962 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1963 {
1964     u_int x = get_flags(ppp_dev_fd);
1965
1966     if (vjcomp) {
1967         if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1968             if (! ok_error (errno))
1969                 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1970             vjcomp = 0;
1971         }
1972     }
1973
1974     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
1975     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1976     set_flags (ppp_dev_fd, x);
1977
1978     return 1;
1979 }
1980
1981 /********************************************************************
1982  *
1983  * sifup - Config the interface up and enable IP packets to pass.
1984  */
1985
1986 int sifup(int u)
1987 {
1988     struct ifreq ifr;
1989
1990     memset (&ifr, '\0', sizeof (ifr));
1991     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1992     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1993         if (! ok_error (errno))
1994             error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1995         return 0;
1996     }
1997
1998     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1999     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2000         if (! ok_error (errno))
2001             error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2002         return 0;
2003     }
2004     if_is_up++;
2005
2006     return 1;
2007 }
2008
2009 /********************************************************************
2010  *
2011  * sifdown - Disable the indicated protocol and config the interface
2012  *           down if there are no remaining protocols.
2013  */
2014
2015 int sifdown (int u)
2016 {
2017     struct ifreq ifr;
2018
2019     if (if_is_up && --if_is_up > 0)
2020         return 1;
2021
2022     memset (&ifr, '\0', sizeof (ifr));
2023     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2024     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2025         if (! ok_error (errno))
2026             error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2027         return 0;
2028     }
2029
2030     ifr.ifr_flags &= ~IFF_UP;
2031     ifr.ifr_flags |= IFF_POINTOPOINT;
2032     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2033         if (! ok_error (errno))
2034             error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2035         return 0;
2036     }
2037     return 1;
2038 }
2039
2040 /********************************************************************
2041  *
2042  * sifaddr - Config the interface IP addresses and netmask.
2043  */
2044
2045 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2046              u_int32_t net_mask)
2047 {
2048     struct ifreq   ifr;
2049     struct rtentry rt;
2050
2051     memset (&ifr, '\0', sizeof (ifr));
2052     memset (&rt,  '\0', sizeof (rt));
2053
2054     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET);
2055     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2056     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2057
2058     strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2059 /*
2060  *  Set our IP address
2061  */
2062     SIN_ADDR(ifr.ifr_addr) = our_adr;
2063     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2064         if (errno != EEXIST) {
2065             if (! ok_error (errno))
2066                 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2067         }
2068         else {
2069             warn("ioctl(SIOCSIFADDR): Address already exists");
2070         }
2071         return (0);
2072     }
2073 /*
2074  *  Set the gateway address
2075  */
2076     SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2077     if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2078         if (! ok_error (errno))
2079             error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2080         return (0);
2081     }
2082 /*
2083  *  Set the netmask.
2084  *  For recent kernels, force the netmask to 255.255.255.255.
2085  */
2086     if (kernel_version >= KVERSION(2,1,16))
2087         net_mask = ~0L;
2088     if (net_mask != 0) {
2089         SIN_ADDR(ifr.ifr_netmask) = net_mask;
2090         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2091             if (! ok_error (errno))
2092                 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2093             return (0);
2094         }
2095     }
2096 /*
2097  *  Add the device route
2098  */
2099     if (kernel_version < KVERSION(2,1,16)) {
2100         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2101         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2102         rt.rt_dev = ifname;
2103
2104         SIN_ADDR(rt.rt_gateway) = 0L;
2105         SIN_ADDR(rt.rt_dst)     = his_adr;
2106         rt.rt_flags = RTF_UP | RTF_HOST;
2107
2108         if (kernel_version > KVERSION(2,1,0)) {
2109             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2110             SIN_ADDR(rt.rt_genmask) = -1L;
2111         }
2112
2113         if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2114             if (! ok_error (errno))
2115                 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2116             return (0);
2117         }
2118     }
2119
2120     /* set ip_dynaddr in demand mode if address changes */
2121     if (demand && tune_kernel && !dynaddr_set
2122         && our_old_addr && our_old_addr != our_adr) {
2123         /* set ip_dynaddr if possible */
2124         char *path;
2125         int fd;
2126
2127         path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2128         if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2129             if (write(fd, "1", 1) != 1)
2130                 error("Couldn't enable dynamic IP addressing: %m");
2131             close(fd);
2132         }
2133         dynaddr_set = 1;        /* only 1 attempt */
2134     }
2135     our_old_addr = 0;
2136
2137     return 1;
2138 }
2139
2140 /********************************************************************
2141  *
2142  * cifaddr - Clear the interface IP addresses, and delete routes
2143  * through the interface if possible.
2144  */
2145
2146 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2147 {
2148     struct ifreq ifr;
2149
2150     if (kernel_version < KVERSION(2,1,16)) {
2151 /*
2152  *  Delete the route through the device
2153  */
2154         struct rtentry rt;
2155         memset (&rt, '\0', sizeof (rt));
2156
2157         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2158         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2159         rt.rt_dev = ifname;
2160
2161         SIN_ADDR(rt.rt_gateway) = 0;
2162         SIN_ADDR(rt.rt_dst)     = his_adr;
2163         rt.rt_flags = RTF_UP | RTF_HOST;
2164
2165         if (kernel_version > KVERSION(2,1,0)) {
2166             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2167             SIN_ADDR(rt.rt_genmask) = -1L;
2168         }
2169
2170         if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2171             if (still_ppp() && ! ok_error (errno))
2172                 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2173             return (0);
2174         }
2175     }
2176
2177     /* This way it is possible to have an IPX-only or IPv6-only interface */
2178     memset(&ifr, 0, sizeof(ifr));
2179     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2180     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2181
2182     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2183         if (! ok_error (errno)) {
2184             error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2185             return 0;
2186         }
2187     }
2188
2189     our_old_addr = our_adr;
2190
2191     return 1;
2192 }
2193
2194 #ifdef INET6
2195 /********************************************************************
2196  *
2197  * sif6addr - Config the interface with an IPv6 link-local address
2198  */
2199 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2200 {
2201     struct in6_ifreq ifr6;
2202     struct ifreq ifr;
2203     struct in6_rtmsg rt6;
2204
2205     memset(&ifr, 0, sizeof (ifr));
2206     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2207     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2208         error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2209         return 0;
2210     }
2211
2212     /* Local interface */
2213     memset(&ifr6, 0, sizeof(ifr6));
2214     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2215     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2216     ifr6.ifr6_prefixlen = 10;
2217
2218     if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2219         error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2220         return 0;
2221     }
2222
2223     /* Route to remote host */
2224     memset(&rt6, 0, sizeof(rt6));
2225     IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2226     rt6.rtmsg_flags = RTF_UP;
2227     rt6.rtmsg_dst_len = 10;
2228     rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2229     rt6.rtmsg_metric = 1;
2230
2231     if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2232         error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2233         return 0;
2234     }
2235
2236     return 1;
2237 }
2238
2239
2240 /********************************************************************
2241  *
2242  * cif6addr - Remove IPv6 address from interface
2243  */
2244 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2245 {
2246     struct ifreq ifr;
2247     struct in6_ifreq ifr6;
2248
2249     memset(&ifr, 0, sizeof(ifr));
2250     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2251     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2252         error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2253         return 0;
2254     }
2255
2256     memset(&ifr6, 0, sizeof(ifr6));
2257     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2258     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2259     ifr6.ifr6_prefixlen = 10;
2260
2261     if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2262         if (errno != EADDRNOTAVAIL) {
2263             if (! ok_error (errno))
2264                 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2265         }
2266         else {
2267             warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2268         }
2269         return (0);
2270     }
2271     return 1;
2272 }
2273 #endif /* INET6 */
2274
2275 /*
2276  * get_pty - get a pty master/slave pair and chown the slave side
2277  * to the uid given.  Assumes slave_name points to >= 16 bytes of space.
2278  */
2279 int
2280 get_pty(master_fdp, slave_fdp, slave_name, uid)
2281     int *master_fdp;
2282     int *slave_fdp;
2283     char *slave_name;
2284     int uid;
2285 {
2286     int i, mfd, sfd = -1;
2287     char pty_name[16];
2288     struct termios tios;
2289
2290 #ifdef TIOCGPTN
2291     /*
2292      * Try the unix98 way first.
2293      */
2294     mfd = open("/dev/ptmx", O_RDWR);
2295     if (mfd >= 0) {
2296         int ptn;
2297         if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2298             slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2299             chmod(pty_name, S_IRUSR | S_IWUSR);
2300 #ifdef TIOCSPTLCK
2301             ptn = 0;
2302             if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2303                 warn("Couldn't unlock pty slave %s: %m", pty_name);
2304 #endif
2305             if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2306                 warn("Couldn't open pty slave %s: %m", pty_name);
2307         }
2308     }
2309 #endif /* TIOCGPTN */
2310
2311     if (sfd < 0) {
2312         /* the old way - scan through the pty name space */
2313         for (i = 0; i < 64; ++i) {
2314             slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2315                      'p' + i / 16, i % 16);
2316             mfd = open(pty_name, O_RDWR, 0);
2317             if (mfd >= 0) {
2318                 pty_name[5] = 't';
2319                 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2320                 if (sfd >= 0) {
2321                     fchown(sfd, uid, -1);
2322                     fchmod(sfd, S_IRUSR | S_IWUSR);
2323                     break;
2324                 }
2325                 close(mfd);
2326             }
2327         }
2328     }
2329
2330     if (sfd < 0)
2331         return 0;
2332
2333     strlcpy(slave_name, pty_name, 16);
2334     *master_fdp = mfd;
2335     *slave_fdp = sfd;
2336     if (tcgetattr(sfd, &tios) == 0) {
2337         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2338         tios.c_cflag |= CS8 | CREAD;
2339         tios.c_iflag  = IGNPAR | CLOCAL;
2340         tios.c_oflag  = 0;
2341         tios.c_lflag  = 0;
2342         if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2343             warn("couldn't set attributes on pty: %m");
2344     } else
2345         warn("couldn't get attributes on pty: %m");
2346
2347     return 1;
2348 }
2349
2350 /********************************************************************
2351  *
2352  * open_loopback - open the device we use for getting packets
2353  * in demand mode.  Under Linux, we use a pty master/slave pair.
2354  */
2355 int
2356 open_ppp_loopback(void)
2357 {
2358     int flags, x;
2359
2360     looped = 1;
2361     if (new_style_driver) {
2362         /* allocate ourselves a ppp unit */
2363         ifunit = req_unit;
2364         x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
2365         if (x < 0 && req_unit >= 0 && errno == EEXIST) {
2366             warn("Couldn't allocate PPP unit %d as it is already in use");
2367             ifunit = -1;
2368             x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
2369         }
2370         if (x < 0)
2371             fatal("Couldn't create PPP unit: %m");
2372         set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2373         set_kdebugflag(kdebugflag);
2374         ppp_fd = -1;
2375         return ppp_dev_fd;
2376     }
2377
2378     if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2379         fatal("No free pty for loopback");
2380     SYSDEBUG(("using %s for loopback", loop_name));
2381
2382     set_ppp_fd(slave_fd);
2383
2384     flags = fcntl(master_fd, F_GETFL);
2385     if (flags == -1 ||
2386         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2387         warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2388
2389     flags = fcntl(ppp_fd, F_GETFL);
2390     if (flags == -1 ||
2391         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2392         warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2393
2394     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2395         fatal("ioctl(TIOCSETD): %m(%d)", errno);
2396 /*
2397  * Find out which interface we were given.
2398  */
2399     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2400         fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2401 /*
2402  * Enable debug in the driver if requested.
2403  */
2404     set_kdebugflag (kdebugflag);
2405
2406     return master_fd;
2407 }
2408
2409 /********************************************************************
2410  *
2411  * restore_loop - reattach the ppp unit to the loopback.
2412  *
2413  * The kernel ppp driver automatically reattaches the ppp unit to
2414  * the loopback if the serial port is set to a line discipline other
2415  * than ppp, or if it detects a modem hangup.  The former will happen
2416  * in disestablish_ppp if the latter hasn't already happened, so we
2417  * shouldn't need to do anything.
2418  *
2419  * Just to be sure, set the real serial port to the normal discipline.
2420  */
2421
2422 void
2423 restore_loop(void)
2424 {
2425     looped = 1;
2426     if (new_style_driver) {
2427         set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2428         return;
2429     }
2430     if (ppp_fd != slave_fd) {
2431         (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2432         set_ppp_fd(slave_fd);
2433     }
2434 }
2435
2436 /********************************************************************
2437  *
2438  * sifnpmode - Set the mode for handling packets for a given NP.
2439  */
2440
2441 int
2442 sifnpmode(u, proto, mode)
2443     int u;
2444     int proto;
2445     enum NPmode mode;
2446 {
2447     struct npioctl npi;
2448
2449     npi.protocol = proto;
2450     npi.mode     = mode;
2451     if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2452         if (! ok_error (errno))
2453             error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2454                    proto, mode, errno);
2455         return 0;
2456     }
2457     return 1;
2458 }
2459
2460 \f
2461 /********************************************************************
2462  *
2463  * sipxfaddr - Config the interface IPX networknumber
2464  */
2465
2466 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2467 {
2468     int    result = 1;
2469
2470 #ifdef IPX_CHANGE
2471     int    skfd;
2472     struct ifreq         ifr;
2473     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2474
2475     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2476     if (skfd < 0) {
2477         if (! ok_error (errno))
2478             dbglog("socket(AF_IPX): %m (%d)", errno);
2479         result = 0;
2480     }
2481     else {
2482         memset (&ifr, '\0', sizeof (ifr));
2483         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2484
2485         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2486         sipx->sipx_family  = AF_IPX;
2487         sipx->sipx_port    = 0;
2488         sipx->sipx_network = htonl (network);
2489         sipx->sipx_type    = IPX_FRAME_ETHERII;
2490         sipx->sipx_action  = IPX_CRTITF;
2491 /*
2492  *  Set the IPX device
2493  */
2494         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2495             result = 0;
2496             if (errno != EEXIST) {
2497                 if (! ok_error (errno))
2498                     dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2499             }
2500             else {
2501                 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2502             }
2503         }
2504         close (skfd);
2505     }
2506 #endif
2507     return result;
2508 }
2509
2510 /********************************************************************
2511  *
2512  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2513  *             are removed and the device is no longer able to pass IPX
2514  *             frames.
2515  */
2516
2517 int cipxfaddr (int unit)
2518 {
2519     int    result = 1;
2520
2521 #ifdef IPX_CHANGE
2522     int    skfd;
2523     struct ifreq         ifr;
2524     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2525
2526     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2527     if (skfd < 0) {
2528         if (! ok_error (errno))
2529             dbglog("socket(AF_IPX): %m (%d)", errno);
2530         result = 0;
2531     }
2532     else {
2533         memset (&ifr, '\0', sizeof (ifr));
2534         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2535
2536         sipx->sipx_type    = IPX_FRAME_ETHERII;
2537         sipx->sipx_action  = IPX_DLTITF;
2538         sipx->sipx_family  = AF_IPX;
2539 /*
2540  *  Set the IPX device
2541  */
2542         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2543             if (! ok_error (errno))
2544                 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2545             result = 0;
2546         }
2547         close (skfd);
2548     }
2549 #endif
2550     return result;
2551 }
2552
2553 /*
2554  * Use the hostname as part of the random number seed.
2555  */
2556 int
2557 get_host_seed()
2558 {
2559     int h;
2560     char *p = hostname;
2561
2562     h = 407;
2563     for (p = hostname; *p != 0; ++p)
2564         h = h * 37 + *p;
2565     return h;
2566 }
2567
2568 /********************************************************************
2569  *
2570  * sys_check_options - check the options that the user specified
2571  */
2572
2573 int
2574 sys_check_options(void)
2575 {
2576 #ifdef IPX_CHANGE
2577 /*
2578  * Disable the IPX protocol if the support is not present in the kernel.
2579  */
2580     char *path;
2581
2582     if (ipxcp_protent.enabled_flag) {
2583         struct stat stat_buf;
2584         if ((path = path_to_procfs("/net/ipx_interface")) == 0
2585             || lstat(path, &stat_buf) < 0) {
2586             error("IPX support is not present in the kernel\n");
2587             ipxcp_protent.enabled_flag = 0;
2588         }
2589     }
2590 #endif
2591     if (demand && driver_is_old) {
2592         option_error("demand dialling is not supported by kernel driver "
2593                      "version %d.%d.%d", driver_version, driver_modification,
2594                      driver_patch);
2595         return 0;
2596     }
2597     if (multilink && !new_style_driver) {
2598         option_error("multilink is not supported by the kernel driver");
2599         return 0;
2600     }
2601     return 1;
2602 }