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