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