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;
1658     struct ifconf ifc;
1659     struct ifreq ifs[MAX_IFS];
1660
1661     ifc.ifc_len = sizeof(ifs);
1662     ifc.ifc_req = ifs;
1663     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1664         if ( ! ok_error ( errno ))
1665             error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1666         return 0;
1667     }
1668
1669     SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1670                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1671 /*
1672  * Scan through looking for an interface with an Internet
1673  * address on the same subnet as `ipaddr'.
1674  */
1675     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1676     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1677         if (ifr->ifr_addr.sa_family == AF_INET) {
1678             ina = SIN_ADDR(ifr->ifr_addr);
1679             strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1680             SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1681                         ifreq.ifr_name));
1682 /*
1683  * Check that the interface is up, and not point-to-point
1684  * nor loopback.
1685  */
1686             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1687                 continue;
1688
1689             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1690                 continue;
1691 /*
1692  * Get its netmask and check that it's on the right subnet.
1693  */
1694             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1695                 continue;
1696
1697             mask = SIN_ADDR(ifreq.ifr_addr);
1698             SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1699                         ip_ntoa(ina), ntohl(mask)));
1700
1701             if (((ipaddr ^ ina) & mask) != 0)
1702                 continue;
1703             break;
1704         }
1705     }
1706
1707     if (ifr >= ifend)
1708         return 0;
1709
1710     strlcpy(name, ifreq.ifr_name, namelen);
1711
1712     /* trim off the :1 in eth0:1 */
1713     aliasp = strchr(name, ':');
1714     if (aliasp != 0)
1715         *aliasp = 0;
1716
1717     info("found interface %s for proxy arp", name);
1718 /*
1719  * Now get the hardware address.
1720  */
1721     memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1722     if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1723         error("SIOCGIFHWADDR(%s): %m", ifreq.ifr_name);
1724         return 0;
1725     }
1726
1727     memcpy (hwaddr,
1728             &ifreq.ifr_hwaddr,
1729             sizeof (struct sockaddr));
1730
1731     SYSDEBUG ((LOG_DEBUG,
1732            "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1733                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1734                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1735                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1736                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1737                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1738                 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1739                 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1740                 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1741     return 1;
1742 }
1743
1744 /*
1745  * get_if_hwaddr - get the hardware address for the specified
1746  * network interface device.
1747  */
1748 int
1749 get_if_hwaddr(u_char *addr, char *name)
1750 {
1751         struct ifreq ifreq;
1752         int ret, sock_fd;
1753
1754         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1755         if (sock_fd < 0)
1756                 return 0;
1757         memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1758         strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1759         ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1760         close(sock_fd);
1761         if (ret >= 0)
1762                 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1763         return ret;
1764 }
1765
1766 /*
1767  * get_first_ethernet - return the name of the first ethernet-style
1768  * interface on this system.
1769  */
1770 char *
1771 get_first_ethernet()
1772 {
1773         return "eth0";
1774 }
1775
1776 /********************************************************************
1777  *
1778  * Return user specified netmask, modified by any mask we might determine
1779  * for address `addr' (in network byte order).
1780  * Here we scan through the system's list of interfaces, looking for
1781  * any non-point-to-point interfaces which might appear to be on the same
1782  * network as `addr'.  If we find any, we OR in their netmask to the
1783  * user-specified netmask.
1784  */
1785
1786 u_int32_t GetMask (u_int32_t addr)
1787 {
1788     u_int32_t mask, nmask, ina;
1789     struct ifreq *ifr, *ifend, ifreq;
1790     struct ifconf ifc;
1791     struct ifreq ifs[MAX_IFS];
1792
1793     addr = ntohl(addr);
1794
1795     if (IN_CLASSA(addr))        /* determine network mask for address class */
1796         nmask = IN_CLASSA_NET;
1797     else if (IN_CLASSB(addr))
1798             nmask = IN_CLASSB_NET;
1799     else
1800             nmask = IN_CLASSC_NET;
1801
1802     /* class D nets are disallowed by bad_ip_adrs */
1803     mask = netmask | htonl(nmask);
1804 /*
1805  * Scan through the system's network interfaces.
1806  */
1807     ifc.ifc_len = sizeof(ifs);
1808     ifc.ifc_req = ifs;
1809     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1810         if ( ! ok_error ( errno ))
1811             warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1812         return mask;
1813     }
1814
1815     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1816     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1817 /*
1818  * Check the interface's internet address.
1819  */
1820         if (ifr->ifr_addr.sa_family != AF_INET)
1821             continue;
1822         ina = SIN_ADDR(ifr->ifr_addr);
1823         if (((ntohl(ina) ^ addr) & nmask) != 0)
1824             continue;
1825 /*
1826  * Check that the interface is up, and not point-to-point nor loopback.
1827  */
1828         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1829         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1830             continue;
1831
1832         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1833             continue;
1834 /*
1835  * Get its netmask and OR it into our mask.
1836  */
1837         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1838             continue;
1839         mask |= SIN_ADDR(ifreq.ifr_addr);
1840         break;
1841     }
1842     return mask;
1843 }
1844
1845 /********************************************************************
1846  *
1847  * Internal routine to decode the version.modification.patch level
1848  */
1849
1850 static void decode_version (char *buf, int *version,
1851                             int *modification, int *patch)
1852 {
1853     char *endp;
1854
1855     *version      = (int) strtoul (buf, &endp, 10);
1856     *modification = 0;
1857     *patch        = 0;
1858
1859     if (endp != buf && *endp == '.') {
1860         buf = endp + 1;
1861         *modification = (int) strtoul (buf, &endp, 10);
1862         if (endp != buf && *endp == '.') {
1863             buf = endp + 1;
1864             *patch = (int) strtoul (buf, &buf, 10);
1865         }
1866     }
1867 }
1868
1869 /********************************************************************
1870  *
1871  * Procedure to determine if the PPP line discipline is registered.
1872  */
1873
1874 static int
1875 ppp_registered(void)
1876 {
1877     int local_fd;
1878     int mfd = -1;
1879     int ret = 0;
1880     char slave[16];
1881
1882     /*
1883      * We used to open the serial device and set it to the ppp line
1884      * discipline here, in order to create a ppp unit.  But that is
1885      * not a good idea - the user might have specified a device that
1886      * they can't open (permission, or maybe it doesn't really exist).
1887      * So we grab a pty master/slave pair and use that.
1888      */
1889     if (!get_pty(&mfd, &local_fd, slave, 0)) {
1890         no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1891         return 0;
1892     }
1893
1894     /*
1895      * Try to put the device into the PPP discipline.
1896      */
1897     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1898         error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
1899     } else
1900         ret = 1;
1901
1902     close(local_fd);
1903     close(mfd);
1904     return ret;
1905 }
1906
1907 /********************************************************************
1908  *
1909  * ppp_available - check whether the system has any ppp interfaces
1910  * (in fact we check whether we can do an ioctl on ppp0).
1911  */
1912
1913 int ppp_available(void)
1914 {
1915     int s, ok, fd;
1916     struct ifreq ifr;
1917     int    size;
1918     int    my_version, my_modification, my_patch;
1919     int osmaj, osmin, ospatch;
1920
1921     no_ppp_msg =
1922         "This system lacks kernel support for PPP.  This could be because\n"
1923         "the PPP kernel module could not be loaded, or because PPP was not\n"
1924         "included in the kernel configuration.  If PPP was included as a\n"
1925         "module, try `/sbin/modprobe -v ppp'.  If that fails, check that\n"
1926         "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1927         "See README.linux file in the ppp distribution for more details.\n";
1928
1929     /* get the kernel version now, since we are called before sys_init */
1930     uname(&utsname);
1931     osmaj = osmin = ospatch = 0;
1932     sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1933     kernel_version = KVERSION(osmaj, osmin, ospatch);
1934
1935     fd = open("/dev/ppp", O_RDWR);
1936 #if 0
1937     if (fd < 0 && errno == ENOENT) {
1938         /* try making it and see if that helps. */
1939         if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1940                   makedev(108, 0)) >= 0) {
1941             fd = open("/dev/ppp", O_RDWR);
1942             if (fd >= 0)
1943                 info("Created /dev/ppp device node");
1944             else
1945                 unlink("/dev/ppp");     /* didn't work, undo the mknod */
1946         } else if (errno == EEXIST) {
1947             fd = open("/dev/ppp", O_RDWR);
1948         }
1949     }
1950 #endif /* 0 */
1951     if (fd >= 0) {
1952         new_style_driver = 1;
1953
1954         /* XXX should get from driver */
1955         driver_version = 2;
1956         driver_modification = 4;
1957         driver_patch = 0;
1958         close(fd);
1959         return 1;
1960     }
1961     if (kernel_version >= KVERSION(2,3,13)) {
1962         if (errno == ENOENT)
1963             no_ppp_msg =
1964                 "pppd is unable to open the /dev/ppp device.\n"
1965                 "You need to create the /dev/ppp device node by\n"
1966                 "executing the following command as root:\n"
1967                 "       mknod /dev/ppp c 108 0\n";
1968         return 0;
1969     }
1970
1971 /*
1972  * Open a socket for doing the ioctl operations.
1973  */
1974     s = socket(AF_INET, SOCK_DGRAM, 0);
1975     if (s < 0)
1976         return 0;
1977
1978     strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1979     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1980 /*
1981  * If the device did not exist then attempt to create one by putting the
1982  * current tty into the PPP discipline. If this works then obtain the
1983  * flags for the device again.
1984  */
1985     if (!ok) {
1986         if (ppp_registered()) {
1987             strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1988             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1989         }
1990     }
1991 /*
1992  * Ensure that the hardware address is for PPP and not something else
1993  */
1994     if (ok)
1995         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1996
1997     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1998         ok = 0;
1999
2000 /*
2001  *  This is the PPP device. Validate the version of the driver at this
2002  *  point to ensure that this program will work with the driver.
2003  */
2004     if (ok) {
2005         char   abBuffer [1024];
2006
2007         ifr.ifr_data = abBuffer;
2008         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2009         if (size < 0) {
2010             error("Couldn't read driver version: %m");
2011             ok = 0;
2012             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2013
2014         } else {
2015             decode_version(abBuffer,
2016                            &driver_version,
2017                            &driver_modification,
2018                            &driver_patch);
2019 /*
2020  * Validate the version of the driver against the version that we used.
2021  */
2022             decode_version(VERSION,
2023                            &my_version,
2024                            &my_modification,
2025                            &my_patch);
2026
2027             /* The version numbers must match */
2028             if (driver_version != my_version)
2029                 ok = 0;
2030
2031             /* The modification levels must be legal */
2032             if (driver_modification < 3) {
2033                 if (driver_modification >= 2) {
2034                     /* we can cope with 2.2.0 and above */
2035                     driver_is_old = 1;
2036                 } else {
2037                     ok = 0;
2038                 }
2039             }
2040
2041             close (s);
2042             if (!ok) {
2043                 slprintf(route_buffer, sizeof(route_buffer),
2044                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
2045                          driver_version, driver_modification, driver_patch);
2046
2047                 no_ppp_msg = route_buffer;
2048             }
2049         }
2050     }
2051     return ok;
2052 }
2053
2054 /********************************************************************
2055  *
2056  * Update the wtmp file with the appropriate user name and tty device.
2057  */
2058
2059 void logwtmp (const char *line, const char *name, const char *host)
2060 {
2061     struct utmp ut, *utp;
2062     pid_t  mypid = getpid();
2063 #if __GLIBC__ < 2
2064     int    wtmp;
2065 #endif
2066
2067 /*
2068  * Update the signon database for users.
2069  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2070  */
2071     utmpname(_PATH_UTMP);
2072     setutent();
2073     while ((utp = getutent()) && (utp->ut_pid != mypid))
2074         /* nothing */;
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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 (line %d)", __LINE__);
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");
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");
2568
2569     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2570         fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2571 /*
2572  * Find out which interface we were given.
2573  */
2574     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2575         fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2576 /*
2577  * Enable debug in the driver if requested.
2578  */
2579     set_kdebugflag (kdebugflag);
2580
2581     return master_fd;
2582 }
2583
2584 /********************************************************************
2585  *
2586  * sifnpmode - Set the mode for handling packets for a given NP.
2587  */
2588
2589 int
2590 sifnpmode(u, proto, mode)
2591     int u;
2592     int proto;
2593     enum NPmode mode;
2594 {
2595     struct npioctl npi;
2596
2597     npi.protocol = proto;
2598     npi.mode     = mode;
2599     if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2600         if (! ok_error (errno))
2601             error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2602         return 0;
2603     }
2604     return 1;
2605 }
2606
2607 \f
2608 /********************************************************************
2609  *
2610  * sipxfaddr - Config the interface IPX networknumber
2611  */
2612
2613 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2614 {
2615     int    result = 1;
2616
2617 #ifdef IPX_CHANGE
2618     int    skfd;
2619     struct ifreq         ifr;
2620     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2621
2622     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2623     if (skfd < 0) {
2624         if (! ok_error (errno))
2625             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2626         result = 0;
2627     }
2628     else {
2629         memset (&ifr, '\0', sizeof (ifr));
2630         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2631
2632         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2633         sipx->sipx_family  = AF_IPX;
2634         sipx->sipx_port    = 0;
2635         sipx->sipx_network = htonl (network);
2636         sipx->sipx_type    = IPX_FRAME_ETHERII;
2637         sipx->sipx_action  = IPX_CRTITF;
2638 /*
2639  *  Set the IPX device
2640  */
2641         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2642             result = 0;
2643             if (errno != EEXIST) {
2644                 if (! ok_error (errno))
2645                     dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2646             }
2647             else {
2648                 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2649             }
2650         }
2651         close (skfd);
2652     }
2653 #endif
2654     return result;
2655 }
2656
2657 /********************************************************************
2658  *
2659  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2660  *             are removed and the device is no longer able to pass IPX
2661  *             frames.
2662  */
2663
2664 int cipxfaddr (int unit)
2665 {
2666     int    result = 1;
2667
2668 #ifdef IPX_CHANGE
2669     int    skfd;
2670     struct ifreq         ifr;
2671     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2672
2673     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2674     if (skfd < 0) {
2675         if (! ok_error (errno))
2676             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2677         result = 0;
2678     }
2679     else {
2680         memset (&ifr, '\0', sizeof (ifr));
2681         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2682
2683         sipx->sipx_type    = IPX_FRAME_ETHERII;
2684         sipx->sipx_action  = IPX_DLTITF;
2685         sipx->sipx_family  = AF_IPX;
2686 /*
2687  *  Set the IPX device
2688  */
2689         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2690             if (! ok_error (errno))
2691                 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2692             result = 0;
2693         }
2694         close (skfd);
2695     }
2696 #endif
2697     return result;
2698 }
2699
2700 /*
2701  * Use the hostname as part of the random number seed.
2702  */
2703 int
2704 get_host_seed()
2705 {
2706     int h;
2707     char *p = hostname;
2708
2709     h = 407;
2710     for (p = hostname; *p != 0; ++p)
2711         h = h * 37 + *p;
2712     return h;
2713 }
2714
2715 /********************************************************************
2716  *
2717  * sys_check_options - check the options that the user specified
2718  */
2719
2720 int
2721 sys_check_options(void)
2722 {
2723 #ifdef IPX_CHANGE
2724 /*
2725  * Disable the IPX protocol if the support is not present in the kernel.
2726  */
2727     char *path;
2728
2729     if (ipxcp_protent.enabled_flag) {
2730         struct stat stat_buf;
2731         if ((path = path_to_procfs("/net/ipx_interface")) == 0
2732             || lstat(path, &stat_buf) < 0) {
2733             error("IPX support is not present in the kernel\n");
2734             ipxcp_protent.enabled_flag = 0;
2735         }
2736     }
2737 #endif
2738     if (demand && driver_is_old) {
2739         option_error("demand dialling is not supported by kernel driver "
2740                      "version %d.%d.%d", driver_version, driver_modification,
2741                      driver_patch);
2742         return 0;
2743     }
2744     if (multilink && !new_style_driver) {
2745         warn("Warning: multilink is not supported by the kernel driver");
2746         multilink = 0;
2747     }
2748     return 1;
2749 }