pppd/sys-linux.c

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