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     /* Is this call really necessary? There is another one after the 'put' */
2077     endutent();
2078
2079     if (utp)
2080         memcpy(&ut, utp, sizeof(ut));
2081     else
2082         /* some gettys/telnetds don't initialize utmp... */
2083         memset(&ut, 0, sizeof(ut));
2084
2085     if (ut.ut_id[0] == 0)
2086         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2087
2088     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2089     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2090
2091     time(&ut.ut_time);
2092
2093     ut.ut_type = USER_PROCESS;
2094     ut.ut_pid  = mypid;
2095
2096     /* Insert the host name if one is supplied */
2097     if (*host)
2098         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2099
2100     /* Insert the IP address of the remote system if IP is enabled */
2101     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2102         memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2103                  sizeof(ut.ut_addr));
2104
2105     /* CL: Makes sure that the logout works */
2106     if (*host == 0 && *name==0)
2107         ut.ut_host[0]=0;
2108
2109     pututline(&ut);
2110     endutent();
2111 /*
2112  * Update the wtmp file.
2113  */
2114 #if __GLIBC__ >= 2
2115     updwtmp(_PATH_WTMP, &ut);
2116 #else
2117     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2118     if (wtmp >= 0) {
2119         flock(wtmp, LOCK_EX);
2120
2121         if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2122             warn("error writing %s: %m", _PATH_WTMP);
2123
2124         flock(wtmp, LOCK_UN);
2125
2126         close (wtmp);
2127     }
2128 #endif
2129 }
2130
2131
2132 /********************************************************************
2133  *
2134  * sifvjcomp - config tcp header compression
2135  */
2136
2137 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2138 {
2139     u_int x = get_flags(ppp_dev_fd);
2140
2141     if (vjcomp) {
2142         if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2143             if (! ok_error (errno))
2144                 error("ioctl(PPPIOCSMAXCID): %m (line %d)", __LINE__);
2145             vjcomp = 0;
2146         }
2147     }
2148
2149     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
2150     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2151     set_flags (ppp_dev_fd, x);
2152
2153     return 1;
2154 }
2155
2156 /********************************************************************
2157  *
2158  * sifup - Config the interface up and enable IP packets to pass.
2159  */
2160
2161 int sifup(int u)
2162 {
2163     struct ifreq ifr;
2164
2165     memset (&ifr, '\0', sizeof (ifr));
2166     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2167     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2168         if (! ok_error (errno))
2169             error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2170         return 0;
2171     }
2172
2173     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2174     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2175         if (! ok_error (errno))
2176             error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2177         return 0;
2178     }
2179     if_is_up++;
2180
2181     return 1;
2182 }
2183
2184 /********************************************************************
2185  *
2186  * sifdown - Disable the indicated protocol and config the interface
2187  *           down if there are no remaining protocols.
2188  */
2189
2190 int sifdown (int u)
2191 {
2192     struct ifreq ifr;
2193
2194     if (if_is_up && --if_is_up > 0)
2195         return 1;
2196
2197     memset (&ifr, '\0', sizeof (ifr));
2198     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2199     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2200         if (! ok_error (errno))
2201             error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2202         return 0;
2203     }
2204
2205     ifr.ifr_flags &= ~IFF_UP;
2206     ifr.ifr_flags |= IFF_POINTOPOINT;
2207     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2208         if (! ok_error (errno))
2209             error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2210         return 0;
2211     }
2212     return 1;
2213 }
2214
2215 /********************************************************************
2216  *
2217  * sifaddr - Config the interface IP addresses and netmask.
2218  */
2219
2220 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2221              u_int32_t net_mask)
2222 {
2223     struct ifreq   ifr;
2224     struct rtentry rt;
2225
2226     memset (&ifr, '\0', sizeof (ifr));
2227     memset (&rt,  '\0', sizeof (rt));
2228
2229     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET);
2230     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2231     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2232
2233     strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2234 /*
2235  *  Set our IP address
2236  */
2237     SIN_ADDR(ifr.ifr_addr) = our_adr;
2238     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2239         if (errno != EEXIST) {
2240             if (! ok_error (errno))
2241                 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2242         }
2243         else {
2244             warn("ioctl(SIOCSIFADDR): Address already exists");
2245         }
2246         return (0);
2247     }
2248 /*
2249  *  Set the gateway address
2250  */
2251     SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2252     if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2253         if (! ok_error (errno))
2254             error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2255         return (0);
2256     }
2257 /*
2258  *  Set the netmask.
2259  *  For recent kernels, force the netmask to 255.255.255.255.
2260  */
2261     if (kernel_version >= KVERSION(2,1,16))
2262         net_mask = ~0L;
2263     if (net_mask != 0) {
2264         SIN_ADDR(ifr.ifr_netmask) = net_mask;
2265         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2266             if (! ok_error (errno))
2267                 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2268             return (0);
2269         }
2270     }
2271 /*
2272  *  Add the device route
2273  */
2274     if (kernel_version < KVERSION(2,1,16)) {
2275         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2276         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2277         rt.rt_dev = ifname;
2278
2279         SIN_ADDR(rt.rt_gateway) = 0L;
2280         SIN_ADDR(rt.rt_dst)     = his_adr;
2281         rt.rt_flags = RTF_UP | RTF_HOST;
2282
2283         if (kernel_version > KVERSION(2,1,0)) {
2284             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2285             SIN_ADDR(rt.rt_genmask) = -1L;
2286         }
2287
2288         if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2289             if (! ok_error (errno))
2290                 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2291             return (0);
2292         }
2293     }
2294
2295     /* set ip_dynaddr in demand mode if address changes */
2296     if (demand && tune_kernel && !dynaddr_set
2297         && our_old_addr && our_old_addr != our_adr) {
2298         /* set ip_dynaddr if possible */
2299         char *path;
2300         int fd;
2301
2302         path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2303         if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2304             if (write(fd, "1", 1) != 1)
2305                 error("Couldn't enable dynamic IP addressing: %m");
2306             close(fd);
2307         }
2308         dynaddr_set = 1;        /* only 1 attempt */
2309     }
2310     our_old_addr = 0;
2311
2312     return 1;
2313 }
2314
2315 /********************************************************************
2316  *
2317  * cifaddr - Clear the interface IP addresses, and delete routes
2318  * through the interface if possible.
2319  */
2320
2321 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2322 {
2323     struct ifreq ifr;
2324
2325     if (kernel_version < KVERSION(2,1,16)) {
2326 /*
2327  *  Delete the route through the device
2328  */
2329         struct rtentry rt;
2330         memset (&rt, '\0', sizeof (rt));
2331
2332         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2333         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2334         rt.rt_dev = ifname;
2335
2336         SIN_ADDR(rt.rt_gateway) = 0;
2337         SIN_ADDR(rt.rt_dst)     = his_adr;
2338         rt.rt_flags = RTF_UP | RTF_HOST;
2339
2340         if (kernel_version > KVERSION(2,1,0)) {
2341             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2342             SIN_ADDR(rt.rt_genmask) = -1L;
2343         }
2344
2345         if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2346             if (still_ppp() && ! ok_error (errno))
2347                 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2348             return (0);
2349         }
2350     }
2351
2352     /* This way it is possible to have an IPX-only or IPv6-only interface */
2353     memset(&ifr, 0, sizeof(ifr));
2354     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2355     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2356
2357     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2358         if (! ok_error (errno)) {
2359             error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2360             return 0;
2361         }
2362     }
2363
2364     our_old_addr = our_adr;
2365
2366     return 1;
2367 }
2368
2369 #ifdef INET6
2370 /********************************************************************
2371  *
2372  * sif6addr - Config the interface with an IPv6 link-local address
2373  */
2374 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2375 {
2376     struct in6_ifreq ifr6;
2377     struct ifreq ifr;
2378     struct in6_rtmsg rt6;
2379
2380     if (sock6_fd < 0) {
2381         errno = -sock6_fd;
2382         error("IPv6 socket creation failed: %m");
2383         return 0;
2384     }
2385     memset(&ifr, 0, sizeof (ifr));
2386     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2387     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2388         error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2389         return 0;
2390     }
2391
2392     /* Local interface */
2393     memset(&ifr6, 0, sizeof(ifr6));
2394     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2395     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2396     ifr6.ifr6_prefixlen = 10;
2397
2398     if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2399         error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2400         return 0;
2401     }
2402
2403     /* Route to remote host */
2404     memset(&rt6, 0, sizeof(rt6));
2405     IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2406     rt6.rtmsg_flags = RTF_UP;
2407     rt6.rtmsg_dst_len = 10;
2408     rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2409     rt6.rtmsg_metric = 1;
2410
2411     if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2412         error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2413         return 0;
2414     }
2415
2416     return 1;
2417 }
2418
2419
2420 /********************************************************************
2421  *
2422  * cif6addr - Remove IPv6 address from interface
2423  */
2424 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2425 {
2426     struct ifreq ifr;
2427     struct in6_ifreq ifr6;
2428
2429     if (sock6_fd < 0) {
2430         errno = -sock6_fd;
2431         error("IPv6 socket creation failed: %m");
2432         return 0;
2433     }
2434     memset(&ifr, 0, sizeof(ifr));
2435     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2436     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2437         error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2438         return 0;
2439     }
2440
2441     memset(&ifr6, 0, sizeof(ifr6));
2442     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2443     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2444     ifr6.ifr6_prefixlen = 10;
2445
2446     if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2447         if (errno != EADDRNOTAVAIL) {
2448             if (! ok_error (errno))
2449                 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2450         }
2451         else {
2452             warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2453         }
2454         return (0);
2455     }
2456     return 1;
2457 }
2458 #endif /* INET6 */
2459
2460 /*
2461  * get_pty - get a pty master/slave pair and chown the slave side
2462  * to the uid given.  Assumes slave_name points to >= 16 bytes of space.
2463  */
2464 int
2465 get_pty(master_fdp, slave_fdp, slave_name, uid)
2466     int *master_fdp;
2467     int *slave_fdp;
2468     char *slave_name;
2469     int uid;
2470 {
2471     int i, mfd, sfd = -1;
2472     char pty_name[16];
2473     struct termios tios;
2474
2475 #ifdef TIOCGPTN
2476     /*
2477      * Try the unix98 way first.
2478      */
2479     mfd = open("/dev/ptmx", O_RDWR);
2480     if (mfd >= 0) {
2481         int ptn;
2482         if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2483             slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2484             chmod(pty_name, S_IRUSR | S_IWUSR);
2485 #ifdef TIOCSPTLCK
2486             ptn = 0;
2487             if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2488                 warn("Couldn't unlock pty slave %s: %m", pty_name);
2489 #endif
2490             if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2491                 warn("Couldn't open pty slave %s: %m", pty_name);
2492         }
2493     }
2494 #endif /* TIOCGPTN */
2495
2496     if (sfd < 0) {
2497         /* the old way - scan through the pty name space */
2498         for (i = 0; i < 64; ++i) {
2499             slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2500                      'p' + i / 16, i % 16);
2501             mfd = open(pty_name, O_RDWR, 0);
2502             if (mfd >= 0) {
2503                 pty_name[5] = 't';
2504                 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2505                 if (sfd >= 0) {
2506                     fchown(sfd, uid, -1);
2507                     fchmod(sfd, S_IRUSR | S_IWUSR);
2508                     break;
2509                 }
2510                 close(mfd);
2511             }
2512         }
2513     }
2514
2515     if (sfd < 0)
2516         return 0;
2517
2518     strlcpy(slave_name, pty_name, 16);
2519     *master_fdp = mfd;
2520     *slave_fdp = sfd;
2521     if (tcgetattr(sfd, &tios) == 0) {
2522         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2523         tios.c_cflag |= CS8 | CREAD | CLOCAL;
2524         tios.c_iflag  = IGNPAR;
2525         tios.c_oflag  = 0;
2526         tios.c_lflag  = 0;
2527         if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2528             warn("couldn't set attributes on pty: %m");
2529     } else
2530         warn("couldn't get attributes on pty: %m");
2531
2532     return 1;
2533 }
2534
2535 /********************************************************************
2536  *
2537  * open_loopback - open the device we use for getting packets
2538  * in demand mode.  Under Linux, we use a pty master/slave pair.
2539  */
2540 int
2541 open_ppp_loopback(void)
2542 {
2543     int flags;
2544
2545     looped = 1;
2546     if (new_style_driver) {
2547         /* allocate ourselves a ppp unit */
2548         if (make_ppp_unit() < 0)
2549             die(1);
2550         set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2551         set_kdebugflag(kdebugflag);
2552         ppp_fd = -1;
2553         return ppp_dev_fd;
2554     }
2555
2556     if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2557         fatal("No free pty for loopback");
2558     SYSDEBUG(("using %s for loopback", loop_name));
2559
2560     set_ppp_fd(slave_fd);
2561
2562     flags = fcntl(master_fd, F_GETFL);
2563     if (flags == -1 ||
2564         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2565         warn("couldn't set master loopback to nonblock: %m");
2566
2567     flags = fcntl(ppp_fd, F_GETFL);
2568     if (flags == -1 ||
2569         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2570         warn("couldn't set slave loopback to nonblock: %m");
2571
2572     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2573         fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2574 /*
2575  * Find out which interface we were given.
2576  */
2577     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2578         fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2579 /*
2580  * Enable debug in the driver if requested.
2581  */
2582     set_kdebugflag (kdebugflag);
2583
2584     return master_fd;
2585 }
2586
2587 /********************************************************************
2588  *
2589  * sifnpmode - Set the mode for handling packets for a given NP.
2590  */
2591
2592 int
2593 sifnpmode(u, proto, mode)
2594     int u;
2595     int proto;
2596     enum NPmode mode;
2597 {
2598     struct npioctl npi;
2599
2600     npi.protocol = proto;
2601     npi.mode     = mode;
2602     if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2603         if (! ok_error (errno))
2604             error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2605         return 0;
2606     }
2607     return 1;
2608 }
2609
2610 \f
2611 /********************************************************************
2612  *
2613  * sipxfaddr - Config the interface IPX networknumber
2614  */
2615
2616 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2617 {
2618     int    result = 1;
2619
2620 #ifdef IPX_CHANGE
2621     int    skfd;
2622     struct ifreq         ifr;
2623     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2624
2625     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2626     if (skfd < 0) {
2627         if (! ok_error (errno))
2628             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2629         result = 0;
2630     }
2631     else {
2632         memset (&ifr, '\0', sizeof (ifr));
2633         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2634
2635         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2636         sipx->sipx_family  = AF_IPX;
2637         sipx->sipx_port    = 0;
2638         sipx->sipx_network = htonl (network);
2639         sipx->sipx_type    = IPX_FRAME_ETHERII;
2640         sipx->sipx_action  = IPX_CRTITF;
2641 /*
2642  *  Set the IPX device
2643  */
2644         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2645             result = 0;
2646             if (errno != EEXIST) {
2647                 if (! ok_error (errno))
2648                     dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2649             }
2650             else {
2651                 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2652             }
2653         }
2654         close (skfd);
2655     }
2656 #endif
2657     return result;
2658 }
2659
2660 /********************************************************************
2661  *
2662  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2663  *             are removed and the device is no longer able to pass IPX
2664  *             frames.
2665  */
2666
2667 int cipxfaddr (int unit)
2668 {
2669     int    result = 1;
2670
2671 #ifdef IPX_CHANGE
2672     int    skfd;
2673     struct ifreq         ifr;
2674     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2675
2676     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2677     if (skfd < 0) {
2678         if (! ok_error (errno))
2679             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2680         result = 0;
2681     }
2682     else {
2683         memset (&ifr, '\0', sizeof (ifr));
2684         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2685
2686         sipx->sipx_type    = IPX_FRAME_ETHERII;
2687         sipx->sipx_action  = IPX_DLTITF;
2688         sipx->sipx_family  = AF_IPX;
2689 /*
2690  *  Set the IPX device
2691  */
2692         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2693             if (! ok_error (errno))
2694                 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2695             result = 0;
2696         }
2697         close (skfd);
2698     }
2699 #endif
2700     return result;
2701 }
2702
2703 /*
2704  * Use the hostname as part of the random number seed.
2705  */
2706 int
2707 get_host_seed()
2708 {
2709     int h;
2710     char *p = hostname;
2711
2712     h = 407;
2713     for (p = hostname; *p != 0; ++p)
2714         h = h * 37 + *p;
2715     return h;
2716 }
2717
2718 /********************************************************************
2719  *
2720  * sys_check_options - check the options that the user specified
2721  */
2722
2723 int
2724 sys_check_options(void)
2725 {
2726 #ifdef IPX_CHANGE
2727 /*
2728  * Disable the IPX protocol if the support is not present in the kernel.
2729  */
2730     char *path;
2731
2732     if (ipxcp_protent.enabled_flag) {
2733         struct stat stat_buf;
2734         if ((path = path_to_procfs("/net/ipx_interface")) == 0
2735             || lstat(path, &stat_buf) < 0) {
2736             error("IPX support is not present in the kernel\n");
2737             ipxcp_protent.enabled_flag = 0;
2738         }
2739     }
2740 #endif
2741     if (demand && driver_is_old) {
2742         option_error("demand dialling is not supported by kernel driver "
2743                      "version %d.%d.%d", driver_version, driver_modification,
2744                      driver_patch);
2745         return 0;
2746     }
2747     if (multilink && !new_style_driver) {
2748         warn("Warning: multilink is not supported by the kernel driver");
2749         multilink = 0;
2750     }
2751     return 1;
2752 }