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