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