pppd/sys-svr4.c

   1 /*
   2  * System-dependent procedures for pppd under Solaris 2.
   3  *
   4  * Parts re-written by Adi Masputra <adi.masputra@sun.com>, based on
   5  * the original sys-svr4.c
   6  *
   7  * Copyright (c) 2000 by Sun Microsystems, Inc.
   8  * All rights reserved.
   9  *
  10  * Permission to use, copy, modify, and distribute this software and its
  11  * documentation is hereby granted, provided that the above copyright
  12  * notice appears in all copies.
  13  *
  14  * SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF
  15  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  16  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  17  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT.  SUN SHALL NOT BE LIABLE FOR
  18  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  19  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES
  20  *
  21  * Copyright (c) 1995-2002 Paul Mackerras. All rights reserved.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  *
  27  * 1. Redistributions of source code must retain the above copyright
  28  *    notice, this list of conditions and the following disclaimer.
  29  *
  30  * 2. The name(s) of the authors of this software must not be used to
  31  *    endorse or promote products derived from this software without
  32  *    prior written permission.
  33  *
  34  * 3. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by Paul Mackerras
  37  *     <paulus@samba.org>".
  38  *
  39  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  40  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  41  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  42  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  43  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  44  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  45  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  46  *
  47  * Derived from main.c and pppd.h, which are:
  48  *
  49  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
  50  *
  51  * Redistribution and use in source and binary forms, with or without
  52  * modification, are permitted provided that the following conditions
  53  * are met:
  54  *
  55  * 1. Redistributions of source code must retain the above copyright
  56  *    notice, this list of conditions and the following disclaimer.
  57  *
  58  * 2. Redistributions in binary form must reproduce the above copyright
  59  *    notice, this list of conditions and the following disclaimer in
  60  *    the documentation and/or other materials provided with the
  61  *    distribution.
  62  *
  63  * 3. The name "Carnegie Mellon University" must not be used to
  64  *    endorse or promote products derived from this software without
  65  *    prior written permission. For permission or any legal
  66  *    details, please contact
  67  *      Office of Technology Transfer
  68  *      Carnegie Mellon University
  69  *      5000 Forbes Avenue
  70  *      Pittsburgh, PA  15213-3890
  71  *      (412) 268-4387, fax: (412) 268-7395
  72  *      tech-transfer@andrew.cmu.edu
  73  *
  74  * 4. Redistributions of any form whatsoever must retain the following
  75  *    acknowledgment:
  76  *    "This product includes software developed by Computing Services
  77  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
  78  *
  79  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
  80  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  81  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
  82  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  83  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  84  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  85  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  86  */
  87
  88 #define RCSID   "$Id: sys-svr4.c,v 1.46 2004/11/04 10:02:26 paulus Exp $"
  89
  90 #include <limits.h>
  91 #include <stdio.h>
  92 #include <stddef.h>
  93 #include <stdlib.h>
  94 #include <ctype.h>
  95 #include <errno.h>
  96 #include <fcntl.h>
  97 #include <unistd.h>
  98 #include <termios.h>
  99 #ifndef CRTSCTS
 100 #include <sys/termiox.h>
 101 #endif
 102 #include <signal.h>
 103 #include <utmpx.h>
 104 #include <sys/types.h>
 105 #include <sys/ioccom.h>
 106 #include <sys/stream.h>
 107 #include <sys/stropts.h>
 108 #include <sys/socket.h>
 109 #include <sys/sockio.h>
 110 #include <sys/sysmacros.h>
 111 #include <sys/systeminfo.h>
 112 #include <sys/dlpi.h>
 113 #include <sys/stat.h>
 114 #include <sys/mkdev.h>
 115 #include <net/if.h>
 116 #include <net/if_arp.h>
 117 #include <net/route.h>
 118 #include <net/ppp_defs.h>
 119 #include <net/pppio.h>
 120 #include <netinet/in.h>
 121 #ifdef SOL2
 122 #include <sys/tihdr.h>
 123 #include <sys/tiuser.h>
 124 #include <inet/common.h>
 125 #include <inet/mib2.h>
 126 #include <sys/ethernet.h>
 127 #endif
 128
 129 #include "pppd.h"
 130 #include "fsm.h"
 131 #include "lcp.h"
 132 #include "ipcp.h"
 133 #include "ccp.h"
 134
 135 #if !defined(PPP_DEV_NAME)
 136 #define PPP_DEV_NAME    "/dev/ppp"
 137 #endif /* !defined(PPP_DEV_NAME) */
 138
 139 #if !defined(AHDLC_MOD_NAME)
 140 #define AHDLC_MOD_NAME  "ppp_ahdl"
 141 #endif /* !defined(AHDLC_MOD_NAME) */
 142
 143 #if !defined(COMP_MOD_NAME)
 144 #define COMP_MOD_NAME   "ppp_comp"
 145 #endif /* !defined(COMP_MOD_NAME) */
 146
 147 #if !defined(IP_DEV_NAME)
 148 #define IP_DEV_NAME     "/dev/ip"
 149 #endif /* !defined(IP_DEV_NAME) */
 150
 151 #if !defined(IP_MOD_NAME)
 152 #define IP_MOD_NAME     "ip"
 153 #endif /* !defined(IP_MOD_NAME) */
 154
 155 #if !defined(UDP_DEV_NAME) && defined(SOL2)
 156 #define UDP_DEV_NAME    "/dev/udp"
 157 #endif /* !defined(UDP_DEV_NAME) && defined(SOL2) */
 158
 159 #if !defined(UDP6_DEV_NAME) && defined(SOL2)
 160 #define UDP6_DEV_NAME   "/dev/udp6"
 161 #endif /* !defined(UDP6_DEV_NAME) && defined(SOL2) */
 162
 163 static const char rcsid[] = RCSID;
 164
 165 #if defined(SOL2)
 166 /*
 167  * "/dev/udp" is used as a multiplexor to PLINK the interface stream
 168  * under. It is used in place of "/dev/ip" since STREAMS will not let
 169  * a driver be PLINK'ed under itself, and "/dev/ip" is typically the
 170  * driver at the bottom of the tunneling interfaces stream.
 171  */
 172 static char *mux_dev_name = UDP_DEV_NAME;
 173 #else
 174 static char *mux_dev_name = IP_DEV_NAME;
 175 #endif
 176 static int      pppfd;
 177 static int      fdmuxid = -1;
 178 static int      ipfd;
 179 static int      ipmuxid = -1;
 180
 181 #if defined(INET6) && defined(SOL2)
 182 static int      ip6fd;          /* IP file descriptor */
 183 static int      ip6muxid = -1;  /* Multiplexer file descriptor */
 184 static int      if6_is_up = 0;  /* IPv6 interface has been marked up */
 185
 186 #define _IN6_LLX_FROM_EUI64(l, s, eui64, as) do {       \
 187         s->sin6_addr.s6_addr32[0] = htonl(as);  \
 188         eui64_copy(eui64, s->sin6_addr.s6_addr32[2]);   \
 189         s->sin6_family = AF_INET6;              \
 190         l.lifr_addr.ss_family = AF_INET6;       \
 191         l.lifr_addrlen = 10;                    \
 192         l.lifr_addr = laddr;                    \
 193         } while (0)
 194
 195 #define IN6_LLADDR_FROM_EUI64(l, s, eui64)  \
 196     _IN6_LLX_FROM_EUI64(l, s, eui64, 0xfe800000)
 197
 198 #define IN6_LLTOKEN_FROM_EUI64(l, s, eui64) \
 199     _IN6_LLX_FROM_EUI64(l, s, eui64, 0)
 200
 201 #endif /* defined(INET6) && defined(SOL2) */
 202
 203 #if defined(INET6) && defined(SOL2)
 204 static char     first_ether_name[LIFNAMSIZ];    /* Solaris 8 and above */
 205 #else
 206 static char     first_ether_name[IFNAMSIZ];     /* Before Solaris 8 */
 207 #define MAXIFS          256                     /* Max # of interfaces */
 208 #endif /* defined(INET6) && defined(SOL2) */
 209
 210 static int      restore_term;
 211 static struct termios inittermios;
 212 #ifndef CRTSCTS
 213 static struct termiox inittermiox;
 214 static int      termiox_ok;
 215 #endif
 216 static struct winsize wsinfo;   /* Initial window size info */
 217 static pid_t    tty_sid;        /* original session ID for terminal */
 218
 219 extern u_char   inpacket_buf[]; /* borrowed from main.c */
 220
 221 #define MAX_POLLFDS     32
 222 static struct pollfd pollfds[MAX_POLLFDS];
 223 static int n_pollfds;
 224
 225 static int      link_mtu, link_mru;
 226
 227 #define NMODULES        32
 228 static int      tty_nmodules;
 229 static char     tty_modules[NMODULES][FMNAMESZ+1];
 230 static int      tty_npushed;
 231
 232 static int      if_is_up;       /* Interface has been marked up */
 233 static u_int32_t remote_addr;           /* IP address of peer */
 234 static u_int32_t default_route_gateway; /* Gateway for default route added */
 235 static u_int32_t proxy_arp_addr;        /* Addr for proxy arp entry added */
 236
 237 /* Prototypes for procedures local to this file. */
 238 static int translate_speed __P((int));
 239 static int baud_rate_of __P((int));
 240 static int get_ether_addr __P((u_int32_t, struct sockaddr *));
 241 static int get_hw_addr __P((char *, u_int32_t, struct sockaddr *));
 242 static int get_hw_addr_dlpi __P((char *, struct sockaddr *));
 243 static int dlpi_attach __P((int, int));
 244 static int dlpi_info_req __P((int));
 245 static int dlpi_get_reply __P((int, union DL_primitives *, int, int));
 246 static int strioctl __P((int, int, void *, int, int));
 247
 248 #ifdef SOL2
 249 /*
 250  * sifppa - Sets interface ppa
 251  *
 252  * without setting the ppa, ip module will return EINVAL upon setting the
 253  * interface UP (SIOCSxIFFLAGS). This is because ip module in 2.8 expects
 254  * two DLPI_INFO_REQ to be sent down to the driver (below ip) before
 255  * IFF_UP can be set. Plumbing the device causes one DLPI_INFO_REQ to
 256  * be sent down, and the second DLPI_INFO_REQ is sent upon receiving
 257  * IF_UNITSEL (old) or SIOCSLIFNAME (new) ioctls. Such setting of the ppa
 258  * is required because the ppp DLPI provider advertises itself as
 259  * a DLPI style 2 type, which requires a point of attachment to be
 260  * specified. The only way the user can specify a point of attachment
 261  * is via SIOCSLIFNAME or IF_UNITSEL.
 262  *
 263  * Such changes in the behavior of ip module was made to meet new or
 264  * evolving standards requirements.
 265  *
 266  */
 267 static int
 268 sifppa(fd, ppa)
 269     int fd;
 270     int ppa;
 271 {
 272     return (int)ioctl(fd, IF_UNITSEL, (char *)&ppa);
 273 }
 274 #endif /* SOL2 */
 275
 276 #if defined(SOL2) && defined(INET6)
 277 /*
 278  * get_first_ethernet - returns the first Ethernet interface name found in
 279  * the system, or NULL if none is found
 280  *
 281  * NOTE: This is the lifreq version (Solaris 8 and above)
 282  */
 283 char *
 284 get_first_ethernet()
 285 {
 286     struct lifnum lifn;
 287     struct lifconf lifc;
 288     struct lifreq *plifreq;
 289     struct lifreq lifr;
 290     int fd, num_ifs, i, found;
 291     uint_t fl, req_size;
 292     char *req;
 293
 294     fd = socket(AF_INET, SOCK_DGRAM, 0);
 295     if (fd < 0) {
 296         return 0;
 297     }
 298
 299     /*
 300      * Find out how many interfaces are running
 301      */
 302     lifn.lifn_family = AF_UNSPEC;
 303     lifn.lifn_flags = LIFC_NOXMIT;
 304     if (ioctl(fd, SIOCGLIFNUM, &lifn) < 0) {
 305         close(fd);
 306         error("could not determine number of interfaces: %m");
 307         return 0;
 308     }
 309
 310     num_ifs = lifn.lifn_count;
 311     req_size = num_ifs * sizeof(struct lifreq);
 312     req = malloc(req_size);
 313     if (req == NULL) {
 314         close(fd);
 315         error("out of memory");
 316         return 0;
 317     }
 318
 319     /*
 320      * Get interface configuration info for all interfaces
 321      */
 322     lifc.lifc_family = AF_UNSPEC;
 323     lifc.lifc_flags = LIFC_NOXMIT;
 324     lifc.lifc_len = req_size;
 325     lifc.lifc_buf = req;
 326     if (ioctl(fd, SIOCGLIFCONF, &lifc) < 0) {
 327         close(fd);
 328         free(req);
 329         error("SIOCGLIFCONF: %m");
 330         return 0;
 331     }
 332
 333     /*
 334      * And traverse each interface to look specifically for the first
 335      * occurence of an Ethernet interface which has been marked up
 336      */
 337     plifreq = lifc.lifc_req;
 338     found = 0;
 339     for (i = lifc.lifc_len / sizeof(struct lifreq); i > 0; i--, plifreq++) {
 340
 341         if (strchr(plifreq->lifr_name, ':') != NULL)
 342             continue;
 343
 344         memset(&lifr, 0, sizeof(lifr));
 345         strncpy(lifr.lifr_name, plifreq->lifr_name, sizeof(lifr.lifr_name));
 346         if (ioctl(fd, SIOCGLIFFLAGS, &lifr) < 0) {
 347             close(fd);
 348             free(req);
 349             error("SIOCGLIFFLAGS: %m");
 350             return 0;
 351         }
 352         fl = lifr.lifr_flags;
 353
 354         if ((fl & (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
 355                 != (IFF_UP | IFF_BROADCAST))
 356             continue;
 357
 358         found = 1;
 359         break;
 360     }
 361     free(req);
 362     close(fd);
 363
 364     if (found) {
 365         strncpy(first_ether_name, lifr.lifr_name, sizeof(first_ether_name));
 366         return (char *)first_ether_name;
 367     } else
 368         return NULL;
 369 }
 370 #else
 371 /*
 372  * get_first_ethernet - returns the first Ethernet interface name found in
 373  * the system, or NULL if none is found
 374  *
 375  * NOTE: This is the ifreq version (before Solaris 8).
 376  */
 377 char *
 378 get_first_ethernet()
 379 {
 380     struct ifconf ifc;
 381     struct ifreq *pifreq;
 382     struct ifreq ifr;
 383     int fd, num_ifs, i, found;
 384     uint_t fl, req_size;
 385     char *req;
 386
 387     fd = socket(AF_INET, SOCK_DGRAM, 0);
 388     if (fd < 0) {
 389         return 0;
 390     }
 391
 392     /*
 393      * Find out how many interfaces are running
 394      */
 395     if (ioctl(fd, SIOCGIFNUM, (char *)&num_ifs) < 0) {
 396         num_ifs = MAXIFS;
 397     }
 398
 399     req_size = num_ifs * sizeof(struct ifreq);
 400     req = malloc(req_size);
 401     if (req == NULL) {
 402         close(fd);
 403         error("out of memory");
 404         return 0;
 405     }
 406
 407     /*
 408      * Get interface configuration info for all interfaces
 409      */
 410     ifc.ifc_len = req_size;
 411     ifc.ifc_buf = req;
 412     if (ioctl(fd, SIOCGIFCONF, &ifc) < 0) {
 413         close(fd);
 414         free(req);
 415         error("SIOCGIFCONF: %m");
 416         return 0;
 417     }
 418
 419     /*
 420      * And traverse each interface to look specifically for the first
 421      * occurence of an Ethernet interface which has been marked up
 422      */
 423     pifreq = ifc.ifc_req;
 424     found = 0;
 425     for (i = ifc.ifc_len / sizeof(struct ifreq); i > 0; i--, pifreq++) {
 426
 427         if (strchr(pifreq->ifr_name, ':') != NULL)
 428             continue;
 429
 430         memset(&ifr, 0, sizeof(ifr));
 431         strncpy(ifr.ifr_name, pifreq->ifr_name, sizeof(ifr.ifr_name));
 432         if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
 433             close(fd);
 434             free(req);
 435             error("SIOCGIFFLAGS: %m");
 436             return 0;
 437         }
 438         fl = ifr.ifr_flags;
 439
 440         if ((fl & (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
 441                 != (IFF_UP | IFF_BROADCAST))
 442             continue;
 443
 444         found = 1;
 445         break;
 446     }
 447     free(req);
 448     close(fd);
 449
 450     if (found) {
 451         strncpy(first_ether_name, ifr.ifr_name, sizeof(first_ether_name));
 452         return (char *)first_ether_name;
 453     } else
 454         return NULL;
 455 }
 456 #endif /* defined(SOL2) && defined(INET6) */
 457
 458 #if defined(SOL2)
 459 /*
 460  * get_if_hwaddr - get the hardware address for the specified
 461  * network interface device.
 462  */
 463 int
 464 get_if_hwaddr(u_char *addr, char *if_name)
 465 {
 466     struct sockaddr s_eth_addr;
 467     struct ether_addr *eth_addr = (struct ether_addr *)&s_eth_addr.sa_data;
 468
 469     if (if_name == NULL)
 470         return -1;
 471
 472     /*
 473      * Send DL_INFO_REQ to the driver to solicit its MAC address
 474      */
 475     if (!get_hw_addr_dlpi(if_name, &s_eth_addr)) {
 476         error("could not obtain hardware address for %s", if_name);
 477         return -1;
 478     }
 479
 480     memcpy(addr, eth_addr->ether_addr_octet, 6);
 481     return 1;
 482 }
 483 #endif /* SOL2 */
 484
 485 #if defined(SOL2) && defined(INET6)
 486 /*
 487  * slifname - Sets interface ppa and flags
 488  *
 489  * in addition to the comments stated in sifppa(), IFF_IPV6 bit must
 490  * be set in order to declare this as an IPv6 interface
 491  */
 492 static int
 493 slifname(fd, ppa)
 494     int fd;
 495     int ppa;
 496 {
 497     struct  lifreq lifr;
 498     int     ret;
 499
 500     memset(&lifr, 0, sizeof(lifr));
 501     ret = ioctl(fd, SIOCGLIFFLAGS, &lifr);
 502     if (ret < 0)
 503         goto slifname_done;
 504
 505     lifr.lifr_flags |= IFF_IPV6;
 506     lifr.lifr_flags &= ~(IFF_BROADCAST | IFF_IPV4);
 507     lifr.lifr_ppa = ppa;
 508     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
 509
 510     ret = ioctl(fd, SIOCSLIFNAME, &lifr);
 511
 512 slifname_done:
 513     return ret;
 514
 515
 516 }
 517
 518
 519 /*
 520  * ether_to_eui64 - Convert 48-bit Ethernet address into 64-bit EUI
 521  *
 522  * walks the list of valid ethernet interfaces, and convert the first
 523  * found 48-bit MAC address into EUI 64. caller also assumes that
 524  * the system has a properly configured Ethernet interface for this
 525  * function to return non-zero.
 526  */
 527 int
 528 ether_to_eui64(eui64_t *p_eui64)
 529 {
 530     struct sockaddr s_eth_addr;
 531     struct ether_addr *eth_addr = (struct ether_addr *)&s_eth_addr.sa_data;
 532     char *if_name;
 533
 534     if ((if_name = get_first_ethernet()) == NULL) {
 535         error("no persistent id can be found");
 536         return 0;
 537     }
 538
 539     /*
 540      * Send DL_INFO_REQ to the driver to solicit its MAC address
 541      */
 542     if (!get_hw_addr_dlpi(if_name, &s_eth_addr)) {
 543         error("could not obtain hardware address for %s", if_name);
 544         return 0;
 545     }
 546
 547     /*
 548      * And convert the EUI-48 into EUI-64, per RFC 2472 [sec 4.1]
 549      */
 550     p_eui64->e8[0] = (eth_addr->ether_addr_octet[0] & 0xFF) | 0x02;
 551     p_eui64->e8[1] = (eth_addr->ether_addr_octet[1] & 0xFF);
 552     p_eui64->e8[2] = (eth_addr->ether_addr_octet[2] & 0xFF);
 553     p_eui64->e8[3] = 0xFF;
 554     p_eui64->e8[4] = 0xFE;
 555     p_eui64->e8[5] = (eth_addr->ether_addr_octet[3] & 0xFF);
 556     p_eui64->e8[6] = (eth_addr->ether_addr_octet[4] & 0xFF);
 557     p_eui64->e8[7] = (eth_addr->ether_addr_octet[5] & 0xFF);
 558
 559     return 1;
 560 }
 561 #endif /* defined(SOL2) && defined(INET6) */
 562
 563 /*
 564  * sys_init - System-dependent initialization.
 565  */
 566 void
 567 sys_init()
 568 {
 569     int ifd, x;
 570     struct ifreq ifr;
 571 #if defined(INET6) && defined(SOL2)
 572     int i6fd;
 573     struct lifreq lifr;
 574 #endif /* defined(INET6) && defined(SOL2) */
 575 #if !defined(SOL2)
 576     struct {
 577         union DL_primitives prim;
 578         char space[64];
 579     } reply;
 580 #endif /* !defined(SOL2) */
 581
 582     ipfd = open(mux_dev_name, O_RDWR, 0);
 583     if (ipfd < 0)
 584         fatal("Couldn't open IP device: %m");
 585
 586 #if defined(INET6) && defined(SOL2)
 587     ip6fd = open(UDP6_DEV_NAME, O_RDWR, 0);
 588     if (ip6fd < 0)
 589         fatal("Couldn't open IP device (2): %m");
 590 #endif /* defined(INET6) && defined(SOL2) */
 591
 592     if (default_device && !notty)
 593         tty_sid = getsid((pid_t)0);
 594
 595     pppfd = open(PPP_DEV_NAME, O_RDWR | O_NONBLOCK, 0);
 596     if (pppfd < 0)
 597         fatal("Can't open %s: %m", PPP_DEV_NAME);
 598     if (kdebugflag & 1) {
 599         x = PPPDBG_LOG + PPPDBG_DRIVER;
 600         strioctl(pppfd, PPPIO_DEBUG, &x, sizeof(int), 0);
 601     }
 602
 603     /* Assign a new PPA and get its unit number. */
 604     if (strioctl(pppfd, PPPIO_NEWPPA, &ifunit, 0, sizeof(int)) < 0)
 605         fatal("Can't create new PPP interface: %m");
 606
 607 #if defined(SOL2)
 608     /*
 609      * Since sys_init() is called prior to ifname being set in main(),
 610      * we need to get the ifname now, otherwise slifname(), and others,
 611      * will fail, or maybe, I should move them to a later point ?
 612      * <adi.masputra@sun.com>
 613      */
 614     sprintf(ifname, "ppp%d", ifunit);
 615 #endif /* defined(SOL2) */
 616     /*
 617      * Open the ppp device again and link it under the ip multiplexor.
 618      * IP will assign a unit number which hopefully is the same as ifunit.
 619      * I don't know any way to be certain they will be the same. :-(
 620      */
 621     ifd = open(PPP_DEV_NAME, O_RDWR, 0);
 622     if (ifd < 0)
 623         fatal("Can't open %s (2): %m", PPP_DEV_NAME);
 624     if (kdebugflag & 1) {
 625         x = PPPDBG_LOG + PPPDBG_DRIVER;
 626         strioctl(ifd, PPPIO_DEBUG, &x, sizeof(int), 0);
 627     }
 628
 629 #if defined(INET6) && defined(SOL2)
 630     i6fd = open(PPP_DEV_NAME, O_RDWR, 0);
 631     if (i6fd < 0) {
 632         close(ifd);
 633         fatal("Can't open %s (3): %m", PPP_DEV_NAME);
 634     }
 635     if (kdebugflag & 1) {
 636         x = PPPDBG_LOG + PPPDBG_DRIVER;
 637         strioctl(i6fd, PPPIO_DEBUG, &x, sizeof(int), 0);
 638     }
 639 #endif /* defined(INET6) && defined(SOL2) */
 640
 641 #if defined(SOL2)
 642     if (ioctl(ifd, I_PUSH, IP_MOD_NAME) < 0) {
 643         close(ifd);
 644 #if defined(INET6)
 645         close(i6fd);
 646 #endif /* defined(INET6) */
 647         fatal("Can't push IP module: %m");
 648     }
 649
 650     /*
 651      * Assign ppa according to the unit number returned by ppp device
 652      * after plumbing is completed above.
 653      */
 654     if (sifppa(ifd, ifunit) < 0) {
 655         close (ifd);
 656 #if defined(INET6)
 657         close(i6fd);
 658 #endif /* defined(INET6) */
 659         fatal("Can't set ppa for unit %d: %m", ifunit);
 660     }
 661
 662 #if defined(INET6)
 663     /*
 664      * An IPv6 interface is created anyway, even when the user does not
 665      * explicitly enable it. Note that the interface will be marked
 666      * IPv6 during slifname().
 667      */
 668     if (ioctl(i6fd, I_PUSH, IP_MOD_NAME) < 0) {
 669         close(ifd);
 670         close(i6fd);
 671         fatal("Can't push IP module (2): %m");
 672     }
 673
 674     /*
 675      * Assign ppa according to the unit number returned by ppp device
 676      * after plumbing is completed above. In addition, mark the interface
 677      * as an IPv6 interface.
 678      */
 679     if (slifname(i6fd, ifunit) < 0) {
 680         close(ifd);
 681         close(i6fd);
 682         fatal("Can't set ifname for unit %d: %m", ifunit);
 683     }
 684 #endif /* defined(INET6) */
 685
 686     ipmuxid = ioctl(ipfd, I_PLINK, ifd);
 687     close(ifd);
 688     if (ipmuxid < 0) {
 689 #if defined(INET6)
 690         close(i6fd);
 691 #endif /* defined(INET6) */
 692         fatal("Can't I_PLINK PPP device to IP: %m");
 693     }
 694
 695     memset(&ifr, 0, sizeof(ifr));
 696     sprintf(ifr.ifr_name, "%s", ifname);
 697     ifr.ifr_ip_muxid = ipmuxid;
 698
 699     /*
 700      * In Sol 8 and later, STREAMS dynamic module plumbing feature exists.
 701      * This is so that an arbitrary module can be inserted, or deleted,
 702      * between ip module and the device driver without tearing down the
 703      * existing stream. Such feature requires the mux ids, which is set
 704      * by SIOCSIFMUXID (or SIOCLSIFMUXID).
 705      */
 706     if (ioctl(ipfd, SIOCSIFMUXID, &ifr) < 0) {
 707         ioctl(ipfd, I_PUNLINK, ipmuxid);
 708 #if defined(INET6)
 709         close(i6fd);
 710 #endif /* defined(INET6) */
 711         fatal("SIOCSIFMUXID: %m");
 712     }
 713
 714 #else /* else if !defined(SOL2) */
 715
 716     if (dlpi_attach(ifd, ifunit) < 0 ||
 717         dlpi_get_reply(ifd, &reply.prim, DL_OK_ACK, sizeof(reply)) < 0) {
 718         close(ifd);
 719         fatal("Can't attach to ppp%d: %m", ifunit);
 720     }
 721
 722     ipmuxid = ioctl(ipfd, I_LINK, ifd);
 723     close(ifd);
 724     if (ipmuxid < 0)
 725         fatal("Can't link PPP device to IP: %m");
 726 #endif /* defined(SOL2) */
 727
 728 #if defined(INET6) && defined(SOL2)
 729     ip6muxid = ioctl(ip6fd, I_PLINK, i6fd);
 730     close(i6fd);
 731     if (ip6muxid < 0) {
 732         ioctl(ipfd, I_PUNLINK, ipmuxid);
 733         fatal("Can't I_PLINK PPP device to IP (2): %m");
 734     }
 735
 736     memset(&lifr, 0, sizeof(lifr));
 737     sprintf(lifr.lifr_name, "%s", ifname);
 738     lifr.lifr_ip_muxid = ip6muxid;
 739
 740     /*
 741      * Let IP know of the mux id [see comment for SIOCSIFMUXID above]
 742      */
 743     if (ioctl(ip6fd, SIOCSLIFMUXID, &lifr) < 0) {
 744         ioctl(ipfd, I_PUNLINK, ipmuxid);
 745         ioctl(ip6fd, I_PUNLINK, ip6muxid);
 746         fatal("Can't link PPP device to IP (2): %m");
 747     }
 748 #endif /* defined(INET6) && defined(SOL2) */
 749
 750 #if !defined(SOL2)
 751     /* Set the interface name for the link. */
 752     slprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "ppp%d", ifunit);
 753     ifr.ifr_metric = ipmuxid;
 754     if (strioctl(ipfd, SIOCSIFNAME, (char *)&ifr, sizeof ifr, 0) < 0)
 755         fatal("Can't set interface name %s: %m", ifr.ifr_name);
 756 #endif /* !defined(SOL2) */
 757
 758     n_pollfds = 0;
 759 }
 760
 761 /*
 762  * sys_cleanup - restore any system state we modified before exiting:
 763  * mark the interface down, delete default route and/or proxy arp entry.
 764  * This should call die() because it's called from die().
 765  */
 766 void
 767 sys_cleanup()
 768 {
 769 #if defined(SOL2)
 770     struct ifreq ifr;
 771 #if defined(INET6)
 772     struct lifreq lifr;
 773 #endif /* defined(INET6) */
 774 #endif /* defined(SOL2) */
 775
 776 #if defined(SOL2) && defined(INET6)
 777     if (if6_is_up)
 778         sif6down(0);
 779 #endif /* defined(SOL2) && defined(INET6) */
 780     if (if_is_up)
 781         sifdown(0);
 782     if (default_route_gateway)
 783         cifdefaultroute(0, default_route_gateway, default_route_gateway);
 784     if (proxy_arp_addr)
 785         cifproxyarp(0, proxy_arp_addr);
 786 #if defined(SOL2)
 787     /*
 788      * Make sure we ask ip what the muxid, because 'ifconfig modlist' will
 789      * unlink and re-link the modules, causing the muxid to change.
 790      */
 791     memset(&ifr, 0, sizeof(ifr));
 792     sprintf(ifr.ifr_name, "%s", ifname);
 793     if (ioctl(ipfd, SIOCGIFFLAGS, &ifr) < 0) {
 794         error("SIOCGIFFLAGS: %m");
 795         return;
 796     }
 797
 798     if (ioctl(ipfd, SIOCGIFMUXID, &ifr) < 0) {
 799         error("SIOCGIFMUXID: %m");
 800         return;
 801     }
 802
 803     ipmuxid = ifr.ifr_ip_muxid;
 804
 805     if (ioctl(ipfd, I_PUNLINK, ipmuxid) < 0) {
 806         error("Can't I_PUNLINK PPP from IP: %m");
 807         return;
 808     }
 809 #if defined(INET6)
 810     /*
 811      * Make sure we ask ip what the muxid, because 'ifconfig modlist' will
 812      * unlink and re-link the modules, causing the muxid to change.
 813      */
 814     memset(&lifr, 0, sizeof(lifr));
 815     sprintf(lifr.lifr_name, "%s", ifname);
 816     if (ioctl(ip6fd, SIOCGLIFFLAGS, &lifr) < 0) {
 817         error("SIOCGLIFFLAGS: %m");
 818         return;
 819     }
 820
 821     if (ioctl(ip6fd, SIOCGLIFMUXID, &lifr) < 0) {
 822         error("SIOCGLIFMUXID: %m");
 823         return;
 824     }
 825
 826     ip6muxid = lifr.lifr_ip_muxid;
 827
 828     if (ioctl(ip6fd, I_PUNLINK, ip6muxid) < 0) {
 829         error("Can't I_PUNLINK PPP from IP (2): %m");
 830     }
 831 #endif /* defined(INET6) */
 832 #endif /* defined(SOL2) */
 833 }
 834
 835 /*
 836  * sys_close - Clean up in a child process before execing.
 837  */
 838 void
 839 sys_close()
 840 {
 841     close(ipfd);
 842 #if defined(INET6) && defined(SOL2)
 843     close(ip6fd);
 844 #endif /* defined(INET6) && defined(SOL2) */
 845     if (pppfd >= 0)
 846         close(pppfd);
 847 }
 848
 849 /*
 850  * sys_check_options - check the options that the user specified
 851  */
 852 int
 853 sys_check_options()
 854 {
 855     return 1;
 856 }
 857
 858 #if 0
 859 /*
 860  * daemon - Detach us from controlling terminal session.
 861  */
 862 int
 863 daemon(nochdir, noclose)
 864     int nochdir, noclose;
 865 {
 866     int pid;
 867
 868     if ((pid = fork()) < 0)
 869         return -1;
 870     if (pid != 0)
 871         exit(0);                /* parent dies */
 872     setsid();
 873     if (!nochdir)
 874         chdir("/");
 875     if (!noclose) {
 876         fclose(stdin);          /* don't need stdin, stdout, stderr */
 877         fclose(stdout);
 878         fclose(stderr);
 879     }
 880     return 0;
 881 }
 882 #endif
 883
 884 /*
 885  * ppp_available - check whether the system has any ppp interfaces
 886  */
 887 int
 888 ppp_available()
 889 {
 890     struct stat buf;
 891
 892     return stat(PPP_DEV_NAME, &buf) >= 0;
 893 }
 894
 895 /*
 896  * any_compressions - see if compression is enabled or not
 897  *
 898  * In the STREAMS implementation of kernel-portion pppd,
 899  * the comp STREAMS module performs the ACFC, PFC, as well
 900  * CCP and VJ compressions. However, if the user has explicitly
 901  * declare to not enable them from the command line, there is
 902  * no point of having the comp module be pushed on the stream.
 903  */
 904 static int
 905 any_compressions()
 906 {
 907     if ((!lcp_wantoptions[0].neg_accompression) &&
 908         (!lcp_wantoptions[0].neg_pcompression) &&
 909         (!ccp_protent.enabled_flag) &&
 910         (!ipcp_wantoptions[0].neg_vj)) {
 911             return 0;
 912     }
 913     return 1;
 914 }
 915
 916 /*
 917  * establish_ppp - Turn the serial port into a ppp interface.
 918  */
 919 int
 920 establish_ppp(fd)
 921     int fd;
 922 {
 923     int i;
 924
 925     /* Pop any existing modules off the tty stream. */
 926     for (i = 0;; ++i)
 927         if (ioctl(fd, I_LOOK, tty_modules[i]) < 0
 928             || strcmp(tty_modules[i], "ptem") == 0
 929             || ioctl(fd, I_POP, 0) < 0)
 930             break;
 931     tty_nmodules = i;
 932
 933     /* Push the async hdlc module and the compressor module. */
 934     tty_npushed = 0;
 935
 936     if(!sync_serial) {
 937         if (ioctl(fd, I_PUSH, AHDLC_MOD_NAME) < 0) {
 938             error("Couldn't push PPP Async HDLC module: %m");
 939             return -1;
 940         }
 941         ++tty_npushed;
 942     }
 943     if (kdebugflag & 4) {
 944         i = PPPDBG_LOG + PPPDBG_AHDLC;
 945         strioctl(pppfd, PPPIO_DEBUG, &i, sizeof(int), 0);
 946     }
 947     /*
 948      * There's no need to push comp module if we don't intend
 949      * to compress anything
 950      */
 951     if (any_compressions()) {
 952         if (ioctl(fd, I_PUSH, COMP_MOD_NAME) < 0)
 953             error("Couldn't push PPP compression module: %m");
 954         else
 955             ++tty_npushed;
 956     }
 957
 958     if (kdebugflag & 2) {
 959         i = PPPDBG_LOG;
 960         if (any_compressions())
 961             i += PPPDBG_COMP;
 962         strioctl(pppfd, PPPIO_DEBUG, &i, sizeof(int), 0);
 963     }
 964
 965     /* Link the serial port under the PPP multiplexor. */
 966     if ((fdmuxid = ioctl(pppfd, I_LINK, fd)) < 0) {
 967         error("Can't link tty to PPP mux: %m");
 968         return -1;
 969     }
 970
 971     return pppfd;
 972 }
 973
 974 /*
 975  * restore_loop - reattach the ppp unit to the loopback.
 976  * This doesn't need to do anything because disestablish_ppp does it.
 977  */
 978 void
 979 restore_loop()
 980 {
 981 }
 982
 983 /*
 984  * disestablish_ppp - Restore the serial port to normal operation.
 985  * It attempts to reconstruct the stream with the previously popped
 986  * modules.  This shouldn't call die() because it's called from die().
 987  */
 988 void
 989 disestablish_ppp(fd)
 990     int fd;
 991 {
 992     int i;
 993
 994     if (fdmuxid >= 0) {
 995         if (ioctl(pppfd, I_UNLINK, fdmuxid) < 0) {
 996             if (!hungup)
 997                 error("Can't unlink tty from PPP mux: %m");
 998         }
 999         fdmuxid = -1;
1000
1001         if (!hungup) {
1002             while (tty_npushed > 0 && ioctl(fd, I_POP, 0) >= 0)
1003                 --tty_npushed;
1004             for (i = tty_nmodules - 1; i >= 0; --i)
1005                 if (ioctl(fd, I_PUSH, tty_modules[i]) < 0)
1006                     error("Couldn't restore tty module %s: %m",
1007                            tty_modules[i]);
1008         }
1009         if (hungup && default_device && tty_sid > 0) {
1010             /*
1011              * If we have received a hangup, we need to send a SIGHUP
1012              * to the terminal's controlling process.  The reason is
1013              * that the original stream head for the terminal hasn't
1014              * seen the M_HANGUP message (it went up through the ppp
1015              * driver to the stream head for our fd to /dev/ppp).
1016              */
1017             kill(tty_sid, SIGHUP);
1018         }
1019     }
1020 }
1021
1022 /*
1023  * Check whether the link seems not to be 8-bit clean.
1024  */
1025 void
1026 clean_check()
1027 {
1028     int x;
1029     char *s;
1030
1031     if (strioctl(pppfd, PPPIO_GCLEAN, &x, 0, sizeof(x)) < 0)
1032         return;
1033     s = NULL;
1034     switch (~x) {
1035     case RCV_B7_0:
1036         s = "bit 7 set to 1";
1037         break;
1038     case RCV_B7_1:
1039         s = "bit 7 set to 0";
1040         break;
1041     case RCV_EVNP:
1042         s = "odd parity";
1043         break;
1044     case RCV_ODDP:
1045         s = "even parity";
1046         break;
1047     }
1048     if (s != NULL) {
1049         warn("Serial link is not 8-bit clean:");
1050         warn("All received characters had %s", s);
1051     }
1052 }
1053
1054 /*
1055  * List of valid speeds.
1056  */
1057 struct speed {
1058     int speed_int, speed_val;
1059 } speeds[] = {
1060 #ifdef B50
1061     { 50, B50 },
1062 #endif
1063 #ifdef B75
1064     { 75, B75 },
1065 #endif
1066 #ifdef B110
1067     { 110, B110 },
1068 #endif
1069 #ifdef B134
1070     { 134, B134 },
1071 #endif
1072 #ifdef B150
1073     { 150, B150 },
1074 #endif
1075 #ifdef B200
1076     { 200, B200 },
1077 #endif
1078 #ifdef B300
1079     { 300, B300 },
1080 #endif
1081 #ifdef B600
1082     { 600, B600 },
1083 #endif
1084 #ifdef B1200
1085     { 1200, B1200 },
1086 #endif
1087 #ifdef B1800
1088     { 1800, B1800 },
1089 #endif
1090 #ifdef B2000
1091     { 2000, B2000 },
1092 #endif
1093 #ifdef B2400
1094     { 2400, B2400 },
1095 #endif
1096 #ifdef B3600
1097     { 3600, B3600 },
1098 #endif
1099 #ifdef B4800
1100     { 4800, B4800 },
1101 #endif
1102 #ifdef B7200
1103     { 7200, B7200 },
1104 #endif
1105 #ifdef B9600
1106     { 9600, B9600 },
1107 #endif
1108 #ifdef B19200
1109     { 19200, B19200 },
1110 #endif
1111 #ifdef B38400
1112     { 38400, B38400 },
1113 #endif
1114 #ifdef EXTA
1115     { 19200, EXTA },
1116 #endif
1117 #ifdef EXTB
1118     { 38400, EXTB },
1119 #endif
1120 #ifdef B57600
1121     { 57600, B57600 },
1122 #endif
1123 #ifdef B76800
1124     { 76800, B76800 },
1125 #endif
1126 #ifdef B115200
1127     { 115200, B115200 },
1128 #endif
1129 #ifdef B153600
1130     { 153600, B153600 },
1131 #endif
1132 #ifdef B230400
1133     { 230400, B230400 },
1134 #endif
1135 #ifdef B307200
1136     { 307200, B307200 },
1137 #endif
1138 #ifdef B460800
1139     { 460800, B460800 },
1140 #endif
1141     { 0, 0 }
1142 };
1143
1144 /*
1145  * Translate from bits/second to a speed_t.
1146  */
1147 static int
1148 translate_speed(bps)
1149     int bps;
1150 {
1151     struct speed *speedp;
1152
1153     if (bps == 0)
1154         return 0;
1155     for (speedp = speeds; speedp->speed_int; speedp++)
1156         if (bps == speedp->speed_int)
1157             return speedp->speed_val;
1158     warn("speed %d not supported", bps);
1159     return 0;
1160 }
1161
1162 /*
1163  * Translate from a speed_t to bits/second.
1164  */
1165 static int
1166 baud_rate_of(speed)
1167     int speed;
1168 {
1169     struct speed *speedp;
1170
1171     if (speed == 0)
1172         return 0;
1173     for (speedp = speeds; speedp->speed_int; speedp++)
1174         if (speed == speedp->speed_val)
1175             return speedp->speed_int;
1176     return 0;
1177 }
1178
1179 /*
1180  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
1181  * at the requested speed, etc.  If `local' is true, set CLOCAL
1182  * regardless of whether the modem option was specified.
1183  */
1184 void
1185 set_up_tty(fd, local)
1186     int fd, local;
1187 {
1188     int speed;
1189     struct termios tios;
1190 #if !defined (CRTSCTS)
1191     struct termiox tiox;
1192 #endif
1193
1194     if (!sync_serial && tcgetattr(fd, &tios) < 0)
1195         fatal("tcgetattr: %m");
1196
1197 #ifndef CRTSCTS
1198     termiox_ok = 1;
1199     if (!sync_serial && ioctl (fd, TCGETX, &tiox) < 0) {
1200         termiox_ok = 0;
1201         if (errno != ENOTTY)
1202             error("TCGETX: %m");
1203     }
1204 #endif
1205
1206     if (!restore_term) {
1207         inittermios = tios;
1208 #ifndef CRTSCTS
1209         inittermiox = tiox;
1210 #endif
1211         if (!sync_serial)
1212             ioctl(fd, TIOCGWINSZ, &wsinfo);
1213     }
1214
1215     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
1216 #ifdef CRTSCTS
1217     if (crtscts > 0)
1218         tios.c_cflag |= CRTSCTS;
1219     else if (crtscts < 0)
1220         tios.c_cflag &= ~CRTSCTS;
1221 #else
1222     if (crtscts != 0 && !termiox_ok) {
1223         error("Can't set RTS/CTS flow control");
1224     } else if (crtscts > 0) {
1225         tiox.x_hflag |= RTSXOFF|CTSXON;
1226     } else if (crtscts < 0) {
1227         tiox.x_hflag &= ~(RTSXOFF|CTSXON);
1228     }
1229 #endif
1230
1231     tios.c_cflag |= CS8 | CREAD | HUPCL;
1232     if (local || !modem)
1233         tios.c_cflag |= CLOCAL;
1234     tios.c_iflag = IGNBRK | IGNPAR;
1235     tios.c_oflag = 0;
1236     tios.c_lflag = 0;
1237     tios.c_cc[VMIN] = 1;
1238     tios.c_cc[VTIME] = 0;
1239
1240     if (crtscts == -2) {
1241         tios.c_iflag |= IXON | IXOFF;
1242         tios.c_cc[VSTOP] = 0x13;        /* DC3 = XOFF = ^S */
1243         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
1244     }
1245
1246     speed = translate_speed(inspeed);
1247     if (speed) {
1248         cfsetospeed(&tios, speed);
1249         cfsetispeed(&tios, speed);
1250     } else {
1251         speed = cfgetospeed(&tios);
1252         /*
1253          * We can't proceed if the serial port speed is 0,
1254          * since that implies that the serial port is disabled.
1255          */
1256         if ((speed == B0) && !sync_serial)
1257             fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
1258     }
1259
1260     if (!sync_serial && tcsetattr(fd, TCSAFLUSH, &tios) < 0)
1261         fatal("tcsetattr: %m");
1262
1263 #ifndef CRTSCTS
1264     if (!sync_serial && termiox_ok && ioctl (fd, TCSETXF, &tiox) < 0){
1265         error("TCSETXF: %m");
1266     }
1267 #endif
1268
1269     baud_rate = inspeed = baud_rate_of(speed);
1270     if (!sync_serial)
1271         restore_term = 1;
1272 }
1273
1274 /*
1275  * restore_tty - restore the terminal to the saved settings.
1276  */
1277 void
1278 restore_tty(fd)
1279     int fd;
1280 {
1281     if (restore_term) {
1282         if (!default_device) {
1283             /*
1284              * Turn off echoing, because otherwise we can get into
1285              * a loop with the tty and the modem echoing to each other.
1286              * We presume we are the sole user of this tty device, so
1287              * when we close it, it will revert to its defaults anyway.
1288              */
1289             inittermios.c_lflag &= ~(ECHO | ECHONL);
1290         }
1291         if (!sync_serial && tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
1292             if (!hungup && errno != ENXIO)
1293                 warn("tcsetattr: %m");
1294 #ifndef CRTSCTS
1295         if (!sync_serial && ioctl (fd, TCSETXF, &inittermiox) < 0){
1296             if (!hungup && errno != ENXIO)
1297                 error("TCSETXF: %m");
1298         }
1299 #endif
1300         if (!sync_serial)
1301             ioctl(fd, TIOCSWINSZ, &wsinfo);
1302         restore_term = 0;
1303     }
1304 }
1305
1306 /*
1307  * setdtr - control the DTR line on the serial port.
1308  * This is called from die(), so it shouldn't call die().
1309  */
1310 void
1311 setdtr(fd, on)
1312 int fd, on;
1313 {
1314     int modembits = TIOCM_DTR;
1315
1316     ioctl(fd, (on? TIOCMBIS: TIOCMBIC), &modembits);
1317 }
1318
1319 /*
1320  * open_loopback - open the device we use for getting packets
1321  * in demand mode.  Under Solaris 2, we use our existing fd
1322  * to the ppp driver.
1323  */
1324 int
1325 open_ppp_loopback()
1326 {
1327     return pppfd;
1328 }
1329
1330 /*
1331  * output - Output PPP packet.
1332  */
1333 void
1334 output(unit, p, len)
1335     int unit;
1336     u_char *p;
1337     int len;
1338 {
1339     struct strbuf data;
1340     int retries;
1341     struct pollfd pfd;
1342
1343     dump_packet("sent", p, len);
1344     if (snoop_send_hook) snoop_send_hook(p, len);
1345
1346     data.len = len;
1347     data.buf = (caddr_t) p;
1348     retries = 4;
1349     while (putmsg(pppfd, NULL, &data, 0) < 0) {
1350         if (--retries < 0 || (errno != EWOULDBLOCK && errno != EAGAIN)) {
1351             if (errno != ENXIO)
1352                 error("Couldn't send packet: %m");
1353             break;
1354         }
1355         pfd.fd = pppfd;
1356         pfd.events = POLLOUT;
1357         poll(&pfd, 1, 250);     /* wait for up to 0.25 seconds */
1358     }
1359 }
1360
1361
1362 /*
1363  * wait_input - wait until there is data available,
1364  * for the length of time specified by *timo (indefinite
1365  * if timo is NULL).
1366  */
1367 void
1368 wait_input(timo)
1369     struct timeval *timo;
1370 {
1371     int t;
1372
1373     t = timo == NULL? -1: timo->tv_sec * 1000 + timo->tv_usec / 1000;
1374     if (poll(pollfds, n_pollfds, t) < 0 && errno != EINTR)
1375         fatal("poll: %m");
1376 }
1377
1378 /*
1379  * add_fd - add an fd to the set that wait_input waits for.
1380  */
1381 void add_fd(fd)
1382     int fd;
1383 {
1384     int n;
1385
1386     for (n = 0; n < n_pollfds; ++n)
1387         if (pollfds[n].fd == fd)
1388             return;
1389     if (n_pollfds < MAX_POLLFDS) {
1390         pollfds[n_pollfds].fd = fd;
1391         pollfds[n_pollfds].events = POLLIN | POLLPRI | POLLHUP;
1392         ++n_pollfds;
1393     } else
1394         error("Too many inputs!");
1395 }
1396
1397 /*
1398  * remove_fd - remove an fd from the set that wait_input waits for.
1399  */
1400 void remove_fd(fd)
1401     int fd;
1402 {
1403     int n;
1404
1405     for (n = 0; n < n_pollfds; ++n) {
1406         if (pollfds[n].fd == fd) {
1407             while (++n < n_pollfds)
1408                 pollfds[n-1] = pollfds[n];
1409             --n_pollfds;
1410             break;
1411         }
1412     }
1413 }
1414
1415 #if 0
1416 /*
1417  * wait_loop_output - wait until there is data available on the
1418  * loopback, for the length of time specified by *timo (indefinite
1419  * if timo is NULL).
1420  */
1421 void
1422 wait_loop_output(timo)
1423     struct timeval *timo;
1424 {
1425     wait_input(timo);
1426 }
1427
1428 /*
1429  * wait_time - wait for a given length of time or until a
1430  * signal is received.
1431  */
1432 void
1433 wait_time(timo)
1434     struct timeval *timo;
1435 {
1436     int n;
1437
1438     n = select(0, NULL, NULL, NULL, timo);
1439     if (n < 0 && errno != EINTR)
1440         fatal("select: %m");
1441 }
1442 #endif
1443
1444
1445 /*
1446  * read_packet - get a PPP packet from the serial device.
1447  */
1448 int
1449 read_packet(buf)
1450     u_char *buf;
1451 {
1452     struct strbuf ctrl, data;
1453     int flags, len;
1454     unsigned char ctrlbuf[sizeof(union DL_primitives) + 64];
1455
1456     for (;;) {
1457         data.maxlen = PPP_MRU + PPP_HDRLEN;
1458         data.buf = (caddr_t) buf;
1459         ctrl.maxlen = sizeof(ctrlbuf);
1460         ctrl.buf = (caddr_t) ctrlbuf;
1461         flags = 0;
1462         len = getmsg(pppfd, &ctrl, &data, &flags);
1463         if (len < 0) {
1464             if (errno == EAGAIN || errno == EINTR)
1465                 return -1;
1466             fatal("Error reading packet: %m");
1467         }
1468
1469         if (ctrl.len <= 0)
1470             return data.len;
1471
1472         /*
1473          * Got a M_PROTO or M_PCPROTO message.  Interpret it
1474          * as a DLPI primitive??
1475          */
1476         if (debug)
1477             dbglog("got dlpi prim 0x%x, len=%d",
1478                    ((union DL_primitives *)ctrlbuf)->dl_primitive, ctrl.len);
1479
1480     }
1481 }
1482
1483 /*
1484  * get_loop_output - get outgoing packets from the ppp device,
1485  * and detect when we want to bring the real link up.
1486  * Return value is 1 if we need to bring up the link, 0 otherwise.
1487  */
1488 int
1489 get_loop_output()
1490 {
1491     int len;
1492     int rv = 0;
1493
1494     while ((len = read_packet(inpacket_buf)) > 0) {
1495         if (loop_frame(inpacket_buf, len))
1496             rv = 1;
1497     }
1498     return rv;
1499 }
1500
1501 /*
1502  * ppp_send_config - configure the transmit characteristics of
1503  * the ppp interface.
1504  */
1505 void
1506 ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
1507     int unit, mtu;
1508     u_int32_t asyncmap;
1509     int pcomp, accomp;
1510 {
1511     int cf[2];
1512     struct ifreq ifr;
1513 #if defined(INET6) && defined(SOL2)
1514     struct lifreq lifr;
1515     int fd;
1516 #endif /* defined(INET6) && defined(SOL2) */
1517
1518     link_mtu = mtu;
1519     if (strioctl(pppfd, PPPIO_MTU, &mtu, sizeof(mtu), 0) < 0) {
1520         if (hungup && errno == ENXIO)
1521             return;
1522         error("Couldn't set MTU: %m");
1523     }
1524     if (fdmuxid >= 0) {
1525         if (!sync_serial) {
1526             if (strioctl(pppfd, PPPIO_XACCM, &asyncmap, sizeof(asyncmap), 0) < 0) {
1527                 error("Couldn't set transmit ACCM: %m");
1528             }
1529         }
1530         cf[0] = (pcomp? COMP_PROT: 0) + (accomp? COMP_AC: 0);
1531         cf[1] = COMP_PROT | COMP_AC;
1532         if (any_compressions() &&
1533             strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
1534             error("Couldn't set prot/AC compression: %m");
1535         }
1536     }
1537
1538     /* set the MTU for IP as well */
1539     memset(&ifr, 0, sizeof(ifr));
1540     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
1541     ifr.ifr_metric = link_mtu;
1542     if (ioctl(ipfd, SIOCSIFMTU, &ifr) < 0) {
1543         error("Couldn't set IP MTU: %m");
1544     }
1545
1546 #if defined(INET6) && defined(SOL2)
1547     fd = socket(AF_INET6, SOCK_DGRAM, 0);
1548     if (fd < 0)
1549         error("Couldn't open IPv6 socket: %m");
1550
1551     memset(&lifr, 0, sizeof(lifr));
1552     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
1553     lifr.lifr_mtu = link_mtu;
1554     if (ioctl(fd, SIOCSLIFMTU, &lifr) < 0) {
1555         close(fd);
1556         error("Couldn't set IPv6 MTU: %m");
1557     }
1558     close(fd);
1559 #endif /* defined(INET6) && defined(SOL2) */
1560 }
1561
1562 /*
1563  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1564  */
1565 void
1566 ppp_set_xaccm(unit, accm)
1567     int unit;
1568     ext_accm accm;
1569 {
1570     if (sync_serial)
1571         return;
1572
1573     if (fdmuxid >= 0
1574         && strioctl(pppfd, PPPIO_XACCM, accm, sizeof(ext_accm), 0) < 0) {
1575         if (!hungup || errno != ENXIO)
1576             warn("Couldn't set extended ACCM: %m");
1577     }
1578 }
1579
1580 /*
1581  * ppp_recv_config - configure the receive-side characteristics of
1582  * the ppp interface.
1583  */
1584 void
1585 ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
1586     int unit, mru;
1587     u_int32_t asyncmap;
1588     int pcomp, accomp;
1589 {
1590     int cf[2];
1591
1592     link_mru = mru;
1593     if (strioctl(pppfd, PPPIO_MRU, &mru, sizeof(mru), 0) < 0) {
1594         if (hungup && errno == ENXIO)
1595             return;
1596         error("Couldn't set MRU: %m");
1597     }
1598     if (fdmuxid >= 0) {
1599         if (!sync_serial) {
1600             if (strioctl(pppfd, PPPIO_RACCM, &asyncmap, sizeof(asyncmap), 0) < 0) {
1601                 error("Couldn't set receive ACCM: %m");
1602             }
1603         }
1604         cf[0] = (pcomp? DECOMP_PROT: 0) + (accomp? DECOMP_AC: 0);
1605         cf[1] = DECOMP_PROT | DECOMP_AC;
1606         if (any_compressions() &&
1607             strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
1608             error("Couldn't set prot/AC decompression: %m");
1609         }
1610     }
1611 }
1612
1613 /*
1614  * ccp_test - ask kernel whether a given compression method
1615  * is acceptable for use.
1616  */
1617 int
1618 ccp_test(unit, opt_ptr, opt_len, for_transmit)
1619     int unit, opt_len, for_transmit;
1620     u_char *opt_ptr;
1621 {
1622     if (strioctl(pppfd, (for_transmit? PPPIO_XCOMP: PPPIO_RCOMP),
1623                  opt_ptr, opt_len, 0) >= 0)
1624         return 1;
1625     return (errno == ENOSR)? 0: -1;
1626 }
1627
1628 /*
1629  * ccp_flags_set - inform kernel about the current state of CCP.
1630  */
1631 void
1632 ccp_flags_set(unit, isopen, isup)
1633     int unit, isopen, isup;
1634 {
1635     int cf[2];
1636
1637     cf[0] = (isopen? CCP_ISOPEN: 0) + (isup? CCP_ISUP: 0);
1638     cf[1] = CCP_ISOPEN | CCP_ISUP | CCP_ERROR | CCP_FATALERROR;
1639     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
1640         if (!hungup || errno != ENXIO)
1641             error("Couldn't set kernel CCP state: %m");
1642     }
1643 }
1644
1645 /*
1646  * get_idle_time - return how long the link has been idle.
1647  */
1648 int
1649 get_idle_time(u, ip)
1650     int u;
1651     struct ppp_idle *ip;
1652 {
1653     return strioctl(pppfd, PPPIO_GIDLE, ip, 0, sizeof(struct ppp_idle)) >= 0;
1654 }
1655
1656 /*
1657  * get_ppp_stats - return statistics for the link.
1658  */
1659 int
1660 get_ppp_stats(u, stats)
1661     int u;
1662     struct pppd_stats *stats;
1663 {
1664     struct ppp_stats s;
1665
1666     if (!sync_serial &&
1667         strioctl(pppfd, PPPIO_GETSTAT, &s, 0, sizeof(s)) < 0) {
1668         error("Couldn't get link statistics: %m");
1669         return 0;
1670     }
1671     stats->bytes_in = s.p.ppp_ibytes;
1672     stats->bytes_out = s.p.ppp_obytes;
1673     return 1;
1674 }
1675
1676 #if 0
1677 /*
1678  * set_filters - transfer the pass and active filters to the kernel.
1679  */
1680 int
1681 set_filters(pass, active)
1682     struct bpf_program *pass, *active;
1683 {
1684     int ret = 1;
1685
1686     if (pass->bf_len > 0) {
1687         if (strioctl(pppfd, PPPIO_PASSFILT, pass,
1688                      sizeof(struct bpf_program), 0) < 0) {
1689             error("Couldn't set pass-filter in kernel: %m");
1690             ret = 0;
1691         }
1692     }
1693     if (active->bf_len > 0) {
1694         if (strioctl(pppfd, PPPIO_ACTIVEFILT, active,
1695                      sizeof(struct bpf_program), 0) < 0) {
1696             error("Couldn't set active-filter in kernel: %m");
1697             ret = 0;
1698         }
1699     }
1700     return ret;
1701 }
1702 #endif
1703
1704 /*
1705  * ccp_fatal_error - returns 1 if decompression was disabled as a
1706  * result of an error detected after decompression of a packet,
1707  * 0 otherwise.  This is necessary because of patent nonsense.
1708  */
1709 int
1710 ccp_fatal_error(unit)
1711     int unit;
1712 {
1713     int cf[2];
1714
1715     cf[0] = cf[1] = 0;
1716     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
1717         if (errno != ENXIO && errno != EINVAL)
1718             error("Couldn't get compression flags: %m");
1719         return 0;
1720     }
1721     return cf[0] & CCP_FATALERROR;
1722 }
1723
1724 /*
1725  * sifvjcomp - config tcp header compression
1726  */
1727 int
1728 sifvjcomp(u, vjcomp, xcidcomp, xmaxcid)
1729     int u, vjcomp, xcidcomp, xmaxcid;
1730 {
1731     int cf[2];
1732     char maxcid[2];
1733
1734     if (vjcomp) {
1735         maxcid[0] = xcidcomp;
1736         maxcid[1] = 15;         /* XXX should be rmaxcid */
1737         if (strioctl(pppfd, PPPIO_VJINIT, maxcid, sizeof(maxcid), 0) < 0) {
1738             error("Couldn't initialize VJ compression: %m");
1739         }
1740     }
1741
1742     cf[0] = (vjcomp? COMP_VJC + DECOMP_VJC: 0)  /* XXX this is wrong */
1743         + (xcidcomp? COMP_VJCCID + DECOMP_VJCCID: 0);
1744     cf[1] = COMP_VJC + DECOMP_VJC + COMP_VJCCID + DECOMP_VJCCID;
1745     if (strioctl(pppfd, PPPIO_CFLAGS, cf, sizeof(cf), sizeof(int)) < 0) {
1746         if (vjcomp)
1747             error("Couldn't enable VJ compression: %m");
1748     }
1749
1750     return 1;
1751 }
1752
1753 /*
1754  * sifup - Config the interface up and enable IP packets to pass.
1755  */
1756 int
1757 sifup(u)
1758     int u;
1759 {
1760     struct ifreq ifr;
1761
1762     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
1763     if (ioctl(ipfd, SIOCGIFFLAGS, &ifr) < 0) {
1764         error("Couldn't mark interface up (get): %m");
1765         return 0;
1766     }
1767     ifr.ifr_flags |= IFF_UP;
1768     if (ioctl(ipfd, SIOCSIFFLAGS, &ifr) < 0) {
1769         error("Couldn't mark interface up (set): %m");
1770         return 0;
1771     }
1772     if_is_up = 1;
1773     return 1;
1774 }
1775
1776 /*
1777  * sifdown - Config the interface down and disable IP.
1778  */
1779 int
1780 sifdown(u)
1781     int u;
1782 {
1783     struct ifreq ifr;
1784
1785     if (ipmuxid < 0)
1786         return 1;
1787     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
1788     if (ioctl(ipfd, SIOCGIFFLAGS, &ifr) < 0) {
1789         error("Couldn't mark interface down (get): %m");
1790         return 0;
1791     }
1792     ifr.ifr_flags &= ~IFF_UP;
1793     if (ioctl(ipfd, SIOCSIFFLAGS, &ifr) < 0) {
1794         error("Couldn't mark interface down (set): %m");
1795         return 0;
1796     }
1797     if_is_up = 0;
1798     return 1;
1799 }
1800
1801 /*
1802  * sifnpmode - Set the mode for handling packets for a given NP.
1803  */
1804 int
1805 sifnpmode(u, proto, mode)
1806     int u;
1807     int proto;
1808     enum NPmode mode;
1809 {
1810     int npi[2];
1811
1812     npi[0] = proto;
1813     npi[1] = (int) mode;
1814     if (strioctl(pppfd, PPPIO_NPMODE, &npi, 2 * sizeof(int), 0) < 0) {
1815         error("ioctl(set NP %d mode to %d): %m", proto, mode);
1816         return 0;
1817     }
1818     return 1;
1819 }
1820
1821 #if defined(SOL2) && defined(INET6)
1822 /*
1823  * sif6up - Config the IPv6 interface up and enable IPv6 packets to pass.
1824  */
1825 int
1826 sif6up(u)
1827     int u;
1828 {
1829     struct lifreq lifr;
1830     int fd;
1831
1832     fd = socket(AF_INET6, SOCK_DGRAM, 0);
1833     if (fd < 0) {
1834         return 0;
1835     }
1836
1837     memset(&lifr, 0, sizeof(lifr));
1838     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
1839     if (ioctl(fd, SIOCGLIFFLAGS, &lifr) < 0) {
1840         close(fd);
1841         return 0;
1842     }
1843
1844     lifr.lifr_flags |= IFF_UP;
1845     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
1846     if (ioctl(fd, SIOCSLIFFLAGS, &lifr) < 0) {
1847         close(fd);
1848         return 0;
1849     }
1850
1851     if6_is_up = 1;
1852     close(fd);
1853     return 1;
1854 }
1855
1856 /*
1857  * sifdown - Config the IPv6 interface down and disable IPv6.
1858  */
1859 int
1860 sif6down(u)
1861     int u;
1862 {
1863     struct lifreq lifr;
1864     int fd;
1865
1866     fd = socket(AF_INET6, SOCK_DGRAM, 0);
1867     if (fd < 0)
1868         return 0;
1869
1870     memset(&lifr, 0, sizeof(lifr));
1871     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
1872     if (ioctl(fd, SIOCGLIFFLAGS, &lifr) < 0) {
1873         close(fd);
1874         return 0;
1875     }
1876
1877     lifr.lifr_flags &= ~IFF_UP;
1878     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
1879     if (ioctl(fd, SIOCGLIFFLAGS, &lifr) < 0) {
1880         close(fd);
1881         return 0;
1882     }
1883
1884     if6_is_up = 0;
1885     close(fd);
1886     return 1;
1887 }
1888
1889 /*
1890  * sif6addr - Config the interface with an IPv6 link-local address
1891  */
1892 int
1893 sif6addr(u, o, h)
1894     int u;
1895     eui64_t o, h;
1896 {
1897     struct lifreq lifr;
1898     struct sockaddr_storage laddr;
1899     struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&laddr;
1900     int fd;
1901
1902     fd = socket(AF_INET6, SOCK_DGRAM, 0);
1903     if (fd < 0)
1904         return 0;
1905
1906     memset(&lifr, 0, sizeof(lifr));
1907     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
1908
1909     /*
1910      * Do this because /dev/ppp responds to DL_PHYS_ADDR_REQ with
1911      * zero values, hence the interface token came to be zero too,
1912      * and without this, in.ndpd will complain
1913      */
1914     IN6_LLTOKEN_FROM_EUI64(lifr, sin6, o);
1915     if (ioctl(fd, SIOCSLIFTOKEN, &lifr) < 0) {
1916         close(fd);
1917         return 0;
1918     }
1919
1920     /*
1921      * Set the interface address and destination address
1922      */
1923     IN6_LLADDR_FROM_EUI64(lifr, sin6, o);
1924     if (ioctl(fd, SIOCSLIFADDR, &lifr) < 0) {
1925         close(fd);
1926         return 0;
1927     }
1928
1929     memset(&lifr, 0, sizeof(lifr));
1930     strlcpy(lifr.lifr_name, ifname, sizeof(lifr.lifr_name));
1931     IN6_LLADDR_FROM_EUI64(lifr, sin6, h);
1932     if (ioctl(fd, SIOCSLIFDSTADDR, &lifr) < 0) {
1933         close(fd);
1934         return 0;
1935     }
1936
1937     return 1;
1938 }
1939
1940 /*
1941  * cif6addr - Remove the IPv6 address from interface
1942  */
1943 int
1944 cif6addr(u, o, h)
1945     int u;
1946     eui64_t o, h;
1947 {
1948     return 1;
1949 }
1950
1951 #endif /* defined(SOL2) && defined(INET6) */
1952
1953
1954 #define INET_ADDR(x)    (((struct sockaddr_in *) &(x))->sin_addr.s_addr)
1955
1956 /*
1957  * sifaddr - Config the interface IP addresses and netmask.
1958  */
1959 int
1960 sifaddr(u, o, h, m)
1961     int u;
1962     u_int32_t o, h, m;
1963 {
1964     struct ifreq ifr;
1965     int ret = 1;
1966
1967     memset(&ifr, 0, sizeof(ifr));
1968     strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
1969     ifr.ifr_addr.sa_family = AF_INET;
1970     INET_ADDR(ifr.ifr_addr) = m;
1971     if (ioctl(ipfd, SIOCSIFNETMASK, &ifr) < 0) {
1972         error("Couldn't set IP netmask: %m");
1973         ret = 0;
1974     }
1975     ifr.ifr_addr.sa_family = AF_INET;
1976     INET_ADDR(ifr.ifr_addr) = o;
1977     if (ioctl(ipfd, SIOCSIFADDR, &ifr) < 0) {
1978         error("Couldn't set local IP address: %m");
1979         ret = 0;
1980     }
1981
1982     /*
1983      * On some systems, we have to explicitly set the point-to-point
1984      * flag bit before we can set a destination address.
1985      */
1986     if (ioctl(ipfd, SIOCGIFFLAGS, &ifr) >= 0
1987         && (ifr.ifr_flags & IFF_POINTOPOINT) == 0) {
1988         ifr.ifr_flags |= IFF_POINTOPOINT;
1989         if (ioctl(ipfd, SIOCSIFFLAGS, &ifr) < 0) {
1990             error("Couldn't mark interface pt-to-pt: %m");
1991             ret = 0;
1992         }
1993     }
1994     ifr.ifr_dstaddr.sa_family = AF_INET;
1995     INET_ADDR(ifr.ifr_dstaddr) = h;
1996     if (ioctl(ipfd, SIOCSIFDSTADDR, &ifr) < 0) {
1997         error("Couldn't set remote IP address: %m");
1998         ret = 0;
1999     }
2000 #if 0   /* now done in ppp_send_config */
2001     ifr.ifr_metric = link_mtu;
2002     if (ioctl(ipfd, SIOCSIFMTU, &ifr) < 0) {
2003         error("Couldn't set IP MTU: %m");
2004     }
2005 #endif
2006
2007     remote_addr = h;
2008     return ret;
2009 }
2010
2011 /*
2012  * cifaddr - Clear the interface IP addresses, and delete routes
2013  * through the interface if possible.
2014  */
2015 int
2016 cifaddr(u, o, h)
2017     int u;
2018     u_int32_t o, h;
2019 {
2020 #if defined(__USLC__)           /* was: #if 0 */
2021     cifroute(unit, ouraddr, hisaddr);
2022     if (ipmuxid >= 0) {
2023         notice("Removing ppp interface unit");
2024         if (ioctl(ipfd, I_UNLINK, ipmuxid) < 0) {
2025             error("Can't remove ppp interface unit: %m");
2026             return 0;
2027         }
2028         ipmuxid = -1;
2029     }
2030 #endif
2031     remote_addr = 0;
2032     return 1;
2033 }
2034
2035 /*
2036  * sifdefaultroute - assign a default route through the address given.
2037  */
2038 int
2039 sifdefaultroute(u, l, g)
2040     int u;
2041     u_int32_t l, g;
2042 {
2043     struct rtentry rt;
2044
2045 #if defined(__USLC__)
2046     g = l;                      /* use the local address as gateway */
2047 #endif
2048     memset(&rt, 0, sizeof(rt));
2049     rt.rt_dst.sa_family = AF_INET;
2050     INET_ADDR(rt.rt_dst) = 0;
2051     rt.rt_gateway.sa_family = AF_INET;
2052     INET_ADDR(rt.rt_gateway) = g;
2053     rt.rt_flags = RTF_GATEWAY;
2054
2055     if (ioctl(ipfd, SIOCADDRT, &rt) < 0) {
2056         error("Can't add default route: %m");
2057         return 0;
2058     }
2059
2060     default_route_gateway = g;
2061     return 1;
2062 }
2063
2064 /*
2065  * cifdefaultroute - delete a default route through the address given.
2066  */
2067 int
2068 cifdefaultroute(u, l, g)
2069     int u;
2070     u_int32_t l, g;
2071 {
2072     struct rtentry rt;
2073
2074 #if defined(__USLC__)
2075     g = l;                      /* use the local address as gateway */
2076 #endif
2077     memset(&rt, 0, sizeof(rt));
2078     rt.rt_dst.sa_family = AF_INET;
2079     INET_ADDR(rt.rt_dst) = 0;
2080     rt.rt_gateway.sa_family = AF_INET;
2081     INET_ADDR(rt.rt_gateway) = g;
2082     rt.rt_flags = RTF_GATEWAY;
2083
2084     if (ioctl(ipfd, SIOCDELRT, &rt) < 0) {
2085         error("Can't delete default route: %m");
2086         return 0;
2087     }
2088
2089     default_route_gateway = 0;
2090     return 1;
2091 }
2092
2093 /*
2094  * sifproxyarp - Make a proxy ARP entry for the peer.
2095  */
2096 int
2097 sifproxyarp(unit, hisaddr)
2098     int unit;
2099     u_int32_t hisaddr;
2100 {
2101     struct arpreq arpreq;
2102
2103     memset(&arpreq, 0, sizeof(arpreq));
2104     if (!get_ether_addr(hisaddr, &arpreq.arp_ha))
2105         return 0;
2106
2107     arpreq.arp_pa.sa_family = AF_INET;
2108     INET_ADDR(arpreq.arp_pa) = hisaddr;
2109     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
2110     if (ioctl(ipfd, SIOCSARP, (caddr_t) &arpreq) < 0) {
2111         error("Couldn't set proxy ARP entry: %m");
2112         return 0;
2113     }
2114
2115     proxy_arp_addr = hisaddr;
2116     return 1;
2117 }
2118
2119 /*
2120  * cifproxyarp - Delete the proxy ARP entry for the peer.
2121  */
2122 int
2123 cifproxyarp(unit, hisaddr)
2124     int unit;
2125     u_int32_t hisaddr;
2126 {
2127     struct arpreq arpreq;
2128
2129     memset(&arpreq, 0, sizeof(arpreq));
2130     arpreq.arp_pa.sa_family = AF_INET;
2131     INET_ADDR(arpreq.arp_pa) = hisaddr;
2132     if (ioctl(ipfd, SIOCDARP, (caddr_t)&arpreq) < 0) {
2133         error("Couldn't delete proxy ARP entry: %m");
2134         return 0;
2135     }
2136
2137     proxy_arp_addr = 0;
2138     return 1;
2139 }
2140
2141 /*
2142  * get_ether_addr - get the hardware address of an interface on the
2143  * the same subnet as ipaddr.
2144  */
2145 #define MAX_IFS         32
2146
2147 static int
2148 get_ether_addr(ipaddr, hwaddr)
2149     u_int32_t ipaddr;
2150     struct sockaddr *hwaddr;
2151 {
2152     struct ifreq *ifr, *ifend, ifreq;
2153     int nif;
2154     struct ifconf ifc;
2155     u_int32_t ina, mask;
2156
2157     /*
2158      * Scan through the system's network interfaces.
2159      */
2160 #ifdef SIOCGIFNUM
2161     if (ioctl(ipfd, SIOCGIFNUM, &nif) < 0)
2162 #endif
2163         nif = MAX_IFS;
2164     ifc.ifc_len = nif * sizeof(struct ifreq);
2165     ifc.ifc_buf = (caddr_t) malloc(ifc.ifc_len);
2166     if (ifc.ifc_buf == 0)
2167         return 0;
2168     if (ioctl(ipfd, SIOCGIFCONF, &ifc) < 0) {
2169         warn("Couldn't get system interface list: %m");
2170         free(ifc.ifc_buf);
2171         return 0;
2172     }
2173     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2174     for (ifr = ifc.ifc_req; ifr < ifend; ++ifr) {
2175         if (ifr->ifr_addr.sa_family != AF_INET)
2176             continue;
2177         /*
2178          * Check that the interface is up, and not point-to-point or loopback.
2179          */
2180         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2181         if (ioctl(ipfd, SIOCGIFFLAGS, &ifreq) < 0)
2182             continue;
2183         if ((ifreq.ifr_flags &
2184              (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
2185             != (IFF_UP|IFF_BROADCAST))
2186             continue;
2187         /*
2188          * Get its netmask and check that it's on the right subnet.
2189          */
2190         if (ioctl(ipfd, SIOCGIFNETMASK, &ifreq) < 0)
2191             continue;
2192         ina = INET_ADDR(ifr->ifr_addr);
2193         mask = INET_ADDR(ifreq.ifr_addr);
2194         if ((ipaddr & mask) == (ina & mask))
2195             break;
2196     }
2197
2198     if (ifr >= ifend) {
2199         warn("No suitable interface found for proxy ARP");
2200         free(ifc.ifc_buf);
2201         return 0;
2202     }
2203
2204     info("found interface %s for proxy ARP", ifr->ifr_name);
2205     if (!get_hw_addr(ifr->ifr_name, ina, hwaddr)) {
2206         error("Couldn't get hardware address for %s", ifr->ifr_name);
2207         free(ifc.ifc_buf);
2208         return 0;
2209     }
2210
2211     free(ifc.ifc_buf);
2212     return 1;
2213 }
2214
2215 /*
2216  * get_hw_addr_dlpi - obtain the hardware address using DLPI
2217  */
2218 static int
2219 get_hw_addr_dlpi(name, hwaddr)
2220     char *name;
2221     struct sockaddr *hwaddr;
2222 {
2223     char *p, *q;
2224     int unit, iffd, adrlen;
2225     unsigned char *adrp;
2226     char ifdev[24];
2227     struct {
2228         union DL_primitives prim;
2229         char space[64];
2230     } reply;
2231
2232     /*
2233      * We have to open the device and ask it for its hardware address.
2234      * First split apart the device name and unit.
2235      */
2236     slprintf(ifdev, sizeof(ifdev), "/dev/%s", name);
2237     for (q = ifdev + strlen(ifdev); --q >= ifdev; )
2238         if (!isdigit(*q))
2239             break;
2240     unit = atoi(q+1);
2241     q[1] = 0;
2242
2243     /*
2244      * Open the device and do a DLPI attach and phys_addr_req.
2245      */
2246     iffd = open(ifdev, O_RDWR);
2247     if (iffd < 0) {
2248         error("Can't open %s: %m", ifdev);
2249         return 0;
2250     }
2251     if (dlpi_attach(iffd, unit) < 0
2252         || dlpi_get_reply(iffd, &reply.prim, DL_OK_ACK, sizeof(reply)) < 0
2253         || dlpi_info_req(iffd) < 0
2254         || dlpi_get_reply(iffd, &reply.prim, DL_INFO_ACK, sizeof(reply)) < 0) {
2255         close(iffd);
2256         return 0;
2257     }
2258
2259     adrlen = reply.prim.info_ack.dl_addr_length;
2260     adrp = (unsigned char *)&reply + reply.prim.info_ack.dl_addr_offset;
2261
2262 #if DL_CURRENT_VERSION >= 2
2263     if (reply.prim.info_ack.dl_sap_length < 0)
2264         adrlen += reply.prim.info_ack.dl_sap_length;
2265     else
2266         adrp += reply.prim.info_ack.dl_sap_length;
2267 #endif
2268
2269     hwaddr->sa_family = AF_UNSPEC;
2270     memcpy(hwaddr->sa_data, adrp, adrlen);
2271
2272     return 1;
2273 }
2274 /*
2275  * get_hw_addr - obtain the hardware address for a named interface.
2276  */
2277 static int
2278 get_hw_addr(name, ina, hwaddr)
2279     char *name;
2280     u_int32_t ina;
2281     struct sockaddr *hwaddr;
2282 {
2283     /* New way - get the address by doing an arp request. */
2284     int s;
2285     struct arpreq req;
2286
2287     s = socket(AF_INET, SOCK_DGRAM, 0);
2288     if (s < 0)
2289         return 0;
2290     memset(&req, 0, sizeof(req));
2291     req.arp_pa.sa_family = AF_INET;
2292     INET_ADDR(req.arp_pa) = ina;
2293     if (ioctl(s, SIOCGARP, &req) < 0) {
2294         error("Couldn't get ARP entry for %s: %m", ip_ntoa(ina));
2295         return 0;
2296     }
2297     *hwaddr = req.arp_ha;
2298     hwaddr->sa_family = AF_UNSPEC;
2299
2300     return 1;
2301 }
2302
2303 static int
2304 dlpi_attach(fd, ppa)
2305     int fd, ppa;
2306 {
2307     dl_attach_req_t req;
2308     struct strbuf buf;
2309
2310     req.dl_primitive = DL_ATTACH_REQ;
2311     req.dl_ppa = ppa;
2312     buf.len = sizeof(req);
2313     buf.buf = (void *) &req;
2314     return putmsg(fd, &buf, NULL, RS_HIPRI);
2315 }
2316
2317 static int
2318 dlpi_info_req(fd)
2319     int fd;
2320 {
2321     dl_info_req_t req;
2322     struct strbuf buf;
2323
2324     req.dl_primitive = DL_INFO_REQ;
2325     buf.len = sizeof(req);
2326     buf.buf = (void *) &req;
2327     return putmsg(fd, &buf, NULL, RS_HIPRI);
2328 }
2329
2330 static int
2331 dlpi_get_reply(fd, reply, expected_prim, maxlen)
2332     union DL_primitives *reply;
2333     int fd, expected_prim, maxlen;
2334 {
2335     struct strbuf buf;
2336     int flags, n;
2337     struct pollfd pfd;
2338
2339     /*
2340      * Use poll to wait for a message with a timeout.
2341      */
2342     pfd.fd = fd;
2343     pfd.events = POLLIN | POLLPRI;
2344     do {
2345         n = poll(&pfd, 1, 1000);
2346     } while (n == -1 && errno == EINTR);
2347     if (n <= 0)
2348         return -1;
2349
2350     /*
2351      * Get the reply.
2352      */
2353     buf.maxlen = maxlen;
2354     buf.buf = (void *) reply;
2355     flags = 0;
2356     if (getmsg(fd, &buf, NULL, &flags) < 0)
2357         return -1;
2358
2359     if (buf.len < sizeof(ulong)) {
2360         if (debug)
2361             dbglog("dlpi response short (len=%d)\n", buf.len);
2362         return -1;
2363     }
2364
2365     if (reply->dl_primitive == expected_prim)
2366         return 0;
2367
2368     if (debug) {
2369         if (reply->dl_primitive == DL_ERROR_ACK) {
2370             dbglog("dlpi error %d (unix errno %d) for prim %x\n",
2371                    reply->error_ack.dl_errno, reply->error_ack.dl_unix_errno,
2372                    reply->error_ack.dl_error_primitive);
2373         } else {
2374             dbglog("dlpi unexpected response prim %x\n",
2375                    reply->dl_primitive);
2376         }
2377     }
2378
2379     return -1;
2380 }
2381
2382 /*
2383  * Return user specified netmask, modified by any mask we might determine
2384  * for address `addr' (in network byte order).
2385  * Here we scan through the system's list of interfaces, looking for
2386  * any non-point-to-point interfaces which might appear to be on the same
2387  * network as `addr'.  If we find any, we OR in their netmask to the
2388  * user-specified netmask.
2389  */
2390 u_int32_t
2391 GetMask(addr)
2392     u_int32_t addr;
2393 {
2394     u_int32_t mask, nmask, ina;
2395     struct ifreq *ifr, *ifend, ifreq;
2396     int nif;
2397     struct ifconf ifc;
2398
2399     addr = ntohl(addr);
2400     if (IN_CLASSA(addr))        /* determine network mask for address class */
2401         nmask = IN_CLASSA_NET;
2402     else if (IN_CLASSB(addr))
2403         nmask = IN_CLASSB_NET;
2404     else
2405         nmask = IN_CLASSC_NET;
2406     /* class D nets are disallowed by bad_ip_adrs */
2407     mask = netmask | htonl(nmask);
2408
2409     /*
2410      * Scan through the system's network interfaces.
2411      */
2412 #ifdef SIOCGIFNUM
2413     if (ioctl(ipfd, SIOCGIFNUM, &nif) < 0)
2414 #endif
2415         nif = MAX_IFS;
2416     ifc.ifc_len = nif * sizeof(struct ifreq);
2417     ifc.ifc_buf = (caddr_t) malloc(ifc.ifc_len);
2418     if (ifc.ifc_buf == 0)
2419         return mask;
2420     if (ioctl(ipfd, SIOCGIFCONF, &ifc) < 0) {
2421         warn("Couldn't get system interface list: %m");
2422         free(ifc.ifc_buf);
2423         return mask;
2424     }
2425     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
2426     for (ifr = ifc.ifc_req; ifr < ifend; ++ifr) {
2427         /*
2428          * Check the interface's internet address.
2429          */
2430         if (ifr->ifr_addr.sa_family != AF_INET)
2431             continue;
2432         ina = INET_ADDR(ifr->ifr_addr);
2433         if ((ntohl(ina) & nmask) != (addr & nmask))
2434             continue;
2435         /*
2436          * Check that the interface is up, and not point-to-point or loopback.
2437          */
2438         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
2439         if (ioctl(ipfd, SIOCGIFFLAGS, &ifreq) < 0)
2440             continue;
2441         if ((ifreq.ifr_flags & (IFF_UP|IFF_POINTOPOINT|IFF_LOOPBACK))
2442             != IFF_UP)
2443             continue;
2444         /*
2445          * Get its netmask and OR it into our mask.
2446          */
2447         if (ioctl(ipfd, SIOCGIFNETMASK, &ifreq) < 0)
2448             continue;
2449         mask |= INET_ADDR(ifreq.ifr_addr);
2450     }
2451
2452     free(ifc.ifc_buf);
2453     return mask;
2454 }
2455
2456 /*
2457  * logwtmp - write an accounting record to the /var/adm/wtmp file.
2458  */
2459 void
2460 logwtmp(line, name, host)
2461     const char *line, *name, *host;
2462 {
2463     static struct utmpx utmpx;
2464
2465     if (name[0] != 0) {
2466         /* logging in */
2467         strncpy(utmpx.ut_user, name, sizeof(utmpx.ut_user));
2468         strncpy(utmpx.ut_id, ifname, sizeof(utmpx.ut_id));
2469         strncpy(utmpx.ut_line, line, sizeof(utmpx.ut_line));
2470         utmpx.ut_pid = getpid();
2471         utmpx.ut_type = USER_PROCESS;
2472     } else {
2473         utmpx.ut_type = DEAD_PROCESS;
2474     }
2475     gettimeofday(&utmpx.ut_tv, NULL);
2476     updwtmpx("/var/adm/wtmpx", &utmpx);
2477 }
2478
2479 /*
2480  * get_host_seed - return the serial number of this machine.
2481  */
2482 int
2483 get_host_seed()
2484 {
2485     char buf[32];
2486
2487     if (sysinfo(SI_HW_SERIAL, buf, sizeof(buf)) < 0) {
2488         error("sysinfo: %m");
2489         return 0;
2490     }
2491     return (int) strtoul(buf, NULL, 16);
2492 }
2493
2494 static int
2495 strioctl(fd, cmd, ptr, ilen, olen)
2496     int fd, cmd, ilen, olen;
2497     void *ptr;
2498 {
2499     struct strioctl str;
2500
2501     str.ic_cmd = cmd;
2502     str.ic_timout = 0;
2503     str.ic_len = ilen;
2504     str.ic_dp = ptr;
2505     if (ioctl(fd, I_STR, &str) == -1)
2506         return -1;
2507     if (str.ic_len != olen)
2508         dbglog("strioctl: expected %d bytes, got %d for cmd %x\n",
2509                olen, str.ic_len, cmd);
2510     return 0;
2511 }
2512
2513 #if 0
2514 /*
2515  * lock - create a lock file for the named lock device
2516  */
2517
2518 #define LOCK_PREFIX     "/var/spool/locks/LK."
2519 static char lock_file[40];      /* name of lock file created */
2520
2521 int
2522 lock(dev)
2523     char *dev;
2524 {
2525     int n, fd, pid;
2526     struct stat sbuf;
2527     char ascii_pid[12];
2528
2529     if (stat(dev, &sbuf) < 0) {
2530         error("Can't get device number for %s: %m", dev);
2531         return -1;
2532     }
2533     if ((sbuf.st_mode & S_IFMT) != S_IFCHR) {
2534         error("Can't lock %s: not a character device", dev);
2535         return -1;
2536     }
2537     slprintf(lock_file, sizeof(lock_file), "%s%03d.%03d.%03d",
2538              LOCK_PREFIX, major(sbuf.st_dev),
2539              major(sbuf.st_rdev), minor(sbuf.st_rdev));
2540
2541     while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) {
2542         if (errno == EEXIST
2543             && (fd = open(lock_file, O_RDONLY, 0)) >= 0) {
2544             /* Read the lock file to find out who has the device locked */
2545             n = read(fd, ascii_pid, 11);
2546             if (n <= 0) {
2547                 error("Can't read pid from lock file %s", lock_file);
2548                 close(fd);
2549             } else {
2550                 ascii_pid[n] = 0;
2551                 pid = atoi(ascii_pid);
2552                 if (pid > 0 && kill(pid, 0) == -1 && errno == ESRCH) {
2553                     /* pid no longer exists - remove the lock file */
2554                     if (unlink(lock_file) == 0) {
2555                         close(fd);
2556                         notice("Removed stale lock on %s (pid %d)",
2557                                dev, pid);
2558                         continue;
2559                     } else
2560                         warn("Couldn't remove stale lock on %s",
2561                                dev);
2562                 } else
2563                     notice("Device %s is locked by pid %d",
2564                            dev, pid);
2565             }
2566             close(fd);
2567         } else
2568             error("Can't create lock file %s: %m", lock_file);
2569         lock_file[0] = 0;
2570         return -1;
2571     }
2572
2573     slprintf(ascii_pid, sizeof(ascii_pid), "%10d\n", getpid());
2574     write(fd, ascii_pid, 11);
2575
2576     close(fd);
2577     return 1;
2578 }
2579
2580 /*
2581  * unlock - remove our lockfile
2582  */
2583 void
2584 unlock()
2585 {
2586     if (lock_file[0]) {
2587         unlink(lock_file);
2588         lock_file[0] = 0;
2589     }
2590 }
2591 #endif
2592
2593 /*
2594  * cifroute - delete a route through the addresses given.
2595  */
2596 int
2597 cifroute(u, our, his)
2598     int u;
2599     u_int32_t our, his;
2600 {
2601     struct rtentry rt;
2602
2603     memset(&rt, 0, sizeof(rt));
2604     rt.rt_dst.sa_family = AF_INET;
2605     INET_ADDR(rt.rt_dst) = his;
2606     rt.rt_gateway.sa_family = AF_INET;
2607     INET_ADDR(rt.rt_gateway) = our;
2608     rt.rt_flags = RTF_HOST;
2609
2610     if (ioctl(ipfd, SIOCDELRT, &rt) < 0) {
2611         error("Can't delete route: %m");
2612         return 0;
2613     }
2614
2615     return 1;
2616 }
2617
2618 /*
2619  * have_route_to - determine if the system has a route to the specified
2620  * IP address.  Returns 0 if not, 1 if so, -1 if we can't tell.
2621  * `addr' is in network byte order.
2622  * For demand mode to work properly, we have to ignore routes
2623  * through our own interface.
2624  */
2625 #ifndef T_CURRENT               /* needed for Solaris 2.5 */
2626 #define T_CURRENT       MI_T_CURRENT
2627 #endif
2628
2629 int
2630 have_route_to(addr)
2631     u_int32_t addr;
2632 {
2633 #ifdef SOL2
2634     int fd, r, flags, i;
2635     struct {
2636         struct T_optmgmt_req req;
2637         struct opthdr hdr;
2638     } req;
2639     union {
2640         struct T_optmgmt_ack ack;
2641         unsigned char space[64];
2642     } ack;
2643     struct opthdr *rh;
2644     struct strbuf cbuf, dbuf;
2645     int nroutes;
2646     mib2_ipRouteEntry_t routes[8];
2647     mib2_ipRouteEntry_t *rp;
2648
2649     fd = open(mux_dev_name, O_RDWR);
2650     if (fd < 0) {
2651         warn("have_route_to: couldn't open %s: %m", mux_dev_name);
2652         return -1;
2653     }
2654
2655     req.req.PRIM_type = T_OPTMGMT_REQ;
2656     req.req.OPT_offset = (char *) &req.hdr - (char *) &req;
2657     req.req.OPT_length = sizeof(req.hdr);
2658     req.req.MGMT_flags = T_CURRENT;
2659
2660     req.hdr.level = MIB2_IP;
2661     req.hdr.name = 0;
2662     req.hdr.len = 0;
2663
2664     cbuf.buf = (char *) &req;
2665     cbuf.len = sizeof(req);
2666
2667     if (putmsg(fd, &cbuf, NULL, 0) == -1) {
2668         warn("have_route_to: putmsg: %m");
2669         close(fd);
2670         return -1;
2671     }
2672
2673     for (;;) {
2674         cbuf.buf = (char *) &ack;
2675         cbuf.maxlen = sizeof(ack);
2676         dbuf.buf = (char *) routes;
2677         dbuf.maxlen = sizeof(routes);
2678         flags = 0;
2679         r = getmsg(fd, &cbuf, &dbuf, &flags);
2680         if (r == -1) {
2681             warn("have_route_to: getmsg: %m");
2682             close(fd);
2683             return -1;
2684         }
2685
2686         if (cbuf.len < sizeof(struct T_optmgmt_ack)
2687             || ack.ack.PRIM_type != T_OPTMGMT_ACK
2688             || ack.ack.MGMT_flags != T_SUCCESS
2689             || ack.ack.OPT_length < sizeof(struct opthdr)) {
2690             dbglog("have_route_to: bad message len=%d prim=%d",
2691                    cbuf.len, ack.ack.PRIM_type);
2692             close(fd);
2693             return -1;
2694         }
2695
2696         rh = (struct opthdr *) ((char *)&ack + ack.ack.OPT_offset);
2697         if (rh->level == 0 && rh->name == 0)
2698             break;
2699         if (rh->level != MIB2_IP || rh->name != MIB2_IP_21) {
2700             while (r == MOREDATA)
2701                 r = getmsg(fd, NULL, &dbuf, &flags);
2702             continue;
2703         }
2704
2705         for (;;) {
2706             nroutes = dbuf.len / sizeof(mib2_ipRouteEntry_t);
2707             for (rp = routes, i = 0; i < nroutes; ++i, ++rp) {
2708                 if (rp->ipRouteMask != ~0) {
2709                     dbglog("have_route_to: dest=%x gw=%x mask=%x\n",
2710                            rp->ipRouteDest, rp->ipRouteNextHop,
2711                            rp->ipRouteMask);
2712                     if (((addr ^ rp->ipRouteDest) & rp->ipRouteMask) == 0
2713                         && rp->ipRouteNextHop != remote_addr)
2714                         return 1;
2715                 }
2716             }
2717             if (r == 0)
2718                 break;
2719             r = getmsg(fd, NULL, &dbuf, &flags);
2720         }
2721     }
2722     close(fd);
2723     return 0;
2724 #else
2725     return -1;
2726 #endif /* SOL2 */
2727 }
2728
2729 /*
2730  * get_pty - get a pty master/slave pair and chown the slave side to
2731  * the uid given.  Assumes slave_name points to MAXPATHLEN bytes of space.
2732  */
2733 int
2734 get_pty(master_fdp, slave_fdp, slave_name, uid)
2735     int *master_fdp;
2736     int *slave_fdp;
2737     char *slave_name;
2738     int uid;
2739 {
2740     int mfd, sfd;
2741     char *pty_name;
2742     struct termios tios;
2743
2744     mfd = open("/dev/ptmx", O_RDWR);
2745     if (mfd < 0) {
2746         error("Couldn't open pty master: %m");
2747         return 0;
2748     }
2749
2750     pty_name = ptsname(mfd);
2751     if (pty_name == NULL) {
2752         error("Couldn't get name of pty slave");
2753         close(mfd);
2754         return 0;
2755     }
2756     if (chown(pty_name, uid, -1) < 0)
2757         warn("Couldn't change owner of pty slave: %m");
2758     if (chmod(pty_name, S_IRUSR | S_IWUSR) < 0)
2759         warn("Couldn't change permissions on pty slave: %m");
2760     if (unlockpt(mfd) < 0)
2761         warn("Couldn't unlock pty slave: %m");
2762
2763     sfd = open(pty_name, O_RDWR);
2764     if (sfd < 0) {
2765         error("Couldn't open pty slave %s: %m", pty_name);
2766         close(mfd);
2767         return 0;
2768     }
2769     if (ioctl(sfd, I_PUSH, "ptem") < 0)
2770         warn("Couldn't push ptem module on pty slave: %m");
2771
2772     dbglog("Using %s", pty_name);
2773     strlcpy(slave_name, pty_name, MAXPATHLEN);
2774     *master_fdp = mfd;
2775     *slave_fdp = sfd;
2776
2777     return 1;
2778 }