MD4Update takes bytes not bits! Now the regression test of the README.MSCHAP80
[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 #include <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
24 #include <sys/time.h>
25 #include <sys/errno.h>
26 #include <sys/file.h>
27 #include <sys/stat.h>
28 #include <sys/utsname.h>
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <syslog.h>
33 #include <string.h>
34 #include <time.h>
35 #include <memory.h>
36 #include <utmp.h>
37 #include <mntent.h>
38 #include <signal.h>
39 #include <fcntl.h>
40 #include <ctype.h>
41 #include <termios.h>
42 #include <unistd.h>
43
44 /* This is in netdevice.h. However, this compile will fail miserably if
45    you attempt to include netdevice.h because it has so many references
46    to __memcpy functions which it should not attempt to do. So, since I
47    really don't use it, but it must be defined, define it now. */
48
49 #ifndef MAX_ADDR_LEN
50 #define MAX_ADDR_LEN 7
51 #endif
52
53 #if __GLIBC__ >= 2
54 #include <asm/types.h>          /* glibc 2 conflicts with linux/types.h */
55 #include <net/if.h>
56 #include <net/if_arp.h>
57 #include <net/route.h>
58 #include <netinet/if_ether.h>
59 #else
60 #include <linux/types.h>
61 #include <linux/if.h>
62 #include <linux/if_arp.h>
63 #include <linux/route.h>
64 #include <linux/if_ether.h>
65 #endif
66 #include <netinet/in.h>
67 #include <arpa/inet.h>
68
69 #include <linux/ppp_defs.h>
70 #include <linux/if_ppp.h>
71
72 #include "pppd.h"
73 #include "fsm.h"
74 #include "ipcp.h"
75 #include "patchlevel.h"
76
77 #ifdef IPX_CHANGE
78 #include "ipxcp.h"
79 #if __GLIBC__ >= 2 && \
80     !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
81 #include <netipx/ipx.h>
82 #else
83 #include <linux/ipx.h>
84 #endif
85 #endif /* IPX_CHANGE */
86
87 #ifdef LOCKLIB
88 #include <sys/locks.h>
89 #endif
90
91 #ifndef RTF_DEFAULT  /* Normally in <linux/route.h> from <net/route.h> */
92 #define RTF_DEFAULT  0
93 #endif
94
95 #define ok_error(num) ((num)==EIO)
96
97 static int tty_disc = N_TTY;    /* The TTY discipline */
98 static int ppp_disc = N_PPP;    /* The PPP discpline */
99 static int initfdflags = -1;    /* Initial file descriptor flags for fd */
100 static int ppp_fd = -1;         /* fd which is set to PPP discipline */
101 static int sock_fd = -1;        /* socket for doing interface ioctls */
102 static int slave_fd = -1;
103 static int master_fd = -1;
104
105 static int has_proxy_arp       = 0;
106 static int driver_version      = 0;
107 static int driver_modification = 0;
108 static int driver_patch        = 0;
109 static int driver_is_old       = 0;
110 static int restore_term        = 0;     /* 1 => we've munged the terminal */
111 static struct termios inittermios;      /* Initial TTY termios */
112
113 static char loop_name[20];
114 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
115
116 static int      if_is_up;       /* Interface has been marked up */
117 static u_int32_t default_route_gateway; /* Gateway for default route added */
118 static u_int32_t proxy_arp_addr;        /* Addr for proxy arp entry added */
119
120 static char *lock_file;
121
122 static struct utsname utsname;  /* for the kernel version */
123 static int kernel_version;
124 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
125
126 #define MAX_IFS         100
127
128 #define FLAGS_GOOD (IFF_UP          | IFF_BROADCAST)
129 #define FLAGS_MASK (IFF_UP          | IFF_BROADCAST | \
130                     IFF_POINTOPOINT | IFF_LOOPBACK  | IFF_NOARP)
131
132 /* Prototypes for procedures local to this file. */
133 static int get_flags (void);
134 static void set_flags (int flags);
135 static int translate_speed (int bps);
136 static int baud_rate_of (int speed);
137 static char *path_to_route (void);
138 static void close_route_table (void);
139 static int open_route_table (void);
140 static int read_route_table (struct rtentry *rt);
141 static int defaultroute_exists (struct rtentry *rt);
142 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
143                            char *name);
144 static void decode_version (char *buf, int *version, int *mod, int *patch);
145
146 extern u_char   inpacket_buf[]; /* borrowed from main.c */
147
148 /*
149  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
150  * if it exists.
151  */
152
153 #define SET_SA_FAMILY(addr, family)                     \
154     memset ((char *) &(addr), '\0', sizeof(addr));      \
155     addr.sa_family = (family);
156
157 /*
158  * Determine if the PPP connection should still be present.
159  */
160
161 extern int hungup;
162
163 #ifndef LOCK_PREFIX
164 #define LOCK_PREFIX     "/var/lock/LCK.."
165 #endif
166
167 static void set_ppp_fd (int new_fd)
168 {
169         SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
170         ppp_fd = new_fd;
171 }
172
173 static int still_ppp(void)
174 {
175         if (!hungup || ppp_fd == slave_fd)
176                 return 1;
177         if (slave_fd >= 0) {
178                 set_ppp_fd(slave_fd);
179                 return 1;
180         }
181         return 0;
182 }
183
184 /********************************************************************
185  *
186  * Functions to read and set the flags value in the device driver
187  */
188
189 static int get_flags (void)
190   {    
191     int flags;
192
193     if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0)
194       {
195         if ( ok_error (errno) )
196           {
197             flags = 0;
198           }
199         else
200           {
201             syslog(LOG_ERR, "ioctl(PPPIOCGFLAGS): %m");
202             quit();
203           }
204       }
205
206     SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
207     return flags;
208   }
209
210 /********************************************************************/
211
212 static void set_flags (int flags)
213   {    
214     SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
215
216     if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0)
217       {
218         if (! ok_error (errno) )
219           {
220             syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
221             quit();
222           }
223       }
224   }
225
226 /********************************************************************
227  *
228  * sys_init - System-dependent initialization.
229  */
230
231 void sys_init(void)
232   {
233     int osmaj, osmin, ospatch;
234
235     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
236     setlogmask(LOG_UPTO(LOG_INFO));
237     if (debug)
238       {
239         setlogmask(LOG_UPTO(LOG_DEBUG));
240       }
241     
242     /* Get an internet socket for doing socket ioctls. */
243     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
244     if (sock_fd < 0)
245       {
246         if ( ! ok_error ( errno ))
247           {
248             syslog(LOG_ERR, "Couldn't create IP socket: %m(%d)", errno);
249             die(1);
250           }
251       }
252
253     uname(&utsname);
254     osmaj = osmin = ospatch = 0;
255     sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
256     kernel_version = KVERSION(osmaj, osmin, ospatch);
257   }
258
259 /********************************************************************
260  *
261  * sys_cleanup - restore any system state we modified before exiting:
262  * mark the interface down, delete default route and/or proxy arp entry.
263  * This should call die() because it's called from die().
264  */
265
266 void sys_cleanup(void)
267   {
268 /*
269  * Take down the device
270  */
271     if (if_is_up)
272       {
273         sifdown(0);
274       }
275 /*
276  * Delete any routes through the device.
277  */
278     if (default_route_gateway != 0)
279       {
280         cifdefaultroute(0, 0, default_route_gateway);
281       }
282
283     if (has_proxy_arp)
284       {
285         cifproxyarp(0, proxy_arp_addr);
286       }
287   }
288
289 /********************************************************************
290  *
291  * sys_close - Clean up in a child process before execing.
292  */
293 void
294 sys_close(void)
295   {
296     close(sock_fd);
297     sock_fd = -1;
298     closelog();
299   }
300
301 /********************************************************************
302  *
303  * note_debug_level - note a change in the debug level.
304  */
305
306 void note_debug_level (void)
307   {
308     if (debug)
309       {
310         SYSDEBUG ((LOG_INFO, "Debug turned ON, Level %d", debug));
311         setlogmask(LOG_UPTO(LOG_DEBUG));
312       }
313     else
314       {
315         setlogmask(LOG_UPTO(LOG_WARNING));
316       }
317   }
318
319 /********************************************************************
320  *
321  * set_kdebugflag - Define the debugging level for the kernel
322  */
323
324 int set_kdebugflag (int requested_level)
325   {
326     if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0)
327       {
328         if ( ! ok_error (errno) )
329           {
330             syslog (LOG_ERR, "ioctl(PPPIOCSDEBUG): %m");
331           }
332         return (0);
333       }
334     SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
335                 requested_level));
336     return (1);
337   }
338
339 /********************************************************************
340  *
341  * establish_ppp - Turn the serial port into a ppp interface.
342  */
343
344 void establish_ppp (int tty_fd)
345   {
346     int x;
347 /*
348  * The current PPP device will be the tty file.
349  */
350     set_ppp_fd (tty_fd);
351 /*
352  * Ensure that the tty device is in exclusive mode.
353  */
354     if (ioctl(tty_fd, TIOCEXCL, 0) < 0)
355       {
356         if ( ! ok_error ( errno ))
357           {
358             syslog (LOG_WARNING, "ioctl(TIOCEXCL): %m");
359           }
360       }
361 /*
362  * Demand mode - prime the old ppp device to relinquish the unit.
363  */
364     if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
365       {
366         syslog(LOG_ERR, "ioctl(transfer ppp unit): %m(%d)", errno);
367         die(1);
368       }
369 /*
370  * Set the current tty to the PPP discpline
371  */
372     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
373       {
374         if ( ! ok_error (errno) )
375           {
376             syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
377             die(1);
378           }
379       }
380 /*
381  * Find out which interface we were given.
382  */
383     if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0)
384       { 
385         if ( ! ok_error (errno))
386           {
387             syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
388             die(1);
389           }
390       }
391 /*
392  * Check that we got the same unit again.
393  */
394     if (demand)
395       {
396         if (x != ifunit)
397           {
398             syslog(LOG_ERR, "transfer_ppp failed: wanted unit %d, got %d",
399                    ifunit, x);
400             die(1);
401           }
402       }
403
404     ifunit = x;
405 /*
406  * Enable debug in the driver if requested.
407  */
408     if (!demand)
409       set_kdebugflag (kdebugflag);
410
411     set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
412                                SC_RCV_EVNP | SC_RCV_ODDP));
413
414     SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
415             driver_version, driver_modification, driver_patch));
416 /*
417  * Fetch the initial file flags and reset blocking mode on the file.
418  */
419     initfdflags = fcntl(ppp_fd, F_GETFL);
420
421     if (initfdflags == -1 ||
422         fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1)
423       {
424         if ( ! ok_error (errno))
425           {
426             syslog(LOG_WARNING,
427                    "Couldn't set device to non-blocking mode: %m");
428           }
429       }
430   }
431
432 /********************************************************************
433  *
434  * disestablish_ppp - Restore the serial port to normal operation.
435  * This shouldn't call die() because it's called from die().
436  */
437
438 void disestablish_ppp(int tty_fd)
439   {
440 /*
441  * Attempt to restore the previous tty settings
442  */
443     if (!hungup)
444       {
445 /*
446  * Restore the previous line discipline
447  */
448         if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0)
449           {
450             if ( ! ok_error (errno))
451               {
452                 syslog(LOG_ERR, "ioctl(TIOCSETD, N_TTY): %m");
453               }
454           }
455         
456         if (ioctl(tty_fd, TIOCNXCL, 0) < 0)
457           {
458             if ( ! ok_error (errno))
459               {
460                 syslog (LOG_WARNING, "ioctl(TIOCNXCL): %m(%d)", errno);
461               }
462           }
463
464         /* Reset non-blocking mode on fd. */
465         if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0)
466           {
467             if ( ! ok_error (errno))
468               {
469                 syslog (LOG_WARNING,
470                         "Couldn't restore device fd flags: %m");
471               }
472           }
473       }
474     initfdflags = -1;
475   }
476
477 /********************************************************************
478  *
479  * clean_check - Fetch the flags for the device and generate
480  * appropriate error messages.
481  */
482 void clean_check(void)
483   {
484     int x;
485     char *s;
486
487     if (still_ppp())
488       {
489         if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0)
490           {
491             s = NULL;
492             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP))
493               {
494               case SC_RCV_B7_0:
495               case SC_RCV_B7_0 | SC_RCV_EVNP:
496               case SC_RCV_B7_0 | SC_RCV_ODDP:
497               case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
498                 s = "all had bit 7 set to 1";
499                 break;
500                 
501               case SC_RCV_B7_1:
502               case SC_RCV_B7_1 | SC_RCV_EVNP:
503               case SC_RCV_B7_1 | SC_RCV_ODDP:
504               case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
505                 s = "all had bit 7 set to 0";
506                 break;
507                 
508               case SC_RCV_EVNP:
509                 s = "all had odd parity";
510                 break;
511                 
512               case SC_RCV_ODDP:
513                 s = "all had even parity";
514                 break;
515               }
516             
517             if (s != NULL)
518               {
519                 syslog(LOG_WARNING, "Receive serial link is not"
520                        " 8-bit clean:");
521                 syslog(LOG_WARNING, "Problem: %s", s);
522               }
523           }
524       }
525   }
526         
527
528 /*
529  * List of valid speeds.
530  */
531
532 struct speed {
533     int speed_int, speed_val;
534 } speeds[] = {
535 #ifdef B50
536     { 50, B50 },
537 #endif
538 #ifdef B75
539     { 75, B75 },
540 #endif
541 #ifdef B110
542     { 110, B110 },
543 #endif
544 #ifdef B134
545     { 134, B134 },
546 #endif
547 #ifdef B150
548     { 150, B150 },
549 #endif
550 #ifdef B200
551     { 200, B200 },
552 #endif
553 #ifdef B300
554     { 300, B300 },
555 #endif
556 #ifdef B600
557     { 600, B600 },
558 #endif
559 #ifdef B1200
560     { 1200, B1200 },
561 #endif
562 #ifdef B1800
563     { 1800, B1800 },
564 #endif
565 #ifdef B2000
566     { 2000, B2000 },
567 #endif
568 #ifdef B2400
569     { 2400, B2400 },
570 #endif
571 #ifdef B3600
572     { 3600, B3600 },
573 #endif
574 #ifdef B4800
575     { 4800, B4800 },
576 #endif
577 #ifdef B7200
578     { 7200, B7200 },
579 #endif
580 #ifdef B9600
581     { 9600, B9600 },
582 #endif
583 #ifdef B19200
584     { 19200, B19200 },
585 #endif
586 #ifdef B38400
587     { 38400, B38400 },
588 #endif
589 #ifdef B57600
590     { 57600, B57600 },
591 #endif
592 #ifdef B115200
593     { 115200, B115200 },
594 #endif
595 #ifdef EXTA
596     { 19200, EXTA },
597 #endif
598 #ifdef EXTB
599     { 38400, EXTB },
600 #endif
601 #ifdef B230400
602     { 230400, B230400 },
603 #endif
604 #ifdef B460800
605     { 460800, B460800 },
606 #endif
607     { 0, 0 }
608 };
609
610 /********************************************************************
611  *
612  * Translate from bits/second to a speed_t.
613  */
614
615 static int translate_speed (int bps)
616   {
617     struct speed *speedp;
618
619     if (bps != 0)
620       {
621         for (speedp = speeds; speedp->speed_int; speedp++)
622           {
623             if (bps == speedp->speed_int)
624               {
625                 return speedp->speed_val;
626               }
627           }
628         syslog(LOG_WARNING, "speed %d not supported", bps);
629       }
630     return 0;
631   }
632
633 /********************************************************************
634  *
635  * Translate from a speed_t to bits/second.
636  */
637
638 static int baud_rate_of (int speed)
639   {
640     struct speed *speedp;
641     
642     if (speed != 0)
643       {
644         for (speedp = speeds; speedp->speed_int; speedp++)
645           {
646             if (speed == speedp->speed_val)
647               {
648                 return speedp->speed_int;
649               }
650           }
651       }
652     return 0;
653   }
654
655 /********************************************************************
656  *
657  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
658  * at the requested speed, etc.  If `local' is true, set CLOCAL
659  * regardless of whether the modem option was specified.
660  */
661
662 void set_up_tty(int tty_fd, int local)
663   {
664     int speed;
665     struct termios tios;
666
667     setdtr(tty_fd, 1);
668     if (tcgetattr(tty_fd, &tios) < 0)
669       {
670         syslog(LOG_ERR, "tcgetattr: %m(%d)", errno);
671         die(1);
672       }
673     
674     if (!restore_term)
675       {
676         inittermios = tios;
677       }
678     
679     tios.c_cflag     &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
680     tios.c_cflag     |= CS8 | CREAD | HUPCL;
681
682     tios.c_iflag      = IGNBRK | IGNPAR;
683     tios.c_oflag      = 0;
684     tios.c_lflag      = 0;
685     tios.c_cc[VMIN]   = 1;
686     tios.c_cc[VTIME]  = 0;
687     
688     if (local || !modem)
689       {
690         tios.c_cflag ^= (CLOCAL | HUPCL);
691       }
692
693     switch (crtscts)
694       {
695     case 1:
696         tios.c_cflag |= CRTSCTS;
697         break;
698
699     case -2:
700         tios.c_iflag     |= IXON | IXOFF;
701         tios.c_cc[VSTOP]  = 0x13;       /* DC3 = XOFF = ^S */
702         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
703         break;
704
705     case -1:
706         tios.c_cflag &= ~CRTSCTS;
707         break;
708
709     default:
710         break;
711       }
712     
713     speed = translate_speed(inspeed);
714     if (speed)
715       {
716         cfsetospeed (&tios, speed);
717         cfsetispeed (&tios, speed);
718       }
719 /*
720  * We can't proceed if the serial port speed is B0,
721  * since that implies that the serial port is disabled.
722  */
723     else
724       {
725         speed = cfgetospeed(&tios);
726         if (speed == B0)
727           {
728             syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
729                    devnam);
730             die (1);
731           }
732       }
733
734     if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
735       {
736         syslog(LOG_ERR, "tcsetattr: %m");
737         die(1);
738       }
739     
740     baud_rate    = baud_rate_of(speed);
741     restore_term = TRUE;
742   }
743
744 /*
745  * hangup_modem - hang up the modem by clearing DTR.
746  */
747 void hangup_modem(int ttyfd)
748 {
749     setdtr(ttyfd, 0);
750 }
751
752 /********************************************************************
753  *
754  * setdtr - control the DTR line on the serial port.
755  * This is called from die(), so it shouldn't call die().
756  */
757
758 void setdtr (int tty_fd, int on)
759   {
760     int modembits = TIOCM_DTR;
761
762     ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
763   }
764
765 /********************************************************************
766  *
767  * restore_tty - restore the terminal to the saved settings.
768  */
769
770 void restore_tty (int tty_fd)
771   {
772     if (restore_term)
773       {
774         restore_term = 0;
775 /*
776  * Turn off echoing, because otherwise we can get into
777  * a loop with the tty and the modem echoing to each other.
778  * We presume we are the sole user of this tty device, so
779  * when we close it, it will revert to its defaults anyway.
780  */
781         if (!default_device)
782           {
783             inittermios.c_lflag &= ~(ECHO | ECHONL);
784           }
785         
786         if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0)
787           {
788             if (! ok_error (errno))
789               {
790                 syslog(LOG_WARNING, "tcsetattr: %m");
791               }
792           }
793       }
794   }
795
796 /********************************************************************
797  *
798  * output - Output PPP packet.
799  */
800
801 void output (int unit, unsigned char *p, int len)
802   {
803     if (debug)
804       {
805         log_packet(p, len, "sent ", LOG_DEBUG);
806       }
807     
808     if (write(ppp_fd, p, len) < 0)
809       {
810         if (errno == EWOULDBLOCK || errno == ENOBUFS
811             || errno == ENXIO || errno == EIO)
812           {
813             syslog(LOG_WARNING, "write: warning: %m(%d)", errno);
814           } 
815         else
816           {
817             syslog(LOG_ERR, "write: %m(%d)", errno);
818             die(1);
819           }
820       }
821   }
822
823 /********************************************************************
824  *
825  * wait_input - wait until there is data available on ppp_fd,
826  * for the length of time specified by *timo (indefinite
827  * if timo is NULL).
828  */
829
830 void wait_input (struct timeval *timo)
831   {
832     fd_set ready;
833     int n;
834     
835     FD_ZERO(&ready);
836     FD_SET(ppp_fd, &ready);
837
838     n = select(ppp_fd + 1, &ready, NULL, &ready, timo);
839     if (n < 0 && errno != EINTR)
840       {
841         syslog(LOG_ERR, "select: %m(%d)", errno);
842         die(1);
843       }
844   }
845
846 /********************************************************************
847  *
848  * wait_loop_output - wait until there is data available on the
849  * loopback, for the length of time specified by *timo (indefinite
850  * if timo is NULL).
851  */
852 void wait_loop_output(timo)
853     struct timeval *timo;
854   {
855     fd_set ready;
856     int n;
857
858     FD_ZERO(&ready);
859     FD_SET(master_fd, &ready);
860     n = select(master_fd + 1, &ready, NULL, &ready, timo);
861     if (n < 0 && errno != EINTR)
862       {
863         syslog(LOG_ERR, "select: %m(%d)", errno);
864         die(1);
865       }
866   }
867
868 /********************************************************************
869  *
870  * wait_time - wait for a given length of time or until a
871  * signal is received.
872  */
873
874 void wait_time(timo)
875     struct timeval *timo;
876 {
877     int n;
878
879     n = select(0, NULL, NULL, NULL, timo);
880     if (n < 0 && errno != EINTR) {
881         syslog(LOG_ERR, "select: %m(%d)", errno);
882         die(1);
883     }
884 }
885
886 /********************************************************************
887  *
888  * read_packet - get a PPP packet from the serial device.
889  */
890
891 int read_packet (unsigned char *buf)
892   {
893     int len;
894   
895     len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
896     if (len < 0)
897       {
898         if (errno == EWOULDBLOCK)
899           {
900             return -1;
901           }
902         syslog(LOG_ERR, "read: %m(%d)", errno);
903         die(1);
904       }
905     return len;
906   }
907
908 /********************************************************************
909  *
910  * get_loop_output - get outgoing packets from the ppp device,
911  * and detect when we want to bring the real link up.
912  * Return value is 1 if we need to bring up the link, 0 otherwise.
913  */
914 int
915 get_loop_output(void)
916   {
917     int rv = 0;
918     int n  = read(master_fd, inbuf, sizeof(inbuf));
919
920     while (n > 0)
921       {
922         if (loop_chars(inbuf, n))
923           {
924             rv = 1;
925           }
926         n = read(master_fd, inbuf, sizeof(inbuf));
927       }
928
929     if (n == 0)
930       {
931         syslog(LOG_ERR, "eof on loopback");
932         die(1);
933       }
934
935     if (errno != EWOULDBLOCK)
936       {
937         syslog(LOG_ERR, "read from loopback: %m(%d)", errno);
938         die(1);
939       }
940     
941     return rv;
942   }
943
944 /********************************************************************
945  *
946  * ppp_send_config - configure the transmit characteristics of
947  * the ppp interface.
948  */
949
950 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
951   {
952     u_int x;
953     struct ifreq ifr;
954   
955     SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
956 /*
957  * Ensure that the link is still up.
958  */
959     if (still_ppp())
960       {
961 /*
962  * Set the MTU and other parameters for the ppp device
963  */
964         memset (&ifr, '\0', sizeof (ifr));
965         strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
966         ifr.ifr_mtu = mtu;
967         
968         if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
969           {
970             syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m(%d)", errno);
971             quit();
972           }
973         
974         SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
975         if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0)
976           {
977             syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
978             quit();
979           }
980     
981         x = get_flags();
982         x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
983         x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
984         set_flags(x);
985       }
986   }
987
988 /********************************************************************
989  *
990  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
991  */
992
993 void ppp_set_xaccm (int unit, ext_accm accm)
994   {
995     SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
996                 accm[0], accm[1], accm[2], accm[3]));
997
998     if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
999       {
1000         if ( ! ok_error (errno))
1001           {
1002             syslog(LOG_WARNING, "ioctl(set extended ACCM): %m(%d)", errno);
1003           }
1004       }
1005   }
1006
1007 /********************************************************************
1008  *
1009  * ppp_recv_config - configure the receive-side characteristics of
1010  * the ppp interface.
1011  */
1012
1013 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1014   {
1015     u_int x;
1016
1017     SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1018 /*
1019  * If we were called because the link has gone down then there is nothing
1020  * which may be done. Just return without incident.
1021  */
1022     if (!still_ppp())
1023       {
1024         return;
1025       }
1026 /*
1027  * Set the receiver parameters
1028  */
1029     if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1030       {
1031         if ( ! ok_error (errno))
1032           {
1033             syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m(%d)", errno);
1034           }
1035       }
1036
1037     SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1038     if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0)
1039       {
1040         syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1041         quit();
1042       }
1043
1044     x = get_flags();
1045     x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
1046     set_flags (x);
1047   }
1048
1049 /********************************************************************
1050  *
1051  * ccp_test - ask kernel whether a given compression method
1052  * is acceptable for use.
1053  */
1054
1055 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1056   {
1057     struct ppp_option_data data;
1058
1059     memset (&data, '\0', sizeof (data));
1060     data.ptr      = opt_ptr;
1061     data.length   = opt_len;
1062     data.transmit = for_transmit;
1063
1064     if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1065       {
1066         return 1;
1067       }
1068
1069     return (errno == ENOBUFS)? 0: -1;
1070   }
1071
1072 /********************************************************************
1073  *
1074  * ccp_flags_set - inform kernel about the current state of CCP.
1075  */
1076
1077 void ccp_flags_set (int unit, int isopen, int isup)
1078   {
1079     if (still_ppp())
1080       {
1081         int x = get_flags();
1082         x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1083         x = isup?   x | SC_CCP_UP   : x &~ SC_CCP_UP;
1084         set_flags (x);
1085       }
1086   }
1087
1088 /********************************************************************
1089  *
1090  * get_idle_time - return how long the link has been idle.
1091  */
1092 int
1093 get_idle_time(u, ip)
1094     int u;
1095     struct ppp_idle *ip;
1096 {
1097     return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
1098
1099
1100 /********************************************************************
1101  *
1102  * ccp_fatal_error - returns 1 if decompression was disabled as a
1103  * result of an error detected after decompression of a packet,
1104  * 0 otherwise.  This is necessary because of patent nonsense.
1105  */
1106
1107 int ccp_fatal_error (int unit)
1108 {
1109     int x = get_flags();
1110
1111     return x & SC_DC_FERROR;
1112 }
1113
1114 /*
1115  * path_to_route - determine the path to the proc file system data
1116  */
1117 #define ROUTE_MAX_COLS  12
1118 FILE *route_fd = (FILE *) 0;
1119 static char route_buffer [512];
1120 static int route_dev_col, route_dest_col, route_gw_col;
1121 static int route_flags_col, route_mask_col;
1122 static int route_num_cols;
1123
1124 static char *path_to_route (void);
1125 static int open_route_table (void);
1126 static void close_route_table (void);
1127 static int read_route_table (struct rtentry *rt);
1128
1129 /********************************************************************
1130  *
1131  * path_to_procfs - find the path to the proc file system mount point
1132  */
1133
1134 static int path_to_procfs (void)
1135 {
1136     struct mntent *mntent;
1137     FILE *fp;
1138
1139     fp = fopen(MOUNTED, "r");
1140     if (fp == NULL) {
1141         /* Default the mount location of /proc */
1142         strncpy (route_buffer, "/proc", sizeof (route_buffer)-10);
1143         return 1;
1144     }
1145
1146     while ((mntent = getmntent(fp)) != NULL) {
1147         if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1148             continue;
1149         if (strcmp(mntent->mnt_type, "proc") == 0)
1150             break;
1151     }
1152     fclose (fp);
1153     if (mntent == 0)
1154         return 0;
1155
1156     strncpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer)-10);
1157     route_buffer [sizeof (route_buffer)-10] = '\0';
1158     return 1;
1159 }
1160
1161 /********************************************************************
1162  *
1163  * path_to_route - find the path to the route tables in the proc file system
1164  */
1165
1166 static char *path_to_route (void)
1167 {
1168     if (!path_to_procfs()) {
1169         syslog (LOG_ERR, "proc file system not mounted");
1170         return 0;
1171     }
1172     strcat (route_buffer, "/net/route");
1173     return (route_buffer);
1174 }
1175
1176 /********************************************************************
1177  *
1178  * close_route_table - close the interface to the route table
1179  */
1180
1181 static void close_route_table (void)
1182 {
1183     if (route_fd != (FILE *) 0) {
1184         fclose (route_fd);
1185         route_fd = (FILE *) 0;
1186     }
1187 }
1188
1189 /********************************************************************
1190  *
1191  * open_route_table - open the interface to the route table
1192  */
1193 static char route_delims[] = " \t\n";
1194
1195 static int open_route_table (void)
1196 {
1197     char *path;
1198
1199     close_route_table();
1200
1201     path = path_to_route();
1202     if (path == NULL)
1203         return 0;
1204
1205     route_fd = fopen (path, "r");
1206     if (route_fd == NULL) {
1207         syslog (LOG_ERR, "can't open %s: %m (%d)", path, errno);
1208         return 0;
1209     }
1210
1211     route_dev_col = 0;          /* default to usual columns */
1212     route_dest_col = 1;
1213     route_gw_col = 2;
1214     route_flags_col = 3;
1215     route_mask_col = 7;
1216     route_num_cols = 8;
1217
1218     /* parse header line */
1219     if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1220         char *p = route_buffer, *q;
1221         int col;
1222         for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1223             int used = 1;
1224             if ((q = strtok(p, route_delims)) == 0)
1225                 break;
1226             if (strcasecmp(q, "iface") == 0)
1227                 route_dev_col = col;
1228             else if (strcasecmp(q, "destination") == 0)
1229                 route_dest_col = col;
1230             else if (strcasecmp(q, "gateway") == 0)
1231                 route_gw_col = col;
1232             else if (strcasecmp(q, "flags") == 0)
1233                 route_flags_col = col;
1234             else if (strcasecmp(q, "mask") == 0)
1235                 route_mask_col = col;
1236             else
1237                 used = 0;
1238             if (used && col >= route_num_cols)
1239                 route_num_cols = col + 1;
1240             p = NULL;
1241         }
1242     }
1243
1244     return 1;
1245 }
1246
1247 /********************************************************************
1248  *
1249  * read_route_table - read the next entry from the route table
1250  */
1251
1252 static int read_route_table(struct rtentry *rt)
1253 {
1254     char *cols[ROUTE_MAX_COLS], *p;
1255     int col;
1256         
1257     memset (rt, '\0', sizeof (struct rtentry));
1258
1259     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1260         return 0;
1261
1262     p = route_buffer;
1263     for (col = 0; col < route_num_cols; ++col) {
1264         cols[col] = strtok(p, route_delims);
1265         if (cols[col] == NULL)
1266             return 0;           /* didn't get enough columns */
1267     }
1268
1269     ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1270         strtoul(cols[route_dest_col], NULL, 16);
1271
1272     ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1273         strtoul(cols[route_gw_col], NULL, 16);
1274
1275     ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1276         strtoul(cols[route_mask_col], NULL, 16);
1277
1278     rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1279     rt->rt_dev   = cols[route_dev_col];
1280
1281     return 1;
1282 }
1283
1284 /********************************************************************
1285  *
1286  * defaultroute_exists - determine if there is a default route
1287  */
1288
1289 static int defaultroute_exists (struct rtentry *rt)
1290 {
1291     int result = 0;
1292
1293     if (!open_route_table())
1294         return 0;
1295
1296     while (read_route_table(rt) != 0) {
1297         if ((rt->rt_flags & RTF_UP) == 0)
1298             continue;
1299
1300         if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1301             result = 1;
1302             break;
1303         }
1304     }
1305
1306     close_route_table();
1307     return result;
1308 }
1309
1310 /*
1311  * have_route_to - determine if the system has any route to
1312  * a given IP address.
1313  */
1314 int have_route_to(u_int32_t addr)
1315 {
1316     struct rtentry rt;
1317     int result = 0;
1318
1319     if (!open_route_table())
1320         return -1;              /* don't know */
1321
1322     while (read_route_table(&rt)) {
1323         if ((rt.rt_flags & RTF_UP) == 0)
1324             continue;
1325         if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1326             == ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr) {
1327             result = 1;
1328             break;
1329         }
1330     }
1331
1332     close_route_table();
1333     return result;
1334 }
1335
1336 /********************************************************************
1337  *
1338  * sifdefaultroute - assign a default route through the address given.
1339  */
1340
1341 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1342   {
1343     struct rtentry rt;
1344
1345     if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0)
1346       {
1347         struct in_addr old_gateway =
1348           ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1349
1350         if (old_gateway.s_addr != gateway)
1351           {
1352             syslog (LOG_ERR,
1353                     "not replacing existing default route to %s [%s]",
1354                     rt.rt_dev, inet_ntoa (old_gateway));
1355           }
1356         return 0;
1357       }
1358
1359     memset (&rt, '\0', sizeof (rt));
1360     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1361     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1362
1363     if (kernel_version > KVERSION(2,1,0)) {
1364       SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1365       ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1366     }
1367
1368     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1369     
1370     rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1371     if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
1372       {
1373         if ( ! ok_error ( errno ))
1374           {
1375             syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m(%d)", errno);
1376           }
1377         return 0;
1378       }
1379
1380     default_route_gateway = gateway;
1381     return 1;
1382   }
1383
1384 /********************************************************************
1385  *
1386  * cifdefaultroute - delete a default route through the address given.
1387  */
1388
1389 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1390   {
1391     struct rtentry rt;
1392
1393     default_route_gateway = 0;
1394
1395     memset (&rt, '\0', sizeof (rt));
1396     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1397     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1398
1399     if (kernel_version > KVERSION(2,1,0)) {
1400       SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1401       ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1402     }
1403
1404     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1405     
1406     rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1407     if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1408       {
1409         if (still_ppp())
1410           {
1411             if ( ! ok_error ( errno ))
1412               {
1413                 syslog (LOG_ERR,
1414                         "default route ioctl(SIOCDELRT): %m(%d)", errno);
1415               }
1416             return 0;
1417           }
1418       }
1419
1420     return 1;
1421   }
1422
1423 /********************************************************************
1424  *
1425  * sifproxyarp - Make a proxy ARP entry for the peer.
1426  */
1427
1428 int sifproxyarp (int unit, u_int32_t his_adr)
1429   {
1430     struct arpreq arpreq;
1431
1432     if (has_proxy_arp == 0)
1433       {
1434         memset (&arpreq, '\0', sizeof(arpreq));
1435     
1436         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1437         ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1438         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1439 /*
1440  * Get the hardware address of an interface on the same subnet
1441  * as our local address.
1442  */
1443         if (!get_ether_addr(his_adr, &arpreq.arp_ha, arpreq.arp_dev))
1444           {
1445             syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1446             return 0;
1447           }
1448         
1449         if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0)
1450           {
1451             if ( ! ok_error ( errno ))
1452               {
1453                 syslog(LOG_ERR, "ioctl(SIOCSARP): %m(%d)", errno);
1454               }
1455             return 0;
1456           }
1457       }
1458
1459     proxy_arp_addr = his_adr;
1460     has_proxy_arp = 1;
1461     return 1;
1462   }
1463
1464 /********************************************************************
1465  *
1466  * cifproxyarp - Delete the proxy ARP entry for the peer.
1467  */
1468
1469 int cifproxyarp (int unit, u_int32_t his_adr)
1470   {
1471     struct arpreq arpreq;
1472
1473     if (has_proxy_arp == 1)
1474       {
1475         memset (&arpreq, '\0', sizeof(arpreq));
1476         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1477         ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1478         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1479
1480         if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0)
1481           {
1482             if ( ! ok_error ( errno ))
1483               {
1484                 syslog(LOG_WARNING, "ioctl(SIOCDARP): %m(%d)", errno);
1485               }
1486             return 0;
1487           }
1488       }
1489     has_proxy_arp = 0;
1490     return 1;
1491   }
1492      
1493 /********************************************************************
1494  *
1495  * get_ether_addr - get the hardware address of an interface on the
1496  * the same subnet as ipaddr.
1497  */
1498
1499 static int get_ether_addr (u_int32_t ipaddr,
1500                            struct sockaddr *hwaddr,
1501                            char *name)
1502   {
1503     struct ifreq *ifr, *ifend;
1504     u_int32_t ina, mask;
1505     struct ifreq ifreq;
1506     struct ifconf ifc;
1507     struct ifreq ifs[MAX_IFS];
1508     
1509     ifc.ifc_len = sizeof(ifs);
1510     ifc.ifc_req = ifs;
1511     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1512       {
1513         if ( ! ok_error ( errno ))
1514           {
1515             syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1516           }
1517         return 0;
1518       }
1519
1520     SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1521                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1522 /*
1523  * Scan through looking for an interface with an Internet
1524  * address on the same subnet as `ipaddr'.
1525  */
1526     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1527     for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1528       {
1529         if (ifr->ifr_addr.sa_family == AF_INET)
1530           {
1531             ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1532             strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1533             SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1534                         ifreq.ifr_name));
1535 /*
1536  * Check that the interface is up, and not point-to-point
1537  * nor loopback.
1538  */
1539             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1540               {
1541                 continue;
1542               }
1543
1544             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1545               {
1546                 continue;
1547               }
1548 /*
1549  * Get its netmask and check that it's on the right subnet.
1550  */
1551             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1552               {
1553                 continue;
1554               }
1555
1556             mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1557             SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1558                         ip_ntoa(ina), ntohl(mask)));
1559
1560             if (((ipaddr ^ ina) & mask) != 0)
1561               {
1562                 continue;
1563               }
1564             break;
1565           }
1566       }
1567     
1568     if (ifr >= ifend)
1569       {
1570         return 0;
1571       }
1572
1573     memcpy (name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
1574     syslog(LOG_INFO, "found interface %s for proxy arp", name);
1575 /*
1576  * Now get the hardware address.
1577  */
1578     memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1579     if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0)
1580       {
1581         syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1582         return 0;
1583       }
1584
1585     memcpy (hwaddr,
1586             &ifreq.ifr_hwaddr,
1587             sizeof (struct sockaddr));
1588
1589     SYSDEBUG ((LOG_DEBUG,
1590            "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1591                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1592                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1593                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1594                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1595                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1596                 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1597                 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1598                 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1599     return 1;
1600   }
1601
1602 /********************************************************************
1603  *
1604  * Return user specified netmask, modified by any mask we might determine
1605  * for address `addr' (in network byte order).
1606  * Here we scan through the system's list of interfaces, looking for
1607  * any non-point-to-point interfaces which might appear to be on the same
1608  * network as `addr'.  If we find any, we OR in their netmask to the
1609  * user-specified netmask.
1610  */
1611
1612 u_int32_t GetMask (u_int32_t addr)
1613   {
1614     u_int32_t mask, nmask, ina;
1615     struct ifreq *ifr, *ifend, ifreq;
1616     struct ifconf ifc;
1617     struct ifreq ifs[MAX_IFS];
1618
1619     addr = ntohl(addr);
1620     
1621     if (IN_CLASSA(addr))        /* determine network mask for address class */
1622       {
1623         nmask = IN_CLASSA_NET;
1624       }
1625     else
1626       {
1627         if (IN_CLASSB(addr))
1628           {
1629             nmask = IN_CLASSB_NET;
1630           }
1631         else
1632           {
1633             nmask = IN_CLASSC_NET;
1634           }
1635       }
1636     
1637     /* class D nets are disallowed by bad_ip_adrs */
1638     mask = netmask | htonl(nmask);
1639 /*
1640  * Scan through the system's network interfaces.
1641  */
1642     ifc.ifc_len = sizeof(ifs);
1643     ifc.ifc_req = ifs;
1644     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1645       {
1646         if ( ! ok_error ( errno ))
1647           {
1648             syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1649           }
1650         return mask;
1651       }
1652     
1653     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1654     for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1655       {
1656 /*
1657  * Check the interface's internet address.
1658  */
1659         if (ifr->ifr_addr.sa_family != AF_INET)
1660           {
1661             continue;
1662           }
1663         ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1664         if (((ntohl(ina) ^ addr) & nmask) != 0)
1665           {
1666             continue;
1667           }
1668 /*
1669  * Check that the interface is up, and not point-to-point nor loopback.
1670  */
1671         strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1672         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1673           {
1674             continue;
1675           }
1676         
1677         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1678           {
1679             continue;
1680           }
1681 /*
1682  * Get its netmask and OR it into our mask.
1683  */
1684         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1685           {
1686             continue;
1687           }
1688         mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1689         break;
1690       }
1691     return mask;
1692   }
1693
1694 /********************************************************************
1695  *
1696  * Internal routine to decode the version.modification.patch level
1697  */
1698
1699 static void decode_version (char *buf, int *version,
1700                             int *modification, int *patch)
1701   {
1702     *version      = (int) strtoul (buf, &buf, 10);
1703     *modification = 0;
1704     *patch        = 0;
1705     
1706     if (*buf == '.')
1707       {
1708         ++buf;
1709         *modification = (int) strtoul (buf, &buf, 10);
1710         if (*buf == '.')
1711           {
1712             ++buf;
1713             *patch = (int) strtoul (buf, &buf, 10);
1714           }
1715       }
1716     
1717     if (*buf != '\0')
1718       {
1719         *version      =
1720         *modification =
1721         *patch        = 0;
1722       }
1723   }
1724
1725 /********************************************************************
1726  *
1727  * Procedure to determine if the PPP line discipline is registered.
1728  */
1729
1730 int
1731 ppp_registered(void)
1732   {
1733     int local_fd;
1734     int init_disc = -1;
1735     int initfdflags;
1736
1737     local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1738     if (local_fd < 0)
1739       {
1740         syslog(LOG_ERR, "Failed to open %s: %m(%d)", devnam, errno);
1741         return 0;
1742       }
1743
1744     initfdflags = fcntl(local_fd, F_GETFL);
1745     if (initfdflags == -1)
1746       {
1747         syslog(LOG_ERR, "Couldn't get device fd flags: %m(%d)", errno);
1748         close (local_fd);
1749         return 0;
1750       }
1751
1752     initfdflags &= ~O_NONBLOCK;
1753     fcntl(local_fd, F_SETFL, initfdflags);
1754 /*
1755  * Read the initial line dicipline and try to put the device into the
1756  * PPP dicipline.
1757  */
1758     if (ioctl(local_fd, TIOCGETD, &init_disc) < 0)
1759       {
1760         syslog(LOG_ERR, "ioctl(TIOCGETD): %m(%d)", errno);
1761         close (local_fd);
1762         return 0;
1763       }
1764     
1765     if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0)
1766       {
1767         syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1768         close (local_fd);
1769         return 0;
1770       }
1771     
1772     if (ioctl(local_fd, TIOCSETD, &init_disc) < 0)
1773       {
1774         syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1775         close (local_fd);
1776         return 0;
1777       }
1778     
1779     close (local_fd);
1780     return 1;
1781   }
1782
1783 /********************************************************************
1784  *
1785  * ppp_available - check whether the system has any ppp interfaces
1786  * (in fact we check whether we can do an ioctl on ppp0).
1787  */
1788
1789 int ppp_available(void)
1790 {
1791     int s, ok;
1792     struct ifreq ifr;
1793     int    size;
1794     int    my_version, my_modification, my_patch;
1795     extern char *no_ppp_msg;
1796 /*
1797  * Open a socket for doing the ioctl operations.
1798  */    
1799     s = socket(AF_INET, SOCK_DGRAM, 0);
1800     if (s < 0)
1801     {
1802         return 0;
1803     }
1804     
1805     strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1806     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1807 /*
1808  * If the device did not exist then attempt to create one by putting the
1809  * current tty into the PPP discipline. If this works then obtain the
1810  * flags for the device again.
1811  */
1812     if (!ok)
1813     {
1814         if (ppp_registered())
1815         {
1816             strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1817             ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1818         }
1819     }
1820 /*
1821  * Ensure that the hardware address is for PPP and not something else
1822  */
1823     if (ok)
1824     {
1825         ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1826     }
1827
1828     if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1829     {
1830         ok = 0;
1831     }
1832
1833     if (!ok)
1834     {
1835         no_ppp_msg = 
1836           "This system lacks kernel support for PPP.  This could be because\n"
1837           "the PPP kernel module is not loaded, or because the kernel is\n"
1838           "not configured for PPP.  See the README.linux file in the\n"
1839           "ppp-2.3.5 distribution.\n";
1840     }
1841 /*
1842  *  This is the PPP device. Validate the version of the driver at this
1843  *  point to ensure that this program will work with the driver.
1844  */
1845     else
1846     {
1847         char   abBuffer [1024];
1848
1849         ifr.ifr_data = abBuffer;
1850         size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1851         if (size < 0) {
1852             syslog(LOG_ERR, "Couldn't read driver version: %m");
1853             ok = 0;
1854             no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1855
1856         } else {
1857             decode_version(abBuffer,
1858                            &driver_version,
1859                            &driver_modification,
1860                            &driver_patch);
1861 /*
1862  * Validate the version of the driver against the version that we used.
1863  */
1864             decode_version(VERSION,
1865                            &my_version,
1866                            &my_modification,
1867                            &my_patch);
1868
1869             /* The version numbers must match */
1870             if (driver_version != my_version)
1871             {
1872                 ok = 0;
1873             }
1874       
1875             /* The modification levels must be legal */
1876             if (driver_modification < 3)
1877             {
1878                 if (driver_modification >= 2) {
1879                     /* we can cope with 2.2.0 and above */
1880                     driver_is_old = 1;
1881                 } else {
1882                     ok = 0;
1883                 }
1884             }
1885
1886             close (s);
1887             if (!ok)
1888             {
1889                 sprintf (route_buffer,
1890                          "Sorry - PPP driver version %d.%d.%d is out of date\n",
1891                          driver_version, driver_modification, driver_patch);
1892
1893                 no_ppp_msg = route_buffer;
1894             }
1895         }
1896     }
1897     return ok;
1898 }
1899
1900 /********************************************************************
1901  *
1902  * Update the wtmp file with the appropriate user name and tty device.
1903  */
1904
1905 void logwtmp (const char *line, const char *name, const char *host)
1906   {
1907     int    wtmp;
1908     struct utmp ut, *utp;
1909     pid_t  mypid = getpid();
1910 /*
1911  * Update the signon database for users.
1912  * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1913  */
1914     utmpname(_PATH_UTMP);
1915     setutent();
1916     while ((utp = getutent()) && (utp->ut_pid != mypid))
1917         /* nothing */;
1918
1919     /* Is this call really necessary? There is another one after the 'put' */
1920     endutent();
1921     
1922     if (utp)
1923       {
1924         memcpy(&ut, utp, sizeof(ut));
1925       }
1926     else
1927       {
1928         /* some gettys/telnetds don't initialize utmp... */
1929         memset(&ut, 0, sizeof(ut));
1930       }
1931
1932     if (ut.ut_id[0] == 0)
1933       {
1934         strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1935       }
1936         
1937     strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1938     strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1939
1940     time(&ut.ut_time);
1941
1942     ut.ut_type = USER_PROCESS;
1943     ut.ut_pid  = mypid;
1944
1945     /* Insert the host name if one is supplied */
1946     if (*host)
1947       {
1948         strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1949       }
1950
1951     /* Insert the IP address of the remote system if IP is enabled */
1952     if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1953       {
1954         memcpy  (&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1955                  sizeof(ut.ut_addr));
1956       }
1957         
1958     /* CL: Makes sure that the logout works */
1959     if (*host == 0 && *name==0)
1960       {
1961         ut.ut_host[0]=0;
1962       }
1963
1964     pututline(&ut);
1965     endutent();
1966 /*
1967  * Update the wtmp file.
1968  */
1969     wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1970     if (wtmp >= 0)
1971       {
1972         flock(wtmp, LOCK_EX);
1973
1974         /* we really should check for error on the write for a full disk! */
1975         write (wtmp, (char *)&ut, sizeof(ut));
1976         close (wtmp);
1977
1978         flock(wtmp, LOCK_UN);
1979       }
1980   }
1981
1982 /********************************************************************
1983  * Code for locking/unlocking the serial device.
1984  * This code is derived from chat.c.
1985  */
1986
1987 /*
1988  * lock - create a lock file for the named device
1989  */
1990
1991 int lock (char *dev)
1992   {
1993 #ifdef LOCKLIB
1994     int result;
1995     lock_file = malloc(strlen(dev) + 1);
1996     if (lock_file == NULL)
1997       {
1998         novm("lock file name");
1999       }
2000     strcpy (lock_file, dev);
2001     result = mklock (dev, (void *) 0);
2002
2003     if (result > 0)
2004       {
2005         syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, result);
2006         free (lock_file);
2007         lock_file = NULL;
2008         result = -1;
2009       }
2010     else
2011       {
2012         if (result < 0)
2013           {
2014             syslog (LOG_ERR, "Can't create lock file %s", lock_file);
2015             free (lock_file);
2016             lock_file = NULL;
2017             result = -1;
2018           }
2019       }
2020     return (result);
2021 #else
2022     char hdb_lock_buffer[12];
2023     int fd, n;
2024     int pid = getpid();
2025     char *p;
2026
2027     p = strrchr(dev, '/');
2028     if (p != NULL)
2029       {
2030         dev = ++p;
2031       }
2032
2033     lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
2034     if (lock_file == NULL)
2035       {
2036         novm("lock file name");
2037       }
2038
2039     strcpy (lock_file, LOCK_PREFIX);
2040     strcat (lock_file, dev);
2041 /*
2042  * Attempt to create the lock file at this point.
2043  */
2044     while (1)
2045       {
2046         fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
2047         if (fd >= 0)
2048           {
2049             pid = getpid();
2050 #ifndef PID_BINARY
2051             sprintf (hdb_lock_buffer, "%010d\n", pid);
2052             write (fd, hdb_lock_buffer, 11);
2053 #else
2054             write(fd, &pid, sizeof (pid));
2055 #endif
2056             close(fd);
2057             return 0;
2058           }
2059 /*
2060  * If the file exists then check to see if the pid is stale
2061  */
2062         if (errno == EEXIST)
2063           {
2064             fd = open(lock_file, O_RDONLY, 0);
2065             if (fd < 0)
2066               {
2067                 if (errno == ENOENT) /* This is just a timing problem. */
2068                   {
2069                     continue;
2070                   }
2071                 break;
2072               }
2073
2074             /* Read the lock file to find out who has the device locked */
2075             n = read (fd, hdb_lock_buffer, 11);
2076             close (fd);
2077             if (n < 0)
2078               {
2079                 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
2080                 break;
2081               }
2082
2083             /* See the process still exists. */
2084             if (n > 0)
2085               {
2086 #ifndef PID_BINARY
2087                 hdb_lock_buffer[n] = '\0';
2088                 sscanf (hdb_lock_buffer, " %d", &pid);
2089 #else
2090                 pid = ((int *) hdb_lock_buffer)[0];
2091 #endif
2092                 if (pid == 0 || pid == getpid()
2093                     || (kill(pid, 0) == -1 && errno == ESRCH))
2094                   {
2095                     n = 0;
2096                   }
2097               }
2098
2099             /* If the process does not exist then try to remove the lock */
2100             if (n == 0 && unlink (lock_file) == 0)
2101               {
2102                 syslog (LOG_NOTICE, "Removed stale lock on %s (pid %d)",
2103                         dev, pid);
2104                 continue;
2105               }
2106
2107             syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, pid);
2108             break;
2109           }
2110
2111         syslog(LOG_ERR, "Can't create lock file %s: %m(%d)", lock_file, errno);
2112         break;
2113       }
2114
2115     free(lock_file);
2116     lock_file = NULL;
2117     return -1;
2118 #endif
2119 }
2120
2121
2122 /********************************************************************
2123  *
2124  * unlock - remove our lockfile
2125  */
2126
2127 void unlock(void)
2128   {
2129     if (lock_file)
2130       {
2131 #ifdef LOCKLIB
2132         (void) rmlock (lock_file, (void *) 0);
2133 #else
2134         unlink(lock_file);
2135 #endif
2136         free(lock_file);
2137         lock_file = NULL;
2138       }
2139   }
2140
2141 /********************************************************************
2142  *
2143  * sifvjcomp - config tcp header compression
2144  */
2145
2146 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2147   {
2148     u_int x = get_flags();
2149
2150     if (vjcomp)
2151       {
2152         if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2153           {
2154             if (! ok_error (errno))
2155               {
2156                 syslog (LOG_ERR, "ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2157               }
2158             vjcomp = 0;
2159           }
2160       }
2161
2162     x = vjcomp  ? x | SC_COMP_TCP     : x &~ SC_COMP_TCP;
2163     x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2164     set_flags (x);
2165
2166     return 1;
2167   }
2168
2169 /********************************************************************
2170  *
2171  * sifup - Config the interface up and enable IP packets to pass.
2172  */
2173
2174 int sifup (int u)
2175   {
2176     struct ifreq ifr;
2177
2178     memset (&ifr, '\0', sizeof (ifr));
2179     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2180     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2181       {
2182         if (! ok_error (errno))
2183           {
2184             syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2185           }
2186         return 0;
2187       }
2188
2189     ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2190     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2191       {
2192         if (! ok_error (errno))
2193           {
2194             syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2195           }
2196         return 0;
2197       }
2198     if_is_up = 1;
2199     return 1;
2200   }
2201
2202 /********************************************************************
2203  *
2204  * sifdown - Config the interface down and disable IP.
2205  */
2206
2207 int sifdown (int u)
2208   {
2209     struct ifreq ifr;
2210
2211     if_is_up = 0;
2212
2213     memset (&ifr, '\0', sizeof (ifr));
2214     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2215     if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2216       {
2217         if (! ok_error (errno))
2218           {
2219             syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2220           }
2221         return 0;
2222       }
2223
2224     ifr.ifr_flags &= ~IFF_UP;
2225     ifr.ifr_flags |= IFF_POINTOPOINT;
2226     if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2227       {
2228         if (! ok_error (errno))
2229           {
2230             syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2231           }
2232         return 0;
2233       }
2234     return 1;
2235   }
2236
2237 /********************************************************************
2238  *
2239  * sifaddr - Config the interface IP addresses and netmask.
2240  */
2241
2242 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2243              u_int32_t net_mask)
2244   {
2245     struct ifreq   ifr; 
2246     struct rtentry rt;
2247     
2248     memset (&ifr, '\0', sizeof (ifr));
2249     memset (&rt,  '\0', sizeof (rt));
2250     
2251     SET_SA_FAMILY (ifr.ifr_addr,    AF_INET); 
2252     SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET); 
2253     SET_SA_FAMILY (ifr.ifr_netmask, AF_INET); 
2254
2255     strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2256 /*
2257  *  Set our IP address
2258  */
2259     ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2260     if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2261       {
2262         if (errno != EEXIST)
2263           {
2264             if (! ok_error (errno))
2265               {
2266                 syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m(%d)", errno);
2267               }
2268           }
2269         else
2270           {
2271             syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
2272           }
2273         return (0);
2274       } 
2275 /*
2276  *  Set the gateway address
2277  */
2278     ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2279     if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0)
2280       {
2281         if (! ok_error (errno))
2282           {
2283             syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m(%d)", errno); 
2284           }
2285         return (0);
2286       } 
2287 /*
2288  *  Set the netmask.
2289  *  For recent kernels, force the netmask to 255.255.255.255.
2290  */
2291     if (kernel_version >= KVERSION(2,1,16))
2292       net_mask = ~0L;
2293     if (net_mask != 0)
2294       {
2295         ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2296         if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0)
2297           {
2298             if (! ok_error (errno))
2299               {
2300                 syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m(%d)", errno); 
2301               }
2302             return (0);
2303           } 
2304       }
2305 /*
2306  *  Add the device route
2307  */
2308     if (kernel_version < KVERSION(2,1,16)) {
2309       SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2310       SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2311       rt.rt_dev = ifname;
2312
2313       ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2314       ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
2315       rt.rt_flags = RTF_UP | RTF_HOST;
2316
2317       if (kernel_version > KVERSION(2,1,0)) {
2318         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2319         ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2320       }
2321
2322       if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
2323         {
2324           if (! ok_error (errno))
2325             {
2326               syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m(%d)", errno);
2327             }
2328           return (0);
2329         }
2330     }
2331     return 1;
2332   }
2333
2334 /********************************************************************
2335  *
2336  * cifaddr - Clear the interface IP addresses, and delete routes
2337  * through the interface if possible.
2338  */
2339
2340 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2341   {
2342     struct rtentry rt;
2343
2344     if (kernel_version < KVERSION(2,1,16)) {
2345 /*
2346  *  Delete the route through the device
2347  */
2348       memset (&rt, '\0', sizeof (rt));
2349
2350       SET_SA_FAMILY (rt.rt_dst,     AF_INET);
2351       SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2352       rt.rt_dev = ifname;
2353
2354       ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2355       ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr     = his_adr;
2356       rt.rt_flags = RTF_UP | RTF_HOST;
2357
2358       if (kernel_version > KVERSION(2,1,0)) {
2359         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2360         ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2361       }
2362
2363       if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
2364         {
2365           if (still_ppp() && ! ok_error (errno))
2366             {
2367               syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m(%d)", errno);
2368             }
2369           return (0);
2370         }
2371     }
2372     return 1;
2373   }
2374
2375 /********************************************************************
2376  *
2377  * open_loopback - open the device we use for getting packets
2378  * in demand mode.  Under Linux, we use our existing fd
2379  * to the ppp driver.
2380  */
2381 void
2382 open_ppp_loopback(void)
2383   {
2384     int flags, i;
2385     struct termios tios;
2386
2387     master_fd = -1;
2388     for (i = 0; i < 64; ++i) {
2389       sprintf(loop_name, "/dev/pty%c%x", 'p' + i / 16, i % 16);
2390       master_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2391       if (master_fd >= 0)
2392         break;
2393     }
2394     if (master_fd < 0) {
2395       syslog(LOG_ERR, "No free pty for loopback");
2396       die(1);
2397     }
2398     SYSDEBUG((LOG_DEBUG, "using %s for loopback", loop_name));
2399     loop_name[5] = 't';
2400     slave_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2401     if (slave_fd < 0) {
2402       syslog(LOG_ERR, "Couldn't open %s for loopback: %m", loop_name);
2403       die(1);
2404     }
2405
2406     set_ppp_fd(slave_fd);
2407
2408     if (tcgetattr(ppp_fd, &tios) == 0)
2409       {
2410         tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2411         tios.c_cflag |= CS8 | CREAD;
2412         tios.c_iflag  = IGNPAR | CLOCAL;
2413         tios.c_oflag  = 0;
2414         tios.c_lflag  = 0;
2415         if (tcsetattr(ppp_fd, TCSAFLUSH, &tios) < 0)
2416           {
2417             syslog(LOG_WARNING, "couldn't set attributes on loopback: %m(%d)", errno);
2418           }
2419       }
2420
2421     flags = fcntl(master_fd, F_GETFL);
2422     if (flags == -1 ||
2423         fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2424       {
2425         syslog(LOG_WARNING, "couldn't set master loopback to nonblock: %m(%d)", errno);
2426       }
2427
2428     flags = fcntl(ppp_fd, F_GETFL);
2429     if (flags == -1 ||
2430         fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2431       {
2432         syslog(LOG_WARNING, "couldn't set slave loopback to nonblock: %m(%d)", errno);
2433       }
2434
2435     if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2436       {
2437         syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
2438         die(1);
2439       }
2440 /*
2441  * Find out which interface we were given.
2442  */
2443     if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2444       { 
2445         syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
2446         die(1);
2447       }
2448 /*
2449  * Enable debug in the driver if requested.
2450  */
2451     set_kdebugflag (kdebugflag);
2452   }
2453
2454 /********************************************************************
2455  *
2456  * restore_loop - reattach the ppp unit to the loopback.
2457  *
2458  * The kernel ppp driver automatically reattaches the ppp unit to
2459  * the loopback if the serial port is set to a line discipline other
2460  * than ppp, or if it detects a modem hangup.  The former will happen
2461  * in disestablish_ppp if the latter hasn't already happened, so we
2462  * shouldn't need to do anything.
2463  *
2464  * Just to be sure, set the real serial port to the normal discipline.
2465  */
2466
2467 void
2468 restore_loop(void)
2469   {
2470     if (ppp_fd != slave_fd)
2471       {
2472         (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2473         set_ppp_fd(slave_fd);
2474       }
2475   }
2476
2477 /********************************************************************
2478  *
2479  * sifnpmode - Set the mode for handling packets for a given NP.
2480  */
2481
2482 int
2483 sifnpmode(u, proto, mode)
2484     int u;
2485     int proto;
2486     enum NPmode mode;
2487 {
2488     struct npioctl npi;
2489
2490     npi.protocol = proto;
2491     npi.mode     = mode;
2492     if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0)
2493       {
2494         if (! ok_error (errno))
2495           {
2496             syslog(LOG_ERR, "ioctl(PPPIOCSNPMODE, %d, %d): %m(%d)",
2497                    proto, mode, errno);
2498             syslog(LOG_ERR, "ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2499           }
2500         return 0;
2501       }
2502     return 1;
2503   }
2504
2505 \f
2506 /********************************************************************
2507  *
2508  * sipxfaddr - Config the interface IPX networknumber
2509  */
2510
2511 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2512   {
2513     int    result = 1;
2514
2515 #ifdef IPX_CHANGE
2516     int    skfd; 
2517     struct ifreq         ifr;
2518     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2519
2520     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2521     if (skfd < 0)
2522       { 
2523         if (! ok_error (errno))
2524           {
2525             syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2526           }
2527         result = 0;
2528       }
2529     else
2530       {
2531         memset (&ifr, '\0', sizeof (ifr));
2532         strcpy (ifr.ifr_name, ifname);
2533
2534         memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2535         sipx->sipx_family  = AF_IPX;
2536         sipx->sipx_port    = 0;
2537         sipx->sipx_network = htonl (network);
2538         sipx->sipx_type    = IPX_FRAME_ETHERII;
2539         sipx->sipx_action  = IPX_CRTITF;
2540 /*
2541  *  Set the IPX device
2542  */
2543         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2544           {
2545             result = 0;
2546             if (errno != EEXIST)
2547               {
2548                 if (! ok_error (errno))
2549                   {
2550                     syslog (LOG_DEBUG,
2551                             "ioctl(SIOCAIFADDR, CRTITF): %m(%d)", errno);
2552                   }
2553               }
2554             else
2555               {
2556                 syslog (LOG_WARNING,
2557                         "ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2558               }
2559           }
2560         close (skfd);
2561       }
2562 #endif
2563     return result;
2564   }
2565
2566 /********************************************************************
2567  *
2568  * cipxfaddr - Clear the information for the IPX network. The IPX routes
2569  *             are removed and the device is no longer able to pass IPX
2570  *             frames.
2571  */
2572
2573 int cipxfaddr (int unit)
2574   {
2575     int    result = 1;
2576
2577 #ifdef IPX_CHANGE
2578     int    skfd; 
2579     struct ifreq         ifr;
2580     struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2581
2582     skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2583     if (skfd < 0)
2584       { 
2585         if (! ok_error (errno))
2586           {
2587             syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2588           }
2589         result = 0;
2590       }
2591     else
2592       {
2593         memset (&ifr, '\0', sizeof (ifr));
2594         strcpy (ifr.ifr_name, ifname);
2595
2596         sipx->sipx_type    = IPX_FRAME_ETHERII;
2597         sipx->sipx_action  = IPX_DLTITF;
2598         sipx->sipx_family  = AF_IPX;
2599 /*
2600  *  Set the IPX device
2601  */
2602         if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2603           {
2604             if (! ok_error (errno))
2605               {
2606                 syslog (LOG_INFO,
2607                         "ioctl(SIOCAIFADDR, IPX_DLTITF): %m(%d)", errno);
2608               }
2609             result = 0;
2610           }
2611         close (skfd);
2612       }
2613 #endif
2614     return result;
2615   }
2616
2617 /*
2618  * daemon - Detach us from controlling terminal session.
2619  */
2620 int
2621 daemon(nochdir, noclose)
2622     int nochdir, noclose;
2623 {
2624     int pid;
2625
2626     if ((pid = fork()) < 0)
2627         return -1;
2628     if (pid != 0)
2629         exit(0);                /* parent dies */
2630     setsid();
2631     if (!nochdir)
2632         chdir("/");
2633     if (!noclose) {
2634         fclose(stdin);          /* don't need stdin, stdout, stderr */
2635         fclose(stdout);
2636         fclose(stderr);
2637     }
2638     return 0;
2639 }
2640
2641 /*
2642  * Use the hostname as part of the random number seed.
2643  */
2644 int
2645 get_host_seed()
2646 {
2647     int h;
2648     char *p = hostname;
2649
2650     h = 407;
2651     for (p = hostname; *p != 0; ++p)
2652         h = h * 37 + *p;
2653     return h;
2654 }
2655
2656 /********************************************************************
2657  *
2658  * sys_check_options - check the options that the user specified
2659  */
2660
2661 int
2662 sys_check_options(void)
2663   {
2664 #ifdef IPX_CHANGE
2665     struct stat stat_buf;
2666 /*
2667  * Disable the IPX protocol if the support is not present in the kernel.
2668  * If we disable it then ensure that IP support is enabled.
2669  */
2670     while (ipxcp_protent.enabled_flag)
2671       {
2672         if (path_to_procfs())
2673           {
2674             strcat (route_buffer, "/net/ipx_interface");
2675             if (lstat (route_buffer, &stat_buf) >= 0)
2676               {
2677                 break;
2678               }
2679           }
2680         syslog (LOG_ERR, "IPX support is not present in the kernel\n");
2681         ipxcp_protent.enabled_flag = 0;
2682         ipcp_protent.enabled_flag  = 1;
2683         break;
2684       }
2685 #endif
2686     if (demand && driver_is_old) {
2687       option_error("demand dialling is not supported by kernel driver version "
2688                    "%d.%d.%d", driver_version, driver_modification,
2689                    driver_patch);
2690       return 0;
2691     }
2692     return 1;
2693   }