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 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     if (snoop_send_hook) snoop_send_hook(p, len);
 950
 951     if (len < PPP_HDRLEN)
 952         return;
 953     if (new_style_driver) {
 954         p += 2;
 955         len -= 2;
 956         proto = (p[0] << 8) + p[1];
 957         if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
 958             fd = ppp_dev_fd;
 959     }
 960     if (write(fd, p, len) < 0) {
 961         if (errno == EWOULDBLOCK || errno == ENOBUFS
 962             || errno == ENXIO || errno == EIO || errno == EINTR)
 963             warn("write: warning: %m (%d)", errno);
 964         else
 965             error("write: %m (%d)", errno);
 966     }
 967 }
 968
 969 /********************************************************************
 970  *
 971  * wait_input - wait until there is data available,
 972  * for the length of time specified by *timo (indefinite
 973  * if timo is NULL).
 974  */
 975
 976 void wait_input(struct timeval *timo)
 977 {
 978     fd_set ready, exc;
 979     int n;
 980
 981     ready = in_fds;
 982     exc = in_fds;
 983     n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
 984     if (n < 0 && errno != EINTR)
 985         fatal("select: %m");
 986 }
 987
 988 /*
 989  * add_fd - add an fd to the set that wait_input waits for.
 990  */
 991 void add_fd(int fd)
 992 {
 993     FD_SET(fd, &in_fds);
 994     if (fd > max_in_fd)
 995         max_in_fd = fd;
 996 }
 997
 998 /*
 999  * remove_fd - remove an fd from the set that wait_input waits for.
1000  */
1001 void remove_fd(int fd)
1002 {
1003     FD_CLR(fd, &in_fds);
1004 }
1005
1006
1007 /********************************************************************
1008  *
1009  * read_packet - get a PPP packet from the serial device.
1010  */
1011
1012 int read_packet (unsigned char *buf)
1013 {
1014     int len, nr;
1015
1016     len = PPP_MRU + PPP_HDRLEN;
1017     if (new_style_driver) {
1018         *buf++ = PPP_ALLSTATIONS;
1019         *buf++ = PPP_UI;
1020         len -= 2;
1021     }
1022     nr = -1;
1023     if (ppp_fd >= 0) {
1024         nr = read(ppp_fd, buf, len);
1025         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1026             error("read: %m");
1027         if (nr < 0 && errno == ENXIO)
1028             return 0;
1029     }
1030     if (nr < 0 && new_style_driver && ifunit >= 0) {
1031         /* N.B. we read ppp_fd first since LCP packets come in there. */
1032         nr = read(ppp_dev_fd, buf, len);
1033         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1034             error("read /dev/ppp: %m");
1035         if (nr < 0 && errno == ENXIO)
1036             return 0;
1037     }
1038     return (new_style_driver && nr > 0)? nr+2: nr;
1039 }
1040
1041 /********************************************************************
1042  *
1043  * get_loop_output - get outgoing packets from the ppp device,
1044  * and detect when we want to bring the real link up.
1045  * Return value is 1 if we need to bring up the link, 0 otherwise.
1046  */
1047 int
1048 get_loop_output(void)
1049 {
1050     int rv = 0;
1051     int n;
1052
1053     if (new_style_driver) {
1054         while ((n = read_packet(inpacket_buf)) > 0)
1055             if (loop_frame(inpacket_buf, n))
1056                 rv = 1;
1057         return rv;
1058     }
1059
1060     while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1061         if (loop_chars(inbuf, n))
1062             rv = 1;
1063
1064     if (n == 0)
1065         fatal("eof on loopback");
1066
1067     if (errno != EWOULDBLOCK)
1068         fatal("read from loopback: %m(%d)", errno);
1069
1070     return rv;
1071 }
1072
1073 /*
1074  * netif_set_mtu - set the MTU on the PPP network interface.
1075  */
1076 void
1077 netif_set_mtu(int unit, int mtu)
1078 {
1079     struct ifreq ifr;
1080
1081     SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1082
1083     memset (&ifr, '\0', sizeof (ifr));
1084     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1085     ifr.ifr_mtu = mtu;
1086
1087     if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1088         error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1089 }
1090
1091 /********************************************************************
1092  *
1093  * tty_send_config - configure the transmit characteristics of
1094  * the ppp interface.
1095  */
1096
1097 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1098 {
1099     u_int x;
1100
1101 /*
1102  * Set the asyncmap and other parameters for the ppp device
1103  */
1104     if (!still_ppp())
1105         return;
1106     link_mtu = mtu;
1107     SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1108     if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1109         if (!ok_error(errno))
1110             fatal("ioctl(PPPIOCSASYNCMAP): %m (line %d)", __LINE__);
1111         return;
1112     }
1113
1114     x = get_flags(ppp_fd);
1115     x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1116     x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
1117     x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1118     set_flags(ppp_fd, x);
1119 }
1120
1121 /********************************************************************
1122  *
1123  * tty_set_xaccm - set the extended transmit ACCM for the interface.
1124  */
1125
1126 void tty_set_xaccm (ext_accm accm)
1127 {
1128     SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1129                 accm[0], accm[1], accm[2], accm[3]));
1130
1131     if (!still_ppp())
1132         return;
1133     if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1134         if ( ! ok_error (errno))
1135             warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1136     }
1137 }
1138
1139 /********************************************************************
1140  *
1141  * tty_recv_config - configure the receive-side characteristics of
1142  * the ppp interface.
1143  */
1144
1145 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1146 {
1147     SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1148 /*
1149  * If we were called because the link has gone down then there is nothing
1150  * which may be done. Just return without incident.
1151  */
1152     if (!still_ppp())
1153         return;
1154 /*
1155  * Set the receiver parameters
1156  */
1157     if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1158         if ( ! ok_error (errno))
1159             error("ioctl(PPPIOCSMRU): %m (line %d)", __LINE__);
1160     }
1161     if (new_style_driver && ifunit >= 0
1162         && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1163         error("Couldn't set MRU in generic PPP layer: %m");
1164
1165     SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1166     if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1167         if (!ok_error(errno))
1168             error("ioctl(PPPIOCSRASYNCMAP): %m (line %d)", __LINE__);
1169     }
1170 }
1171
1172 /********************************************************************
1173  *
1174  * ccp_test - ask kernel whether a given compression method
1175  * is acceptable for use.
1176  */
1177
1178 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1179 {
1180     struct ppp_option_data data;
1181
1182     memset (&data, '\0', sizeof (data));
1183     data.ptr      = opt_ptr;
1184     data.length   = opt_len;
1185     data.transmit = for_transmit;
1186
1187     if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1188         return 1;
1189
1190     return (errno == ENOBUFS)? 0: -1;
1191 }
1192
1193 /********************************************************************
1194  *
1195  * ccp_flags_set - inform kernel about the current state of CCP.
1196  */
1197
1198 void ccp_flags_set (int unit, int isopen, int isup)
1199 {
1200     if (still_ppp() && ifunit >= 0) {
1201         int x = get_flags(ppp_dev_fd);
1202         x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1203         x = isup?   x | SC_CCP_UP   : x &~ SC_CCP_UP;
1204         set_flags (ppp_dev_fd, x);
1205     }
1206 }
1207
1208 #ifdef PPP_FILTER
1209 /*
1210  * set_filters - set the active and pass filters in the kernel driver.
1211  */
1212 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1213 {
1214         struct sock_fprog fp;
1215
1216         fp.len = pass->bf_len;
1217         fp.filter = (struct sock_filter *) pass->bf_insns;
1218         if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1219                 if (errno == ENOTTY)
1220                         warn("kernel does not support PPP filtering");
1221                 else
1222                         error("Couldn't set pass-filter in kernel: %m");
1223                 return 0;
1224         }
1225         fp.len = active->bf_len;
1226         fp.filter = (struct sock_filter *) active->bf_insns;
1227         if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1228                 error("Couldn't set active-filter in kernel: %m");
1229                 return 0;
1230         }
1231         return 1;
1232 }
1233 #endif /* PPP_FILTER */
1234
1235 /********************************************************************
1236  *
1237  * get_idle_time - return how long the link has been idle.
1238  */
1239 int
1240 get_idle_time(u, ip)
1241     int u;
1242     struct ppp_idle *ip;
1243 {
1244     return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1245 }
1246
1247 /********************************************************************
1248  *
1249  * get_ppp_stats - return statistics for the link.
1250  */
1251 int
1252 get_ppp_stats(u, stats)
1253     int u;
1254     struct pppd_stats *stats;
1255 {
1256     struct ifpppstatsreq req;
1257
1258     memset (&req, 0, sizeof (req));
1259
1260     req.stats_ptr = (caddr_t) &req.stats;
1261     strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1262     if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1263         error("Couldn't get PPP statistics: %m");
1264         return 0;
1265     }
1266     stats->bytes_in = req.stats.p.ppp_ibytes;
1267     stats->bytes_out = req.stats.p.ppp_obytes;
1268     stats->pkts_in = req.stats.p.ppp_ipackets;
1269     stats->pkts_out = req.stats.p.ppp_opackets;
1270     return 1;
1271 }
1272
1273 /********************************************************************
1274  *
1275  * ccp_fatal_error - returns 1 if decompression was disabled as a
1276  * result of an error detected after decompression of a packet,
1277  * 0 otherwise.  This is necessary because of patent nonsense.
1278  */
1279
1280 int ccp_fatal_error (int unit)
1281 {
1282     int x = get_flags(ppp_dev_fd);
1283
1284     return x & SC_DC_FERROR;
1285 }
1286
1287 /********************************************************************
1288  *
1289  * path_to_procfs - find the path to the proc file system mount point
1290  */
1291 static char proc_path[MAXPATHLEN];
1292 static int proc_path_len;
1293
1294 static char *path_to_procfs(const char *tail)
1295 {
1296     struct mntent *mntent;
1297     FILE *fp;
1298
1299     if (proc_path_len == 0) {
1300         /* Default the mount location of /proc */
1301         strlcpy (proc_path, "/proc", sizeof(proc_path));
1302         proc_path_len = 5;
1303         fp = fopen(MOUNTED, "r");
1304         if (fp != NULL) {
1305             while ((mntent = getmntent(fp)) != NULL) {
1306                 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1307                     continue;
1308                 if (strcmp(mntent->mnt_type, "proc") == 0) {
1309                     strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1310                     proc_path_len = strlen(proc_path);
1311                     break;
1312                 }
1313             }
1314             fclose (fp);
1315         }
1316     }
1317
1318     strlcpy(proc_path + proc_path_len, tail,
1319             sizeof(proc_path) - proc_path_len);
1320     return proc_path;
1321 }
1322
1323 /*
1324  * /proc/net/route parsing stuff.
1325  */
1326 #define ROUTE_MAX_COLS  12
1327 FILE *route_fd = (FILE *) 0;
1328 static char route_buffer[512];
1329 static int route_dev_col, route_dest_col, route_gw_col;
1330 static int route_flags_col, route_mask_col;
1331 static int route_num_cols;
1332
1333 static int open_route_table (void);
1334 static void close_route_table (void);
1335 static int read_route_table (struct rtentry *rt);
1336
1337 /********************************************************************
1338  *
1339  * close_route_table - close the interface to the route table
1340  */
1341
1342 static void close_route_table (void)
1343 {
1344     if (route_fd != (FILE *) 0) {
1345         fclose (route_fd);
1346         route_fd = (FILE *) 0;
1347     }
1348 }
1349
1350 /********************************************************************
1351  *
1352  * open_route_table - open the interface to the route table
1353  */
1354 static char route_delims[] = " \t\n";
1355
1356 static int open_route_table (void)
1357 {
1358     char *path;
1359
1360     close_route_table();
1361
1362     path = path_to_procfs("/net/route");
1363     route_fd = fopen (path, "r");
1364     if (route_fd == NULL) {
1365         error("can't open routing table %s: %m", path);
1366         return 0;
1367     }
1368
1369     route_dev_col = 0;          /* default to usual columns */
1370     route_dest_col = 1;
1371     route_gw_col = 2;
1372     route_flags_col = 3;
1373     route_mask_col = 7;
1374     route_num_cols = 8;
1375
1376     /* parse header line */
1377     if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1378         char *p = route_buffer, *q;
1379         int col;
1380         for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1381             int used = 1;
1382             if ((q = strtok(p, route_delims)) == 0)
1383                 break;
1384             if (strcasecmp(q, "iface") == 0)
1385                 route_dev_col = col;
1386             else if (strcasecmp(q, "destination") == 0)
1387                 route_dest_col = col;
1388             else if (strcasecmp(q, "gateway") == 0)
1389                 route_gw_col = col;
1390             else if (strcasecmp(q, "flags") == 0)
1391                 route_flags_col = col;
1392             else if (strcasecmp(q, "mask") == 0)
1393                 route_mask_col = col;
1394             else
1395                 used = 0;
1396             if (used && col >= route_num_cols)
1397                 route_num_cols = col + 1;
1398             p = NULL;
1399         }
1400     }
1401
1402     return 1;
1403 }
1404
1405 /********************************************************************
1406  *
1407  * read_route_table - read the next entry from the route table
1408  */
1409
1410 static int read_route_table(struct rtentry *rt)
1411 {
1412     char *cols[ROUTE_MAX_COLS], *p;
1413     int col;
1414
1415     memset (rt, '\0', sizeof (struct rtentry));
1416
1417     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1418         return 0;
1419
1420     p = route_buffer;
1421     for (col = 0; col < route_num_cols; ++col) {
1422         cols[col] = strtok(p, route_delims);
1423         if (cols[col] == NULL)
1424             return 0;           /* didn't get enough columns */
1425         p = NULL;
1426     }
1427
1428     SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1429     SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1430     SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1431
1432     rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1433     rt->rt_dev   = cols[route_dev_col];
1434
1435     return 1;
1436 }
1437
1438 /********************************************************************
1439  *
1440  * defaultroute_exists - determine if there is a default route
1441  */
1442
1443 static int defaultroute_exists (struct rtentry *rt)
1444 {
1445     int result = 0;
1446
1447     if (!open_route_table())
1448         return 0;
1449
1450     while (read_route_table(rt) != 0) {
1451         if ((rt->rt_flags & RTF_UP) == 0)
1452             continue;
1453
1454         if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1455             continue;
1456         if (SIN_ADDR(rt->rt_dst) == 0L) {
1457             result = 1;
1458             break;
1459         }
1460     }
1461
1462     close_route_table();
1463     return result;
1464 }
1465
1466 /*
1467  * have_route_to - determine if the system has any route to
1468  * a given IP address.  `addr' is in network byte order.
1469  * Return value is 1 if yes, 0 if no, -1 if don't know.
1470  * For demand mode to work properly, we have to ignore routes
1471  * through our own interface.
1472  */
1473 int have_route_to(u_int32_t addr)
1474 {
1475     struct rtentry rt;
1476     int result = 0;
1477
1478     if (!open_route_table())
1479         return -1;              /* don't know */
1480
1481     while (read_route_table(&rt)) {
1482         if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1483             continue;
1484         if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1485             result = 1;
1486             break;
1487         }
1488     }
1489
1490     close_route_table();
1491     return result;
1492 }
1493
1494 /********************************************************************
1495  *
1496  * sifdefaultroute - assign a default route through the address given.
1497  */
1498
1499 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1500 {
1501     struct rtentry rt;
1502
1503     if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1504         u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1505
1506         if (old_gateway != gateway)
1507             error("not replacing existing default route to %s [%I]",
1508                   rt.rt_dev, old_gateway);
1509         return 0;
1510     }
1511
1512     memset (&rt, '\0', sizeof (rt));
1513     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1514     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1515
1516     rt.rt_dev = ifname;
1517
1518     if (kernel_version > KVERSION(2,1,0)) {
1519         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1520         SIN_ADDR(rt.rt_genmask) = 0L;
1521     }
1522
1523     SIN_ADDR(rt.rt_gateway) = gateway;
1524
1525     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1526     if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1527         if ( ! ok_error ( errno ))
1528             error("default route ioctl(SIOCADDRT): %m");
1529         return 0;
1530     }
1531
1532     default_route_gateway = gateway;
1533     return 1;
1534 }
1535
1536 /********************************************************************
1537  *
1538  * cifdefaultroute - delete a default route through the address given.
1539  */
1540
1541 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1542 {
1543     struct rtentry rt;
1544
1545     default_route_gateway = 0;
1546
1547     memset (&rt, '\0', sizeof (rt));
1548     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1549     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1550
1551     if (kernel_version > KVERSION(2,1,0)) {
1552         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1553         SIN_ADDR(rt.rt_genmask) = 0L;
1554     }
1555
1556     SIN_ADDR(rt.rt_gateway) = gateway;
1557
1558     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1559     if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1560         if (still_ppp()) {
1561             if ( ! ok_error ( errno ))
1562                 error("default route ioctl(SIOCDELRT): %m");
1563             return 0;
1564         }
1565     }
1566
1567     return 1;
1568 }
1569
1570 /********************************************************************
1571  *
1572  * sifproxyarp - Make a proxy ARP entry for the peer.
1573  */
1574
1575 int sifproxyarp (int unit, u_int32_t his_adr)
1576 {
1577     struct arpreq arpreq;
1578     char *forw_path;
1579
1580     if (has_proxy_arp == 0) {
1581         memset (&arpreq, '\0', sizeof(arpreq));
1582
1583         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1584         SIN_ADDR(arpreq.arp_pa) = his_adr;
1585         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1586 /*
1587  * Get the hardware address of an interface on the same subnet
1588  * as our local address.
1589  */
1590         if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1591                             sizeof(proxy_arp_dev))) {
1592             error("Cannot determine ethernet address for proxy ARP");
1593             return 0;
1594         }
1595         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1596
1597         if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1598             if ( ! ok_error ( errno ))
1599                 error("ioctl(SIOCSARP): %m");
1600             return 0;
1601         }
1602         proxy_arp_addr = his_adr;
1603         has_proxy_arp = 1;
1604
1605         if (tune_kernel) {
1606             forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1607             if (forw_path != 0) {
1608                 int fd = open(forw_path, O_WRONLY);
1609                 if (fd >= 0) {
1610                     if (write(fd, "1", 1) != 1)
1611                         error("Couldn't enable IP forwarding: %m");
1612                     close(fd);
1613                 }
1614             }
1615         }
1616     }
1617
1618     return 1;
1619 }
1620
1621 /********************************************************************
1622  *
1623  * cifproxyarp - Delete the proxy ARP entry for the peer.
1624  */
1625
1626 int cifproxyarp (int unit, u_int32_t his_adr)
1627 {
1628     struct arpreq arpreq;
1629
1630     if (has_proxy_arp) {
1631         has_proxy_arp = 0;
1632         memset (&arpreq, '\0', sizeof(arpreq));
1633         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1634         SIN_ADDR(arpreq.arp_pa) = his_adr;
1635         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1636         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1637
1638         if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1639             if ( ! ok_error ( errno ))
1640                 warn("ioctl(SIOCDARP): %m");
1641             return 0;
1642         }
1643     }
1644     return 1;
1645 }
1646
1647 /********************************************************************
1648  *
1649  * get_ether_addr - get the hardware address of an interface on the
1650  * the same subnet as ipaddr.
1651  */
1652
1653 static int get_ether_addr (u_int32_t ipaddr,
1654                            struct sockaddr *hwaddr,
1655                            char *name, int namelen)
1656 {
1657     struct ifreq *ifr, *ifend;
1658     u_int32_t ina, mask;
1659     char *aliasp;
1660     struct ifreq ifreq, bestifreq;
1661     struct ifconf ifc;
1662     struct ifreq ifs[MAX_IFS];
1663
1664     u_int32_t bestmask=0;
1665     int found_interface = 0;
1666
1667     ifc.ifc_len = sizeof(ifs);
1668     ifc.ifc_req = ifs;
1669     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1670         if ( ! ok_error ( errno ))
1671             error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1672         return 0;
1673     }
1674
1675     SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1676                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1677 /*
1678  * Scan through looking for an interface with an Internet
1679  * address on the same subnet as `ipaddr'.
1680  */
1681     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1682     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1683         if (ifr->ifr_addr.sa_family == AF_INET) {
1684             ina = SIN_ADDR(ifr->ifr_addr);
1685             strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1686             SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1687                         ifreq.ifr_name));
1688 /*
1689  * Check that the interface is up, and not point-to-point
1690  * nor loopback.
1691  */
1692             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1693                 continue;
1694
1695             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1696                 continue;
1697 /*
1698  * Get its netmask and check that it's on the right subnet.
1699  */
1700             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1701                 continue;
1702
1703             mask = SIN_ADDR(ifreq.ifr_addr);
1704             SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1705                        ip_ntoa(ina), ntohl(mask)));
1706
1707             if (((ipaddr ^ ina) & mask) != 0)
1708                 continue; /* no match */
1709             /* matched */
1710             if (mask >= bestmask) {
1711                 /* Compare using >= instead of > -- it is possible for
1712                    an interface to have a netmask of 0.0.0.0 */
1713                 found_interface = 1;
1714                 bestifreq = ifreq;
1715                 bestmask = mask;
1716             }
1717         }
1718     }
1719
1720     if (!found_interface) return 0;
1721
1722     strlcpy(name, bestifreq.ifr_name, namelen);
1723
1724     /* trim off the :1 in eth0:1 */
1725     aliasp = strchr(name, ':');
1726     if (aliasp != 0)
1727         *aliasp = 0;
1728
1729     info("found interface %s for proxy arp", name);
1730 /*
1731  * Now get the hardware address.
1732  */
1733     memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1734     if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1735         error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1736         return 0;
1737     }
1738
1739     memcpy (hwaddr,
1740             &bestifreq.ifr_hwaddr,
1741             sizeof (struct sockaddr));
1742
1743     SYSDEBUG ((LOG_DEBUG,
1744            "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1745                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1746                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1747                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1748                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1749                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1750                 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1751                 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1752                 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1753     return 1;
1754 }
1755
1756 /*
1757  * get_if_hwaddr - get the hardware address for the specified
1758  * network interface device.
1759  */
1760 int
1761 get_if_hwaddr(u_char *addr, char *name)
1762 {
1763         struct ifreq ifreq;
1764         int ret, sock_fd;
1765
1766         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1767         if (sock_fd < 0)
1768                 return 0;
1769         memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1770         strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1771         ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1772         close(sock_fd);
1773         if (ret >= 0)
1774                 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1775         return ret;
1776 }
1777
1778 /*
1779  * get_first_ethernet - return the name of the first ethernet-style
1780  * interface on this system.
1781  */
1782 char *
1783 get_first_ethernet()
1784 {
1785         return "eth0";
1786 }
1787
1788 /********************************************************************
1789  *
1790  * Return user specified netmask, modified by any mask we might determine
1791  * for address `addr' (in network byte order).
1792  * Here we scan through the system's list of interfaces, looking for
1793  * any non-point-to-point interfaces which might appear to be on the same
1794  * network as `addr'.  If we find any, we OR in their netmask to the
1795  * user-specified netmask.
1796  */
1797
1798 u_int32_t GetMask (u_int32_t addr)
1799 {
1800     u_int32_t mask, nmask, ina;
1801     struct ifreq *ifr, *ifend, ifreq;
1802     struct ifconf ifc;
1803     struct ifreq ifs[MAX_IFS];
1804
1805     addr = ntohl(addr);
1806
1807     if (IN_CLASSA(addr))        /* determine network mask for address class */
1808         nmask = IN_CLASSA_NET;
1809     else if (IN_CLASSB(addr))
1810             nmask = IN_CLASSB_NET;
1811     else
1812             nmask = IN_CLASSC_NET;
1813
1814     /* class D nets are disallowed by bad_ip_adrs */
1815     mask = netmask | htonl(nmask);
1816 /*
1817  * Scan through the system's network interfaces.
1818  */
1819     ifc.ifc_len = sizeof(ifs);
1820     ifc.ifc_req = ifs;
1821     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1822         if ( ! ok_error ( errno ))
1823             warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1824         return mask;
1825     }
1826
1827     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1828     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1829 /*
1830  * Check the interface's internet address.
1831  */
1832         if (ifr->ifr_addr.sa_family != AF_INET)
1833             continue;
1834         ina = SIN_ADDR(ifr->ifr_addr);
1835         if (((ntohl(ina) ^ addr) & nmask) != 0)
1836             continue;
1837 /*
1838  * Check that the interface is up, and not point-to-point nor loopback.
1839  */
1840         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1841         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1842             continue;
1843
1844         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1845             continue;
1846 /*
1847  * Get its netmask and OR it into our mask.
1848  */
1849         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1850             continue;
1851         mask |= SIN_ADDR(ifreq.ifr_addr);
1852         break;
1853     }
1854     return mask;
1855 }
1856
1857 /********************************************************************
1858  *
1859  * Internal routine to decode the version.modification.patch level
1860  */
1861
1862 static void decode_version (char *buf, int *version,
1863                             int *modification, int *patch)
1864 {
1865     char *endp;
1866
1867     *version      = (int) strtoul (buf, &endp, 10);
1868     *modification = 0;
1869     *patch        = 0;
1870
1871     if (endp != buf && *endp == '.') {
1872         buf = endp + 1;
1873         *modification = (int) strtoul (buf, &endp, 10);
1874         if (endp != buf && *endp == '.') {
1875             buf = endp + 1;
1876             *patch = (int) strtoul (buf, &buf, 10);
1877         }
1878     }
1879 }
1880
1881 /********************************************************************
1882  *
1883  * Procedure to determine if the PPP line discipline is registered.
1884  */
1885
1886 static int
1887 ppp_registered(void)
1888 {
1889     int local_fd;
1890     int mfd = -1;
1891     int ret = 0;
1892     char slave[16];
1893
1894     /*
1895      * We used to open the serial device and set it to the ppp line
1896      * discipline here, in order to create a ppp unit.  But that is
1897      * not a good idea - the user might have specified a device that
1898      * they can't open (permission, or maybe it doesn't really exist).
1899      * So we grab a pty master/slave pair and use that.
1900      */
1901     if (!get_pty(&mfd, &local_fd, slave, 0)) {
1902         no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1903         return 0;
1904     }
1905
1906     /*
1907      * Try to put the device into the PPP discipline.
1908      */
1909     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1910         error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
1911     } else
1912         ret = 1;
1913
1914     close(local_fd);
1915     close(mfd);
1916     return ret;
1917 }
1918
1919 /********************************************************************
1920  *
1921  * ppp_available - check whether the system has any ppp interfaces
1922  * (in fact we check whether we can do an ioctl on ppp0).
1923  */
1924
1925 int ppp_available(void)
1926 {
1927     int s, ok, fd;
1928     struct ifreq ifr;
1929     int    size;
1930     int    my_version, my_modification, my_patch;
1931     int osmaj, osmin, ospatch;
1932
1933     no_ppp_msg =
1934         "This system lacks kernel support for PPP.  This could be because\n"
1935         "the PPP kernel module could not be loaded, or because PPP was not\n"
1936         "included in the kernel configuration.  If PPP was included as a\n"
1937         "module, try `/sbin/modprobe -v ppp'.  If that fails, check that\n"
1938         "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1939         "See README.linux file in the ppp distribution for more details.\n";
1940
1941     /* get the kernel version now, since we are called before sys_init */
1942     uname(&utsname);
1943     osmaj = osmin = ospatch = 0;
1944     sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1945     kernel_version = KVERSION(osmaj, osmin, ospatch);
1946
1947     fd = open("/dev/ppp", O_RDWR);
1948 #if 0
1949     if (fd < 0 && errno == ENOENT) {
1950         /* try making it and see if that helps. */
1951         if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1952                   makedev(108, 0)) >= 0) {
1953             fd = open("/dev/ppp", O_RDWR);
1954             if (fd >= 0)
1955                 info("Created /dev/ppp device node");
1956             else
1957                 unlink("/dev/ppp");     /* didn't work, undo the mknod */
1958         } else if (errno == EEXIST) {
1959             fd = open("/dev/ppp", O_RDWR);
1960         }
1961     }
1962 #endif /* 0 */
1963     if (fd >= 0) {
1964         new_style_driver = 1;
1965
1966         /* XXX should get from driver */
1967         driver_version = 2;
1968         driver_modification = 4;
1969         driver_patch = 0;
1970         close(fd);
1971         return 1;
1972     }
1973     if (kernel_version >= KVERSION(2,3,13)) {
1974         if (errno == ENOENT)
1975             no_ppp_msg =
1976                 "pppd is unable to open the /dev/ppp device.\n"
1977                 "You need to create the /dev/ppp device node by\n"
1978                 "executing the following command as root:\n"
1979                 "       mknod /dev/ppp c 108 0\n";
1980         return 0;
1981     }
1982
1983 /*
1984  * Open a socket for doing the ioctl operations.
1985  */
1986     s = socket(AF_INET, SOCK_DGRAM, 0);
1987     if (s < 0)
1988         return 0;
1989
1990     strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1991     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1992 /*
1993  * If the device did not exist then attempt to create one by putting the
1994  * current tty into the PPP discipline. If this works then obtain the
1995  * flags for the device again.
1996  */
1997     if (!ok) {
1998         if (ppp_registered()) {
1999             strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
2000             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2001         }
2002     }
2003 /*
2004  * Ensure that the hardware address is for PPP and not something else
2005  */
2006     if (ok)
2007         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2008
2009     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2010         ok = 0;
2011
2012 /*
2013  *  This is the PPP device. Validate the version of the driver at this
2014  *  point to ensure that this program will work with the driver.
2015  */
2016     if (ok) {
2017         char   abBuffer [1024];
2018
2019         ifr.ifr_data = abBuffer;
2020         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2021         if (size < 0) {
2022             error("Couldn't read driver version: %m");
2023             ok = 0;
2024             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2025
2026         } else {
2027             decode_version(abBuffer,
2028                            &driver_version,
2029                            &driver_modification,
2030                            &driver_patch);
2031 /*
2032  * Validate the version of the driver against the version that we used.
2033  */
2034             decode_version(VERSION,
2035                            &my_version,
2036                            &my_modification,
2037                            &my_patch);
2038
2039             /* The version numbers must match */
2040             if (driver_version != my_version)
2041                 ok = 0;
2042
2043             /* The modification levels must be legal */
2044             if (driver_modification < 3) {
2045                 if (driver_modification >= 2) {
2046                     /* we can cope with 2.2.0 and above */
2047                     driver_is_old = 1;
2048                 } else {
2049                     ok = 0;
2050                 }
2051             }
2052
2053             close (s);
2054             if (!ok) {
2055                 slprintf(route_buffer, sizeof(route_buffer),
2056                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
2057                          driver_version, driver_modification, driver_patch);
2058
2059                 no_ppp_msg = route_buffer;
2060             }
2061         }
2062     }
2063     return ok;
2064 }
2065
2066 /********************************************************************
2067  *
2068  * Update the wtmp file with the appropriate user name and tty device.
2069  */
2070
2071 void logwtmp (const char *line, const char *name, const char *host)
2072 {
2073     struct utmp ut, *utp;
2074     pid_t  mypid = getpid();
2075 #if __GLIBC__ < 2
2076     int    wtmp;
2077 #endif
2078
2079 /*
2080  * Update the signon database for users.
2081  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2082  */
2083     utmpname(_PATH_UTMP);
2084     setutent();
2085     while ((utp = getutent()) && (utp->ut_pid != mypid))
2086         /* nothing */;
2087
2088     if (utp)
2089         memcpy(&ut, utp, sizeof(ut));
2090     else
2091         /* some gettys/telnetds don't initialize utmp... */
2092         memset(&ut, 0, sizeof(ut));
2093
2094     if (ut.ut_id[0] == 0)
2095         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2096
2097     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2098     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2099
2100     time(&ut.ut_time);
2101
2102     ut.ut_type = USER_PROCESS;
2103     ut.ut_pid  = mypid;
2104
2105     /* Insert the host name if one is supplied */
2106     if (*host)
2107         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2108
2109     /* Insert the IP address of the remote system if IP is enabled */
2110     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2111         memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2112                  sizeof(ut.ut_addr));
2113
2114     /* CL: Makes sure that the logout works */
2115     if (*host == 0 && *name==0)
2116         ut.ut_host[0]=0;
2117
2118     pututline(&ut);
2119     endutent();
2120 /*
2121  * Update the wtmp file.
2122  */
2123 #if __GLIBC__ >= 2
2124     updwtmp(_PATH_WTMP, &ut);
2125 #else
2126     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2127     if (wtmp >= 0) {
2128         flock(wtmp, LOCK_EX);
2129
2130         if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2131             warn("error writing %s: %m", _PATH_WTMP);
2132
2133         flock(wtmp, LOCK_UN);
2134
2135         close (wtmp);
2136     }
2137 #endif
2138 }
2139
2140
2141 /********************************************************************
2142  *
2143  * sifvjcomp - config tcp header compression
2144  */
2145
2146 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2147 {
2148     u_int x = get_flags(ppp_dev_fd);
2149
2150     if (vjcomp) {
2151         if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2152             if (! ok_error (errno))
2153                 error("ioctl(PPPIOCSMAXCID): %m (line %d)", __LINE__);
2154             vjcomp = 0;
2155         }
2156     }
2157
2158     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
2159     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2160     set_flags (ppp_dev_fd, x);
2161
2162     return 1;
2163 }
2164
2165 /********************************************************************
2166  *
2167  * sifup - Config the interface up and enable IP packets to pass.
2168  */
2169
2170 int sifup(int u)
2171 {
2172     struct ifreq ifr;
2173
2174     memset (&ifr, '\0', sizeof (ifr));
2175     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2176     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2177         if (! ok_error (errno))
2178             error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2179         return 0;
2180     }
2181
2182     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2183     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2184         if (! ok_error (errno))
2185             error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2186         return 0;
2187     }
2188     if_is_up++;
2189
2190     return 1;
2191 }
2192
2193 /********************************************************************
2194  *
2195  * sifdown - Disable the indicated protocol and config the interface
2196  *           down if there are no remaining protocols.
2197  */
2198
2199 int sifdown (int u)
2200 {
2201     struct ifreq ifr;
2202
2203     if (if_is_up && --if_is_up > 0)
2204         return 1;
2205
2206     memset (&ifr, '\0', sizeof (ifr));
2207     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2208     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2209         if (! ok_error (errno))
2210             error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2211         return 0;
2212     }
2213
2214     ifr.ifr_flags &= ~IFF_UP;
2215     ifr.ifr_flags |= IFF_POINTOPOINT;
2216     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2217         if (! ok_error (errno))
2218             error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2219         return 0;
2220     }
2221     return 1;
2222 }
2223
2224 /********************************************************************
2225  *
2226  * sifaddr - Config the interface IP addresses and netmask.
2227  */
2228
2229 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2230              u_int32_t net_mask)
2231 {
2232     struct ifreq   ifr;
2233     struct rtentry rt;
2234
2235     memset (&ifr, '\0', sizeof (ifr));
2236     memset (&rt,  '\0', sizeof (rt));
2237
2238     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET);
2239     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2240     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2241
2242     strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2243 /*
2244  *  Set our IP address
2245  */
2246     SIN_ADDR(ifr.ifr_addr) = our_adr;
2247     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2248         if (errno != EEXIST) {
2249             if (! ok_error (errno))
2250                 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2251         }
2252         else {
2253             warn("ioctl(SIOCSIFADDR): Address already exists");
2254         }
2255         return (0);
2256     }
2257 /*
2258  *  Set the gateway address
2259  */
2260     SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2261     if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2262         if (! ok_error (errno))
2263             error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2264         return (0);
2265     }
2266 /*
2267  *  Set the netmask.
2268  *  For recent kernels, force the netmask to 255.255.255.255.
2269  */
2270     if (kernel_version >= KVERSION(2,1,16))
2271         net_mask = ~0L;
2272     if (net_mask != 0) {
2273         SIN_ADDR(ifr.ifr_netmask) = net_mask;
2274         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2275             if (! ok_error (errno))
2276                 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2277             return (0);
2278         }
2279     }
2280 /*
2281  *  Add the device route
2282  */
2283     if (kernel_version < KVERSION(2,1,16)) {
2284         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2285         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2286         rt.rt_dev = ifname;
2287
2288         SIN_ADDR(rt.rt_gateway) = 0L;
2289         SIN_ADDR(rt.rt_dst)     = his_adr;
2290         rt.rt_flags = RTF_UP | RTF_HOST;
2291
2292         if (kernel_version > KVERSION(2,1,0)) {
2293             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2294             SIN_ADDR(rt.rt_genmask) = -1L;
2295         }
2296
2297         if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2298             if (! ok_error (errno))
2299                 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2300             return (0);
2301         }
2302     }
2303
2304     /* set ip_dynaddr in demand mode if address changes */
2305     if (demand && tune_kernel && !dynaddr_set
2306         && our_old_addr && our_old_addr != our_adr) {
2307         /* set ip_dynaddr if possible */
2308         char *path;
2309         int fd;
2310
2311         path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2312         if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2313             if (write(fd, "1", 1) != 1)
2314                 error("Couldn't enable dynamic IP addressing: %m");
2315             close(fd);
2316         }
2317         dynaddr_set = 1;        /* only 1 attempt */
2318     }
2319     our_old_addr = 0;
2320
2321     return 1;
2322 }
2323
2324 /********************************************************************
2325  *
2326  * cifaddr - Clear the interface IP addresses, and delete routes
2327  * through the interface if possible.
2328  */
2329
2330 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2331 {
2332     struct ifreq ifr;
2333
2334     if (kernel_version < KVERSION(2,1,16)) {
2335 /*
2336  *  Delete the route through the device
2337  */
2338         struct rtentry rt;
2339         memset (&rt, '\0', sizeof (rt));
2340
2341         SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2342         SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2343         rt.rt_dev = ifname;
2344
2345         SIN_ADDR(rt.rt_gateway) = 0;
2346         SIN_ADDR(rt.rt_dst)     = his_adr;
2347         rt.rt_flags = RTF_UP | RTF_HOST;
2348
2349         if (kernel_version > KVERSION(2,1,0)) {
2350             SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2351             SIN_ADDR(rt.rt_genmask) = -1L;
2352         }
2353
2354         if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2355             if (still_ppp() && ! ok_error (errno))
2356                 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2357             return (0);
2358         }
2359     }
2360
2361     /* This way it is possible to have an IPX-only or IPv6-only interface */
2362     memset(&ifr, 0, sizeof(ifr));
2363     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2364     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2365
2366     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2367         if (! ok_error (errno)) {
2368             error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2369             return 0;
2370         }
2371     }
2372
2373     our_old_addr = our_adr;
2374
2375     return 1;
2376 }
2377
2378 #ifdef INET6
2379 /********************************************************************
2380  *
2381  * sif6addr - Config the interface with an IPv6 link-local address
2382  */
2383 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2384 {
2385     struct in6_ifreq ifr6;
2386     struct ifreq ifr;
2387     struct in6_rtmsg rt6;
2388
2389     if (sock6_fd < 0) {
2390         errno = -sock6_fd;
2391         error("IPv6 socket creation failed: %m");
2392         return 0;
2393     }
2394     memset(&ifr, 0, sizeof (ifr));
2395     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2396     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2397         error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2398         return 0;
2399     }
2400
2401     /* Local interface */
2402     memset(&ifr6, 0, sizeof(ifr6));
2403     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2404     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2405     ifr6.ifr6_prefixlen = 10;
2406
2407     if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2408         error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2409         return 0;
2410     }
2411
2412     /* Route to remote host */
2413     memset(&rt6, 0, sizeof(rt6));
2414     IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2415     rt6.rtmsg_flags = RTF_UP;
2416     rt6.rtmsg_dst_len = 10;
2417     rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2418     rt6.rtmsg_metric = 1;
2419
2420     if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2421         error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2422         return 0;
2423     }
2424
2425     return 1;
2426 }
2427
2428
2429 /********************************************************************
2430  *
2431  * cif6addr - Remove IPv6 address from interface
2432  */
2433 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2434 {
2435     struct ifreq ifr;
2436     struct in6_ifreq ifr6;
2437
2438     if (sock6_fd < 0) {
2439         errno = -sock6_fd;
2440         error("IPv6 socket creation failed: %m");
2441         return 0;
2442     }
2443     memset(&ifr, 0, sizeof(ifr));
2444     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2445     if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2446         error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2447         return 0;
2448     }
2449
2450     memset(&ifr6, 0, sizeof(ifr6));
2451     IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2452     ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2453     ifr6.ifr6_prefixlen = 10;
2454
2455     if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2456         if (errno != EADDRNOTAVAIL) {
2457             if (! ok_error (errno))
2458                 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2459         }
2460         else {
2461             warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2462         }
2463         return (0);
2464     }
2465     return 1;
2466 }
2467 #endif /* INET6 */
2468
2469 /*
2470  * get_pty - get a pty master/slave pair and chown the slave side
2471  * to the uid given.  Assumes slave_name points to >= 16 bytes of space.
2472  */
2473 int
2474 get_pty(master_fdp, slave_fdp, slave_name, uid)
2475     int *master_fdp;
2476     int *slave_fdp;
2477     char *slave_name;
2478     int uid;
2479 {
2480     int i, mfd, sfd = -1;
2481     char pty_name[16];
2482     struct termios tios;
2483
2484 #ifdef TIOCGPTN
2485     /*
2486      * Try the unix98 way first.
2487      */
2488     mfd = open("/dev/ptmx", O_RDWR);
2489     if (mfd >= 0) {
2490         int ptn;
2491         if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2492             slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2493             chmod(pty_name, S_IRUSR | S_IWUSR);
2494 #ifdef TIOCSPTLCK
2495             ptn = 0;
2496             if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2497                 warn("Couldn't unlock pty slave %s: %m", pty_name);
2498 #endif
2499             if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2500                 warn("Couldn't open pty slave %s: %m", pty_name);
2501         }
2502     }
2503 #endif /* TIOCGPTN */
2504
2505     if (sfd < 0) {
2506         /* the old way - scan through the pty name space */
2507         for (i = 0; i < 64; ++i) {
2508             slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2509                      'p' + i / 16, i % 16);
2510             mfd = open(pty_name, O_RDWR, 0);
2511             if (mfd >= 0) {
2512                 pty_name[5] = 't';
2513                 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2514                 if (sfd >= 0) {
2515                     fchown(sfd, uid, -1);
2516                     fchmod(sfd, S_IRUSR | S_IWUSR);
2517                     break;
2518                 }
2519                 close(mfd);
2520             }
2521         }
2522     }
2523
2524     if (sfd < 0)
2525         return 0;
2526
2527     strlcpy(slave_name, pty_name, 16);
2528     *master_fdp = mfd;
2529     *slave_fdp = sfd;
2530     if (tcgetattr(sfd, &tios) == 0) {
2531         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2532         tios.c_cflag |= CS8 | CREAD | CLOCAL;
2533         tios.c_iflag  = IGNPAR;
2534         tios.c_oflag  = 0;
2535         tios.c_lflag  = 0;
2536         if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2537             warn("couldn't set attributes on pty: %m");
2538     } else
2539         warn("couldn't get attributes on pty: %m");
2540
2541     return 1;
2542 }
2543
2544 /********************************************************************
2545  *
2546  * open_loopback - open the device we use for getting packets
2547  * in demand mode.  Under Linux, we use a pty master/slave pair.
2548  */
2549 int
2550 open_ppp_loopback(void)
2551 {
2552     int flags;
2553
2554     looped = 1;
2555     if (new_style_driver) {
2556         /* allocate ourselves a ppp unit */
2557         if (make_ppp_unit() < 0)
2558             die(1);
2559         set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2560         set_kdebugflag(kdebugflag);
2561         ppp_fd = -1;
2562         return ppp_dev_fd;
2563     }
2564
2565     if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2566         fatal("No free pty for loopback");
2567     SYSDEBUG(("using %s for loopback", loop_name));
2568
2569     set_ppp_fd(slave_fd);
2570
2571     flags = fcntl(master_fd, F_GETFL);
2572     if (flags == -1 ||
2573         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2574         warn("couldn't set master loopback to nonblock: %m");
2575
2576     flags = fcntl(ppp_fd, F_GETFL);
2577     if (flags == -1 ||
2578         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2579         warn("couldn't set slave loopback to nonblock: %m");
2580
2581     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2582         fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2583 /*
2584  * Find out which interface we were given.
2585  */
2586     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2587         fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2588 /*
2589  * Enable debug in the driver if requested.
2590  */
2591     set_kdebugflag (kdebugflag);
2592
2593     return master_fd;
2594 }
2595
2596 /********************************************************************
2597  *
2598  * sifnpmode - Set the mode for handling packets for a given NP.
2599  */
2600
2601 int
2602 sifnpmode(u, proto, mode)
2603     int u;
2604     int proto;
2605     enum NPmode mode;
2606 {
2607     struct npioctl npi;
2608
2609     npi.protocol = proto;
2610     npi.mode     = mode;
2611     if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2612         if (! ok_error (errno))
2613             error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2614         return 0;
2615     }
2616     return 1;
2617 }
2618
2619 \f
2620 /********************************************************************
2621  *
2622  * sipxfaddr - Config the interface IPX networknumber
2623  */
2624
2625 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2626 {
2627     int    result = 1;
2628
2629 #ifdef IPX_CHANGE
2630     int    skfd;
2631     struct ifreq         ifr;
2632     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2633
2634     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2635     if (skfd < 0) {
2636         if (! ok_error (errno))
2637             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2638         result = 0;
2639     }
2640     else {
2641         memset (&ifr, '\0', sizeof (ifr));
2642         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2643
2644         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2645         sipx->sipx_family  = AF_IPX;
2646         sipx->sipx_port    = 0;
2647         sipx->sipx_network = htonl (network);
2648         sipx->sipx_type    = IPX_FRAME_ETHERII;
2649         sipx->sipx_action  = IPX_CRTITF;
2650 /*
2651  *  Set the IPX device
2652  */
2653         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2654             result = 0;
2655             if (errno != EEXIST) {
2656                 if (! ok_error (errno))
2657                     dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2658             }
2659             else {
2660                 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2661             }
2662         }
2663         close (skfd);
2664     }
2665 #endif
2666     return result;
2667 }
2668
2669 /********************************************************************
2670  *
2671  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2672  *             are removed and the device is no longer able to pass IPX
2673  *             frames.
2674  */
2675
2676 int cipxfaddr (int unit)
2677 {
2678     int    result = 1;
2679
2680 #ifdef IPX_CHANGE
2681     int    skfd;
2682     struct ifreq         ifr;
2683     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2684
2685     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2686     if (skfd < 0) {
2687         if (! ok_error (errno))
2688             dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2689         result = 0;
2690     }
2691     else {
2692         memset (&ifr, '\0', sizeof (ifr));
2693         strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2694
2695         sipx->sipx_type    = IPX_FRAME_ETHERII;
2696         sipx->sipx_action  = IPX_DLTITF;
2697         sipx->sipx_family  = AF_IPX;
2698 /*
2699  *  Set the IPX device
2700  */
2701         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2702             if (! ok_error (errno))
2703                 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2704             result = 0;
2705         }
2706         close (skfd);
2707     }
2708 #endif
2709     return result;
2710 }
2711
2712 /*
2713  * Use the hostname as part of the random number seed.
2714  */
2715 int
2716 get_host_seed()
2717 {
2718     int h;
2719     char *p = hostname;
2720
2721     h = 407;
2722     for (p = hostname; *p != 0; ++p)
2723         h = h * 37 + *p;
2724     return h;
2725 }
2726
2727 /********************************************************************
2728  *
2729  * sys_check_options - check the options that the user specified
2730  */
2731
2732 int
2733 sys_check_options(void)
2734 {
2735 #ifdef IPX_CHANGE
2736 /*
2737  * Disable the IPX protocol if the support is not present in the kernel.
2738  */
2739     char *path;
2740
2741     if (ipxcp_protent.enabled_flag) {
2742         struct stat stat_buf;
2743         if ((path = path_to_procfs("/net/ipx_interface")) == 0
2744             || lstat(path, &stat_buf) < 0) {
2745             error("IPX support is not present in the kernel\n");
2746             ipxcp_protent.enabled_flag = 0;
2747         }
2748     }
2749 #endif
2750     if (demand && driver_is_old) {
2751         option_error("demand dialling is not supported by kernel driver "
2752                      "version %d.%d.%d", driver_version, driver_modification,
2753                      driver_patch);
2754         return 0;
2755     }
2756     if (multilink && !new_style_driver) {
2757         warn("Warning: multilink is not supported by the kernel driver");
2758         multilink = 0;
2759     }
2760     return 1;
2761 }