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