put logwtmp in here
[ppp.git] / pppd / sys-str.c
1 /*
2  * sys-str.c - System-dependent procedures for setting up
3  * PPP interfaces on systems which use the STREAMS ppp interface.
4  *
5  * Copyright (c) 1989 Carnegie Mellon University.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms are permitted
9  * provided that the above copyright notice and this paragraph are
10  * duplicated in all such forms and that any documentation,
11  * advertising materials, and other materials related to such
12  * distribution and use acknowledge that the software was developed
13  * by Carnegie Mellon University.  The name of the
14  * University may not be used to endorse or promote products derived
15  * from this software without specific prior written permission.
16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19  */
20
21 /*
22  * TODO:
23  */
24
25 #include <stdio.h>
26 #include <errno.h>
27 #include <syslog.h>
28 #include <fcntl.h>
29 #include <string.h>
30 #include <time.h>
31 #include <file.h>
32 #include <utmp.h>
33 #include <sys/ioctl.h>
34 #include <sys/types.h>
35 #include <sys/socket.h>
36 #include <sys/time.h>
37 #include <sys/stream.h>
38 #include <sys/stropts.h>
39
40 #include <net/if.h>
41 #include <net/route.h>
42 #include <net/if_arp.h>
43 #include <netinet/in.h>
44
45 #include "pppd.h"
46 #include "ppp.h"
47 #include <net/if_ppp.h>
48 #include <net/ppp_str.h>
49
50 #ifndef ifr_mtu
51 #define ifr_mtu         ifr_metric
52 #endif
53
54 #define MAXMODULES      10      /* max number of module names to save */
55 static struct   modlist {
56     char        modname[FMNAMESZ+1];
57 } str_modules[MAXMODULES];
58 static int      str_module_count = 0;
59 static int      pushed_ppp;
60
61 extern int hungup;              /* has the physical layer been disconnected? */
62 extern int kdebugflag;
63
64 #define PAI_FLAGS_B7_0          0x100
65 #define PAI_FLAGS_B7_1          0x200
66 #define PAI_FLAGS_PAR_EVEN      0x400
67 #define PAI_FLAGS_PAR_ODD       0x800
68 #define PAI_FLAGS_HIBITS        0xF00
69
70 /*
71  * ppp_available - check if this kernel supports PPP.
72  */
73 int
74 ppp_available()
75 {
76     int fd, ret;
77
78     fd = open("/dev/tty", O_RDONLY, 0);
79     if (fd < 0)
80         return 1;               /* can't find out - assume we have ppp */
81     ret = ioctl(fd, I_FIND, "pppasync") >= 0;
82     close(fd);
83     return ret;
84 }
85
86
87 /*
88  * establish_ppp - Turn the serial port into a ppp interface.
89  */
90 void
91 establish_ppp()
92 {
93     /* go through and save the name of all the modules, then pop em */
94     for (;;) { 
95         if (ioctl(fd, I_LOOK, str_modules[str_module_count].modname) < 0 ||
96             ioctl(fd, I_POP, 0) < 0)
97             break;
98         MAINDEBUG((LOG_DEBUG, "popped stream module : %s",
99                    str_modules[str_module_count].modname));
100         str_module_count++;
101     }
102
103     /* now push the async/fcs module */
104     if (ioctl(fd, I_PUSH, "pppasync") < 0) {
105         syslog(LOG_ERR, "ioctl(I_PUSH, ppp_async): %m");
106         die(1);
107     }
108     /* finally, push the ppp_if module that actually handles the */
109     /* network interface */ 
110     if (ioctl(fd, I_PUSH, "pppif") < 0) {
111         syslog(LOG_ERR, "ioctl(I_PUSH, ppp_if): %m");
112         die(1);
113     }
114     pushed_ppp = 1;
115     if (ioctl(fd, I_SETSIG, S_INPUT) < 0) {
116         syslog(LOG_ERR, "ioctl(I_SETSIG, S_INPUT): %m");
117         die(1);
118     }
119     /* read mode, message non-discard mode */
120     if (ioctl(fd, I_SRDOPT, RMSGN) < 0) {
121         syslog(LOG_ERR, "ioctl(I_SRDOPT, RMSGN): %m");
122         die(1);
123     }
124     /* Flush any waiting messages, or we'll never get SIGPOLL */
125     if (ioctl(fd, I_FLUSH, FLUSHRW) < 0) {
126         syslog(LOG_ERR, "ioctl(I_FLUSH, FLUSHRW): %m");
127         die(1);
128     }
129     /*
130      * Find out which interface we were given.
131      * (ppp_if handles this ioctl)
132      */
133     if (ioctl(fd, SIOCGETU, &ifunit) < 0) {
134         syslog(LOG_ERR, "ioctl(SIOCGETU): %m");
135         die(1);
136     }
137
138     /* Set debug flags in driver */
139     if (ioctl(fd, SIOCSIFDEBUG, &kdebugflag) < 0) {
140         syslog(LOG_ERR, "ioctl(SIOCSIFDEBUG): %m");
141     }
142 }
143
144 /*
145  * disestablish_ppp - Restore the serial port to normal operation.
146  * It attempts to reconstruct the stream with the previously popped
147  * modules.  This shouldn't call die() because it's called from die().
148  */
149 void
150 disestablish_ppp()
151 {
152     int flags;
153     char *s;
154
155     if (hungup) {
156         /* we can't push or pop modules after the stream has hung up */
157         str_module_count = 0;
158         return;
159     }
160
161     if (pushed_ppp) {
162         /*
163          * Check whether the link seems not to be 8-bit clean.
164          */
165         if (ioctl(fd, SIOCGIFDEBUG, (caddr_t) &flags) == 0) {
166             s = NULL;
167             switch (~flags & PAI_FLAGS_HIBITS) {
168             case PAI_FLAGS_B7_0:
169                 s = "bit 7 set to 1";
170                 break;
171             case PAI_FLAGS_B7_1:
172                 s = "bit 7 set to 0";
173                 break;
174             case PAI_FLAGS_PAR_EVEN:
175                 s = "odd parity";
176                 break;
177             case PAI_FLAGS_PAR_ODD:
178                 s = "even parity";
179                 break;
180             }
181             if (s != NULL) {
182                 syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
183                 syslog(LOG_WARNING, "All received characters had %s", s);
184             }
185         }
186     }
187
188     while (ioctl(fd, I_POP, 0) == 0)    /* pop any we pushed */
189         ;
190     pushed_ppp = 0;
191   
192     for (; str_module_count > 0; str_module_count--) {
193         if (ioctl(fd, I_PUSH, str_modules[str_module_count-1].modname)) {
194             syslog(LOG_WARNING, "str_restore: couldn't push module %s: %m",
195                    str_modules[str_module_count-1].modname);
196         } else {
197             MAINDEBUG((LOG_INFO, "str_restore: pushed module %s",
198                        str_modules[str_module_count-1].modname));
199         }
200     }
201 }
202
203
204 /*
205  * output - Output PPP packet.
206  */
207 void
208 output(unit, p, len)
209     int unit;
210     u_char *p;
211     int len;
212 {
213     struct strbuf       str;
214
215     if (unit != 0)
216         MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
217     if (debug)
218         log_packet(p, len, "sent ");
219
220     str.len = len;
221     str.buf = (caddr_t) p;
222     if(putmsg(fd, NULL, &str, 0) < 0) {
223         syslog(LOG_ERR, "putmsg: %m");
224         die(1);
225     }
226 }
227
228
229 /*
230  * read_packet - get a PPP packet from the serial device.
231  */
232 int
233 read_packet(buf)
234     u_char *buf;
235 {
236     struct strbuf str;
237     int len, i;
238
239     str.maxlen = MTU+DLLHEADERLEN;
240     str.buf = (caddr_t) buf;
241     i = 0;
242     len = getmsg(fd, NULL, &str, &i);
243     if (len < 0) {
244         if (errno == EAGAIN || errno == EWOULDBLOCK) {
245             return -1;
246         }
247         syslog(LOG_ERR, "getmsg(fd) %m");
248         die(1);
249     }
250     if (len) 
251         MAINDEBUG((LOG_DEBUG, "getmsg returned 0x%x",len));
252
253     if (str.len < 0) {
254         MAINDEBUG((LOG_DEBUG, "getmsg short return length %d", str.len));
255         return -1;
256     }
257
258     return str.len;
259 }
260
261
262 /*
263  * ppp_send_config - configure the transmit characteristics of
264  * the ppp interface.
265  */
266 void
267 ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
268     int unit, mtu;
269     u_long asyncmap;
270     int pcomp, accomp;
271 {
272     char c;
273     struct ifreq ifr;
274
275     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
276     ifr.ifr_mtu = mtu;
277     if (ioctl(s, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
278         syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
279         quit();
280     }
281
282     if(ioctl(fd, SIOCSIFASYNCMAP, (caddr_t) &asyncmap) < 0) {
283         syslog(LOG_ERR, "ioctl(SIOCSIFASYNCMAP): %m");
284         quit();
285     }
286
287     c = (pcomp? 1: 0);
288     if(ioctl(fd, SIOCSIFCOMPPROT, &c) < 0) {
289         syslog(LOG_ERR, "ioctl(SIOCSIFCOMPPROT): %m");
290         quit();
291     }
292
293     c = (accomp? 1: 0);
294     if(ioctl(fd, SIOCSIFCOMPAC, &c) < 0) {
295         syslog(LOG_ERR, "ioctl(SIOCSIFCOMPAC): %m");
296         quit();
297     }
298 }
299
300
301 /*
302  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
303  */
304 void
305 ppp_set_xaccm(unit, accm)
306     int unit;
307     ext_accm accm;
308 {
309     if (ioctl(fd, SIOCSIFXASYNCMAP, accm) < 0 && errno != ENOTTY)
310         syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
311 }
312
313
314 /*
315  * ppp_recv_config - configure the receive-side characteristics of
316  * the ppp interface.
317  */
318 void
319 ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
320     int unit, mru;
321     u_long asyncmap;
322     int pcomp, accomp;
323 {
324     char c;
325
326     if (ioctl(fd, SIOCSIFMRU, &mru) < 0) {
327         syslog(LOG_ERR, "ioctl(SIOCSIFMRU): %m");
328     }
329
330     if (ioctl(fd, SIOCSIFRASYNCMAP, (caddr_t) &asyncmap) < 0) {
331         syslog(LOG_ERR, "ioctl(SIOCSIFRASYNCMAP): %m");
332     }
333
334     c = 2 + (pcomp? 1: 0);
335     if(ioctl(fd, SIOCSIFCOMPPROT, &c) < 0) {
336         syslog(LOG_ERR, "ioctl(SIOCSIFCOMPPROT): %m");
337     }
338
339     c = 2 + (accomp? 1: 0);
340     if (ioctl(fd, SIOCSIFCOMPAC, &c) < 0) {
341         syslog(LOG_ERR, "ioctl(SIOCSIFCOMPAC): %m");
342     }
343 }
344
345 /*
346  * sifvjcomp - config tcp header compression
347  */
348 int
349 sifvjcomp(u, vjcomp, cidcomp, maxcid)
350     int u, vjcomp, cidcomp, maxcid;
351 {
352     char x;
353
354     x = (vjcomp? 1: 0) + (cidcomp? 0: 2) + (maxcid << 4);
355     if (ioctl(fd, SIOCSIFVJCOMP, (caddr_t) &x) < 0) {
356         syslog(LOG_ERR, "ioctl(SIOCSIFVJCOMP): %m");
357         return 0;
358     }
359     return 1;
360 }
361
362 /*
363  * sifup - Config the interface up.
364  */
365 int
366 sifup(u)
367 {
368     struct ifreq ifr;
369
370     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
371     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
372         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
373         return 0;
374     }
375     ifr.ifr_flags |= IFF_UP;
376     if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
377         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
378         return 0;
379     }
380     return 1;
381 }
382
383 /*
384  * sifdown - Config the interface down.
385  */
386 int
387 sifdown(u)
388 {
389     struct ifreq ifr;
390     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
391     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
392         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
393         return 0;
394     }
395     ifr.ifr_flags &= ~IFF_UP;
396     if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
397         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
398         return 0;
399     }
400     return 1;
401 }
402
403 /*
404  * SET_SA_FAMILY - initialize a struct sockaddr, setting the sa_family field.
405  */
406 #define SET_SA_FAMILY(addr, family)             \
407     BZERO((char *) &(addr), sizeof(addr));      \
408     addr.sa_family = (family);
409
410 /*
411  * sifaddr - Config the interface IP addresses and netmask.
412  */
413 int
414 sifaddr(u, o, h, m)
415 {
416     int ret;
417     struct ifreq ifr;
418
419     ret = 1;
420     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
421     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
422     ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = o;
423     if (ioctl(s, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
424         syslog(LOG_ERR, "ioctl(SIOCSIFADDR): %m");
425         ret = 0;
426     }
427     ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = h;
428     if (ioctl(s, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
429         syslog(LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m");
430         ret = 0;
431     }
432     if (m != 0) {
433         ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = m;
434         syslog(LOG_INFO, "Setting interface mask to %s\n", ip_ntoa(m));
435         if (ioctl(s, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
436             syslog(LOG_ERR, "ioctl(SIOCSIFNETMASK): %m");
437             ret = 0;
438         }
439     }
440     return ret;
441 }
442
443 /*
444  * cifaddr - Clear the interface IP addresses, and delete routes
445  * through the interface if possible.
446  */
447 int
448 cifaddr(u, o, h)
449 {
450     struct rtentry rt;
451
452     SET_SA_FAMILY(rt.rt_dst, AF_INET);
453     ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = h;
454     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
455     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = o;
456     rt.rt_flags = RTF_HOST;
457     if (ioctl(s, SIOCDELRT, (caddr_t) &rt) < 0) {
458         syslog(LOG_ERR, "ioctl(SIOCDELRT): %m");
459         return 0;
460     }
461     return 1;
462 }
463
464 /*
465  * sifdefaultroute - assign a default route through the address given.
466  */
467 int
468 sifdefaultroute(u, g)
469 {
470     struct rtentry rt;
471
472     SET_SA_FAMILY(rt.rt_dst, AF_INET);
473     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
474     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
475     rt.rt_flags = RTF_GATEWAY;
476     if (ioctl(s, SIOCADDRT, &rt) < 0) {
477         syslog(LOG_ERR, "default route ioctl(SIOCADDRT): %m");
478         return 0;
479     }
480     return 1;
481 }
482
483 /*
484  * cifdefaultroute - delete a default route through the address given.
485  */
486 int
487 cifdefaultroute(u, g)
488 {
489     struct rtentry rt;
490
491     SET_SA_FAMILY(rt.rt_dst, AF_INET);
492     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
493     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
494     rt.rt_flags = RTF_GATEWAY;
495     if (ioctl(s, SIOCDELRT, &rt) < 0) {
496         syslog(LOG_ERR, "default route ioctl(SIOCDELRT): %m");
497         return 0;
498     }
499     return 1;
500 }
501
502 /*
503  * sifproxyarp - Make a proxy ARP entry for the peer.
504  */
505 int
506 sifproxyarp(unit, hisaddr)
507     int unit;
508     u_long hisaddr;
509 {
510     struct arpreq arpreq;
511
512     BZERO(&arpreq, sizeof(arpreq));
513
514     /*
515      * Get the hardware address of an interface on the same subnet
516      * as our local address.
517      */
518     if (!get_ether_addr(hisaddr, &arpreq.arp_ha)) {
519         syslog(LOG_WARNING, "Cannot determine ethernet address for proxy ARP");
520         return 0;
521     }
522
523     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
524     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
525     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
526     if (ioctl(s, SIOCSARP, (caddr_t)&arpreq) < 0) {
527         syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
528         return 0;
529     }
530
531     return 1;
532 }
533
534 /*
535  * cifproxyarp - Delete the proxy ARP entry for the peer.
536  */
537 int
538 cifproxyarp(unit, hisaddr)
539     int unit;
540     u_long hisaddr;
541 {
542     struct arpreq arpreq;
543
544     BZERO(&arpreq, sizeof(arpreq));
545     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
546     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
547     if (ioctl(s, SIOCDARP, (caddr_t)&arpreq) < 0) {
548         syslog(LOG_ERR, "ioctl(SIOCDARP): %m");
549         return 0;
550     }
551     return 1;
552 }
553
554 /*
555  * get_ether_addr - get the hardware address of an interface on the
556  * the same subnet as ipaddr.  Code borrowed from myetheraddr.c
557  * in the cslip-2.6 distribution, which is subject to the following
558  * copyright notice (which also applies to logwtmp below):
559  *
560  * Copyright (c) 1990, 1992 The Regents of the University of California.
561  * All rights reserved.
562  *
563  * Redistribution and use in source and binary forms, with or without
564  * modification, are permitted provided that: (1) source code distributions
565  * retain the above copyright notice and this paragraph in its entirety, (2)
566  * distributions including binary code include the above copyright notice and
567  * this paragraph in its entirety in the documentation or other materials
568  * provided with the distribution, and (3) all advertising materials mentioning
569  * features or use of this software display the following acknowledgement:
570  * ``This product includes software developed by the University of California,
571  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
572  * the University nor the names of its contributors may be used to endorse
573  * or promote products derived from this software without specific prior
574  * written permission.
575  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
576  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
577  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
578  */
579
580 #include <fcntl.h>
581 #include <nlist.h>
582 #include <kvm.h>
583 #include <arpa/inet.h>
584
585 /* XXX SunOS 4.1 defines this and 3.5 doesn't... */
586 #ifdef _nlist_h
587 #define SUNOS4
588 #endif
589
590 #ifdef SUNOS4
591 #include <netinet/in_var.h>
592 #endif
593 #include <netinet/if_ether.h>
594
595 /* Cast a struct sockaddr to a structaddr_in */
596 #define SATOSIN(sa) ((struct sockaddr_in *)(sa))
597
598 /* Determine if "bits" is set in "flag" */
599 #define ALLSET(flag, bits) (((flag) & (bits)) == (bits))
600
601 static struct nlist nl[] = {
602 #define N_IFNET 0
603         { "_ifnet" },
604         0
605 };
606
607 static void kread();
608
609 int
610 get_ether_addr(ipaddr, hwaddr)
611     u_long ipaddr;
612     struct sockaddr *hwaddr;
613 {
614     register kvm_t *kd;
615     register struct ifnet *ifp;
616     register struct arpcom *ac;
617     struct arpcom arpcom;
618     struct in_addr *inp;
619 #ifdef SUNOS4
620     register struct ifaddr *ifa;
621     register struct in_ifaddr *in;
622     union {
623         struct ifaddr ifa;
624         struct in_ifaddr in;
625     } ifaddr;
626 #endif
627     u_long addr, mask;
628
629     /* Open kernel memory for reading */
630     kd = kvm_open(0, 0, 0, O_RDONLY, NULL);
631     if (kd == 0) {
632         syslog(LOG_ERR, "kvm_open: %m");
633         return 0;
634     }
635
636     /* Fetch namelist */
637     if (kvm_nlist(kd, nl) != 0) {
638         syslog(LOG_ERR, "kvm_nlist failed");
639         return 0;
640     }
641
642     ac = &arpcom;
643     ifp = &arpcom.ac_if;
644 #ifdef SUNOS4
645     ifa = &ifaddr.ifa;
646     in = &ifaddr.in;
647 #endif
648
649     if (kvm_read(kd, nl[N_IFNET].n_value, (char *)&addr, sizeof(addr))
650         != sizeof(addr)) {
651         syslog(LOG_ERR, "error reading ifnet addr");
652         return 0;
653     }
654     for ( ; addr; addr = (u_long)ifp->if_next) {
655         if (kvm_read(kd, addr, (char *)ac, sizeof(*ac)) != sizeof(*ac)) {
656             syslog(LOG_ERR, "error reading ifnet");
657             return 0;
658         }
659
660         /* Only look at configured, broadcast interfaces */
661         if (!ALLSET(ifp->if_flags, IFF_UP | IFF_BROADCAST))
662             continue;
663 #ifdef SUNOS4
664         /* This probably can't happen... */
665         if (ifp->if_addrlist == 0)
666             continue;
667 #endif
668
669         /* Get interface ip address */
670 #ifdef SUNOS4
671         if (kvm_read(kd, (u_long)ifp->if_addrlist, (char *)&ifaddr,
672                      sizeof(ifaddr)) != sizeof(ifaddr)) {
673             syslog(LOG_ERR, "error reading ifaddr");
674             return 0;
675         }
676         inp = &SATOSIN(&ifa->ifa_addr)->sin_addr;
677 #else
678         inp = &SATOSIN(&ifp->if_addr)->sin_addr;
679 #endif
680
681         /* Check if this interface on the right subnet */
682 #ifdef SUNOS4
683         mask = in->ia_subnetmask;
684 #else
685         mask = ifp->if_subnetmask;
686 #endif
687         if ((ipaddr & mask) != (inp->s_addr & mask))
688             continue;
689
690         /* Copy out the local ethernet address */
691         hwaddr->sa_family = AF_UNSPEC;
692         BCOPY((caddr_t) &arpcom.ac_enaddr, hwaddr->sa_data,
693               sizeof(arpcom.ac_enaddr));
694         return 1;               /* success! */
695     }
696
697     /* couldn't find one */
698     return 0;
699 }
700
701 #define WTMPFILE        "/usr/adm/wtmp"
702
703 int
704 logwtmp(line, name, host)
705     char *line, *name, *host;
706 {
707     int fd;
708     struct stat buf;
709     struct utmp ut;
710
711     if ((fd = open(WTMPFILE, O_WRONLY|O_APPEND, 0)) < 0)
712         return;
713     if (!fstat(fd, &buf)) {
714         (void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
715         (void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
716         (void)strncpy(ut.ut_host, host, sizeof(ut.ut_host));
717         (void)time(&ut.ut_time);
718         if (write(fd, (char *)&ut, sizeof(struct utmp)) != sizeof(struct utmp))
719             (void)ftruncate(fd, buf.st_size);
720     }
721     close(fd);
722 }