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