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