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