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