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