pppd/sys-sunos4.c

   1 /*
   2  * System-dependent procedures for pppd under SunOS 4.
   3  *
   4  * Copyright (c) 1994 The Australian National University.
   5  * All rights reserved.
   6  *
   7  * Permission to use, copy, modify, and distribute this software and its
   8  * documentation is hereby granted, provided that the above copyright
   9  * notice appears in all copies.  This software is provided without any
  10  * warranty, express or implied. The Australian National University
  11  * makes no representations about the suitability of this software for
  12  * any purpose.
  13  *
  14  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
  15  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
  17  * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
  18  * OF SUCH DAMAGE.
  19  *
  20  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  21  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  22  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  23  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
  24  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
  25  * OR MODIFICATIONS.
  26  */
  27
  28 #ifndef lint
  29 static char rcsid[] = "$Id: sys-sunos4.c,v 1.2 1995/12/19 02:04:40 paulus Exp $";
  30 #endif
  31
  32 #include <stdio.h>
  33 #include <stddef.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <ctype.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <unistd.h>
  40 #include <termios.h>
  41 #include <signal.h>
  42 #include <malloc.h>
  43 #include <utmp.h>
  44 #include <sys/types.h>
  45 #include <sys/param.h>
  46 #include <sys/socket.h>
  47 #include <sys/sockio.h>
  48 #include <sys/stream.h>
  49 #include <sys/stropts.h>
  50 #include <sys/syslog.h>
  51 #include <sys/stat.h>
  52 #include <sys/time.h>
  53 #include <sys/poll.h>
  54 #include <net/if.h>
  55 #include <net/if_arp.h>
  56 #include <net/nit_if.h>
  57 #include <net/route.h>
  58 #include <net/ppp_defs.h>
  59 #include <net/pppio.h>
  60 #include <netinet/in.h>
  61
  62 #include "pppd.h"
  63
  64 #if defined(sun) && defined(sparc)
  65 #include <alloca.h>
  66 #endif /*sparc*/
  67
  68 static int      pppfd;
  69 static int      fdmuxid = -1;
  70 static int      iffd;
  71 static int      sockfd;
  72
  73 static int      restore_term;
  74 static struct termios inittermios;
  75 static struct winsize wsinfo;   /* Initial window size info */
  76 static pid_t    parent_pid;     /* PID of our parent */
  77
  78 static int      link_mtu, link_mru;
  79
  80 #define NMODULES        32
  81 static int      tty_nmodules;
  82 static char     tty_modules[NMODULES][FMNAMESZ+1];
  83
  84 static int      if_is_up;       /* Interface has been marked up */
  85 static u_int32_t default_route_gateway; /* Gateway for default route added */
  86 static u_int32_t proxy_arp_addr;        /* Addr for proxy arp entry added */
  87
  88 /* Prototypes for procedures local to this file. */
  89 static int translate_speed __P((int));
  90 static int baud_rate_of __P((int));
  91 static int get_ether_addr __P((u_int32_t, struct sockaddr *));
  92 static int strioctl __P((int, int, void *, int, int));
  93
  94
  95 /*
  96  * sys_init - System-dependent initialization.
  97  */
  98 void
  99 sys_init()
 100 {
 101     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
 102     setlogmask(LOG_UPTO(LOG_INFO));
 103     if (debug)
 104         setlogmask(LOG_UPTO(LOG_DEBUG));
 105
 106     /* Get an internet socket for doing socket ioctl's on. */
 107     if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 108         syslog(LOG_ERR, "Couldn't create IP socket: %m");
 109         die(1);
 110     }
 111
 112     /*
 113      * We may want to send a SIGHUP to the session leader associated
 114      * with our controlling terminal later.  Because SunOS doesn't
 115      * have getsid(), we make do with sending the signal to our
 116      * parent process.
 117      */
 118     parent_pid = getppid();
 119 }
 120
 121 /*
 122  * sys_cleanup - restore any system state we modified before exiting:
 123  * mark the interface down, delete default route and/or proxy arp entry.
 124  * This should call die() because it's called from die().
 125  */
 126 void
 127 sys_cleanup()
 128 {
 129     struct ifreq ifr;
 130
 131     if (if_is_up)
 132         sifdown(0);
 133     if (default_route_gateway)
 134         cifdefaultroute(0, default_route_gateway);
 135     if (proxy_arp_addr)
 136         cifproxyarp(0, proxy_arp_addr);
 137 }
 138
 139 /*
 140  * daemon - Detach us from controlling terminal session.
 141  */
 142 int
 143 daemon(nochdir, noclose)
 144     int nochdir, noclose;
 145 {
 146     int pid;
 147
 148     if ((pid = fork()) < 0)
 149         return -1;
 150     if (pid != 0)
 151         exit(0);                /* parent dies */
 152     setsid();
 153     if (!nochdir)
 154         chdir("/");
 155     if (!noclose) {
 156         fclose(stdin);          /* don't need stdin, stdout, stderr */
 157         fclose(stdout);
 158         fclose(stderr);
 159     }
 160     return 0;
 161 }
 162
 163 /*
 164  * note_debug_level - note a change in the debug level.
 165  */
 166 void
 167 note_debug_level()
 168 {
 169     if (debug) {
 170         syslog(LOG_INFO, "Debug turned ON, Level %d", debug);
 171         setlogmask(LOG_UPTO(LOG_DEBUG));
 172     } else {
 173         setlogmask(LOG_UPTO(LOG_WARNING));
 174     }
 175 }
 176
 177 /*
 178  * ppp_available - check whether the system has any ppp interfaces
 179  */
 180 int
 181 ppp_available()
 182 {
 183     struct stat buf;
 184
 185     return stat("/dev/ppp", &buf) >= 0;
 186 }
 187
 188 /*
 189  * establish_ppp - Turn the serial port into a ppp interface.
 190  */
 191 void
 192 establish_ppp()
 193 {
 194     int i, x;
 195     struct ifreq ifr;
 196
 197     pppfd = open("/dev/ppp", O_RDWR | O_NONBLOCK, 0);
 198     if (pppfd < 0) {
 199         syslog(LOG_ERR, "Can't open /dev/ppp: %m");
 200         die(1);
 201     }
 202     if (kdebugflag) {
 203         x = PPPDBG_LOG + PPPDBG_DRIVER;
 204         strioctl(pppfd, PPPIO_DEBUG, &x, sizeof(int), 0);
 205     }
 206
 207     /* Assign a new PPA and get its unit number. */
 208     if (strioctl(pppfd, PPPIO_NEWPPA, &ifunit, 0, sizeof(int)) < 0) {
 209         syslog(LOG_ERR, "Can't create new PPP interface: %m");
 210         die(1);
 211     }
 212
 213     /*
 214      * Open the ppp device again and push the if_ppp module on it.
 215      */
 216     iffd = open("/dev/ppp", O_RDWR, 0);
 217     if (iffd < 0) {
 218         syslog(LOG_ERR, "Can't open /dev/ppp (2): %m");
 219         die(1);
 220     }
 221     if (kdebugflag) {
 222         x = PPPDBG_LOG + PPPDBG_DRIVER;
 223         strioctl(iffd, PPPIO_DEBUG, &x, sizeof(int), 0);
 224     }
 225     if (strioctl(iffd, PPPIO_ATTACH, &ifunit, sizeof(int), 0) < 0) {
 226         syslog(LOG_ERR, "Couldn't attach ppp interface to device: %m");
 227         die(1);
 228     }
 229     if (ioctl(iffd, I_PUSH, "if_ppp") < 0) {
 230         syslog(LOG_ERR, "Can't push ppp interface module: %m");
 231         die(1);
 232     }
 233     if (kdebugflag) {
 234         x = PPPDBG_LOG + PPPDBG_IF;
 235         strioctl(iffd, PPPIO_DEBUG, &x, sizeof(int), 0);
 236     }
 237     if (strioctl(iffd, PPPIO_NEWPPA, &ifunit, sizeof(int), 0) < 0) {
 238         syslog(LOG_ERR, "Couldn't create ppp interface unit: %m");
 239         die(1);
 240     }
 241     x = PPP_IP;
 242     if (strioctl(iffd, PPPIO_BIND, &x, sizeof(int), 0) < 0) {
 243         syslog(LOG_ERR, "Couldn't bind ppp interface to IP SAP: %m");
 244         die(1);
 245     }
 246
 247     /* Pop any existing modules off the tty stream. */
 248     for (i = 0;; ++i)
 249         if (ioctl(fd, I_LOOK, tty_modules[i]) < 0
 250             || ioctl(fd, I_POP, 0) < 0)
 251             break;
 252     tty_nmodules = i;
 253
 254     /* Push the async hdlc module and the compressor module. */
 255     if (ioctl(fd, I_PUSH, "ppp_ahdl") < 0) {
 256         syslog(LOG_ERR, "Couldn't push PPP Async HDLC module: %m");
 257         die(1);
 258     }
 259     if (ioctl(fd, I_PUSH, "ppp_comp") < 0) {
 260         syslog(LOG_ERR, "Couldn't push PPP compression module: %m");
 261 /*      die(1); */
 262     }
 263
 264     /* Link the serial port under the PPP multiplexor. */
 265     if ((fdmuxid = ioctl(pppfd, I_LINK, fd)) < 0) {
 266         syslog(LOG_ERR, "Can't link tty to PPP mux: %m");
 267         die(1);
 268     }
 269
 270     do {
 271         char buf[PPP_MRU];
 272
 273         i = read(fd, buf, PPP_MRU);
 274         syslog(LOG_DEBUG, "read %d bytes from fd", i);
 275     } while (i > 0);
 276 }
 277
 278 /*
 279  * disestablish_ppp - Restore the serial port to normal operation.
 280  * This shouldn't call die() because it's called from die().
 281  */
 282 void
 283 disestablish_ppp()
 284 {
 285     int i;
 286
 287     if (fdmuxid >= 0) {
 288         if (ioctl(pppfd, I_UNLINK, fdmuxid) < 0) {
 289             if (!hungup)
 290                 syslog(LOG_ERR, "Can't unlink tty from PPP mux: %m");
 291         }
 292         fdmuxid = -1;
 293
 294         if (!hungup) {
 295             while (ioctl(fd, I_POP, 0) >= 0)
 296                 ;
 297             for (i = tty_nmodules - 1; i >= 0; --i)
 298                 if (ioctl(fd, I_PUSH, tty_modules[i]) < 0)
 299                     syslog(LOG_ERR, "Couldn't restore tty module %s: %m",
 300                            tty_modules[i]);
 301         }
 302         if (hungup && default_device && parent_pid > 0) {
 303             /*
 304              * If we have received a hangup, we need to send a SIGHUP
 305              * to the terminal's controlling process.  The reason is
 306              * that the original stream head for the terminal hasn't
 307              * seen the M_HANGUP message (it went up through the ppp
 308              * driver to the stream head for our fd to /dev/ppp).
 309              * Actually we send the signal to the process that invoked
 310              * pppd, since SunOS doesn't have getsid().
 311              */
 312             kill(parent_pid, SIGHUP);
 313         }
 314     }
 315 }
 316
 317 /*
 318  * List of valid speeds.
 319  */
 320 struct speed {
 321     int speed_int, speed_val;
 322 } speeds[] = {
 323 #ifdef B50
 324     { 50, B50 },
 325 #endif
 326 #ifdef B75
 327     { 75, B75 },
 328 #endif
 329 #ifdef B110
 330     { 110, B110 },
 331 #endif
 332 #ifdef B134
 333     { 134, B134 },
 334 #endif
 335 #ifdef B150
 336     { 150, B150 },
 337 #endif
 338 #ifdef B200
 339     { 200, B200 },
 340 #endif
 341 #ifdef B300
 342     { 300, B300 },
 343 #endif
 344 #ifdef B600
 345     { 600, B600 },
 346 #endif
 347 #ifdef B1200
 348     { 1200, B1200 },
 349 #endif
 350 #ifdef B1800
 351     { 1800, B1800 },
 352 #endif
 353 #ifdef B2000
 354     { 2000, B2000 },
 355 #endif
 356 #ifdef B2400
 357     { 2400, B2400 },
 358 #endif
 359 #ifdef B3600
 360     { 3600, B3600 },
 361 #endif
 362 #ifdef B4800
 363     { 4800, B4800 },
 364 #endif
 365 #ifdef B7200
 366     { 7200, B7200 },
 367 #endif
 368 #ifdef B9600
 369     { 9600, B9600 },
 370 #endif
 371 #ifdef B19200
 372     { 19200, B19200 },
 373 #endif
 374 #ifdef B38400
 375     { 38400, B38400 },
 376 #endif
 377 #ifdef EXTA
 378     { 19200, EXTA },
 379 #endif
 380 #ifdef EXTB
 381     { 38400, EXTB },
 382 #endif
 383 #ifdef B57600
 384     { 57600, B57600 },
 385 #endif
 386 #ifdef B115200
 387     { 115200, B115200 },
 388 #endif
 389     { 0, 0 }
 390 };
 391
 392 /*
 393  * Translate from bits/second to a speed_t.
 394  */
 395 static int
 396 translate_speed(bps)
 397     int bps;
 398 {
 399     struct speed *speedp;
 400
 401     if (bps == 0)
 402         return 0;
 403     for (speedp = speeds; speedp->speed_int; speedp++)
 404         if (bps == speedp->speed_int)
 405             return speedp->speed_val;
 406     syslog(LOG_WARNING, "speed %d not supported", bps);
 407     return 0;
 408 }
 409
 410 /*
 411  * Translate from a speed_t to bits/second.
 412  */
 413 static int
 414 baud_rate_of(speed)
 415     int speed;
 416 {
 417     struct speed *speedp;
 418
 419     if (speed == 0)
 420         return 0;
 421     for (speedp = speeds; speedp->speed_int; speedp++)
 422         if (speed == speedp->speed_val)
 423             return speedp->speed_int;
 424     return 0;
 425 }
 426
 427 /*
 428  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
 429  * at the requested speed, etc.  If `local' is true, set CLOCAL
 430  * regardless of whether the modem option was specified.
 431  */
 432 void
 433 set_up_tty(fd, local)
 434     int fd, local;
 435 {
 436     int speed;
 437     struct termios tios;
 438
 439     if (tcgetattr(fd, &tios) < 0) {
 440         syslog(LOG_ERR, "tcgetattr: %m");
 441         die(1);
 442     }
 443
 444     if (!restore_term) {
 445         inittermios = tios;
 446         ioctl(fd, TIOCGWINSZ, &wsinfo);
 447     }
 448
 449     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
 450     if (crtscts > 0)
 451         tios.c_cflag |= CRTSCTS;
 452     else if (crtscts < 0)
 453         tios.c_cflag &= ~CRTSCTS;
 454
 455     tios.c_cflag |= CS8 | CREAD | HUPCL;
 456     if (local || !modem)
 457         tios.c_cflag |= CLOCAL;
 458     tios.c_iflag = IGNBRK | IGNPAR;
 459     tios.c_oflag = 0;
 460     tios.c_lflag = 0;
 461     tios.c_cc[VMIN] = 1;
 462     tios.c_cc[VTIME] = 0;
 463
 464     if (crtscts == -2) {
 465         tios.c_iflag |= IXON | IXOFF;
 466         tios.c_cc[VSTOP] = 0x13;        /* DC3 = XOFF = ^S */
 467         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
 468     }
 469
 470     speed = translate_speed(inspeed);
 471     if (speed) {
 472         cfsetospeed(&tios, speed);
 473         cfsetispeed(&tios, speed);
 474     } else {
 475         speed = cfgetospeed(&tios);
 476         /*
 477          * We can't proceed if the serial port speed is 0,
 478          * since that implies that the serial port is disabled.
 479          */
 480         if (speed == B0) {
 481             syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
 482                    devnam);
 483             die(1);
 484         }
 485     }
 486
 487     if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
 488         syslog(LOG_ERR, "tcsetattr: %m");
 489         die(1);
 490     }
 491
 492     baud_rate = inspeed = baud_rate_of(speed);
 493     restore_term = 1;
 494 }
 495
 496 /*
 497  * restore_tty - restore the terminal to the saved settings.
 498  */
 499 void
 500 restore_tty()
 501 {
 502     if (restore_term) {
 503         if (!default_device) {
 504             /*
 505              * Turn off echoing, because otherwise we can get into
 506              * a loop with the tty and the modem echoing to each other.
 507              * We presume we are the sole user of this tty device, so
 508              * when we close it, it will revert to its defaults anyway.
 509              */
 510             inittermios.c_lflag &= ~(ECHO | ECHONL);
 511         }
 512         if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
 513             if (!hungup && errno != ENXIO)
 514                 syslog(LOG_WARNING, "tcsetattr: %m");
 515         ioctl(fd, TIOCSWINSZ, &wsinfo);
 516         restore_term = 0;
 517     }
 518 }
 519
 520 /*
 521  * setdtr - control the DTR line on the serial port.
 522  * This is called from die(), so it shouldn't call die().
 523  */
 524 void
 525 setdtr(fd, on)
 526 int fd, on;
 527 {
 528     int modembits = TIOCM_DTR;
 529
 530     ioctl(fd, (on? TIOCMBIS: TIOCMBIC), &modembits);
 531 }
 532
 533 /*
 534  * output - Output PPP packet.
 535  */
 536 void
 537 output(unit, p, len)
 538     int unit;
 539     u_char *p;
 540     int len;
 541 {
 542     struct strbuf data;
 543     int retries;
 544     struct pollfd pfd;
 545
 546     if (debug)
 547         log_packet(p, len, "sent ");
 548
 549     data.len = len;
 550     data.buf = (caddr_t) p;
 551     while (putmsg(pppfd, NULL, &data, 0) < 0) {
 552         if (--retries < 0 || (errno != EWOULDBLOCK && errno != EAGAIN)) {
 553             if (errno != ENXIO)
 554                 syslog(LOG_ERR, "Couldn't send packet: %m");
 555             break;
 556         }
 557         pfd.fd = fd;
 558         pfd.events = POLLOUT;
 559         poll(&pfd, 1, 250);     /* wait for up to 0.25 seconds */
 560     }
 561 }
 562
 563 /*
 564  * wait_input - wait until there is data available on fd,
 565  * for the length of time specified by *timo (indefinite
 566  * if timo is NULL).
 567  */
 568 void
 569 wait_input(timo)
 570     struct timeval *timo;
 571 {
 572     int t;
 573     struct pollfd pfd;
 574
 575     t = timo == NULL? -1: timo->tv_sec * 1000 + timo->tv_usec / 1000;
 576     pfd.fd = pppfd;
 577     pfd.events = POLLIN | POLLPRI | POLLHUP;
 578     if (poll(&pfd, 1, t) < 0 && errno != EINTR) {
 579         syslog(LOG_ERR, "poll: %m");
 580         die(1);
 581     }
 582 }
 583
 584 /*
 585  * read_packet - get a PPP packet from the serial device.
 586  */
 587 int
 588 read_packet(buf)
 589     u_char *buf;
 590 {
 591     struct strbuf ctrl, data;
 592     int flags, len;
 593     unsigned char ctrlbuf[64];
 594
 595     for (;;) {
 596         data.maxlen = PPP_MRU + PPP_HDRLEN;
 597         data.buf = (caddr_t) buf;
 598         ctrl.maxlen = sizeof(ctrlbuf);
 599         ctrl.buf = (caddr_t) ctrlbuf;
 600         flags = 0;
 601         len = getmsg(pppfd, &ctrl, &data, &flags);
 602         if (len < 0) {
 603             if (errno = EAGAIN || errno == EINTR)
 604                 return -1;
 605             syslog(LOG_ERR, "Error reading packet: %m");
 606             die(1);
 607         }
 608
 609         if (ctrl.len <= 0)
 610             return data.len;
 611
 612         /*
 613          * Got a M_PROTO or M_PCPROTO message.  Huh?
 614          */
 615         if (debug)
 616             syslog(LOG_DEBUG, "got ctrl msg len=%d", ctrl.len);
 617
 618     }
 619 }
 620
 621 /*
 622  * ppp_send_config - configure the transmit characteristics of
 623  * the ppp interface.
 624  */
 625 void
 626 ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
 627     int unit, mtu;
 628     u_int32_t asyncmap;
 629     int pcomp, accomp;
 630 {
 631     int cf[2];
 632
 633     link_mtu = mtu;
 634     if (strioctl(pppfd, PPPIO_MTU, &mtu, sizeof(mtu), 0) < 0) {
 635         if (hungup && errno == ENXIO)
 636             return;
 637         syslog(LOG_ERR, "Couldn't set MTU: %m");
 638     }
 639     if (strioctl(pppfd, PPPIO_XACCM, &asyncmap, sizeof(asyncmap), 0) < 0) {
 640         syslog(LOG_ERR, "Couldn't set transmit ACCM: %m");
 641     }
 642     cf[0] = (pcomp? COMP_PROT: 0) + (accomp? COMP_AC: 0);
 643     cf[1] = COMP_PROT | COMP_AC;
 644     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
 645         syslog(LOG_ERR, "Couldn't set prot/AC compression: %m");
 646     }
 647 }
 648
 649 /*
 650  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
 651  */
 652 void
 653 ppp_set_xaccm(unit, accm)
 654     int unit;
 655     ext_accm accm;
 656 {
 657     if (strioctl(pppfd, PPPIO_XACCM, accm, sizeof(ext_accm), 0) < 0) {
 658         if (!hungup || errno != ENXIO)
 659             syslog(LOG_WARNING, "Couldn't set extended ACCM: %m");
 660     }
 661 }
 662
 663 /*
 664  * ppp_recv_config - configure the receive-side characteristics of
 665  * the ppp interface.
 666  */
 667 void
 668 ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
 669     int unit, mru;
 670     u_int32_t asyncmap;
 671     int pcomp, accomp;
 672 {
 673     int cf[2];
 674
 675     link_mru = mru;
 676     if (strioctl(pppfd, PPPIO_MRU, &mru, sizeof(mru), 0) < 0) {
 677         if (hungup && errno == ENXIO)
 678             return;
 679         syslog(LOG_ERR, "Couldn't set MRU: %m");
 680     }
 681     if (strioctl(pppfd, PPPIO_RACCM, &asyncmap, sizeof(asyncmap), 0) < 0) {
 682         syslog(LOG_ERR, "Couldn't set receive ACCM: %m");
 683     }
 684     cf[0] = (pcomp? DECOMP_PROT: 0) + (accomp? DECOMP_AC: 0);
 685     cf[1] = DECOMP_PROT | DECOMP_AC;
 686     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
 687         syslog(LOG_ERR, "Couldn't set prot/AC decompression: %m");
 688     }
 689 }
 690
 691 /*
 692  * ccp_test - ask kernel whether a given compression method
 693  * is acceptable for use.
 694  */
 695 int
 696 ccp_test(unit, opt_ptr, opt_len, for_transmit)
 697     int unit, opt_len, for_transmit;
 698     u_char *opt_ptr;
 699 {
 700     if (strioctl(pppfd, (for_transmit? PPPIO_XCOMP: PPPIO_RCOMP),
 701                  opt_ptr, opt_len, 0) >= 0)
 702         return 1;
 703     return (errno == ENOSR)? 0: -1;
 704 }
 705
 706 /*
 707  * ccp_flags_set - inform kernel about the current state of CCP.
 708  */
 709 void
 710 ccp_flags_set(unit, isopen, isup)
 711     int unit, isopen, isup;
 712 {
 713     int cf[2];
 714
 715     cf[0] = (isopen? CCP_ISOPEN: 0) + (isup? CCP_ISUP: 0);
 716     cf[1] = CCP_ISOPEN | CCP_ISUP | CCP_ERROR | CCP_FATALERROR;
 717     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
 718         if (!hungup || errno != ENXIO)
 719             syslog(LOG_ERR, "Couldn't set kernel CCP state: %m");
 720     }
 721 }
 722
 723 /*
 724  * ccp_fatal_error - returns 1 if decompression was disabled as a
 725  * result of an error detected after decompression of a packet,
 726  * 0 otherwise.  This is necessary because of patent nonsense.
 727  */
 728 int
 729 ccp_fatal_error(unit)
 730     int unit;
 731 {
 732     int cf[2];
 733
 734     cf[0] = cf[1] = 0;
 735     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
 736         if (errno != ENXIO && errno != EINVAL)
 737             syslog(LOG_ERR, "Couldn't get compression flags: %m");
 738         return 0;
 739     }
 740     return cf[0] & CCP_FATALERROR;
 741 }
 742
 743 /*
 744  * sifvjcomp - config tcp header compression
 745  */
 746 int
 747 sifvjcomp(u, vjcomp, xcidcomp, xmaxcid)
 748     int u, vjcomp, xcidcomp, xmaxcid;
 749 {
 750     int cf[2];
 751     char maxcid[2];
 752
 753     if (vjcomp) {
 754         maxcid[0] = xcidcomp;
 755         maxcid[1] = 15;         /* XXX should be rmaxcid */
 756         if (strioctl(pppfd, PPPIO_VJINIT, maxcid, sizeof(maxcid), 0) < 0) {
 757             syslog(LOG_ERR, "Couldn't initialize VJ compression: %m");
 758         }
 759     }
 760
 761     cf[0] = (vjcomp? COMP_VJC + DECOMP_VJC: 0)  /* XXX this is wrong */
 762         + (xcidcomp? COMP_VJCCID + DECOMP_VJCCID: 0);
 763     cf[1] = COMP_VJC + DECOMP_VJC + COMP_VJCCID + DECOMP_VJCCID;
 764     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
 765         if (vjcomp)
 766             syslog(LOG_ERR, "Couldn't enable VJ compression: %m");
 767     }
 768
 769     return 1;
 770 }
 771
 772 /*
 773  * sifup - Config the interface up and enable IP packets to pass.
 774  */
 775 int
 776 sifup(u)
 777     int u;
 778 {
 779     struct ifreq ifr;
 780
 781     strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 782     if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) < 0) {
 783         syslog(LOG_ERR, "Couldn't mark interface up (get): %m");
 784         return 0;
 785     }
 786     ifr.ifr_flags |= IFF_UP;
 787     if (ioctl(sockfd, SIOCSIFFLAGS, &ifr) < 0) {
 788         syslog(LOG_ERR, "Couldn't mark interface up (set): %m");
 789         return 0;
 790     }
 791     if_is_up = 1;
 792     return 1;
 793 }
 794
 795 /*
 796  * sifdown - Config the interface down and disable IP.
 797  */
 798 int
 799 sifdown(u)
 800     int u;
 801 {
 802     struct ifreq ifr;
 803
 804     strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 805     if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) < 0) {
 806         syslog(LOG_ERR, "Couldn't mark interface down (get): %m");
 807         return 0;
 808     }
 809     if ((ifr.ifr_flags & IFF_UP) != 0) {
 810         ifr.ifr_flags &= ~IFF_UP;
 811         if (ioctl(sockfd, SIOCSIFFLAGS, &ifr) < 0) {
 812             syslog(LOG_ERR, "Couldn't mark interface down (set): %m");
 813             return 0;
 814         }
 815     }
 816     if_is_up = 0;
 817     return 1;
 818 }
 819
 820 #define INET_ADDR(x)    (((struct sockaddr_in *) &(x))->sin_addr.s_addr)
 821
 822 /*
 823  * sifaddr - Config the interface IP addresses and netmask.
 824  */
 825 int
 826 sifaddr(u, o, h, m)
 827     int u;
 828     u_int32_t o, h, m;
 829 {
 830     struct ifreq ifr;
 831
 832     memset(&ifr, 0, sizeof(ifr));
 833     strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 834     ifr.ifr_addr.sa_family = AF_INET;
 835     INET_ADDR(ifr.ifr_addr) = o;
 836     if (ioctl(sockfd, SIOCSIFADDR, &ifr) < 0) {
 837         syslog(LOG_ERR, "Couldn't set local IP address: %m");
 838     }
 839     ifr.ifr_dstaddr.sa_family = AF_INET;
 840     INET_ADDR(ifr.ifr_dstaddr) = h;
 841     if (ioctl(sockfd, SIOCSIFDSTADDR, &ifr) < 0) {
 842         syslog(LOG_ERR, "Couldn't set remote IP address: %m");
 843     }
 844     ifr.ifr_addr.sa_family = AF_INET;
 845     INET_ADDR(ifr.ifr_addr) = m;
 846     if (ioctl(sockfd, SIOCSIFNETMASK, &ifr) < 0) {
 847         syslog(LOG_ERR, "Couldn't set IP netmask: %m");
 848     }
 849     ifr.ifr_metric = link_mtu;
 850     if (ioctl(sockfd, SIOCSIFMTU, &ifr) < 0) {
 851         syslog(LOG_ERR, "Couldn't set IP MTU: %m");
 852     }
 853
 854     return 1;
 855 }
 856
 857 /*
 858  * cifaddr - Clear the interface IP addresses, and delete routes
 859  * through the interface if possible.
 860  */
 861 int
 862 cifaddr(u, o, h)
 863     int u;
 864     u_int32_t o, h;
 865 {
 866     struct rtentry rt;
 867
 868     rt.rt_dst.sa_family = AF_INET;
 869     INET_ADDR(rt.rt_dst) = h;
 870     rt.rt_gateway.sa_family = AF_INET;
 871     INET_ADDR(rt.rt_gateway) = o;
 872     rt.rt_flags = RTF_HOST;
 873     ioctl(sockfd, SIOCDELRT, &rt);
 874     return 1;
 875 }
 876
 877 /*
 878  * sifdefaultroute - assign a default route through the address given.
 879  */
 880 int
 881 sifdefaultroute(u, g)
 882     int u;
 883     u_int32_t g;
 884 {
 885     struct rtentry rt;
 886
 887     rt.rt_dst.sa_family = AF_INET;
 888     INET_ADDR(rt.rt_dst) = 0;
 889     rt.rt_gateway.sa_family = AF_INET;
 890     INET_ADDR(rt.rt_gateway) = g;
 891     rt.rt_flags = RTF_GATEWAY;
 892
 893     if (ioctl(sockfd, SIOCADDRT, &rt) < 0) {
 894         syslog(LOG_ERR, "Can't add default route: %m");
 895         return 0;
 896     }
 897
 898     default_route_gateway = g;
 899     return 1;
 900 }
 901
 902 /*
 903  * cifdefaultroute - delete a default route through the address given.
 904  */
 905 int
 906 cifdefaultroute(u, g)
 907     int u;
 908     u_int32_t g;
 909 {
 910     struct rtentry rt;
 911
 912     rt.rt_dst.sa_family = AF_INET;
 913     INET_ADDR(rt.rt_dst) = 0;
 914     rt.rt_gateway.sa_family = AF_INET;
 915     INET_ADDR(rt.rt_gateway) = g;
 916     rt.rt_flags = RTF_GATEWAY;
 917
 918     if (ioctl(sockfd, SIOCDELRT, &rt) < 0) {
 919         syslog(LOG_ERR, "Can't delete default route: %m");
 920         return 0;
 921     }
 922
 923     default_route_gateway = 0;
 924     return 1;
 925 }
 926
 927 /*
 928  * sifproxyarp - Make a proxy ARP entry for the peer.
 929  */
 930 int
 931 sifproxyarp(unit, hisaddr)
 932     int unit;
 933     u_int32_t hisaddr;
 934 {
 935     struct arpreq arpreq;
 936
 937     bzero(&arpreq, sizeof(arpreq));
 938     if (!get_ether_addr(hisaddr, &arpreq.arp_ha))
 939         return 0;
 940
 941     arpreq.arp_pa.sa_family = AF_INET;
 942     INET_ADDR(arpreq.arp_pa) = hisaddr;
 943     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
 944     if (ioctl(sockfd, SIOCSARP, (caddr_t) &arpreq) < 0) {
 945         syslog(LOG_ERR, "Couldn't set proxy ARP entry: %m");
 946         return 0;
 947     }
 948
 949     proxy_arp_addr = hisaddr;
 950     return 1;
 951 }
 952
 953 /*
 954  * cifproxyarp - Delete the proxy ARP entry for the peer.
 955  */
 956 int
 957 cifproxyarp(unit, hisaddr)
 958     int unit;
 959     u_int32_t hisaddr;
 960 {
 961     struct arpreq arpreq;
 962
 963     bzero(&arpreq, sizeof(arpreq));
 964     arpreq.arp_pa.sa_family = AF_INET;
 965     INET_ADDR(arpreq.arp_pa) = hisaddr;
 966     if (ioctl(sockfd, SIOCDARP, (caddr_t)&arpreq) < 0) {
 967         syslog(LOG_ERR, "Couldn't delete proxy ARP entry: %m");
 968         return 0;
 969     }
 970
 971     proxy_arp_addr = 0;
 972     return 1;
 973 }
 974
 975 /*
 976  * get_ether_addr - get the hardware address of an interface on the
 977  * the same subnet as ipaddr.
 978  */
 979 #define MAX_IFS         32
 980
 981 static int
 982 get_ether_addr(ipaddr, hwaddr)
 983     u_int32_t ipaddr;
 984     struct sockaddr *hwaddr;
 985 {
 986     struct ifreq *ifr, *ifend;
 987     u_int32_t ina, mask;
 988     struct ifreq ifreq;
 989     struct ifconf ifc;
 990     struct ifreq ifs[MAX_IFS];
 991     int nit_fd;
 992
 993     ifc.ifc_len = sizeof(ifs);
 994     ifc.ifc_req = ifs;
 995     if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) {
 996         syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m");
 997         return 0;
 998     }
 999
1000     /*
1001      * Scan through looking for an interface with an Internet
1002      * address on the same subnet as `ipaddr'.
1003      */
1004     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1005     for (ifr = ifc.ifc_req; ifr < ifend; ifr = (struct ifreq *)
1006             ((char *)&ifr->ifr_addr + sizeof(struct sockaddr))) {
1007         if (ifr->ifr_addr.sa_family == AF_INET) {
1008
1009             /*
1010              * Check that the interface is up, and not point-to-point
1011              * or loopback.
1012              */
1013             strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1014             if (ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0)
1015                 continue;
1016             if ((ifreq.ifr_flags &
1017                  (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
1018                  != (IFF_UP|IFF_BROADCAST))
1019                 continue;
1020
1021             /*
1022              * Get its netmask and check that it's on the right subnet.
1023              */
1024             if (ioctl(sockfd, SIOCGIFNETMASK, &ifreq) < 0)
1025                 continue;
1026             ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1027             mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1028             if ((ipaddr & mask) != (ina & mask))
1029                 continue;
1030
1031             break;
1032         }
1033     }
1034
1035     if (ifr >= ifend)
1036         return 0;
1037     syslog(LOG_INFO, "found interface %s for proxy arp", ifr->ifr_name);
1038
1039     /*
1040      * Grab the physical address for this interface.
1041      */
1042     if ((nit_fd = open("/dev/nit", O_RDONLY)) < 0) {
1043         syslog(LOG_ERR, "Couldn't open /dev/nit: %m");
1044         return 0;
1045     }
1046     strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1047     if (ioctl(nit_fd, NIOCBIND, &ifreq) < 0
1048         || ioctl(nit_fd, SIOCGIFADDR, &ifreq) < 0) {
1049         syslog(LOG_ERR, "Couldn't get hardware address for %s: %m",
1050                ifreq.ifr_name);
1051         close(nit_fd);
1052         return 0;
1053     }
1054
1055     hwaddr->sa_family = AF_UNSPEC;
1056     memcpy(hwaddr->sa_data, ifreq.ifr_addr.sa_data, 6);
1057     close(nit_fd);
1058     return 1;
1059 }
1060
1061 #define WTMPFILE        "/usr/adm/wtmp"
1062
1063 int
1064 logwtmp(line, name, host)
1065     char *line, *name, *host;
1066 {
1067     int fd;
1068     struct stat buf;
1069     struct utmp ut;
1070
1071     if ((fd = open(WTMPFILE, O_WRONLY|O_APPEND, 0)) < 0)
1072         return;
1073     if (!fstat(fd, &buf)) {
1074         (void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1075         (void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
1076         (void)strncpy(ut.ut_host, host, sizeof(ut.ut_host));
1077         (void)time(&ut.ut_time);
1078         if (write(fd, (char *)&ut, sizeof(struct utmp)) != sizeof(struct utmp))
1079             (void)ftruncate(fd, buf.st_size);
1080     }
1081     close(fd);
1082 }
1083
1084 /*
1085  * Return user specified netmask, modified by any mask we might determine
1086  * for address `addr' (in network byte order).
1087  * Here we scan through the system's list of interfaces, looking for
1088  * any non-point-to-point interfaces which might appear to be on the same
1089  * network as `addr'.  If we find any, we OR in their netmask to the
1090  * user-specified netmask.
1091  */
1092 u_int32_t
1093 GetMask(addr)
1094     u_int32_t addr;
1095 {
1096     u_int32_t mask, nmask, ina;
1097     struct ifreq *ifr, *ifend, ifreq;
1098     struct ifconf ifc;
1099
1100     addr = ntohl(addr);
1101     if (IN_CLASSA(addr))        /* determine network mask for address class */
1102         nmask = IN_CLASSA_NET;
1103     else if (IN_CLASSB(addr))
1104         nmask = IN_CLASSB_NET;
1105     else
1106         nmask = IN_CLASSC_NET;
1107     /* class D nets are disallowed by bad_ip_adrs */
1108     mask = netmask | htonl(nmask);
1109
1110     /*
1111      * Scan through the system's network interfaces.
1112      */
1113     ifc.ifc_len = MAX_IFS * sizeof(struct ifreq);
1114     ifc.ifc_req = alloca(ifc.ifc_len);
1115     if (ifc.ifc_req == 0)
1116         return mask;
1117     if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) {
1118         syslog(LOG_WARNING, "Couldn't get system interface list: %m");
1119         return mask;
1120     }
1121     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1122     for (ifr = ifc.ifc_req; ifr < ifend; ++ifr) {
1123         /*
1124          * Check the interface's internet address.
1125          */
1126         if (ifr->ifr_addr.sa_family != AF_INET)
1127             continue;
1128         ina = INET_ADDR(ifr->ifr_addr);
1129         if ((ntohl(ina) & nmask) != (addr & nmask))
1130             continue;
1131         /*
1132          * Check that the interface is up, and not point-to-point or loopback.
1133          */
1134         strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1135         if (ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0)
1136             continue;
1137         if ((ifreq.ifr_flags & (IFF_UP|IFF_POINTOPOINT|IFF_LOOPBACK))
1138             != IFF_UP)
1139             continue;
1140         /*
1141          * Get its netmask and OR it into our mask.
1142          */
1143         if (ioctl(sockfd, SIOCGIFNETMASK, &ifreq) < 0)
1144             continue;
1145         mask |= INET_ADDR(ifreq.ifr_addr);
1146     }
1147
1148     return mask;
1149 }
1150
1151 static int
1152 strioctl(fd, cmd, ptr, ilen, olen)
1153     int fd, cmd, ilen, olen;
1154     void *ptr;
1155 {
1156     struct strioctl str;
1157
1158     str.ic_cmd = cmd;
1159     str.ic_timout = 0;
1160     str.ic_len = ilen;
1161     str.ic_dp = ptr;
1162     if (ioctl(fd, I_STR, &str) == -1)
1163         return -1;
1164     if (str.ic_len != olen)
1165         syslog(LOG_DEBUG, "strioctl: expected %d bytes, got %d for cmd %x\n",
1166                olen, str.ic_len, cmd);
1167     return 0;
1168 }
1169
1170 /*
1171  * Code for locking/unlocking the serial device.
1172  * This code is derived from chat.c.
1173  */
1174
1175 #if !defined(HDB) && !defined(SUNOS3)
1176 #define HDB     1               /* ascii lock files are the default */
1177 #endif
1178
1179 #ifndef LOCK_DIR
1180 # if HDB
1181 #  define       PIDSTRING
1182 #  define       LOCK_PREFIX     "/usr/spool/locks/LCK.."
1183 # else /* HDB */
1184 #  define       LOCK_PREFIX     "/usr/spool/uucp/LCK.."
1185 # endif /* HDB */
1186 #endif /* LOCK_DIR */
1187
1188 static char *lock_file;         /* name of lock file created */
1189
1190 /*
1191  * lock - create a lock file for the named device.
1192  */
1193 int
1194 lock(dev)
1195     char *dev;
1196 {
1197     char hdb_lock_buffer[12];
1198     int fd, pid, n;
1199     char *p;
1200
1201     if ((p = strrchr(dev, '/')) != NULL)
1202         dev = p + 1;
1203     lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
1204     if (lock_file == NULL)
1205         novm("lock file name");
1206     strcat(strcpy(lock_file, LOCK_PREFIX), dev);
1207
1208     while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) {
1209         if (errno == EEXIST
1210             && (fd = open(lock_file, O_RDONLY, 0)) >= 0) {
1211             /* Read the lock file to find out who has the device locked */
1212 #ifdef PIDSTRING
1213             n = read(fd, hdb_lock_buffer, 11);
1214             if (n > 0) {
1215                 hdb_lock_buffer[n] = 0;
1216                 pid = atoi(hdb_lock_buffer);
1217             }
1218 #else
1219             n = read(fd, &pid, sizeof(pid));
1220 #endif
1221             if (n <= 0) {
1222                 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
1223                 close(fd);
1224             } else {
1225                 if (kill(pid, 0) == -1 && errno == ESRCH) {
1226                     /* pid no longer exists - remove the lock file */
1227                     if (unlink(lock_file) == 0) {
1228                         close(fd);
1229                         syslog(LOG_NOTICE, "Removed stale lock on %s (pid %d)",
1230                                dev, pid);
1231                         continue;
1232                     } else
1233                         syslog(LOG_WARNING, "Couldn't remove stale lock on %s",
1234                                dev);
1235                 } else
1236                     syslog(LOG_NOTICE, "Device %s is locked by pid %d",
1237                            dev, pid);
1238             }
1239             close(fd);
1240         } else
1241             syslog(LOG_ERR, "Can't create lock file %s: %m", lock_file);
1242         free(lock_file);
1243         lock_file = NULL;
1244         return -1;
1245     }
1246
1247 #ifdef PIDSTRING
1248     sprintf(hdb_lock_buffer, "%10d\n", getpid());
1249     write(fd, hdb_lock_buffer, 11);
1250 #else
1251     pid = getpid();
1252     write(fd, &pid, sizeof pid);
1253 #endif
1254
1255     close(fd);
1256     return 0;
1257 }
1258
1259 /*
1260  * unlock - remove our lockfile
1261  */
1262 void
1263 unlock()
1264 {
1265     if (lock_file) {
1266         unlink(lock_file);
1267         free(lock_file);
1268         lock_file = NULL;
1269     }
1270 }
1271
1272 /*
1273  * SunOS doesn't have strtoul :-(
1274  */
1275 unsigned long
1276 strtoul(str, ptr, base)
1277     char *str, **ptr;
1278     int base;
1279 {
1280     return (unsigned long) strtol(str, ptr, base);
1281 }