add defns for debug stuff
[ppp.git] / pppd / sys-linux.c
1 /*
2  * sys-linux.c - System-dependent procedures for setting up
3  * PPP interfaces on Linux systems
4  *
5  * Copyright (c) 1989 Carnegie Mellon University.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms are permitted
9  * provided that the above copyright notice and this paragraph are
10  * duplicated in all such forms and that any documentation,
11  * advertising materials, and other materials related to such
12  * distribution and use acknowledge that the software was developed
13  * by Carnegie Mellon University.  The name of the
14  * University may not be used to endorse or promote products derived
15  * from this software without specific prior written permission.
16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19  */
20
21 /*
22  * TODO:
23  */
24
25 #include <sys/ioctl.h>
26 #include <sys/types.h>
27 #include <sys/socket.h>
28 #include <sys/time.h>
29 #include <sys/errno.h>
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <syslog.h>
34 #include <string.h>
35 #include <time.h>
36 #include <memory.h>
37 #include <utmp.h>
38 #include <mntent.h>
39 #include <signal.h>
40 #include <fcntl.h>
41
42 #include <net/if.h>
43 #include <net/ppp_defs.h>
44 #include <net/if_arp.h>
45 #include <net/if_ppp.h>
46 #include <net/if_route.h>
47 #include <linux/if_ether.h>
48 #include <netinet/in.h>
49
50 #include "pppd.h"
51 #include "fsm.h"
52 #include "ipcp.h"
53
54 static int initdisc = -1;       /* Initial TTY discipline */
55 static int prev_kdebugflag = 0;
56
57 static int restore_term;                /* 1 => we've munged the terminal */
58 static struct termios inittermios;      /* Initial TTY termios */
59
60 int sockfd;                     /* socket for doing interface ioctls */
61
62 static int driver_version      = 0;
63 static int driver_modification = 0;
64 static int driver_patch        = 0;
65
66 static char *lock_file;
67
68 #define MAX_IFS         32
69
70 #define FLAGS_GOOD (IFF_UP          | IFF_BROADCAST)
71 #define FLAGS_MASK (IFF_UP          | IFF_BROADCAST | \
72                     IFF_POINTOPOINT | IFF_LOOPBACK  | IFF_NOARP)
73
74 /*
75  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
76  * if it exists.
77  */
78
79 #define SET_SA_FAMILY(addr, family)                     \
80     memset ((char *) &(addr), '\0', sizeof(addr));      \
81     addr.sa_family = (family);
82
83 /*
84  * Functions to read and set the flags value in the device driver
85  */
86
87 int get_flags (void)
88   {    
89     int flags;
90
91     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0)
92       {
93         syslog(LOG_ERR, "ioctl(PPPIOCGFLAGS): %m");
94         quit();
95       }
96
97     MAINDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
98     return flags;
99   }
100
101 void set_flags (int flags)
102   {    
103     MAINDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
104     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0)
105       {
106         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS, %x): %m", flags);
107         quit();
108       }
109   }
110
111 /*
112  * sys_init - System-dependent initialization.
113  */
114
115 void sys_init(void)
116   {
117     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
118     setlogmask(LOG_UPTO(LOG_INFO));
119     if (debug)
120       {
121         setlogmask(LOG_UPTO(LOG_DEBUG));
122       }
123     
124     /* Get an internet socket for doing socket ioctls. */
125     sockfd = socket(AF_INET, SOCK_DGRAM, 0);
126     if (sockfd < 0)
127       {
128         syslog(LOG_ERR, "Couldn't create IP socket: %m");
129         die(1);
130       }
131   }
132
133 /*
134  * note_debug_level - note a change in the debug level.
135  */
136
137 void note_debug_level (void)
138   {
139     if (debug)
140       {
141         MAINDEBUG ((LOG_INFO, "Debug turned ON, Level %d", debug));
142         setlogmask(LOG_UPTO(LOG_DEBUG));
143       }
144     else
145       {
146         setlogmask(LOG_UPTO(LOG_WARNING));
147       }
148   }
149
150 /*
151  * set_kdebugflag - Define the debugging level for the kernel
152  */
153
154 int set_kdebugflag (int requested_level)
155   {
156     if (ioctl(fd, PPPIOCGDEBUG, &prev_kdebugflag) < 0)
157       {
158         syslog(LOG_ERR, "ioctl(PPPIOCGDEBUG): %m");
159         return (0);
160       }
161     
162     if (prev_kdebugflag != requested_level)
163       {
164         if (ioctl(fd, PPPIOCSDEBUG, &requested_level) < 0)
165           {
166             syslog (LOG_ERR, "ioctl(PPPIOCSDEBUG): %m");
167             return (0);
168           }
169         MAINDEBUG ((LOG_INFO, "set kernel debugging level to %d", requested_level));
170       }
171     return (1);
172   }
173
174 /*
175  * establish_ppp - Turn the serial port into a ppp interface.
176  */
177
178 void establish_ppp (void)
179   {
180     int pppdisc = N_PPP;
181     int sig     = SIGIO;
182
183     if (ioctl(fd, TIOCEXCL, 0) < 0)
184       {
185         syslog (LOG_WARNING, "ioctl(TIOCEXCL): %m");
186       }
187     
188     if (ioctl(fd, TIOCGETD, &initdisc) < 0)
189       {
190         syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
191         die (1);
192       }
193     
194     if (ioctl(fd, TIOCSETD, &pppdisc) < 0)
195       {
196         syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
197         die (1);
198       }
199     
200     if (ioctl(fd, PPPIOCGUNIT, &ifunit) < 0)
201       {
202         syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
203         die (1);
204       }
205     
206     set_kdebugflag (kdebugflag);
207
208     set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
209                                SC_RCV_EVNP | SC_RCV_ODDP));
210
211     MAINDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
212             driver_version, driver_modification, driver_patch));
213   }
214
215 /*
216  * disestablish_ppp - Restore the serial port to normal operation.
217  * This shouldn't call die() because it's called from die().
218  */
219
220 void disestablish_ppp(void)
221   {
222     int x;
223     char *s;
224 /*
225  * Check whether the link seems not to be 8-bit clean.
226  */
227     if (initdisc >= 0)
228       {
229         if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) == 0)
230           {
231             s = NULL;
232             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP))
233               {
234             case SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP:
235                 s = "nothing was received";
236                 break;
237
238             case SC_RCV_B7_0:
239             case SC_RCV_B7_0 | SC_RCV_EVNP:
240             case SC_RCV_B7_0 | SC_RCV_ODDP:
241             case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
242                 s = "all had bit 7 set to 1";
243                 break;
244
245             case SC_RCV_B7_1:
246             case SC_RCV_B7_1 | SC_RCV_EVNP:
247             case SC_RCV_B7_1 | SC_RCV_ODDP:
248             case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
249                 s = "all had bit 7 set to 0";
250                 break;
251
252             case SC_RCV_EVNP:
253                 s = "all had odd parity";
254                 break;
255
256             case SC_RCV_ODDP:
257                 s = "all had even parity";
258                 break;
259               }
260
261             if (s != NULL)
262               {
263                 syslog(LOG_WARNING, "Receive serial link is not 8-bit clean:");
264                 syslog(LOG_WARNING, "Problem: %s", s);
265               }
266           }
267
268         set_kdebugflag (prev_kdebugflag);
269         
270         if (ioctl(fd, TIOCSETD, &initdisc) < 0)
271           {
272             syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
273           }
274         
275         if (ioctl(fd, TIOCNXCL, 0) < 0)
276           {
277             syslog (LOG_WARNING, "ioctl(TIOCNXCL): %m");
278           }
279         
280         initdisc = -1;
281       }
282   }
283
284 /*
285  * List of valid speeds.
286  */
287
288 struct speed {
289     int speed_int, speed_val;
290 } speeds[] = {
291 #ifdef B50
292     { 50, B50 },
293 #endif
294 #ifdef B75
295     { 75, B75 },
296 #endif
297 #ifdef B110
298     { 110, B110 },
299 #endif
300 #ifdef B134
301     { 134, B134 },
302 #endif
303 #ifdef B150
304     { 150, B150 },
305 #endif
306 #ifdef B200
307     { 200, B200 },
308 #endif
309 #ifdef B300
310     { 300, B300 },
311 #endif
312 #ifdef B600
313     { 600, B600 },
314 #endif
315 #ifdef B1200
316     { 1200, B1200 },
317 #endif
318 #ifdef B1800
319     { 1800, B1800 },
320 #endif
321 #ifdef B2000
322     { 2000, B2000 },
323 #endif
324 #ifdef B2400
325     { 2400, B2400 },
326 #endif
327 #ifdef B3600
328     { 3600, B3600 },
329 #endif
330 #ifdef B4800
331     { 4800, B4800 },
332 #endif
333 #ifdef B7200
334     { 7200, B7200 },
335 #endif
336 #ifdef B9600
337     { 9600, B9600 },
338 #endif
339 #ifdef B19200
340     { 19200, B19200 },
341 #endif
342 #ifdef B38400
343     { 38400, B38400 },
344 #endif
345 #ifdef EXTA
346     { 19200, EXTA },
347 #endif
348 #ifdef EXTB
349     { 38400, EXTB },
350 #endif
351 #ifdef B57600
352     { 57600, B57600 },
353 #endif
354 #ifdef B115200
355     { 115200, B115200 },
356 #endif
357     { 0, 0 }
358 };
359
360 /*
361  * Translate from bits/second to a speed_t.
362  */
363
364 int translate_speed (int bps)
365   {
366     struct speed *speedp;
367
368     if (bps == 0)
369       {
370         for (speedp = speeds; speedp->speed_int; speedp++)
371           {
372             if (bps == speedp->speed_int)
373               {
374                 return speedp->speed_val;
375               }
376           }
377         syslog(LOG_WARNING, "speed %d not supported", bps);
378       }
379     return 0;
380   }
381
382 /*
383  * Translate from a speed_t to bits/second.
384  */
385
386 int baud_rate_of (int speed)
387   {
388     struct speed *speedp;
389     
390     if (speed != 0)
391       {
392         for (speedp = speeds; speedp->speed_int; speedp++)
393           {
394             if (speed == speedp->speed_val)
395               {
396                 return speedp->speed_int;
397               }
398           }
399       }
400     return 0;
401   }
402
403 /*
404  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
405  * at the requested speed, etc.  If `local' is true, set CLOCAL
406  * regardless of whether the modem option was specified.
407  */
408
409 void set_up_tty (int fd, int local)
410   {
411     int speed, x;
412     struct termios tios;
413     
414     if (tcgetattr(fd, &tios) < 0)
415       {
416         syslog(LOG_ERR, "tcgetattr: %m");
417         die(1);
418       }
419     
420     if (!restore_term)
421       {
422         inittermios = tios;
423       }
424     
425     tios.c_cflag     &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
426     tios.c_cflag     |= CS8 | CREAD | HUPCL;
427
428     tios.c_iflag      = IGNBRK | IGNPAR;
429     tios.c_oflag      = 0;
430     tios.c_lflag      = 0;
431     tios.c_cc[VMIN]   = 1;
432     tios.c_cc[VTIME]  = 0;
433     
434     if (local || !modem)
435       {
436         tios.c_cflag ^= (CLOCAL | HUPCL);
437       }
438
439     switch (crtscts)
440       {
441     case 1:
442         tios.c_cflag |= CRTSCTS;
443         break;
444
445     case 2:
446         tios.c_iflag     |= IXOFF;
447         tios.c_cc[VSTOP]  = 0x13;       /* DC3 = XOFF = ^S */
448         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
449         break;
450
451     case -1:
452         tios.c_cflag &= ~CRTSCTS;
453         break;
454
455     default:
456         break;
457       }
458     
459     speed = translate_speed(inspeed);
460     if (speed)
461       {
462         cfsetospeed (&tios, speed);
463         cfsetispeed (&tios, speed);
464       }
465 /*
466  * We can't proceed if the serial port speed is B0,
467  * since that implies that the serial port is disabled.
468  */
469     else
470       {
471         speed = cfgetospeed(&tios);
472         if (speed == B0)
473           {
474             syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
475                    devnam);
476             die (1);
477           }
478       }
479
480     if (tcsetattr(fd, TCSAFLUSH, &tios) < 0)
481       {
482         syslog(LOG_ERR, "tcsetattr: %m");
483         die(1);
484       }
485     
486     baud_rate    = baud_rate_of(speed);
487     restore_term = TRUE;
488   }
489
490 /*
491  * setdtr - control the DTR line on the serial port.
492  * This is called from die(), so it shouldn't call die().
493  */
494
495 void setdtr (int fd, int on)
496   {
497     int modembits = TIOCM_DTR;
498
499     ioctl(fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
500   }
501
502 /*
503  * restore_tty - restore the terminal to the saved settings.
504  */
505
506 void restore_tty (void)
507   {
508     if (restore_term)
509       {
510         restore_term = 0;
511 /*
512  * Turn off echoing, because otherwise we can get into
513  * a loop with the tty and the modem echoing to each other.
514  * We presume we are the sole user of this tty device, so
515  * when we close it, it will revert to its defaults anyway.
516  */
517         if (!default_device)
518           {
519             inittermios.c_lflag &= ~(ECHO | ECHONL);
520           }
521         
522         if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
523           {
524             if (errno != ENXIO)
525               {
526                 syslog(LOG_WARNING, "tcsetattr: %m");
527               }
528           }
529       }
530   }
531
532 /*
533  * output - Output PPP packet.
534  */
535
536 void output (int unit, unsigned char *p, int len)
537   {
538     if (unit != 0)
539       {
540         MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
541       }
542     
543     if (debug)
544       {
545         log_packet(p, len, "sent ");
546       }
547     
548     if (write(fd, p, len) < 0)
549       {
550         syslog(LOG_ERR, "write: %m");
551         die(1);
552       }
553   }
554
555 /*
556  * wait_input - wait until there is data available on fd,
557  * for the length of time specified by *timo (indefinite
558  * if timo is NULL).
559  */
560
561 void wait_input (struct timeval *timo)
562   {
563     fd_set ready;
564     int n;
565     
566     FD_ZERO(&ready);
567     FD_SET(fd, &ready);
568
569     n = select(fd+1, &ready, NULL, &ready, timo);
570     if (n < 0 && errno != EINTR)
571       {
572         syslog(LOG_ERR, "select: %m");
573         die(1);
574       }
575   }
576
577 /*
578  * read_packet - get a PPP packet from the serial device.
579  */
580
581 int read_packet (unsigned char *buf)
582   {
583     int len;
584   
585     len = read(fd, buf, PPP_MTU + PPP_HDRLEN);
586     if (len < 0)
587       {
588         if (errno == EWOULDBLOCK)
589           {
590             return -1;
591           }
592         syslog(LOG_ERR, "read(fd): %m");
593         die(1);
594       }
595     return len;
596   }
597
598 /*
599  * ppp_send_config - configure the transmit characteristics of
600  * the ppp interface.
601  */
602
603 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
604   {
605     u_int x;
606     struct ifreq ifr;
607   
608     MAINDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
609     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
610     ifr.ifr_mtu = mtu;
611
612     if (ioctl(sockfd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
613       {
614         syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
615         quit();
616       }
617     
618     MAINDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
619     if (ioctl(fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0)
620       {
621         syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m");
622         quit();
623       }
624     
625     x = get_flags();
626     x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
627     x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
628     set_flags(x);
629   }
630
631 /*
632  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
633  */
634
635 void ppp_set_xaccm (int unit, ext_accm accm)
636   {
637     MAINDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
638                 accm[0], accm[1], accm[2], accm[3]));
639
640     if (ioctl(fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
641       {
642         syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
643       }
644   }
645
646 /*
647  * ppp_recv_config - configure the receive-side characteristics of
648  * the ppp interface.
649  */
650
651 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
652   {
653     u_int x;
654
655     MAINDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
656     if (ioctl(fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
657       {
658         syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m");
659       }
660
661     MAINDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
662     if (ioctl(fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0)
663       {
664         syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m");
665         quit();
666       }
667
668     x = get_flags();
669     x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
670     set_flags (x);
671   }
672
673 /*
674  * ccp_test - ask kernel whether a given compression method
675  * is acceptable for use.
676  */
677
678 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
679   {
680     struct ppp_option_data data;
681
682     data.ptr      = opt_ptr;
683     data.length   = opt_len;
684     data.transmit = for_transmit;
685
686     return ioctl(fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0;
687   }
688
689 /*
690  * ccp_flags_set - inform kernel about the current state of CCP.
691  */
692
693 void ccp_flags_set (int unit, int isopen, int isup)
694   {
695     int x = get_flags();
696     x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
697     x = isup?   x | SC_CCP_UP   : x &~ SC_CCP_UP;
698     set_flags (x);
699   }
700
701 /*
702  * ccp_fatal_error - returns 1 if decompression was disabled as a
703  * result of an error detected after decompression of a packet,
704  * 0 otherwise.  This is necessary because of patent nonsense.
705  */
706
707 int ccp_fatal_error (int unit)
708   {
709     int x = get_flags();
710
711     return x & SC_DC_FERROR;
712   }
713
714 /*
715  * sifvjcomp - config tcp header compression
716  */
717
718 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
719   {
720     u_int x = get_flags();
721
722     if (vjcomp)
723       {
724         if (ioctl (fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
725           {
726             syslog (LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
727             vjcomp = 0;
728           }
729       }
730
731     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
732     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
733     set_flags (x);
734
735     return 1;
736   }
737
738 /*
739  * sifup - Config the interface up and enable IP packets to pass.
740  */
741
742 int sifup (int u)
743   {
744     struct ifreq ifr;
745
746     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
747     if (ioctl(sockfd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
748       {
749         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
750         return 0;
751       }
752
753     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
754     if (ioctl(sockfd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
755       {
756         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
757         return 0;
758       }
759     return 1;
760   }
761
762 /*
763  * sifdown - Config the interface down and disable IP.
764  */
765
766 int sifdown (int u)
767   {
768     struct ifreq ifr;
769
770     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
771     if (ioctl(sockfd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
772       {
773         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
774         return 0;
775       }
776
777     ifr.ifr_flags &= ~IFF_UP;
778     ifr.ifr_flags |= IFF_POINTOPOINT;
779     if (ioctl(sockfd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
780       {
781         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
782         return 0;
783       }
784     return 1;
785   }
786
787 /*
788  * sifaddr - Config the interface IP addresses and netmask.
789  */
790
791 int sifaddr (int unit, int our_adr, int his_adr, int net_mask)
792   {
793     struct ifreq   ifr; 
794     struct rtentry rt;
795     
796     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET); 
797     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET); 
798     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET); 
799
800     strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
801 /*
802  *  Set our IP address
803  */
804     ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
805     if (ioctl(sockfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
806       {
807         if (errno != EEXIST)
808           {
809             syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m");
810           }
811         else
812           {
813             syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
814           }
815         return (0);
816       } 
817 /*
818  *  Set the gateway address
819  */
820     ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
821     if (ioctl(sockfd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0)
822       {
823         syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m"); 
824         return (0);
825       } 
826 /*
827  *  Set the netmask
828  */
829     if (net_mask != 0)
830       {
831         ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
832         if (ioctl(sockfd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0)
833           {
834             syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m"); 
835             return (0);
836           } 
837       }
838 /*
839  *  Add the device route
840  */
841     memset (&rt, '\0', sizeof (rt));
842
843     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
844     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
845     rt.rt_dev = ifname;  /* MJC */
846
847     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
848     ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
849     rt.rt_flags = RTF_UP | RTF_HOST;
850
851     if (ioctl(sockfd, SIOCADDRT, &rt) < 0)
852       {
853         syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m");
854         return (0);
855       }
856     return 1;
857   }
858
859 /*
860  * cifaddr - Clear the interface IP addresses, and delete routes
861  * through the interface if possible.
862  */
863
864 int cifaddr (int unit, int our_adr, int his_adr)
865   {
866     struct rtentry rt;
867 /*
868  *  Delete the route through the device
869  */
870     memset (&rt, '\0', sizeof (rt));
871
872     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
873     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
874     rt.rt_dev = ifname;  /* MJC */
875
876     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
877     ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
878     rt.rt_flags = RTF_UP | RTF_HOST;
879
880     if (ioctl(sockfd, SIOCDELRT, &rt) < 0)
881       {
882         syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m");
883         return (0);
884       }
885     return 1;
886   }
887
888 /*
889  * path_to_route - determine the path to the proc file system data
890  */
891
892 FILE *route_fd = (FILE *) 0;
893 static char route_buffer [100];
894
895 static char *path_to_route (void);
896 static int open_route_table (void);
897 static void close_route_table (void);
898 static int read_route_table (struct rtentry *rt);
899 static int defaultroute_exists (void);
900
901 /*
902  * path_to_route - find the path to the route tables in the proc file system
903  */
904
905 static char *path_to_route (void)
906   {
907     struct mntent *mntent;
908     FILE *fp;
909
910     fp = fopen (MOUNTED, "r");
911     if (fp != 0)
912       {
913         mntent = getmntent (fp);
914         while (mntent != (struct mntent *) 0)
915           {
916             if (strcmp (mntent->mnt_type, MNTTYPE_IGNORE) != 0)
917               {
918                 if (strcmp (mntent->mnt_type, "proc") == 0)
919                   {
920                     strncpy (route_buffer, mntent->mnt_dir,
921                              sizeof (route_buffer)-10);
922                     route_buffer [sizeof (route_buffer)-10] = '\0';
923                     strcat (route_buffer, "/net/route");
924                     
925                     fclose (fp);
926                     return (route_buffer);
927                   }
928               }
929             mntent = getmntent (fp);
930           }
931         fclose (fp);
932       }
933
934     syslog (LOG_ERR, "proc file system not mounted");
935     return 0;
936   }
937
938 /*
939  * open_route_table - open the interface to the route table
940  */
941
942 static int open_route_table (void)
943   {
944     char *path;
945
946     if (route_fd != (FILE *) 0)
947       {
948         close_route_table();
949       }
950
951     path = path_to_route();
952     if (path == NULL)
953       {
954         return 0;
955       }
956
957     route_fd = fopen (path, "r");
958     if (route_fd == (FILE *) 0)
959       {
960         syslog (LOG_ERR, "can not open %s: %m", path);
961         return 0;
962       }
963
964     /* read and discard the header line. */
965     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
966       {
967         close_route_table();
968         return 0;
969       }
970     return 1;
971   }
972
973 /*
974  * close_route_table - close the interface to the route table
975  */
976
977 static void close_route_table (void)
978   {
979     if (route_fd != (FILE *) 0)
980       {
981         fclose (route_fd);
982         route_fd = (FILE *) 0;
983       }
984   }
985
986 /*
987  * read_route_table - read the next entry from the route table
988  */
989
990 static int read_route_table (struct rtentry *rt)
991   {
992     static char delims[] = " \t\n";
993     char *dev_ptr, *ptr, *dst_ptr, *gw_ptr, *flag_ptr;
994
995     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
996       {
997         return 0;
998       }
999
1000     memset (rt, '\0', sizeof (struct rtentry));
1001
1002     dev_ptr  = strtok (route_buffer, delims); /* interface name */
1003     dst_ptr  = strtok (NULL,         delims); /* destination address */
1004     gw_ptr   = strtok (NULL,         delims); /* gateway */
1005     flag_ptr = strtok (NULL,         delims); /* flags */
1006
1007     ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1008       strtoul (dst_ptr, NULL, 16);
1009
1010     ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1011       strtoul (gw_ptr, NULL, 16);
1012
1013     rt->rt_flags = (short) strtoul (flag_ptr, NULL, 16);
1014     rt->rt_dev   = dev_ptr;
1015
1016     return 1;
1017   }
1018
1019 /*
1020  * defaultroute_exists - determine if there is a default route
1021  */
1022
1023 static int defaultroute_exists (void)
1024   {
1025     struct rtentry rt;
1026     int    result = 0;
1027
1028     if (!open_route_table())
1029       {
1030         return 0;
1031       }
1032
1033     while (read_route_table(&rt) != 0)
1034       {
1035         if (rt.rt_flags & RTF_UP == 0)
1036           {
1037             continue;
1038           }
1039
1040         if (((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr == 0L)
1041           {
1042             syslog (LOG_ERR,
1043                     "ppp not replacing existing default route to %s[%s]",
1044                     rt.rt_dev,
1045                     inet_ntoa (((struct sockaddr_in *) &rt.rt_gateway)->
1046                                sin_addr.s_addr));
1047             result = 1;
1048             break;
1049           }
1050       }
1051
1052     close_route_table();
1053     return result;
1054   }
1055
1056 /*
1057  * sifdefaultroute - assign a default route through the address given.
1058  */
1059
1060 int sifdefaultroute (int unit, int gateway)
1061   {
1062     struct rtentry rt;
1063
1064     if (defaultroute_exists())
1065       {
1066         return 0;
1067       }
1068
1069     memset (&rt, '\0', sizeof (rt));
1070     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1071     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1072     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1073     
1074     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1075     if (ioctl(sockfd, SIOCADDRT, &rt) < 0)
1076       {
1077         syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m");
1078         return 0;
1079       }
1080     return 1;
1081   }
1082
1083 /*
1084  * cifdefaultroute - delete a default route through the address given.
1085  */
1086
1087 int cifdefaultroute (int unit, int gateway)
1088   {
1089     struct rtentry rt;
1090   
1091     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1092     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1093     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1094     
1095     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1096     if (ioctl(sockfd, SIOCDELRT, &rt) < 0)
1097       {
1098         syslog (LOG_ERR, "default route ioctl(SIOCDELRT): %m");
1099         return 0;
1100       }
1101     return 1;
1102   }
1103
1104 /*
1105  * sifproxyarp - Make a proxy ARP entry for the peer.
1106  */
1107
1108 int sifproxyarp (int unit, u_int32_t his_adr)
1109   {
1110     struct arpreq arpreq;
1111
1112     memset (&arpreq, '\0', sizeof(arpreq));
1113 /*
1114  * Get the hardware address of an interface on the same subnet
1115  * as our local address.
1116  */
1117     if (!get_ether_addr(his_adr, &arpreq.arp_ha))
1118       {
1119         syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1120         return 0;
1121       }
1122     
1123     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1124     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1125     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1126     
1127     if (ioctl(sockfd, SIOCSARP, (caddr_t)&arpreq) < 0)
1128       {
1129         syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
1130         return 0;
1131       }
1132     return 1;
1133   }
1134
1135 /*
1136  * cifproxyarp - Delete the proxy ARP entry for the peer.
1137  */
1138
1139 int cifproxyarp (int unit, u_int32_t his_adr)
1140   {
1141     struct arpreq arpreq;
1142   
1143     memset (&arpreq, '\0', sizeof(arpreq));
1144     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1145     
1146     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1147     if (ioctl(sockfd, SIOCDARP, (caddr_t)&arpreq) < 0)
1148       {
1149         syslog(LOG_WARNING, "ioctl(SIOCDARP): %m");
1150         return 0;
1151       }
1152     return 1;
1153   }
1154      
1155 /*
1156  * get_ether_addr - get the hardware address of an interface on the
1157  * the same subnet as ipaddr.
1158  */
1159
1160 int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr)
1161   {
1162     struct ifreq *ifr, *ifend, *ifp;
1163     int i;
1164     u_int32_t ina, mask;
1165     struct sockaddr_dl *dla;
1166     struct ifreq ifreq;
1167     struct ifconf ifc;
1168     struct ifreq ifs[MAX_IFS];
1169     
1170     ifc.ifc_len = sizeof(ifs);
1171     ifc.ifc_req = ifs;
1172     if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0)
1173       {
1174         syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m");
1175         return 0;
1176       }
1177
1178     MAINDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1179                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1180 /*
1181  * Scan through looking for an interface with an Internet
1182  * address on the same subnet as `ipaddr'.
1183  */
1184     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1185     for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1186       {
1187         if (ifr->ifr_addr.sa_family == AF_INET)
1188           {
1189             ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1190             strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1191             MAINDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1192                         ifreq.ifr_name));
1193 /*
1194  * Check that the interface is up, and not point-to-point
1195  * or loopback.
1196  */
1197             if (ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0)
1198               {
1199                 continue;
1200               }
1201
1202             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1203               {
1204                 continue;
1205               }
1206 /*
1207  * Get its netmask and check that it's on the right subnet.
1208  */
1209             if (ioctl(sockfd, SIOCGIFNETMASK, &ifreq) < 0)
1210               {
1211                 continue;
1212               }
1213
1214             mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1215             MAINDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1216                         ip_ntoa(ina), ntohl(mask)));
1217
1218             if (((ipaddr ^ ina) & mask) != 0)
1219               {
1220                 continue;
1221               }
1222             break;
1223           }
1224       }
1225     
1226     if (ifr >= ifend)
1227       {
1228         return 0;
1229       }
1230
1231     syslog(LOG_INFO, "found interface %s for proxy arp", ifreq.ifr_name);
1232 /*
1233  * Now get the hardware address.
1234  */
1235     if (ioctl (sockfd, SIOCGIFHWADDR, &ifreq) < 0)
1236       {
1237         syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m", ifreq.ifr_name);
1238         return 0;
1239       }
1240
1241     hwaddr->sa_family = ARPHRD_ETHER;
1242     memcpy (&hwaddr->sa_data, &ifreq.ifr_hwaddr.sa_data, ETH_ALEN);
1243
1244     MAINDEBUG ((LOG_DEBUG,
1245                 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x",
1246                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1247                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1248                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1249                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1250                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1251                 (int) ((unsigned char *) &hwaddr->sa_data)[5]));
1252     return 1;
1253   }
1254
1255 /*
1256  * Return user specified netmask, modified by any mask we might determine
1257  * for address `addr' (in network byte order).
1258  * Here we scan through the system's list of interfaces, looking for
1259  * any non-point-to-point interfaces which might appear to be on the same
1260  * network as `addr'.  If we find any, we OR in their netmask to the
1261  * user-specified netmask.
1262  */
1263
1264 u_int32_t GetMask (u_int32_t addr)
1265   {
1266     u_int32_t mask, nmask, ina;
1267     struct ifreq *ifr, *ifend, ifreq;
1268     struct ifconf ifc;
1269     struct ifreq ifs[MAX_IFS];
1270
1271     addr = ntohl(addr);
1272     
1273     if (IN_CLASSA(addr))        /* determine network mask for address class */
1274       {
1275         nmask = IN_CLASSA_NET;
1276       }
1277     else
1278       {
1279         if (IN_CLASSB(addr))
1280           {
1281             nmask = IN_CLASSB_NET;
1282           }
1283         else
1284           {
1285             nmask = IN_CLASSC_NET;
1286           }
1287       }
1288     
1289     /* class D nets are disallowed by bad_ip_adrs */
1290     mask = netmask | htonl(nmask);
1291 /*
1292  * Scan through the system's network interfaces.
1293  */
1294     ifc.ifc_len = sizeof(ifs);
1295     ifc.ifc_req = ifs;
1296     if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0)
1297       {
1298         syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m");
1299         return mask;
1300       }
1301     
1302     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1303     for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1304       {
1305 /*
1306  * Check the interface's internet address.
1307  */
1308         if (ifr->ifr_addr.sa_family != AF_INET)
1309           {
1310             continue;
1311           }
1312         ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1313         if (((ntohl(ina) ^ addr) & nmask) != 0)
1314           {
1315             continue;
1316           }
1317 /*
1318  * Check that the interface is up, and not point-to-point or loopback.
1319  */
1320         strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1321         if (ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0)
1322           {
1323             continue;
1324           }
1325         
1326         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1327           {
1328             continue;
1329           }
1330 /*
1331  * Get its netmask and OR it into our mask.
1332  */
1333         if (ioctl(sockfd, SIOCGIFNETMASK, &ifreq) < 0)
1334           {
1335             continue;
1336           }
1337         mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1338         break;
1339       }
1340
1341     return mask;
1342   }
1343
1344 /*
1345  * Internal routine to decode the version.modification.patch level
1346  */
1347
1348 static void decode_version (char *buf, int *version,
1349                             int *modification, int *patch)
1350   {
1351
1352     *version      = (int) strtoul (buf, &buf, 10);
1353     *modification = 0;
1354     *patch        = 0;
1355     
1356     if (*buf == '.')
1357       {
1358         ++buf;
1359         *modification = (int) strtoul (buf, &buf, 10);
1360         if (*buf == '.')
1361           {
1362             ++buf;
1363             *patch = (int) strtoul (buf, &buf, 10);
1364           }
1365       }
1366     
1367     if (*buf != '\0')
1368       {
1369         *version      =
1370         *modification =
1371         *patch        = 0;
1372       }
1373   }
1374
1375 /*
1376  * Procedure to determine if the PPP line dicipline is registered.
1377  */
1378
1379 int
1380 ppp_registered(void)
1381   {
1382     int local_fd;
1383     int ppp_disc  = N_PPP;
1384     int init_disc = -1;
1385     int initfdflags;
1386
1387     local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1388     if (local_fd < 0)
1389       {
1390         syslog(LOG_ERR, "Failed to open %s: %m", devnam);
1391         return 0;
1392       }
1393
1394     initfdflags = fcntl(local_fd, F_GETFL);
1395     if (initfdflags == -1)
1396       {
1397         syslog(LOG_ERR, "Couldn't get device fd flags: %m");
1398         close (local_fd);
1399         return 0;
1400       }
1401
1402     initfdflags &= ~O_NONBLOCK;
1403     fcntl(local_fd, F_SETFL, initfdflags);
1404 /*
1405  * Read the initial line dicipline and try to put the device into the
1406  * PPP dicipline.
1407  */
1408     if (ioctl(local_fd, TIOCGETD, &init_disc) < 0)
1409       {
1410         syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
1411         close (local_fd);
1412         return 0;
1413       }
1414     
1415     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0)
1416       {
1417         syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
1418         close (local_fd);
1419         return 0;
1420       }
1421     
1422     if (ioctl(local_fd, TIOCSETD, &init_disc) < 0)
1423       {
1424         syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
1425         close (local_fd);
1426         return 0;
1427       }
1428     
1429     close (local_fd);
1430     return 1;
1431   }
1432
1433 /*
1434  * ppp_available - check whether the system has any ppp interfaces
1435  * (in fact we check whether we can do an ioctl on ppp0).
1436  */
1437
1438 int ppp_available(void)
1439   {
1440     int s, ok;
1441     struct ifreq ifr;
1442     int my_version,     my_modification,     my_patch;
1443 /*
1444  * Open a socket for doing the ioctl operations.
1445  */    
1446     s = socket(AF_INET, SOCK_DGRAM, 0);
1447     if (s < 0)
1448       {
1449         return 0;
1450       }
1451     
1452     strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1453     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1454 /*
1455  * If the device did not exist then attempt to create one by putting the
1456  * current tty into the PPP discipline. If this works then obtain the
1457  * flags for the device again.
1458  */
1459     if (!ok)
1460       {
1461         if (ppp_registered())
1462           {
1463             strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1464             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1465           }
1466       }
1467 /*
1468  * Ensure that the hardware address is for PPP and not something else
1469  */
1470     if (ok)
1471       {
1472         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1473       }
1474
1475     if (ok && ifr.ifr_hwaddr.sa_family != ARPHRD_PPP)
1476       {
1477         ok = 0;
1478       }
1479 /*
1480  *  This is the PPP device. Validate the version of the driver at this
1481  *  point to ensure that this program will work with the driver.
1482  */
1483     if (ok)
1484       {
1485         char   abBuffer [1024];
1486         int    size;
1487
1488         ifr.ifr_data = abBuffer;
1489         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1490         ok   = size >= 0;
1491
1492         if (ok)
1493           {
1494             decode_version (abBuffer,
1495                             &driver_version,
1496                             &driver_modification,
1497                             &driver_patch);
1498           }
1499       }
1500     
1501     if (!ok)
1502       {
1503         driver_version      =
1504         driver_modification =
1505         driver_patch        = 0;
1506       }
1507 /*
1508  * Validate the version of the driver against the version that we used.
1509  */
1510     decode_version (PPP_VERSION,
1511                     &my_version,
1512                     &my_modification,
1513                     &my_patch);
1514
1515     /* The version numbers must match */
1516     if (driver_version != my_version)
1517       {
1518         ok = 0;
1519       }
1520       
1521     /* The modification levels must be legal */
1522     if (driver_modification < my_modification)
1523       {
1524         ok = 0;
1525       }
1526
1527     if (!ok)
1528       {
1529         fprintf(stderr, "Sorry - PPP driver version %d.%d.%d is out of date\n",
1530                 driver_version, driver_modification, driver_patch);
1531         close (s);
1532         exit (1);
1533       }
1534     
1535     close(s);
1536     return ok;
1537   }
1538
1539 int logwtmp (char *line, char *name, char *host)
1540   {
1541     struct utmp ut;
1542     int    mode;
1543 /*
1544  * Control the 'mesg' function based upon the state of the logon
1545  * operation.
1546  */
1547     mode = (*name != '\0') ? 0600 : 0622;
1548     if (chmod (devnam, mode) < 0)
1549       {
1550         syslog (LOG_ERR, "chmod(\"%s\", 0%o): %m", devnam, mode);
1551       }
1552 /*
1553  * Update the signon database for users.
1554  */
1555     memset (&ut, 0, sizeof (ut));
1556     (void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1557     (void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
1558     (void)strncpy(ut.ut_host, host, sizeof(ut.ut_host));
1559     (void)time(&ut.ut_time);
1560         
1561     pututline (&ut);            /* Write the line to the proper place */
1562     endutent();                 /* Indicate operation is complete */
1563   }
1564
1565 /*
1566  * Code for locking/unlocking the serial device.
1567  * This code is derived from chat.c.
1568  */
1569
1570 #define LOCK_PREFIX     "/var/lock/LCK.."
1571
1572 /*
1573  * lock - create a lock file for the named device
1574  */
1575
1576 int lock (char *dev)
1577   {
1578     char hdb_lock_buffer[12];
1579     int fd, pid, n;
1580     char *p;
1581
1582     p = strrchr(dev, '/');
1583     if (p != NULL)
1584       {
1585         dev = ++p;
1586       }
1587
1588     lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
1589     if (lock_file == NULL)
1590       {
1591         novm("lock file name");
1592       }
1593
1594     strcpy (lock_file, LOCK_PREFIX);
1595     strcat (lock_file, dev);
1596 /*
1597  * Attempt to create the lock file at this point.
1598  */
1599     while (1)
1600       {
1601         fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1602         if (fd >= 0)
1603           {
1604             sprintf(hdb_lock_buffer, "%010d\n", getpid());
1605             write(fd, hdb_lock_buffer, 11);
1606             close(fd);
1607             return 0;
1608           }
1609 /*
1610  * If the file exists then check to see if the pid is stale
1611  */
1612         if (errno == EEXIST)
1613           {
1614             fd = open(lock_file, O_RDONLY, 0);
1615             if (fd < 0)
1616               {
1617                 if (errno == ENOENT) /* This is just a timing problem. */
1618                   {
1619                     continue;
1620                   }
1621                 break;
1622               }
1623
1624             /* Read the lock file to find out who has the device locked */
1625             n = read (fd, hdb_lock_buffer, 11);
1626             close (fd);
1627             if (n < 0)
1628               {
1629                 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
1630                 break;
1631               }
1632
1633             if (n == 0)
1634               {
1635                 unlink (lock_file);
1636                 syslog (LOG_NOTICE, "Removed stale lock on %s", lock_file);
1637                 continue;
1638               }
1639
1640             hdb_lock_buffer[n] = '\0';
1641             sscanf (hdb_lock_buffer, " %d", &pid);
1642
1643             if (kill(pid, 0) == -1 && errno == ESRCH)
1644               {
1645                 /* pid no longer exists - remove the lock file */
1646                 if (unlink (lock_file) == 0)
1647                   {
1648                     syslog (LOG_NOTICE, "Removed stale lock on %s (pid %d)",
1649                             dev, pid);
1650                     continue;
1651                   }
1652               }
1653
1654             syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, pid);
1655             break;
1656           }
1657
1658         syslog(LOG_ERR, "Can't create lock file %s: %m", lock_file);
1659         break;
1660       }
1661
1662     free(lock_file);
1663     lock_file = NULL;
1664     return -1;
1665 }
1666
1667 /*
1668  * unlock - remove our lockfile
1669  */
1670
1671 void unlock(void)
1672   {
1673     if (lock_file)
1674       {
1675         unlink(lock_file);
1676         free(lock_file);
1677         lock_file = NULL;
1678       }
1679   }