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     fd = open("/dev/ppp", O_RDWR);
1850 #if 0
1851     if (fd < 0 && errno == ENOENT) {
1852         /* try making it and see if that helps. */
1853         if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1854                   makedev(108, 0)) >= 0) {
1855             fd = open("/dev/ppp", O_RDWR);
1856             if (fd >= 0)
1857                 info("Created /dev/ppp device node");
1858             else
1859                 unlink("/dev/ppp");     /* didn't work, undo the mknod */
1860         } else if (errno == EEXIST) {
1861             fd = open("/dev/ppp", O_RDWR);
1862         }
1863     }
1864 #endif /* 0 */
1865     if (fd >= 0) {
1866         new_style_driver = 1;
1867
1868         /* XXX should get from driver */
1869         driver_version = 2;
1870         driver_modification = 4;
1871         driver_patch = 0;
1872         close(fd);
1873         return 1;
1874     }
1875     if (kernel_version >= KVERSION(2,3,13))
1876         return 0;
1877
1878 /*
1879  * Open a socket for doing the ioctl operations.
1880  */
1881     s = socket(AF_INET, SOCK_DGRAM, 0);
1882     if (s < 0)
1883         return 0;
1884
1885     strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1886     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1887 /*
1888  * If the device did not exist then attempt to create one by putting the
1889  * current tty into the PPP discipline. If this works then obtain the
1890  * flags for the device again.
1891  */
1892     if (!ok) {
1893         if (ppp_registered()) {
1894             strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1895             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1896         }
1897     }
1898 /*
1899  * Ensure that the hardware address is for PPP and not something else
1900  */
1901     if (ok)
1902         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1903
1904     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1905         ok = 0;
1906
1907 /*
1908  *  This is the PPP device. Validate the version of the driver at this
1909  *  point to ensure that this program will work with the driver.
1910  */
1911     if (ok) {
1912         char   abBuffer [1024];
1913
1914         ifr.ifr_data = abBuffer;
1915         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1916         if (size < 0) {
1917             error("Couldn't read driver version: %m");
1918             ok = 0;
1919             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1920
1921         } else {
1922             decode_version(abBuffer,
1923                            &driver_version,
1924                            &driver_modification,
1925                            &driver_patch);
1926 /*
1927  * Validate the version of the driver against the version that we used.
1928  */
1929             decode_version(VERSION,
1930                            &my_version,
1931                            &my_modification,
1932                            &my_patch);
1933
1934             /* The version numbers must match */
1935             if (driver_version != my_version)
1936                 ok = 0;
1937
1938             /* The modification levels must be legal */
1939             if (driver_modification < 3) {
1940                 if (driver_modification >= 2) {
1941                     /* we can cope with 2.2.0 and above */
1942                     driver_is_old = 1;
1943                 } else {
1944                     ok = 0;
1945                 }
1946             }
1947
1948             close (s);
1949             if (!ok) {
1950                 slprintf(route_buffer, sizeof(route_buffer),
1951                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
1952                          driver_version, driver_modification, driver_patch);
1953
1954                 no_ppp_msg = route_buffer;
1955             }
1956         }
1957     }
1958     return ok;
1959 }
1960
1961 /********************************************************************
1962  *
1963  * Update the wtmp file with the appropriate user name and tty device.
1964  */
1965
1966 void logwtmp (const char *line, const char *name, const char *host)
1967 {
1968     struct utmp ut, *utp;
1969     pid_t  mypid = getpid();
1970 #if __GLIBC__ < 2
1971     int    wtmp;
1972 #endif
1973
1974 /*
1975  * Update the signon database for users.
1976  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1977  */
1978     utmpname(_PATH_UTMP);
1979     setutent();
1980     while ((utp = getutent()) && (utp->ut_pid != mypid))
1981         /* nothing */;
1982
1983     /* Is this call really necessary? There is another one after the 'put' */
1984     endutent();
1985
1986     if (utp)
1987         memcpy(&ut, utp, sizeof(ut));
1988     else
1989         /* some gettys/telnetds don't initialize utmp... */
1990         memset(&ut, 0, sizeof(ut));
1991
1992     if (ut.ut_id[0] == 0)
1993         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1994
1995     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1996     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1997
1998     time(&ut.ut_time);
1999
2000     ut.ut_type = USER_PROCESS;
2001     ut.ut_pid  = mypid;
2002
2003     /* Insert the host name if one is supplied */
2004     if (*host)
2005         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2006
2007     /* Insert the IP address of the remote system if IP is enabled */
2008     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2009         memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2010                  sizeof(ut.ut_addr));
2011
2012     /* CL: Makes sure that the logout works */
2013     if (*host == 0 && *name==0)
2014         ut.ut_host[0]=0;
2015
2016     pututline(&ut);
2017     endutent();
2018 /*
2019  * Update the wtmp file.
2020  */
2021 #if __GLIBC__ >= 2
2022     updwtmp(_PATH_WTMP, &ut);
2023 #else
2024     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2025     if (wtmp >= 0) {
2026         flock(wtmp, LOCK_EX);
2027
2028         if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2029             warn("error writing %s: %m", _PATH_WTMP);
2030
2031         flock(wtmp, LOCK_UN);
2032
2033         close (wtmp);
2034     }
2035 #endif
2036 }
2037
2038
2039 /********************************************************************
2040  *
2041  * sifvjcomp - config tcp header compression
2042  */
2043
2044 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2045 {
2046     u_int x = get_flags(ppp_dev_fd);
2047
2048     if (vjcomp) {
2049         if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2050             if (! ok_error (errno))
2051                 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2052             vjcomp = 0;
2053         }
2054     }
2055
2056     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
2057     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2058     set_flags (ppp_dev_fd, x);
2059
2060     return 1;
2061 }
2062
2063 /********************************************************************
2064  *
2065  * sifup - Config the interface up and enable IP packets to pass.
2066  */
2067
2068 int sifup(int u)
2069 {
2070     struct ifreq ifr;
2071
2072     memset (&ifr, '\0', sizeof (ifr));
2073     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2074     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2075         if (! ok_error (errno))
2076             error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2077         return 0;
2078     }
2079
2080     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2081     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2082         if (! ok_error (errno))
2083             error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2084         return 0;
2085     }
2086     if_is_up++;
2087
2088     return 1;
2089 }
2090
2091 /********************************************************************
2092  *
2093  * sifdown - Disable the indicated protocol and config the interface
2094  *           down if there are no remaining protocols.
2095  */
2096
2097 int sifdown (int u)
2098 {
2099     struct ifreq ifr;
2100
2101     if (if_is_up && --if_is_up > 0)
2102         return 1;
2103
2104     memset (&ifr, '\0', sizeof (ifr));
2105     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2106     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2107         if (! ok_error (errno))
2108             error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2109         return 0;
2110     }
2111
2112     ifr.ifr_flags &= ~IFF_UP;
2113     ifr.ifr_flags |= IFF_POINTOPOINT;
2114     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2115         if (! ok_error (errno))
2116             error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2117         return 0;
2118     }
2119     return 1;
2120 }
2121
2122 /********************************************************************
2123  *
2124  * sifaddr - Config the interface IP addresses and netmask.
2125  */
2126
2127 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2128              u_int32_t net_mask)
2129 {
2130     struct ifreq   ifr;
2131     struct rtentry rt;
2132
2133     memset (&ifr, '\0', sizeof (ifr));
2134     memset (&rt,  '\0', sizeof (rt));
2135
2136     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET);
2137     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2138     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2139
2140     strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2141 /*
2142  *  Set our IP address
2143  */
2144     SIN_ADDR(ifr.ifr_addr) = our_adr;
2145     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2146         if (errno != EEXIST) {
2147             if (! ok_error (errno))
2148                 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2149         }
2150         else {
2151             warn("ioctl(SIOCSIFADDR): Address already exists");
2152         }
2153         return (0);
2154     }
2155 /*
2156  *  Set the gateway address
2157  */
2158     SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2159     if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2160         if (! ok_error (errno))
2161             error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2162         return (0);
2163     }
2164 /*
2165  *  Set the netmask.
2166  *  For recent kernels, force the netmask to 255.255.255.255.
2167  */
2168     if (kernel_version >= KVERSION(2,1,16))
2169         net_mask = ~0L;
2170     if (net_mask != 0) {
2171         SIN_ADDR(ifr.ifr_netmask) = net_mask;
2172         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2173             if (! ok_error (errno))
2174                 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2175             return (0);
2176         }
2177     }
2178 /*
2179  *  Add the device route
2180  */
2181     if (kernel_version < KVERSION(2,1,16)) {
2182         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2183         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2184         rt.rt_dev = ifname;
2185
2186         SIN_ADDR(rt.rt_gateway) = 0L;
2187         SIN_ADDR(rt.rt_dst)     = his_adr;
2188         rt.rt_flags = RTF_UP | RTF_HOST;
2189
2190         if (kernel_version > KVERSION(2,1,0)) {
2191             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2192             SIN_ADDR(rt.rt_genmask) = -1L;
2193         }
2194
2195         if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2196             if (! ok_error (errno))
2197                 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2198             return (0);
2199         }
2200     }
2201
2202     /* set ip_dynaddr in demand mode if address changes */
2203     if (demand && tune_kernel && !dynaddr_set
2204         && our_old_addr && our_old_addr != our_adr) {
2205         /* set ip_dynaddr if possible */
2206         char *path;
2207         int fd;
2208
2209         path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2210         if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2211             if (write(fd, "1", 1) != 1)
2212                 error("Couldn't enable dynamic IP addressing: %m");
2213             close(fd);
2214         }
2215         dynaddr_set = 1;        /* only 1 attempt */
2216     }
2217     our_old_addr = 0;
2218
2219     return 1;
2220 }
2221
2222 /********************************************************************
2223  *
2224  * cifaddr - Clear the interface IP addresses, and delete routes
2225  * through the interface if possible.
2226  */
2227
2228 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2229 {
2230     struct ifreq ifr;
2231
2232     if (kernel_version < KVERSION(2,1,16)) {
2233 /*
2234  *  Delete the route through the device
2235  */
2236         struct rtentry rt;
2237         memset (&rt, '\0', sizeof (rt));
2238
2239         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2240         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2241         rt.rt_dev = ifname;
2242
2243         SIN_ADDR(rt.rt_gateway) = 0;
2244         SIN_ADDR(rt.rt_dst)     = his_adr;
2245         rt.rt_flags = RTF_UP | RTF_HOST;
2246
2247         if (kernel_version > KVERSION(2,1,0)) {
2248             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2249             SIN_ADDR(rt.rt_genmask) = -1L;
2250         }
2251
2252         if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2253             if (still_ppp() && ! ok_error (errno))
2254                 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2255             return (0);
2256         }
2257     }
2258
2259     /* This way it is possible to have an IPX-only or IPv6-only interface */
2260     memset(&ifr, 0, sizeof(ifr));
2261     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2262     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2263
2264     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2265         if (! ok_error (errno)) {
2266             error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2267             return 0;
2268         }
2269     }
2270
2271     our_old_addr = our_adr;
2272
2273     return 1;
2274 }
2275
2276 #ifdef INET6
2277 /********************************************************************
2278  *
2279  * sif6addr - Config the interface with an IPv6 link-local address
2280  */
2281 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2282 {
2283     struct in6_ifreq ifr6;
2284     struct ifreq ifr;
2285     struct in6_rtmsg rt6;
2286
2287     memset(&ifr, 0, sizeof (ifr));
2288     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2289     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2290         error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2291         return 0;
2292     }
2293
2294     /* Local interface */
2295     memset(&ifr6, 0, sizeof(ifr6));
2296     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2297     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2298     ifr6.ifr6_prefixlen = 10;
2299
2300     if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2301         error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2302         return 0;
2303     }
2304
2305     /* Route to remote host */
2306     memset(&rt6, 0, sizeof(rt6));
2307     IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2308     rt6.rtmsg_flags = RTF_UP;
2309     rt6.rtmsg_dst_len = 10;
2310     rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2311     rt6.rtmsg_metric = 1;
2312
2313     if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2314         error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2315         return 0;
2316     }
2317
2318     return 1;
2319 }
2320
2321
2322 /********************************************************************
2323  *
2324  * cif6addr - Remove IPv6 address from interface
2325  */
2326 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2327 {
2328     struct ifreq ifr;
2329     struct in6_ifreq ifr6;
2330
2331     memset(&ifr, 0, sizeof(ifr));
2332     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2333     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2334         error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2335         return 0;
2336     }
2337
2338     memset(&ifr6, 0, sizeof(ifr6));
2339     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2340     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2341     ifr6.ifr6_prefixlen = 10;
2342
2343     if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2344         if (errno != EADDRNOTAVAIL) {
2345             if (! ok_error (errno))
2346                 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2347         }
2348         else {
2349             warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2350         }
2351         return (0);
2352     }
2353     return 1;
2354 }
2355 #endif /* INET6 */
2356
2357 /*
2358  * get_pty - get a pty master/slave pair and chown the slave side
2359  * to the uid given.  Assumes slave_name points to >= 16 bytes of space.
2360  */
2361 int
2362 get_pty(master_fdp, slave_fdp, slave_name, uid)
2363     int *master_fdp;
2364     int *slave_fdp;
2365     char *slave_name;
2366     int uid;
2367 {
2368     int i, mfd, sfd = -1;
2369     char pty_name[16];
2370     struct termios tios;
2371
2372 #ifdef TIOCGPTN
2373     /*
2374      * Try the unix98 way first.
2375      */
2376     mfd = open("/dev/ptmx", O_RDWR);
2377     if (mfd >= 0) {
2378         int ptn;
2379         if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2380             slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2381             chmod(pty_name, S_IRUSR | S_IWUSR);
2382 #ifdef TIOCSPTLCK
2383             ptn = 0;
2384             if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2385                 warn("Couldn't unlock pty slave %s: %m", pty_name);
2386 #endif
2387             if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2388                 warn("Couldn't open pty slave %s: %m", pty_name);
2389         }
2390     }
2391 #endif /* TIOCGPTN */
2392
2393     if (sfd < 0) {
2394         /* the old way - scan through the pty name space */
2395         for (i = 0; i < 64; ++i) {
2396             slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2397                      'p' + i / 16, i % 16);
2398             mfd = open(pty_name, O_RDWR, 0);
2399             if (mfd >= 0) {
2400                 pty_name[5] = 't';
2401                 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2402                 if (sfd >= 0) {
2403                     fchown(sfd, uid, -1);
2404                     fchmod(sfd, S_IRUSR | S_IWUSR);
2405                     break;
2406                 }
2407                 close(mfd);
2408             }
2409         }
2410     }
2411
2412     if (sfd < 0)
2413         return 0;
2414
2415     strlcpy(slave_name, pty_name, 16);
2416     *master_fdp = mfd;
2417     *slave_fdp = sfd;
2418     if (tcgetattr(sfd, &tios) == 0) {
2419         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2420         tios.c_cflag |= CS8 | CREAD;
2421         tios.c_iflag  = IGNPAR | CLOCAL;
2422         tios.c_oflag  = 0;
2423         tios.c_lflag  = 0;
2424         if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2425             warn("couldn't set attributes on pty: %m");
2426     } else
2427         warn("couldn't get attributes on pty: %m");
2428
2429     return 1;
2430 }
2431
2432 /********************************************************************
2433  *
2434  * open_loopback - open the device we use for getting packets
2435  * in demand mode.  Under Linux, we use a pty master/slave pair.
2436  */
2437 int
2438 open_ppp_loopback(void)
2439 {
2440     int flags;
2441
2442     looped = 1;
2443     if (new_style_driver) {
2444         /* allocate ourselves a ppp unit */
2445         if (make_ppp_unit() < 0)
2446             die(1);
2447         set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2448         set_kdebugflag(kdebugflag);
2449         ppp_fd = -1;
2450         return ppp_dev_fd;
2451     }
2452
2453     if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2454         fatal("No free pty for loopback");
2455     SYSDEBUG(("using %s for loopback", loop_name));
2456
2457     set_ppp_fd(slave_fd);
2458
2459     flags = fcntl(master_fd, F_GETFL);
2460     if (flags == -1 ||
2461         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2462         warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2463
2464     flags = fcntl(ppp_fd, F_GETFL);
2465     if (flags == -1 ||
2466         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2467         warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2468
2469     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2470         fatal("ioctl(TIOCSETD): %m(%d)", errno);
2471 /*
2472  * Find out which interface we were given.
2473  */
2474     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2475         fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2476 /*
2477  * Enable debug in the driver if requested.
2478  */
2479     set_kdebugflag (kdebugflag);
2480
2481     return master_fd;
2482 }
2483
2484 /********************************************************************
2485  *
2486  * restore_loop - reattach the ppp unit to the loopback.
2487  *
2488  * The kernel ppp driver automatically reattaches the ppp unit to
2489  * the loopback if the serial port is set to a line discipline other
2490  * than ppp, or if it detects a modem hangup.  The former will happen
2491  * in disestablish_ppp if the latter hasn't already happened, so we
2492  * shouldn't need to do anything.
2493  *
2494  * Just to be sure, set the real serial port to the normal discipline.
2495  */
2496
2497 void
2498 restore_loop(void)
2499 {
2500     looped = 1;
2501     if (new_style_driver) {
2502         set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2503         return;
2504     }
2505     if (ppp_fd != slave_fd) {
2506         (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2507         set_ppp_fd(slave_fd);
2508     }
2509 }
2510
2511 /********************************************************************
2512  *
2513  * sifnpmode - Set the mode for handling packets for a given NP.
2514  */
2515
2516 int
2517 sifnpmode(u, proto, mode)
2518     int u;
2519     int proto;
2520     enum NPmode mode;
2521 {
2522     struct npioctl npi;
2523
2524     npi.protocol = proto;
2525     npi.mode     = mode;
2526     if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2527         if (! ok_error (errno))
2528             error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2529                    proto, mode, errno);
2530         return 0;
2531     }
2532     return 1;
2533 }
2534
2535 \f
2536 /********************************************************************
2537  *
2538  * sipxfaddr - Config the interface IPX networknumber
2539  */
2540
2541 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2542 {
2543     int    result = 1;
2544
2545 #ifdef IPX_CHANGE
2546     int    skfd;
2547     struct ifreq         ifr;
2548     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2549
2550     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2551     if (skfd < 0) {
2552         if (! ok_error (errno))
2553             dbglog("socket(AF_IPX): %m (%d)", errno);
2554         result = 0;
2555     }
2556     else {
2557         memset (&ifr, '\0', sizeof (ifr));
2558         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2559
2560         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2561         sipx->sipx_family  = AF_IPX;
2562         sipx->sipx_port    = 0;
2563         sipx->sipx_network = htonl (network);
2564         sipx->sipx_type    = IPX_FRAME_ETHERII;
2565         sipx->sipx_action  = IPX_CRTITF;
2566 /*
2567  *  Set the IPX device
2568  */
2569         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2570             result = 0;
2571             if (errno != EEXIST) {
2572                 if (! ok_error (errno))
2573                     dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2574             }
2575             else {
2576                 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2577             }
2578         }
2579         close (skfd);
2580     }
2581 #endif
2582     return result;
2583 }
2584
2585 /********************************************************************
2586  *
2587  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2588  *             are removed and the device is no longer able to pass IPX
2589  *             frames.
2590  */
2591
2592 int cipxfaddr (int unit)
2593 {
2594     int    result = 1;
2595
2596 #ifdef IPX_CHANGE
2597     int    skfd;
2598     struct ifreq         ifr;
2599     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2600
2601     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2602     if (skfd < 0) {
2603         if (! ok_error (errno))
2604             dbglog("socket(AF_IPX): %m (%d)", errno);
2605         result = 0;
2606     }
2607     else {
2608         memset (&ifr, '\0', sizeof (ifr));
2609         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2610
2611         sipx->sipx_type    = IPX_FRAME_ETHERII;
2612         sipx->sipx_action  = IPX_DLTITF;
2613         sipx->sipx_family  = AF_IPX;
2614 /*
2615  *  Set the IPX device
2616  */
2617         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2618             if (! ok_error (errno))
2619                 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2620             result = 0;
2621         }
2622         close (skfd);
2623     }
2624 #endif
2625     return result;
2626 }
2627
2628 /*
2629  * Use the hostname as part of the random number seed.
2630  */
2631 int
2632 get_host_seed()
2633 {
2634     int h;
2635     char *p = hostname;
2636
2637     h = 407;
2638     for (p = hostname; *p != 0; ++p)
2639         h = h * 37 + *p;
2640     return h;
2641 }
2642
2643 /********************************************************************
2644  *
2645  * sys_check_options - check the options that the user specified
2646  */
2647
2648 int
2649 sys_check_options(void)
2650 {
2651 #ifdef IPX_CHANGE
2652 /*
2653  * Disable the IPX protocol if the support is not present in the kernel.
2654  */
2655     char *path;
2656
2657     if (ipxcp_protent.enabled_flag) {
2658         struct stat stat_buf;
2659         if ((path = path_to_procfs("/net/ipx_interface")) == 0
2660             || lstat(path, &stat_buf) < 0) {
2661             error("IPX support is not present in the kernel\n");
2662             ipxcp_protent.enabled_flag = 0;
2663         }
2664     }
2665 #endif
2666     if (demand && driver_is_old) {
2667         option_error("demand dialling is not supported by kernel driver "
2668                      "version %d.%d.%d", driver_version, driver_modification,
2669                      driver_patch);
2670         return 0;
2671     }
2672     if (multilink && !new_style_driver) {
2673         warn("Warning: multilink is not supported by the kernel driver");
2674         multilink = 0;
2675     }
2676     return 1;
2677 }