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