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