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