Remove the requirement that redistributions in binary form reproduce
[ppp.git] / 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 }