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