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