pppd/sys-linux.c

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