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", ppp_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     if (tcgetattr(tty_fd, &tios) < 0)
 668       {
 669         syslog(LOG_ERR, "tcgetattr: %m(%d)", errno);
 670         die(1);
 671       }
 672
 673     if (!restore_term)
 674       {
 675         inittermios = tios;
 676       }
 677
 678     tios.c_cflag     &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
 679     tios.c_cflag     |= CS8 | CREAD | HUPCL;
 680
 681     tios.c_iflag      = IGNBRK | IGNPAR;
 682     tios.c_oflag      = 0;
 683     tios.c_lflag      = 0;
 684     tios.c_cc[VMIN]   = 1;
 685     tios.c_cc[VTIME]  = 0;
 686
 687     if (local || !modem)
 688       {
 689         tios.c_cflag ^= (CLOCAL | HUPCL);
 690       }
 691
 692     switch (crtscts)
 693       {
 694     case 1:
 695         tios.c_cflag |= CRTSCTS;
 696         break;
 697
 698     case -2:
 699         tios.c_iflag     |= IXON | IXOFF;
 700         tios.c_cc[VSTOP]  = 0x13;       /* DC3 = XOFF = ^S */
 701         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
 702         break;
 703
 704     case -1:
 705         tios.c_cflag &= ~CRTSCTS;
 706         break;
 707
 708     default:
 709         break;
 710       }
 711
 712     speed = translate_speed(inspeed);
 713     if (speed)
 714       {
 715         cfsetospeed (&tios, speed);
 716         cfsetispeed (&tios, speed);
 717       }
 718 /*
 719  * We can't proceed if the serial port speed is B0,
 720  * since that implies that the serial port is disabled.
 721  */
 722     else
 723       {
 724         speed = cfgetospeed(&tios);
 725         if (speed == B0)
 726           {
 727             syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
 728                    devnam);
 729             die (1);
 730           }
 731       }
 732
 733     if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
 734       {
 735         syslog(LOG_ERR, "tcsetattr: %m");
 736         die(1);
 737       }
 738
 739     baud_rate    = baud_rate_of(speed);
 740     restore_term = TRUE;
 741   }
 742
 743 /********************************************************************
 744  *
 745  * setdtr - control the DTR line on the serial port.
 746  * This is called from die(), so it shouldn't call die().
 747  */
 748
 749 void setdtr (int tty_fd, int on)
 750   {
 751     int modembits = TIOCM_DTR;
 752
 753     ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
 754   }
 755
 756 /********************************************************************
 757  *
 758  * restore_tty - restore the terminal to the saved settings.
 759  */
 760
 761 void restore_tty (int tty_fd)
 762   {
 763     if (restore_term)
 764       {
 765         restore_term = 0;
 766 /*
 767  * Turn off echoing, because otherwise we can get into
 768  * a loop with the tty and the modem echoing to each other.
 769  * We presume we are the sole user of this tty device, so
 770  * when we close it, it will revert to its defaults anyway.
 771  */
 772         if (!default_device)
 773           {
 774             inittermios.c_lflag &= ~(ECHO | ECHONL);
 775           }
 776
 777         if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0)
 778           {
 779             if (! ok_error (errno))
 780               {
 781                 syslog(LOG_WARNING, "tcsetattr: %m");
 782               }
 783           }
 784       }
 785   }
 786
 787 /********************************************************************
 788  *
 789  * output - Output PPP packet.
 790  */
 791
 792 void output (int unit, unsigned char *p, int len)
 793   {
 794     if (debug)
 795       {
 796         log_packet(p, len, "sent ", LOG_DEBUG);
 797       }
 798
 799     if (write(ppp_fd, p, len) < 0)
 800       {
 801         if (errno == EWOULDBLOCK || errno == ENOBUFS
 802             || errno == ENXIO || errno == EIO)
 803           {
 804             syslog(LOG_WARNING, "write: warning: %m(%d)", errno);
 805           }
 806         else
 807           {
 808             syslog(LOG_ERR, "write: %m(%d)", errno);
 809             die(1);
 810           }
 811       }
 812   }
 813
 814 /********************************************************************
 815  *
 816  * wait_input - wait until there is data available on ppp_fd,
 817  * for the length of time specified by *timo (indefinite
 818  * if timo is NULL).
 819  */
 820
 821 void wait_input (struct timeval *timo)
 822   {
 823     fd_set ready;
 824     int n;
 825
 826     FD_ZERO(&ready);
 827     FD_SET(ppp_fd, &ready);
 828
 829     n = select(ppp_fd + 1, &ready, NULL, &ready, timo);
 830     if (n < 0 && errno != EINTR)
 831       {
 832         syslog(LOG_ERR, "select: %m(%d)", errno);
 833         die(1);
 834       }
 835   }
 836
 837 /********************************************************************
 838  *
 839  * wait_loop_output - wait until there is data available on the
 840  * loopback, for the length of time specified by *timo (indefinite
 841  * if timo is NULL).
 842  */
 843 void wait_loop_output(timo)
 844     struct timeval *timo;
 845   {
 846     fd_set ready;
 847     int n;
 848
 849     FD_ZERO(&ready);
 850     FD_SET(master_fd, &ready);
 851     n = select(master_fd + 1, &ready, NULL, &ready, timo);
 852     if (n < 0 && errno != EINTR)
 853       {
 854         syslog(LOG_ERR, "select: %m(%d)", errno);
 855         die(1);
 856       }
 857   }
 858
 859 /********************************************************************
 860  *
 861  * wait_time - wait for a given length of time or until a
 862  * signal is received.
 863  */
 864
 865 void wait_time(timo)
 866     struct timeval *timo;
 867 {
 868     int n;
 869
 870     n = select(0, NULL, NULL, NULL, timo);
 871     if (n < 0 && errno != EINTR) {
 872         syslog(LOG_ERR, "select: %m(%d)", errno);
 873         die(1);
 874     }
 875 }
 876
 877 /********************************************************************
 878  *
 879  * read_packet - get a PPP packet from the serial device.
 880  */
 881
 882 int read_packet (unsigned char *buf)
 883   {
 884     int len;
 885
 886     len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
 887     if (len < 0)
 888       {
 889         if (errno == EWOULDBLOCK)
 890           {
 891             return -1;
 892           }
 893         syslog(LOG_ERR, "read: %m(%d)", errno);
 894         die(1);
 895       }
 896     return len;
 897   }
 898
 899 /********************************************************************
 900  *
 901  * get_loop_output - get outgoing packets from the ppp device,
 902  * and detect when we want to bring the real link up.
 903  * Return value is 1 if we need to bring up the link, 0 otherwise.
 904  */
 905 int
 906 get_loop_output(void)
 907   {
 908     int rv = 0;
 909     int n  = read(master_fd, inbuf, sizeof(inbuf));
 910
 911     while (n > 0)
 912       {
 913         if (loop_chars(inbuf, n))
 914           {
 915             rv = 1;
 916           }
 917         n = read(master_fd, inbuf, sizeof(inbuf));
 918       }
 919
 920     if (n == 0)
 921       {
 922         syslog(LOG_ERR, "eof on loopback");
 923         die(1);
 924       }
 925
 926     if (errno != EWOULDBLOCK)
 927       {
 928         syslog(LOG_ERR, "read from loopback: %m(%d)", errno);
 929         die(1);
 930       }
 931
 932     return rv;
 933   }
 934
 935 /********************************************************************
 936  *
 937  * ppp_send_config - configure the transmit characteristics of
 938  * the ppp interface.
 939  */
 940
 941 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
 942   {
 943     u_int x;
 944     struct ifreq ifr;
 945
 946     SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
 947 /*
 948  * Ensure that the link is still up.
 949  */
 950     if (still_ppp())
 951       {
 952 /*
 953  * Set the MTU and other parameters for the ppp device
 954  */
 955         memset (&ifr, '\0', sizeof (ifr));
 956         strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
 957         ifr.ifr_mtu = mtu;
 958
 959         if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
 960           {
 961             syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m(%d)", errno);
 962             quit();
 963           }
 964
 965         SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
 966         if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0)
 967           {
 968             syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
 969             quit();
 970           }
 971
 972         x = get_flags();
 973         x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
 974         x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
 975         set_flags(x);
 976       }
 977   }
 978
 979 /********************************************************************
 980  *
 981  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
 982  */
 983
 984 void ppp_set_xaccm (int unit, ext_accm accm)
 985   {
 986     SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
 987                 accm[0], accm[1], accm[2], accm[3]));
 988
 989     if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
 990       {
 991         if ( ! ok_error (errno))
 992           {
 993             syslog(LOG_WARNING, "ioctl(set extended ACCM): %m(%d)", errno);
 994           }
 995       }
 996   }
 997
 998 /********************************************************************
 999  *
1000  * ppp_recv_config - configure the receive-side characteristics of
1001  * the ppp interface.
1002  */
1003
1004 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1005   {
1006     u_int x;
1007
1008     SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1009 /*
1010  * If we were called because the link has gone down then there is nothing
1011  * which may be done. Just return without incident.
1012  */
1013     if (!still_ppp())
1014       {
1015         return;
1016       }
1017 /*
1018  * Set the receiver parameters
1019  */
1020     if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1021       {
1022         if ( ! ok_error (errno))
1023           {
1024             syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m(%d)", errno);
1025           }
1026       }
1027
1028     SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1029     if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0)
1030       {
1031         syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1032         quit();
1033       }
1034
1035     x = get_flags();
1036     x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
1037     set_flags (x);
1038   }
1039
1040 /********************************************************************
1041  *
1042  * ccp_test - ask kernel whether a given compression method
1043  * is acceptable for use.
1044  */
1045
1046 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1047   {
1048     struct ppp_option_data data;
1049
1050     memset (&data, '\0', sizeof (data));
1051     data.ptr      = opt_ptr;
1052     data.length   = opt_len;
1053     data.transmit = for_transmit;
1054
1055     if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1056       {
1057         return 1;
1058       }
1059
1060     return (errno == ENOBUFS)? 0: -1;
1061   }
1062
1063 /********************************************************************
1064  *
1065  * ccp_flags_set - inform kernel about the current state of CCP.
1066  */
1067
1068 void ccp_flags_set (int unit, int isopen, int isup)
1069   {
1070     if (still_ppp())
1071       {
1072         int x = get_flags();
1073         x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1074         x = isup?   x | SC_CCP_UP   : x &~ SC_CCP_UP;
1075         set_flags (x);
1076       }
1077   }
1078
1079 /********************************************************************
1080  *
1081  * get_idle_time - return how long the link has been idle.
1082  */
1083 int
1084 get_idle_time(u, ip)
1085     int u;
1086     struct ppp_idle *ip;
1087 {
1088     return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
1089 }
1090
1091 /********************************************************************
1092  *
1093  * ccp_fatal_error - returns 1 if decompression was disabled as a
1094  * result of an error detected after decompression of a packet,
1095  * 0 otherwise.  This is necessary because of patent nonsense.
1096  */
1097
1098 int ccp_fatal_error (int unit)
1099   {
1100     int x = get_flags();
1101
1102     return x & SC_DC_FERROR;
1103   }
1104
1105 /*
1106  * path_to_route - determine the path to the proc file system data
1107  */
1108
1109 FILE *route_fd = (FILE *) 0;
1110 static char route_buffer [512];
1111
1112 static char *path_to_route (void);
1113 static int open_route_table (void);
1114 static void close_route_table (void);
1115 static int read_route_table (struct rtentry *rt);
1116
1117 /********************************************************************
1118  *
1119  * path_to_procfs - find the path to the proc file system mount point
1120  */
1121
1122 static int path_to_procfs (void)
1123   {
1124     struct mntent *mntent;
1125     FILE *fp;
1126
1127     fp = fopen (MOUNTED, "r");
1128     if (fp != 0)
1129       {
1130         mntent = getmntent (fp);
1131         while (mntent != (struct mntent *) 0)
1132           {
1133             if (strcmp (mntent->mnt_type, MNTTYPE_IGNORE) != 0)
1134               {
1135                 if (strcmp (mntent->mnt_type, "proc") == 0)
1136                   {
1137                     strncpy (route_buffer, mntent->mnt_dir,
1138                              sizeof (route_buffer)-10);
1139                     route_buffer [sizeof (route_buffer)-10] = '\0';
1140                     fclose (fp);
1141                     return 1;
1142                   }
1143               }
1144             mntent = getmntent (fp);
1145           }
1146         fclose (fp);
1147       }
1148
1149     /* Default the mount location of /proc */
1150     strncpy (route_buffer, "/proc", sizeof (route_buffer)-10);
1151     return 1;
1152   }
1153
1154 /********************************************************************
1155  *
1156  * path_to_route - find the path to the route tables in the proc file system
1157  */
1158
1159 static char *path_to_route (void)
1160   {
1161     if (! path_to_procfs())
1162       {
1163         syslog (LOG_ERR, "proc file system not mounted");
1164         return 0;
1165       }
1166     strcat (route_buffer, "/net/route");
1167     return (route_buffer);
1168   }
1169
1170 /********************************************************************
1171  *
1172  * close_route_table - close the interface to the route table
1173  */
1174
1175 static void close_route_table (void)
1176   {
1177     if (route_fd != (FILE *) 0)
1178       {
1179         fclose (route_fd);
1180         route_fd = (FILE *) 0;
1181       }
1182   }
1183
1184 /********************************************************************
1185  *
1186  * open_route_table - open the interface to the route table
1187  */
1188
1189 static int open_route_table (void)
1190   {
1191     char *path;
1192
1193     close_route_table();
1194
1195     path = path_to_route();
1196     if (path == NULL)
1197       {
1198         return 0;
1199       }
1200
1201     route_fd = fopen (path, "r");
1202     if (route_fd == (FILE *) 0)
1203       {
1204         syslog (LOG_ERR, "can not open %s: %m(%d)", path, errno);
1205         return 0;
1206       }
1207     return 1;
1208   }
1209
1210 /********************************************************************
1211  *
1212  * read_route_table - read the next entry from the route table
1213  */
1214
1215 static int read_route_table (struct rtentry *rt)
1216   {
1217     static char delims[] = " \t\n";
1218     char *dev_ptr, *dst_ptr, *gw_ptr, *flag_ptr;
1219
1220     memset (rt, '\0', sizeof (struct rtentry));
1221
1222     for (;;)
1223       {
1224         if (fgets (route_buffer, sizeof (route_buffer), route_fd) ==
1225             (char *) 0)
1226           {
1227             return 0;
1228           }
1229
1230         dev_ptr  = strtok (route_buffer, delims); /* interface name */
1231         dst_ptr  = strtok (NULL,         delims); /* destination address */
1232         gw_ptr   = strtok (NULL,         delims); /* gateway */
1233         flag_ptr = strtok (NULL,         delims); /* flags */
1234
1235         if (flag_ptr == (char *) 0) /* assume that we failed, somewhere. */
1236           {
1237             return 0;
1238           }
1239
1240         /* Discard that stupid header line which should never
1241          * have been there in the first place !! */
1242         if (isxdigit (*dst_ptr) && isxdigit (*gw_ptr) && isxdigit (*flag_ptr))
1243           {
1244             break;
1245           }
1246       }
1247
1248     ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1249       strtoul (dst_ptr, NULL, 16);
1250
1251     ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1252       strtoul (gw_ptr, NULL, 16);
1253
1254     rt->rt_flags = (short) strtoul (flag_ptr, NULL, 16);
1255     rt->rt_dev   = dev_ptr;
1256
1257     return 1;
1258   }
1259
1260 /********************************************************************
1261  *
1262  * defaultroute_exists - determine if there is a default route
1263  */
1264
1265 static int defaultroute_exists (struct rtentry *rt)
1266   {
1267     int    result = 0;
1268
1269     if (!open_route_table())
1270       {
1271         return 0;
1272       }
1273
1274     while (read_route_table(rt) != 0)
1275       {
1276         if ((rt->rt_flags & RTF_UP) == 0)
1277           {
1278             continue;
1279           }
1280
1281         if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L)
1282           {
1283             result = 1;
1284             break;
1285           }
1286       }
1287
1288     close_route_table();
1289     return result;
1290   }
1291
1292 /********************************************************************
1293  *
1294  * sifdefaultroute - assign a default route through the address given.
1295  */
1296
1297 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1298   {
1299     struct rtentry rt;
1300
1301     if (defaultroute_exists(&rt))
1302       {
1303         struct in_addr old_gateway =
1304           ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1305
1306         if (old_gateway.s_addr != gateway)
1307           {
1308             syslog (LOG_ERR,
1309                     "not replacing existing default route to %s [%s]",
1310                     rt.rt_dev,
1311                     inet_ntoa (old_gateway));
1312           }
1313         return 0;
1314       }
1315
1316     memset (&rt, '\0', sizeof (rt));
1317     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1318     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1319
1320     if (kernel_version > KVERSION(2,1,0)) {
1321       SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1322       ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1323     }
1324
1325     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1326
1327     rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1328     if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
1329       {
1330         if ( ! ok_error ( errno ))
1331           {
1332             syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m(%d)", errno);
1333           }
1334         return 0;
1335       }
1336
1337     default_route_gateway = gateway;
1338     return 1;
1339   }
1340
1341 /********************************************************************
1342  *
1343  * cifdefaultroute - delete a default route through the address given.
1344  */
1345
1346 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1347   {
1348     struct rtentry rt;
1349
1350     default_route_gateway = 0;
1351
1352     memset (&rt, '\0', sizeof (rt));
1353     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1354     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1355
1356     if (kernel_version > KVERSION(2,1,0)) {
1357       SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1358       ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1359     }
1360
1361     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1362
1363     rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1364     if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1365       {
1366         if (still_ppp())
1367           {
1368             if ( ! ok_error ( errno ))
1369               {
1370                 syslog (LOG_ERR,
1371                         "default route ioctl(SIOCDELRT): %m(%d)", errno);
1372               }
1373             return 0;
1374           }
1375       }
1376
1377     return 1;
1378   }
1379
1380 /********************************************************************
1381  *
1382  * sifproxyarp - Make a proxy ARP entry for the peer.
1383  */
1384
1385 int sifproxyarp (int unit, u_int32_t his_adr)
1386   {
1387     struct arpreq arpreq;
1388
1389     if (has_proxy_arp == 0)
1390       {
1391         memset (&arpreq, '\0', sizeof(arpreq));
1392
1393         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1394         ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1395         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1396 /*
1397  * Get the hardware address of an interface on the same subnet
1398  * as our local address.
1399  */
1400         if (!get_ether_addr(his_adr, &arpreq.arp_ha, arpreq.arp_dev))
1401           {
1402             syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1403             return 0;
1404           }
1405
1406         if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0)
1407           {
1408             if ( ! ok_error ( errno ))
1409               {
1410                 syslog(LOG_ERR, "ioctl(SIOCSARP): %m(%d)", errno);
1411               }
1412             return 0;
1413           }
1414       }
1415
1416     proxy_arp_addr = his_adr;
1417     has_proxy_arp = 1;
1418     return 1;
1419   }
1420
1421 /********************************************************************
1422  *
1423  * cifproxyarp - Delete the proxy ARP entry for the peer.
1424  */
1425
1426 int cifproxyarp (int unit, u_int32_t his_adr)
1427   {
1428     struct arpreq arpreq;
1429
1430     if (has_proxy_arp == 1)
1431       {
1432         memset (&arpreq, '\0', sizeof(arpreq));
1433         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1434         ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1435         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1436
1437         if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0)
1438           {
1439             if ( ! ok_error ( errno ))
1440               {
1441                 syslog(LOG_WARNING, "ioctl(SIOCDARP): %m(%d)", errno);
1442               }
1443             return 0;
1444           }
1445       }
1446     has_proxy_arp = 0;
1447     return 1;
1448   }
1449
1450 /********************************************************************
1451  *
1452  * get_ether_addr - get the hardware address of an interface on the
1453  * the same subnet as ipaddr.
1454  */
1455
1456 static int get_ether_addr (u_int32_t ipaddr,
1457                            struct sockaddr *hwaddr,
1458                            char *name)
1459   {
1460     struct ifreq *ifr, *ifend;
1461     u_int32_t ina, mask;
1462     struct ifreq ifreq;
1463     struct ifconf ifc;
1464     struct ifreq ifs[MAX_IFS];
1465
1466     ifc.ifc_len = sizeof(ifs);
1467     ifc.ifc_req = ifs;
1468     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1469       {
1470         if ( ! ok_error ( errno ))
1471           {
1472             syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1473           }
1474         return 0;
1475       }
1476
1477     SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1478                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1479 /*
1480  * Scan through looking for an interface with an Internet
1481  * address on the same subnet as `ipaddr'.
1482  */
1483     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1484     for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1485       {
1486         if (ifr->ifr_addr.sa_family == AF_INET)
1487           {
1488             ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1489             strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1490             SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1491                         ifreq.ifr_name));
1492 /*
1493  * Check that the interface is up, and not point-to-point
1494  * nor loopback.
1495  */
1496             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1497               {
1498                 continue;
1499               }
1500
1501             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1502               {
1503                 continue;
1504               }
1505 /*
1506  * Get its netmask and check that it's on the right subnet.
1507  */
1508             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1509               {
1510                 continue;
1511               }
1512
1513             mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1514             SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1515                         ip_ntoa(ina), ntohl(mask)));
1516
1517             if (((ipaddr ^ ina) & mask) != 0)
1518               {
1519                 continue;
1520               }
1521             break;
1522           }
1523       }
1524
1525     if (ifr >= ifend)
1526       {
1527         return 0;
1528       }
1529
1530     memcpy (name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
1531     syslog(LOG_INFO, "found interface %s for proxy arp", name);
1532 /*
1533  * Now get the hardware address.
1534  */
1535     memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1536     if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0)
1537       {
1538         syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1539         return 0;
1540       }
1541
1542     memcpy (hwaddr,
1543             &ifreq.ifr_hwaddr,
1544             sizeof (struct sockaddr));
1545
1546     SYSDEBUG ((LOG_DEBUG,
1547            "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1548                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1549                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1550                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1551                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1552                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1553                 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1554                 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1555                 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1556     return 1;
1557   }
1558
1559 /********************************************************************
1560  *
1561  * Return user specified netmask, modified by any mask we might determine
1562  * for address `addr' (in network byte order).
1563  * Here we scan through the system's list of interfaces, looking for
1564  * any non-point-to-point interfaces which might appear to be on the same
1565  * network as `addr'.  If we find any, we OR in their netmask to the
1566  * user-specified netmask.
1567  */
1568
1569 u_int32_t GetMask (u_int32_t addr)
1570   {
1571     u_int32_t mask, nmask, ina;
1572     struct ifreq *ifr, *ifend, ifreq;
1573     struct ifconf ifc;
1574     struct ifreq ifs[MAX_IFS];
1575
1576     addr = ntohl(addr);
1577
1578     if (IN_CLASSA(addr))        /* determine network mask for address class */
1579       {
1580         nmask = IN_CLASSA_NET;
1581       }
1582     else
1583       {
1584         if (IN_CLASSB(addr))
1585           {
1586             nmask = IN_CLASSB_NET;
1587           }
1588         else
1589           {
1590             nmask = IN_CLASSC_NET;
1591           }
1592       }
1593
1594     /* class D nets are disallowed by bad_ip_adrs */
1595     mask = netmask | htonl(nmask);
1596 /*
1597  * Scan through the system's network interfaces.
1598  */
1599     ifc.ifc_len = sizeof(ifs);
1600     ifc.ifc_req = ifs;
1601     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1602       {
1603         if ( ! ok_error ( errno ))
1604           {
1605             syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1606           }
1607         return mask;
1608       }
1609
1610     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1611     for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1612       {
1613 /*
1614  * Check the interface's internet address.
1615  */
1616         if (ifr->ifr_addr.sa_family != AF_INET)
1617           {
1618             continue;
1619           }
1620         ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1621         if (((ntohl(ina) ^ addr) & nmask) != 0)
1622           {
1623             continue;
1624           }
1625 /*
1626  * Check that the interface is up, and not point-to-point nor loopback.
1627  */
1628         strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1629         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1630           {
1631             continue;
1632           }
1633
1634         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1635           {
1636             continue;
1637           }
1638 /*
1639  * Get its netmask and OR it into our mask.
1640  */
1641         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1642           {
1643             continue;
1644           }
1645         mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1646         break;
1647       }
1648     return mask;
1649   }
1650
1651 /********************************************************************
1652  *
1653  * Internal routine to decode the version.modification.patch level
1654  */
1655
1656 static void decode_version (char *buf, int *version,
1657                             int *modification, int *patch)
1658   {
1659     *version      = (int) strtoul (buf, &buf, 10);
1660     *modification = 0;
1661     *patch        = 0;
1662
1663     if (*buf == '.')
1664       {
1665         ++buf;
1666         *modification = (int) strtoul (buf, &buf, 10);
1667         if (*buf == '.')
1668           {
1669             ++buf;
1670             *patch = (int) strtoul (buf, &buf, 10);
1671           }
1672       }
1673
1674     if (*buf != '\0')
1675       {
1676         *version      =
1677         *modification =
1678         *patch        = 0;
1679       }
1680   }
1681
1682 /********************************************************************
1683  *
1684  * Procedure to determine if the PPP line discipline is registered.
1685  */
1686
1687 int
1688 ppp_registered(void)
1689   {
1690     int local_fd;
1691     int init_disc = -1;
1692     int initfdflags;
1693
1694     local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1695     if (local_fd < 0)
1696       {
1697         syslog(LOG_ERR, "Failed to open %s: %m(%d)", devnam, errno);
1698         return 0;
1699       }
1700
1701     initfdflags = fcntl(local_fd, F_GETFL);
1702     if (initfdflags == -1)
1703       {
1704         syslog(LOG_ERR, "Couldn't get device fd flags: %m(%d)", errno);
1705         close (local_fd);
1706         return 0;
1707       }
1708
1709     initfdflags &= ~O_NONBLOCK;
1710     fcntl(local_fd, F_SETFL, initfdflags);
1711 /*
1712  * Read the initial line dicipline and try to put the device into the
1713  * PPP dicipline.
1714  */
1715     if (ioctl(local_fd, TIOCGETD, &init_disc) < 0)
1716       {
1717         syslog(LOG_ERR, "ioctl(TIOCGETD): %m(%d)", errno);
1718         close (local_fd);
1719         return 0;
1720       }
1721
1722     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0)
1723       {
1724         syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1725         close (local_fd);
1726         return 0;
1727       }
1728
1729     if (ioctl(local_fd, TIOCSETD, &init_disc) < 0)
1730       {
1731         syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1732         close (local_fd);
1733         return 0;
1734       }
1735
1736     close (local_fd);
1737     return 1;
1738   }
1739
1740 /********************************************************************
1741  *
1742  * ppp_available - check whether the system has any ppp interfaces
1743  * (in fact we check whether we can do an ioctl on ppp0).
1744  */
1745
1746 int ppp_available(void)
1747 {
1748     int s, ok;
1749     struct ifreq ifr;
1750     int    size;
1751     int    my_version, my_modification, my_patch;
1752     extern char *no_ppp_msg;
1753 /*
1754  * Open a socket for doing the ioctl operations.
1755  */
1756     s = socket(AF_INET, SOCK_DGRAM, 0);
1757     if (s < 0)
1758     {
1759         return 0;
1760     }
1761
1762     strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1763     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1764 /*
1765  * If the device did not exist then attempt to create one by putting the
1766  * current tty into the PPP discipline. If this works then obtain the
1767  * flags for the device again.
1768  */
1769     if (!ok)
1770     {
1771         if (ppp_registered())
1772         {
1773             strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1774             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1775         }
1776     }
1777 /*
1778  * Ensure that the hardware address is for PPP and not something else
1779  */
1780     if (ok)
1781     {
1782         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1783     }
1784
1785     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1786     {
1787         ok = 0;
1788     }
1789
1790     if (!ok)
1791     {
1792         no_ppp_msg =
1793           "This system lacks kernel support for PPP.  This could be because\n"
1794           "the PPP kernel module is not loaded, or because the kernel is\n"
1795           "not configured for PPP.  See the README.linux file in the\n"
1796           "ppp-2.3.5 distribution.\n";
1797     }
1798 /*
1799  *  This is the PPP device. Validate the version of the driver at this
1800  *  point to ensure that this program will work with the driver.
1801  */
1802     else
1803     {
1804         char   abBuffer [1024];
1805
1806         ifr.ifr_data = abBuffer;
1807         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1808         if (size < 0) {
1809             syslog(LOG_ERR, "Couldn't read driver version: %m");
1810             ok = 0;
1811             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1812
1813         } else {
1814             decode_version(abBuffer,
1815                            &driver_version,
1816                            &driver_modification,
1817                            &driver_patch);
1818 /*
1819  * Validate the version of the driver against the version that we used.
1820  */
1821             decode_version(VERSION,
1822                            &my_version,
1823                            &my_modification,
1824                            &my_patch);
1825
1826             /* The version numbers must match */
1827             if (driver_version != my_version)
1828             {
1829                 ok = 0;
1830             }
1831
1832             /* The modification levels must be legal */
1833             if (driver_modification < my_modification)
1834             {
1835                 if (driver_modification >= 2) {
1836                     /* we can cope with 2.2.0 and above */
1837                     driver_is_old = 1;
1838                 } else {
1839                     ok = 0;
1840                 }
1841             }
1842
1843             close (s);
1844             if (!ok)
1845             {
1846                 sprintf (route_buffer,
1847                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
1848                          driver_version, driver_modification, driver_patch);
1849
1850                 no_ppp_msg = route_buffer;
1851             }
1852         }
1853     }
1854     return ok;
1855 }
1856
1857 /********************************************************************
1858  *
1859  * Update the wtmp file with the appropriate user name and tty device.
1860  */
1861
1862 void logwtmp (const char *line, const char *name, const char *host)
1863   {
1864     int    wtmp;
1865     struct utmp ut, *utp;
1866     pid_t  mypid = getpid();
1867 /*
1868  * Update the signon database for users.
1869  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1870  */
1871     utmpname(_PATH_UTMP);
1872     setutent();
1873     while ((utp = getutent()) && (utp->ut_pid != mypid))
1874         /* nothing */;
1875
1876     /* Is this call really necessary? There is another one after the 'put' */
1877     endutent();
1878
1879     if (utp)
1880       {
1881         memcpy(&ut, utp, sizeof(ut));
1882       }
1883     else
1884       {
1885         /* some gettys/telnetds don't initialize utmp... */
1886         memset(&ut, 0, sizeof(ut));
1887       }
1888
1889     if (ut.ut_id[0] == 0)
1890       {
1891         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1892       }
1893
1894     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1895     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1896
1897     time(&ut.ut_time);
1898
1899     ut.ut_type = USER_PROCESS;
1900     ut.ut_pid  = mypid;
1901
1902     /* Insert the host name if one is supplied */
1903     if (*host)
1904       {
1905         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1906       }
1907
1908     /* Insert the IP address of the remote system if IP is enabled */
1909     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1910       {
1911         memcpy  (&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1912                  sizeof(ut.ut_addr));
1913       }
1914
1915     /* CL: Makes sure that the logout works */
1916     if (*host == 0 && *name==0)
1917       {
1918         ut.ut_host[0]=0;
1919       }
1920
1921     pututline(&ut);
1922     endutent();
1923 /*
1924  * Update the wtmp file.
1925  */
1926     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1927     if (wtmp >= 0)
1928       {
1929         flock(wtmp, LOCK_EX);
1930
1931         /* we really should check for error on the write for a full disk! */
1932         write (wtmp, (char *)&ut, sizeof(ut));
1933         close (wtmp);
1934
1935         flock(wtmp, LOCK_UN);
1936       }
1937   }
1938
1939 /********************************************************************
1940  * Code for locking/unlocking the serial device.
1941  * This code is derived from chat.c.
1942  */
1943
1944 /*
1945  * lock - create a lock file for the named device
1946  */
1947
1948 int lock (char *dev)
1949   {
1950 #ifdef LOCKLIB
1951     int result;
1952     lock_file = malloc(strlen(dev) + 1);
1953     if (lock_file == NULL)
1954       {
1955         novm("lock file name");
1956       }
1957     strcpy (lock_file, dev);
1958     result = mklock (dev, (void *) 0);
1959
1960     if (result > 0)
1961       {
1962         syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, result);
1963         free (lock_file);
1964         lock_file = NULL;
1965         result = -1;
1966       }
1967     else
1968       {
1969         if (result < 0)
1970           {
1971             syslog (LOG_ERR, "Can't create lock file %s", lock_file);
1972             free (lock_file);
1973             lock_file = NULL;
1974             result = -1;
1975           }
1976       }
1977     return (result);
1978 #else
1979     char hdb_lock_buffer[12];
1980     int fd, n;
1981     int pid = getpid();
1982     char *p;
1983
1984     p = strrchr(dev, '/');
1985     if (p != NULL)
1986       {
1987         dev = ++p;
1988       }
1989
1990     lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
1991     if (lock_file == NULL)
1992       {
1993         novm("lock file name");
1994       }
1995
1996     strcpy (lock_file, LOCK_PREFIX);
1997     strcat (lock_file, dev);
1998 /*
1999  * Attempt to create the lock file at this point.
2000  */
2001     while (1)
2002       {
2003         fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
2004         if (fd >= 0)
2005           {
2006             pid = getpid();
2007 #ifndef PID_BINARY
2008             sprintf (hdb_lock_buffer, "%010d\n", pid);
2009             write (fd, hdb_lock_buffer, 11);
2010 #else
2011             write(fd, &pid, sizeof (pid));
2012 #endif
2013             close(fd);
2014             return 0;
2015           }
2016 /*
2017  * If the file exists then check to see if the pid is stale
2018  */
2019         if (errno == EEXIST)
2020           {
2021             fd = open(lock_file, O_RDONLY, 0);
2022             if (fd < 0)
2023               {
2024                 if (errno == ENOENT) /* This is just a timing problem. */
2025                   {
2026                     continue;
2027                   }
2028                 break;
2029               }
2030
2031             /* Read the lock file to find out who has the device locked */
2032             n = read (fd, hdb_lock_buffer, 11);
2033             close (fd);
2034             if (n < 0)
2035               {
2036                 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
2037                 break;
2038               }
2039
2040             /* See the process still exists. */
2041             if (n > 0)
2042               {
2043 #ifndef PID_BINARY
2044                 hdb_lock_buffer[n] = '\0';
2045                 sscanf (hdb_lock_buffer, " %d", &pid);
2046 #else
2047                 pid = ((int *) hdb_lock_buffer)[0];
2048 #endif
2049                 if (pid == 0 || pid == getpid()
2050                     || (kill(pid, 0) == -1 && errno == ESRCH))
2051                   {
2052                     n = 0;
2053                   }
2054               }
2055
2056             /* If the process does not exist then try to remove the lock */
2057             if (n == 0 && unlink (lock_file) == 0)
2058               {
2059                 syslog (LOG_NOTICE, "Removed stale lock on %s (pid %d)",
2060                         dev, pid);
2061                 continue;
2062               }
2063
2064             syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, pid);
2065             break;
2066           }
2067
2068         syslog(LOG_ERR, "Can't create lock file %s: %m(%d)", lock_file, errno);
2069         break;
2070       }
2071
2072     free(lock_file);
2073     lock_file = NULL;
2074     return -1;
2075 #endif
2076 }
2077
2078
2079 /********************************************************************
2080  *
2081  * unlock - remove our lockfile
2082  */
2083
2084 void unlock(void)
2085   {
2086     if (lock_file)
2087       {
2088 #ifdef LOCKLIB
2089         (void) rmlock (lock_file, (void *) 0);
2090 #else
2091         unlink(lock_file);
2092 #endif
2093         free(lock_file);
2094         lock_file = NULL;
2095       }
2096   }
2097
2098 /********************************************************************
2099  *
2100  * sifvjcomp - config tcp header compression
2101  */
2102
2103 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2104   {
2105     u_int x = get_flags();
2106
2107     if (vjcomp)
2108       {
2109         if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2110           {
2111             if (! ok_error (errno))
2112               {
2113                 syslog (LOG_ERR, "ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2114               }
2115             vjcomp = 0;
2116           }
2117       }
2118
2119     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
2120     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2121     set_flags (x);
2122
2123     return 1;
2124   }
2125
2126 /********************************************************************
2127  *
2128  * sifup - Config the interface up and enable IP packets to pass.
2129  */
2130
2131 int sifup (int u)
2132   {
2133     struct ifreq ifr;
2134
2135     memset (&ifr, '\0', sizeof (ifr));
2136     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2137     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2138       {
2139         if (! ok_error (errno))
2140           {
2141             syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2142           }
2143         return 0;
2144       }
2145
2146     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2147     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2148       {
2149         if (! ok_error (errno))
2150           {
2151             syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2152           }
2153         return 0;
2154       }
2155     if_is_up = 1;
2156     return 1;
2157   }
2158
2159 /********************************************************************
2160  *
2161  * sifdown - Config the interface down and disable IP.
2162  */
2163
2164 int sifdown (int u)
2165   {
2166     struct ifreq ifr;
2167
2168     if_is_up = 0;
2169
2170     memset (&ifr, '\0', sizeof (ifr));
2171     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2172     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2173       {
2174         if (! ok_error (errno))
2175           {
2176             syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2177           }
2178         return 0;
2179       }
2180
2181     ifr.ifr_flags &= ~IFF_UP;
2182     ifr.ifr_flags |= IFF_POINTOPOINT;
2183     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2184       {
2185         if (! ok_error (errno))
2186           {
2187             syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2188           }
2189         return 0;
2190       }
2191     return 1;
2192   }
2193
2194 /********************************************************************
2195  *
2196  * sifaddr - Config the interface IP addresses and netmask.
2197  */
2198
2199 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2200              u_int32_t net_mask)
2201   {
2202     struct ifreq   ifr;
2203     struct rtentry rt;
2204
2205     memset (&ifr, '\0', sizeof (ifr));
2206     memset (&rt,  '\0', sizeof (rt));
2207
2208     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET);
2209     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2210     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2211
2212     strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2213 /*
2214  *  Set our IP address
2215  */
2216     ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2217     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2218       {
2219         if (errno != EEXIST)
2220           {
2221             if (! ok_error (errno))
2222               {
2223                 syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m(%d)", errno);
2224               }
2225           }
2226         else
2227           {
2228             syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
2229           }
2230         return (0);
2231       }
2232 /*
2233  *  Set the gateway address
2234  */
2235     ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2236     if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0)
2237       {
2238         if (! ok_error (errno))
2239           {
2240             syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2241           }
2242         return (0);
2243       }
2244 /*
2245  *  Set the netmask.
2246  *  For recent kernels, force the netmask to 255.255.255.255.
2247  */
2248     if (kernel_version >= KVERSION(2,1,16))
2249       net_mask = ~0L;
2250     if (net_mask != 0)
2251       {
2252         ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2253         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0)
2254           {
2255             if (! ok_error (errno))
2256               {
2257                 syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2258               }
2259             return (0);
2260           }
2261       }
2262 /*
2263  *  Add the device route
2264  */
2265     if (kernel_version < KVERSION(2,1,16)) {
2266       SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2267       SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2268       rt.rt_dev = ifname;
2269
2270       ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2271       ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
2272       rt.rt_flags = RTF_UP | RTF_HOST;
2273
2274       if (kernel_version > KVERSION(2,1,0)) {
2275         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2276         ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2277       }
2278
2279       if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
2280         {
2281           if (! ok_error (errno))
2282             {
2283               syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m(%d)", errno);
2284             }
2285           return (0);
2286         }
2287     }
2288     return 1;
2289   }
2290
2291 /********************************************************************
2292  *
2293  * cifaddr - Clear the interface IP addresses, and delete routes
2294  * through the interface if possible.
2295  */
2296
2297 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2298   {
2299     struct rtentry rt;
2300
2301     if (kernel_version < KVERSION(2,1,16)) {
2302 /*
2303  *  Delete the route through the device
2304  */
2305       memset (&rt, '\0', sizeof (rt));
2306
2307       SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2308       SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2309       rt.rt_dev = ifname;
2310
2311       ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2312       ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
2313       rt.rt_flags = RTF_UP | RTF_HOST;
2314
2315       if (kernel_version > KVERSION(2,1,0)) {
2316         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2317         ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2318       }
2319
2320       if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
2321         {
2322           if (still_ppp() && ! ok_error (errno))
2323             {
2324               syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m(%d)", errno);
2325             }
2326           return (0);
2327         }
2328     }
2329     return 1;
2330   }
2331
2332 /********************************************************************
2333  *
2334  * open_loopback - open the device we use for getting packets
2335  * in demand mode.  Under Linux, we use our existing fd
2336  * to the ppp driver.
2337  */
2338 void
2339 open_ppp_loopback(void)
2340   {
2341     int flags, i;
2342     struct termios tios;
2343
2344     master_fd = -1;
2345     for (i = 0; i < 64; ++i) {
2346       sprintf(loop_name, "/dev/pty%c%x", 'p' + i / 16, i % 16);
2347       master_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2348       if (master_fd >= 0)
2349         break;
2350     }
2351     if (master_fd < 0) {
2352       syslog(LOG_ERR, "No free pty for loopback");
2353       die(1);
2354     }
2355     SYSDEBUG((LOG_DEBUG, "using %s for loopback", loop_name));
2356     loop_name[5] = 't';
2357     slave_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2358     if (slave_fd < 0) {
2359       syslog(LOG_ERR, "Couldn't open %s for loopback: %m", loop_name);
2360       die(1);
2361     }
2362
2363     set_ppp_fd(slave_fd);
2364
2365     if (tcgetattr(ppp_fd, &tios) == 0)
2366       {
2367         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2368         tios.c_cflag |= CS8 | CREAD;
2369         tios.c_iflag  = IGNPAR | CLOCAL;
2370         tios.c_oflag  = 0;
2371         tios.c_lflag  = 0;
2372         if (tcsetattr(ppp_fd, TCSAFLUSH, &tios) < 0)
2373           {
2374             syslog(LOG_WARNING, "couldn't set attributes on loopback: %m(%d)", errno);
2375           }
2376       }
2377
2378     flags = fcntl(master_fd, F_GETFL);
2379     if (flags == -1 ||
2380         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2381       {
2382         syslog(LOG_WARNING, "couldn't set master loopback to nonblock: %m(%d)", errno);
2383       }
2384
2385     flags = fcntl(ppp_fd, F_GETFL);
2386     if (flags == -1 ||
2387         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2388       {
2389         syslog(LOG_WARNING, "couldn't set slave loopback to nonblock: %m(%d)", errno);
2390       }
2391
2392     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2393       {
2394         syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
2395         die(1);
2396       }
2397 /*
2398  * Find out which interface we were given.
2399  */
2400     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2401       {
2402         syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
2403         die(1);
2404       }
2405 /*
2406  * Enable debug in the driver if requested.
2407  */
2408     set_kdebugflag (kdebugflag);
2409   }
2410
2411 /********************************************************************
2412  *
2413  * restore_loop - reattach the ppp unit to the loopback.
2414  *
2415  * The kernel ppp driver automatically reattaches the ppp unit to
2416  * the loopback if the serial port is set to a line discipline other
2417  * than ppp, or if it detects a modem hangup.  The former will happen
2418  * in disestablish_ppp if the latter hasn't already happened, so we
2419  * shouldn't need to do anything.
2420  *
2421  * Just to be sure, set the real serial port to the normal discipline.
2422  */
2423
2424 void
2425 restore_loop(void)
2426   {
2427     if (ppp_fd != slave_fd)
2428       {
2429         (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2430         set_ppp_fd(slave_fd);
2431       }
2432   }
2433
2434 /********************************************************************
2435  *
2436  * sifnpmode - Set the mode for handling packets for a given NP.
2437  */
2438
2439 int
2440 sifnpmode(u, proto, mode)
2441     int u;
2442     int proto;
2443     enum NPmode mode;
2444 {
2445     struct npioctl npi;
2446
2447     npi.protocol = proto;
2448     npi.mode     = mode;
2449     if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0)
2450       {
2451         if (! ok_error (errno))
2452           {
2453             syslog(LOG_ERR, "ioctl(PPPIOCSNPMODE, %d, %d): %m(%d)",
2454                    proto, mode, errno);
2455             syslog(LOG_ERR, "ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2456           }
2457         return 0;
2458       }
2459     return 1;
2460   }
2461
2462 \f
2463 /********************************************************************
2464  *
2465  * sipxfaddr - Config the interface IPX networknumber
2466  */
2467
2468 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2469   {
2470     int    result = 1;
2471
2472 #ifdef IPX_CHANGE
2473     int    skfd;
2474     struct ifreq         ifr;
2475     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2476
2477     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2478     if (skfd < 0)
2479       {
2480         if (! ok_error (errno))
2481           {
2482             syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2483           }
2484         result = 0;
2485       }
2486     else
2487       {
2488         memset (&ifr, '\0', sizeof (ifr));
2489         strcpy (ifr.ifr_name, ifname);
2490
2491         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2492         sipx->sipx_family  = AF_IPX;
2493         sipx->sipx_port    = 0;
2494         sipx->sipx_network = htonl (network);
2495         sipx->sipx_type    = IPX_FRAME_ETHERII;
2496         sipx->sipx_action  = IPX_CRTITF;
2497 /*
2498  *  Set the IPX device
2499  */
2500         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2501           {
2502             result = 0;
2503             if (errno != EEXIST)
2504               {
2505                 if (! ok_error (errno))
2506                   {
2507                     syslog (LOG_DEBUG,
2508                             "ioctl(SIOCAIFADDR, CRTITF): %m(%d)", errno);
2509                   }
2510               }
2511             else
2512               {
2513                 syslog (LOG_WARNING,
2514                         "ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2515               }
2516           }
2517         close (skfd);
2518       }
2519 #endif
2520     return result;
2521   }
2522
2523 /********************************************************************
2524  *
2525  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2526  *             are removed and the device is no longer able to pass IPX
2527  *             frames.
2528  */
2529
2530 int cipxfaddr (int unit)
2531   {
2532     int    result = 1;
2533
2534 #ifdef IPX_CHANGE
2535     int    skfd;
2536     struct ifreq         ifr;
2537     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2538
2539     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2540     if (skfd < 0)
2541       {
2542         if (! ok_error (errno))
2543           {
2544             syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2545           }
2546         result = 0;
2547       }
2548     else
2549       {
2550         memset (&ifr, '\0', sizeof (ifr));
2551         strcpy (ifr.ifr_name, ifname);
2552
2553         sipx->sipx_type    = IPX_FRAME_ETHERII;
2554         sipx->sipx_action  = IPX_DLTITF;
2555         sipx->sipx_family  = AF_IPX;
2556 /*
2557  *  Set the IPX device
2558  */
2559         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2560           {
2561             if (! ok_error (errno))
2562               {
2563                 syslog (LOG_INFO,
2564                         "ioctl(SIOCAIFADDR, IPX_DLTITF): %m(%d)", errno);
2565               }
2566             result = 0;
2567           }
2568         close (skfd);
2569       }
2570 #endif
2571     return result;
2572   }
2573
2574 /*
2575  * daemon - Detach us from controlling terminal session.
2576  */
2577 int
2578 daemon(nochdir, noclose)
2579     int nochdir, noclose;
2580 {
2581     int pid;
2582
2583     if ((pid = fork()) < 0)
2584         return -1;
2585     if (pid != 0)
2586         exit(0);                /* parent dies */
2587     setsid();
2588     if (!nochdir)
2589         chdir("/");
2590     if (!noclose) {
2591         fclose(stdin);          /* don't need stdin, stdout, stderr */
2592         fclose(stdout);
2593         fclose(stderr);
2594     }
2595     return 0;
2596 }
2597
2598 /*
2599  * Use the hostname as part of the random number seed.
2600  */
2601 int
2602 get_host_seed()
2603 {
2604     int h;
2605     char *p = hostname;
2606
2607     h = 407;
2608     for (p = hostname; *p != 0; ++p)
2609         h = h * 37 + *p;
2610     return h;
2611 }
2612
2613 /********************************************************************
2614  *
2615  * sys_check_options - check the options that the user specified
2616  */
2617
2618 void
2619 sys_check_options(void)
2620   {
2621 #ifdef IPX_CHANGE
2622     struct stat stat_buf;
2623 /*
2624  * Disable the IPX protocol if the support is not present in the kernel.
2625  * If we disable it then ensure that IP support is enabled.
2626  */
2627     while (ipxcp_protent.enabled_flag)
2628       {
2629         if (path_to_procfs())
2630           {
2631             strcat (route_buffer, "/net/ipx_interface");
2632             if (lstat (route_buffer, &stat_buf) >= 0)
2633               {
2634                 break;
2635               }
2636           }
2637         syslog (LOG_ERR, "IPX support is not present in the kernel\n");
2638         ipxcp_protent.enabled_flag = 0;
2639         ipcp_protent.enabled_flag  = 1;
2640         break;
2641       }
2642 #endif
2643     if (demand && driver_is_old) {
2644       option_error("demand dialling is not supported by kernel driver version "
2645                    "%d.%d.%d", driver_version, driver_modification,
2646                    driver_patch);
2647       demand = 0;
2648     }
2649   }