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