fix silly bug in pr_log
[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
77 #ifdef IPX_CHANGE
78 #include "ipxcp.h"
79 #if __GLIBC__ >= 2 && \
80     !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
81 #include <netipx/ipx.h>
82 #else
83 #include <linux/ipx.h>
84 #endif
85 #endif /* IPX_CHANGE */
86
87 #ifdef PPP_FILTER
88 #include <net/bpf.h>
89 #include <linux/filter.h>
90 #endif /* PPP_FILTER */
91
92 #ifdef LOCKLIB
93 #include <sys/locks.h>
94 #endif
95
96 #ifdef INET6
97 #ifndef _LINUX_IN6_H
98 /*
99  *    This is in linux/include/net/ipv6.h.
100  */
101
102 struct in6_ifreq {
103     struct in6_addr ifr6_addr;
104     __u32 ifr6_prefixlen;
105     unsigned int ifr6_ifindex;
106 };
107 #endif
108
109 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do {                 \
110         memset(&sin6.s6_addr, 0, sizeof(struct in6_addr));      \
111         sin6.s6_addr16[0] = htons(0xfe80);                      \
112         eui64_copy(eui64, sin6.s6_addr32[2]);                   \
113         } while (0)
114
115 #endif /* INET6 */
116
117 /* We can get an EIO error on an ioctl if the modem has hung up */
118 #define ok_error(num) ((num)==EIO)
119
120 static int tty_disc = N_TTY;    /* The TTY discipline */
121 static int ppp_disc = N_PPP;    /* The PPP discpline */
122 static int initfdflags = -1;    /* Initial file descriptor flags for fd */
123 static int ppp_fd = -1;         /* fd which is set to PPP discipline */
124 static int sock_fd = -1;        /* socket for doing interface ioctls */
125 static int slave_fd = -1;
126 static int master_fd = -1;
127 #ifdef INET6
128 static int sock6_fd = -1;
129 #endif /* INET6 */
130 static int ppp_dev_fd = -1;     /* fd for /dev/ppp (new style driver) */
131 static int chindex;             /* channel index (new style driver) */
132
133 static fd_set in_fds;           /* set of fds that wait_input waits for */
134 static int max_in_fd;           /* highest fd set in in_fds */
135
136 static int has_proxy_arp       = 0;
137 static int driver_version      = 0;
138 static int driver_modification = 0;
139 static int driver_patch        = 0;
140 static int driver_is_old       = 0;
141 static int restore_term        = 0;     /* 1 => we've munged the terminal */
142 static struct termios inittermios;      /* Initial TTY termios */
143
144 static int new_style_driver = 0;
145
146 static char loop_name[20];
147 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
148
149 static int      if_is_up;       /* Interface has been marked up */
150 static u_int32_t default_route_gateway; /* Gateway for default route added */
151 static u_int32_t proxy_arp_addr;        /* Addr for proxy arp entry added */
152 static char proxy_arp_dev[16];          /* Device for proxy arp entry */
153 static u_int32_t our_old_addr;          /* for detecting address changes */
154 static int      dynaddr_set;            /* 1 if ip_dynaddr set */
155 static int      looped;                 /* 1 if using loop */
156 static int      link_mtu;               /* mtu for the link (not bundle) */
157
158 static struct utsname utsname;  /* for the kernel version */
159 static int kernel_version;
160 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
161
162 #define MAX_IFS         100
163
164 #define FLAGS_GOOD (IFF_UP          | IFF_BROADCAST)
165 #define FLAGS_MASK (IFF_UP          | IFF_BROADCAST | \
166                     IFF_POINTOPOINT | IFF_LOOPBACK  | IFF_NOARP)
167
168 #define SIN_ADDR(x)     (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
169
170 /* Prototypes for procedures local to this file. */
171 static int get_flags (int fd);
172 static void set_flags (int fd, int flags);
173 static int translate_speed (int bps);
174 static int baud_rate_of (int speed);
175 static void close_route_table (void);
176 static int open_route_table (void);
177 static int read_route_table (struct rtentry *rt);
178 static int defaultroute_exists (struct rtentry *rt);
179 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
180                            char *name, int namelen);
181 static void decode_version (char *buf, int *version, int *mod, int *patch);
182 static int set_kdebugflag(int level);
183 static int ppp_registered(void);
184 static int make_ppp_unit(void);
185
186 extern u_char   inpacket_buf[]; /* borrowed from main.c */
187
188 /*
189  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
190  * if it exists.
191  */
192
193 #define SET_SA_FAMILY(addr, family)                     \
194     memset ((char *) &(addr), '\0', sizeof(addr));      \
195     addr.sa_family = (family);
196
197 /*
198  * Determine if the PPP connection should still be present.
199  */
200
201 extern int hungup;
202
203 /* new_fd is the fd of a tty */
204 static void set_ppp_fd (int new_fd)
205 {
206         SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
207         ppp_fd = new_fd;
208         if (!new_style_driver)
209                 ppp_dev_fd = new_fd;
210 }
211
212 static int still_ppp(void)
213 {
214         if (new_style_driver)
215                 return !hungup && ppp_fd >= 0;
216         if (!hungup || ppp_fd == slave_fd)
217                 return 1;
218         if (slave_fd >= 0) {
219                 set_ppp_fd(slave_fd);
220                 return 1;
221         }
222         return 0;
223 }
224
225 /********************************************************************
226  *
227  * Functions to read and set the flags value in the device driver
228  */
229
230 static int get_flags (int fd)
231 {    
232     int flags;
233
234     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
235         if ( ok_error (errno) )
236             flags = 0;
237         else
238             fatal("ioctl(PPPIOCGFLAGS): %m");
239     }
240
241     SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
242     return flags;
243 }
244
245 /********************************************************************/
246
247 static void set_flags (int fd, int flags)
248 {    
249     SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
250
251     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
252         if (! ok_error (errno) )
253             fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
254     }
255 }
256
257 /********************************************************************
258  *
259  * sys_init - System-dependent initialization.
260  */
261
262 void sys_init(void)
263 {
264     int flags;
265
266     if (new_style_driver) {
267         ppp_dev_fd = open("/dev/ppp", O_RDWR);
268         if (ppp_dev_fd < 0)
269             fatal("Couldn't open /dev/ppp: %m");
270         flags = fcntl(ppp_dev_fd, F_GETFL);
271         if (flags == -1
272             || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
273             warn("Couldn't set /dev/ppp to nonblock: %m");
274     }
275
276     /* Get an internet socket for doing socket ioctls. */
277     sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
278     if (sock_fd < 0)
279         fatal("Couldn't create IP socket: %m(%d)", errno);
280
281 #ifdef INET6
282     sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
283     if (sock6_fd < 0)
284         sock6_fd = -errno;      /* save errno for later */
285 #endif
286
287     FD_ZERO(&in_fds);
288     max_in_fd = 0;
289 }
290
291 /********************************************************************
292  *
293  * sys_cleanup - restore any system state we modified before exiting:
294  * mark the interface down, delete default route and/or proxy arp entry.
295  * This shouldn't call die() because it's called from die().
296  */
297
298 void sys_cleanup(void)
299 {
300 /*
301  * Take down the device
302  */
303     if (if_is_up) {
304         if_is_up = 0;
305         sifdown(0);
306     }
307 /*
308  * Delete any routes through the device.
309  */
310     if (default_route_gateway != 0)
311         cifdefaultroute(0, 0, default_route_gateway);
312
313     if (has_proxy_arp)
314         cifproxyarp(0, proxy_arp_addr);
315 }
316
317 /********************************************************************
318  *
319  * sys_close - Clean up in a child process before execing.
320  */
321 void
322 sys_close(void)
323 {
324     if (new_style_driver)
325         close(ppp_dev_fd);
326     if (sock_fd >= 0)
327         close(sock_fd);
328     if (slave_fd >= 0)
329         close(slave_fd);
330     if (master_fd >= 0)
331         close(master_fd);
332     closelog();
333 }
334
335 /********************************************************************
336  *
337  * set_kdebugflag - Define the debugging level for the kernel
338  */
339
340 static int set_kdebugflag (int requested_level)
341 {
342     if (new_style_driver && ifunit < 0)
343         return 1;
344     if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
345         if ( ! ok_error (errno) )
346             error("ioctl(PPPIOCSDEBUG): %m");
347         return (0);
348     }
349     SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
350                 requested_level));
351     return (1);
352 }
353
354 /********************************************************************
355  *
356  * establish_ppp - Turn the serial port into a ppp interface.
357  */
358
359 int establish_ppp (int tty_fd)
360 {
361     int x;
362     int fd = -1;
363
364 /*
365  * Ensure that the tty device is in exclusive mode.
366  */
367     if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
368         if ( ! ok_error ( errno ))
369             warn("Couldn't make tty exclusive: %m");
370     }
371 /*
372  * Demand mode - prime the old ppp device to relinquish the unit.
373  */
374     if (!new_style_driver && looped
375         && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
376         error("ioctl(transfer ppp unit): %m");
377         return -1;
378     }
379 /*
380  * Set the current tty to the PPP discpline
381  */
382
383 #ifndef N_SYNC_PPP
384 #define N_SYNC_PPP 14
385 #endif
386     ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
387     if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
388         if ( ! ok_error (errno) ) {
389             error("Couldn't set tty to PPP discipline: %m");
390             return -1;
391         }
392     }
393
394     if (new_style_driver) {
395         /* Open another instance of /dev/ppp and connect the channel to it */
396         int flags;
397
398         if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
399             error("Couldn't get channel number: %m");
400             goto err;
401         }
402         dbglog("using channel %d", chindex);
403         fd = open("/dev/ppp", O_RDWR);
404         if (fd < 0) {
405             error("Couldn't reopen /dev/ppp: %m");
406             goto err;
407         }
408         if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
409             error("Couldn't attach to channel %d: %m", chindex);
410             goto err_close;
411         }
412         flags = fcntl(fd, F_GETFL);
413         if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
414             warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
415         set_ppp_fd(fd);
416
417         if (!looped)
418             ifunit = -1;
419         if (!looped && !multilink) {
420             /*
421              * Create a new PPP unit.
422              */
423             if (make_ppp_unit() < 0)
424                 goto err_close;
425         }
426
427         if (looped)
428             set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
429
430         if (!multilink) {
431             add_fd(ppp_dev_fd);
432             if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
433                 error("Couldn't attach to PPP unit %d: %m", ifunit);
434                 goto err_close;
435             }
436         }
437
438     } else {
439         /*
440          * Old-style driver: find out which interface we were given.
441          */
442         set_ppp_fd (tty_fd);
443         if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {       
444             if (ok_error (errno))
445                 goto err;
446             fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
447         }
448         /* Check that we got the same unit again. */
449         if (looped && x != ifunit)
450             fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
451         ifunit = x;
452
453         /*
454          * Fetch the initial file flags and reset blocking mode on the file.
455          */
456         initfdflags = fcntl(tty_fd, F_GETFL);
457         if (initfdflags == -1 ||
458             fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
459             if ( ! ok_error (errno))
460                 warn("Couldn't set device to non-blocking mode: %m");
461         }
462     }
463
464     looped = 0;
465
466     /*
467      * Enable debug in the driver if requested.
468      */
469     if (!looped)
470         set_kdebugflag (kdebugflag);
471
472 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
473 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
474                  | SC_LOG_FLUSH)
475
476     set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
477                        | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
478
479     SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
480             driver_version, driver_modification, driver_patch));
481
482     return ppp_fd;
483
484  err_close:
485     close(fd);
486  err:
487     if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
488         warn("Couldn't reset tty to normal line discipline: %m");
489     return -1;
490 }
491
492 /********************************************************************
493  *
494  * disestablish_ppp - Restore the serial port to normal operation.
495  * This shouldn't call die() because it's called from die().
496  */
497
498 void disestablish_ppp(int tty_fd)
499 {
500     if (!hungup) {
501 /*
502  * Flush the tty output buffer so that the TIOCSETD doesn't hang.
503  */
504         if (tcflush(tty_fd, TCIOFLUSH) < 0)
505             warn("tcflush failed: %m");
506 /*
507  * Restore the previous line discipline
508  */
509         if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
510             if ( ! ok_error (errno))
511                 error("ioctl(TIOCSETD, N_TTY): %m");
512         }
513         
514         if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
515             if ( ! ok_error (errno))
516                 warn("ioctl(TIOCNXCL): %m(%d)", errno);
517         }
518
519         /* Reset non-blocking mode on fd. */
520         if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
521             if ( ! ok_error (errno))
522                 warn("Couldn't restore device fd flags: %m");
523         }
524     }
525     initfdflags = -1;
526
527     if (new_style_driver) {
528         close(ppp_fd);
529         ppp_fd = -1;
530         if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
531             error("Couldn't release PPP unit: %m");
532         if (!multilink)
533             remove_fd(ppp_dev_fd);
534     }
535 }
536
537 /*
538  * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
539  * Assumes new_style_driver.
540  */
541 static int make_ppp_unit()
542 {
543         int x;
544
545         ifunit = req_unit;
546         x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
547         if (x < 0 && req_unit >= 0 && errno == EEXIST) {
548                 warn("Couldn't allocate PPP unit %d as it is already in use");
549                 ifunit = -1;
550                 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
551         }
552         if (x < 0)
553                 error("Couldn't create new ppp unit: %m");
554         return x;
555 }
556
557 /*
558  * cfg_bundle - configure the existing bundle.
559  * Used in demand mode.
560  */
561 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
562 {
563         int flags;
564
565         if (!new_style_driver)
566                 return;
567
568         /* set the mrru, mtu and flags */
569         if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
570                 error("Couldn't set MRRU: %m");
571         flags = get_flags(ppp_dev_fd);
572         flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
573         flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
574                 | (mrru? SC_MULTILINK: 0);
575
576         set_flags(ppp_dev_fd, flags);
577
578         /* connect up the channel */
579         if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
580                 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
581         add_fd(ppp_dev_fd);
582 }
583
584 /*
585  * make_new_bundle - create a new PPP unit (i.e. a bundle)
586  * and connect our channel to it.  This should only get called
587  * if `multilink' was set at the time establish_ppp was called.
588  * In demand mode this uses our existing bundle instead of making
589  * a new one.
590  */
591 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
592 {
593         if (!new_style_driver)
594                 return;
595
596         /* make us a ppp unit */
597         if (make_ppp_unit() < 0)
598                 die(1);
599
600         /* set the mrru and flags */
601         cfg_bundle(mrru, mtru, rssn, tssn);
602 }
603
604 /*
605  * bundle_attach - attach our link to a given PPP unit.
606  * We assume the unit is controlled by another pppd.
607  */
608 int bundle_attach(int ifnum)
609 {
610         if (!new_style_driver)
611                 return -1;
612
613         if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
614                 if (errno == ENXIO)
615                         return 0;       /* doesn't still exist */
616                 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
617         }
618         if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
619                 fatal("Couldn't connect to interface unit %d: %m", ifnum);
620         set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
621
622         ifunit = ifnum;
623         return 1;
624 }
625
626 /********************************************************************
627  *
628  * clean_check - Fetch the flags for the device and generate
629  * appropriate error messages.
630  */
631 void clean_check(void)
632 {
633     int x;
634     char *s;
635
636     if (still_ppp()) {
637         if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
638             s = NULL;
639             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
640             case SC_RCV_B7_0:
641                 s = "all had bit 7 set to 1";
642                 break;
643                 
644             case SC_RCV_B7_1:
645                 s = "all had bit 7 set to 0";
646                 break;
647                 
648             case SC_RCV_EVNP:
649                 s = "all had odd parity";
650                 break;
651                 
652             case SC_RCV_ODDP:
653                 s = "all had even parity";
654                 break;
655             }
656             
657             if (s != NULL) {
658                 warn("Receive serial link is not 8-bit clean:");
659                 warn("Problem: %s", s);
660             }
661         }
662     }
663 }
664         
665
666 /*
667  * List of valid speeds.
668  */
669
670 struct speed {
671     int speed_int, speed_val;
672 } speeds[] = {
673 #ifdef B50
674     { 50, B50 },
675 #endif
676 #ifdef B75
677     { 75, B75 },
678 #endif
679 #ifdef B110
680     { 110, B110 },
681 #endif
682 #ifdef B134
683     { 134, B134 },
684 #endif
685 #ifdef B150
686     { 150, B150 },
687 #endif
688 #ifdef B200
689     { 200, B200 },
690 #endif
691 #ifdef B300
692     { 300, B300 },
693 #endif
694 #ifdef B600
695     { 600, B600 },
696 #endif
697 #ifdef B1200
698     { 1200, B1200 },
699 #endif
700 #ifdef B1800
701     { 1800, B1800 },
702 #endif
703 #ifdef B2000
704     { 2000, B2000 },
705 #endif
706 #ifdef B2400
707     { 2400, B2400 },
708 #endif
709 #ifdef B3600
710     { 3600, B3600 },
711 #endif
712 #ifdef B4800
713     { 4800, B4800 },
714 #endif
715 #ifdef B7200
716     { 7200, B7200 },
717 #endif
718 #ifdef B9600
719     { 9600, B9600 },
720 #endif
721 #ifdef B19200
722     { 19200, B19200 },
723 #endif
724 #ifdef B38400
725     { 38400, B38400 },
726 #endif
727 #ifdef B57600
728     { 57600, B57600 },
729 #endif
730 #ifdef B76800
731     { 76800, B76800 },
732 #endif
733 #ifdef B115200
734     { 115200, B115200 },
735 #endif
736 #ifdef EXTA
737     { 19200, EXTA },
738 #endif
739 #ifdef EXTB
740     { 38400, EXTB },
741 #endif
742 #ifdef B230400
743     { 230400, B230400 },
744 #endif
745 #ifdef B460800
746     { 460800, B460800 },
747 #endif
748 #ifdef B921600
749     { 921600, B921600 },
750 #endif
751     { 0, 0 }
752 };
753
754 /********************************************************************
755  *
756  * Translate from bits/second to a speed_t.
757  */
758
759 static int translate_speed (int bps)
760 {
761     struct speed *speedp;
762
763     if (bps != 0) {
764         for (speedp = speeds; speedp->speed_int; speedp++) {
765             if (bps == speedp->speed_int)
766                 return speedp->speed_val;
767         }
768         warn("speed %d not supported", bps);
769     }
770     return 0;
771 }
772
773 /********************************************************************
774  *
775  * Translate from a speed_t to bits/second.
776  */
777
778 static int baud_rate_of (int speed)
779 {
780     struct speed *speedp;
781     
782     if (speed != 0) {
783         for (speedp = speeds; speedp->speed_int; speedp++) {
784             if (speed == speedp->speed_val)
785                 return speedp->speed_int;
786         }
787     }
788     return 0;
789 }
790
791 /********************************************************************
792  *
793  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
794  * at the requested speed, etc.  If `local' is true, set CLOCAL
795  * regardless of whether the modem option was specified.
796  */
797
798 void set_up_tty(int tty_fd, int local)
799 {
800     int speed;
801     struct termios tios;
802
803     setdtr(tty_fd, 1);
804     if (tcgetattr(tty_fd, &tios) < 0) {
805         if (!ok_error(errno))
806             fatal("tcgetattr: %m(%d)", errno);
807         return;
808     }
809     
810     if (!restore_term)
811         inittermios = tios;
812     
813     tios.c_cflag     &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
814     tios.c_cflag     |= CS8 | CREAD | HUPCL;
815
816     tios.c_iflag      = IGNBRK | IGNPAR;
817     tios.c_oflag      = 0;
818     tios.c_lflag      = 0;
819     tios.c_cc[VMIN]   = 1;
820     tios.c_cc[VTIME]  = 0;
821     
822     if (local || !modem)
823         tios.c_cflag ^= (CLOCAL | HUPCL);
824
825     switch (crtscts) {
826     case 1:
827         tios.c_cflag |= CRTSCTS;
828         break;
829
830     case -2:
831         tios.c_iflag     |= IXON | IXOFF;
832         tios.c_cc[VSTOP]  = 0x13;       /* DC3 = XOFF = ^S */
833         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
834         break;
835
836     case -1:
837         tios.c_cflag &= ~CRTSCTS;
838         break;
839
840     default:
841         break;
842     }
843     
844     speed = translate_speed(inspeed);
845     if (speed) {
846         cfsetospeed (&tios, speed);
847         cfsetispeed (&tios, speed);
848     }
849 /*
850  * We can't proceed if the serial port speed is B0,
851  * since that implies that the serial port is disabled.
852  */
853     else {
854         speed = cfgetospeed(&tios);
855         if (speed == B0)
856             fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
857     }
858
859     if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
860         if (!ok_error(errno))
861             fatal("tcsetattr: %m");
862     
863     baud_rate    = baud_rate_of(speed);
864     restore_term = 1;
865 }
866
867 /********************************************************************
868  *
869  * setdtr - control the DTR line on the serial port.
870  * This is called from die(), so it shouldn't call die().
871  */
872
873 void setdtr (int tty_fd, int on)
874 {
875     int modembits = TIOCM_DTR;
876
877     ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
878 }
879
880 /********************************************************************
881  *
882  * restore_tty - restore the terminal to the saved settings.
883  */
884
885 void restore_tty (int tty_fd)
886 {
887     if (restore_term) {
888         restore_term = 0;
889 /*
890  * Turn off echoing, because otherwise we can get into
891  * a loop with the tty and the modem echoing to each other.
892  * We presume we are the sole user of this tty device, so
893  * when we close it, it will revert to its defaults anyway.
894  */
895         if (!default_device)
896             inittermios.c_lflag &= ~(ECHO | ECHONL);
897         
898         if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
899             if (! ok_error (errno))
900                 warn("tcsetattr: %m");
901         }
902     }
903 }
904
905 /********************************************************************
906  *
907  * output - Output PPP packet.
908  */
909
910 void output (int unit, unsigned char *p, int len)
911 {
912     int fd = ppp_fd;
913     int proto;
914
915     if (debug)
916         dbglog("sent %P", p, len);
917
918     if (len < PPP_HDRLEN)
919         return;
920     if (new_style_driver) {
921         p += 2;
922         len -= 2;
923         proto = (p[0] << 8) + p[1];
924         if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
925             fd = ppp_dev_fd;
926     }
927     if (write(fd, p, len) < 0) {
928         if (errno == EWOULDBLOCK || errno == ENOBUFS
929             || errno == ENXIO || errno == EIO || errno == EINTR)
930             warn("write: warning: %m (%d)", errno);
931         else
932             error("write: %m (%d)", errno);
933     }
934 }
935
936 /********************************************************************
937  *
938  * wait_input - wait until there is data available,
939  * for the length of time specified by *timo (indefinite
940  * if timo is NULL).
941  */
942
943 void wait_input(struct timeval *timo)
944 {
945     fd_set ready, exc;
946     int n;
947
948     ready = in_fds;
949     exc = in_fds;
950     n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
951     if (n < 0 && errno != EINTR)
952         fatal("select: %m(%d)", errno);
953 }
954
955 /*
956  * add_fd - add an fd to the set that wait_input waits for.
957  */
958 void add_fd(int fd)
959 {
960     FD_SET(fd, &in_fds);
961     if (fd > max_in_fd)
962         max_in_fd = fd;
963 }
964
965 /*
966  * remove_fd - remove an fd from the set that wait_input waits for.
967  */
968 void remove_fd(int fd)
969 {
970     FD_CLR(fd, &in_fds);
971 }
972
973
974 /********************************************************************
975  *
976  * read_packet - get a PPP packet from the serial device.
977  */
978
979 int read_packet (unsigned char *buf)
980 {
981     int len, nr;
982
983     len = PPP_MRU + PPP_HDRLEN;
984     if (new_style_driver) {
985         *buf++ = PPP_ALLSTATIONS;
986         *buf++ = PPP_UI;
987         len -= 2;
988     }
989     nr = -1;
990     if (ppp_fd >= 0) {
991         nr = read(ppp_fd, buf, len);
992         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
993             error("read: %m");
994     }
995     if (nr < 0 && new_style_driver && ifunit >= 0) {
996         /* N.B. we read ppp_fd first since LCP packets come in there. */
997         nr = read(ppp_dev_fd, buf, len);
998         if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
999             error("read /dev/ppp: %m");
1000     }
1001     return (new_style_driver && nr > 0)? nr+2: nr;
1002 }
1003
1004 /********************************************************************
1005  *
1006  * get_loop_output - get outgoing packets from the ppp device,
1007  * and detect when we want to bring the real link up.
1008  * Return value is 1 if we need to bring up the link, 0 otherwise.
1009  */
1010 int
1011 get_loop_output(void)
1012 {
1013     int rv = 0;
1014     int n;
1015
1016     if (new_style_driver) {
1017         while ((n = read_packet(inpacket_buf)) > 0)
1018             if (loop_frame(inpacket_buf, n))
1019                 rv = 1;
1020         return rv;
1021     }
1022
1023     while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1024         if (loop_chars(inbuf, n))
1025             rv = 1;
1026
1027     if (n == 0)
1028         fatal("eof on loopback");
1029
1030     if (errno != EWOULDBLOCK)
1031         fatal("read from loopback: %m(%d)", errno);
1032
1033     return rv;
1034 }
1035
1036 /*
1037  * netif_set_mtu - set the MTU on the PPP network interface.
1038  */
1039 void
1040 netif_set_mtu(int unit, int mtu)
1041 {
1042     struct ifreq ifr;
1043
1044     SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1045
1046     memset (&ifr, '\0', sizeof (ifr));
1047     strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1048     ifr.ifr_mtu = mtu;
1049         
1050     if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1051         fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
1052 }
1053
1054 /********************************************************************
1055  *
1056  * tty_send_config - configure the transmit characteristics of
1057  * the ppp interface.
1058  */
1059
1060 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1061 {
1062     u_int x;
1063
1064 /*
1065  * Set the asyncmap and other parameters for the ppp device
1066  */
1067     if (!still_ppp())
1068         return;
1069     link_mtu = mtu;
1070     SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1071     if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1072         if (!ok_error(errno))
1073             fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1074         return;
1075     }
1076     
1077     x = get_flags(ppp_fd);
1078     x = pcomp  ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1079     x = accomp ? x | SC_COMP_AC   : x & ~SC_COMP_AC;
1080     x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1081     set_flags(ppp_fd, x);
1082 }
1083
1084 /********************************************************************
1085  *
1086  * tty_set_xaccm - set the extended transmit ACCM for the interface.
1087  */
1088
1089 void tty_set_xaccm (ext_accm accm)
1090 {
1091     SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1092                 accm[0], accm[1], accm[2], accm[3]));
1093
1094     if (!still_ppp())
1095         return;
1096     if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1097         if ( ! ok_error (errno))
1098             warn("ioctl(set extended ACCM): %m(%d)", errno);
1099     }
1100 }
1101
1102 /********************************************************************
1103  *
1104  * tty_recv_config - configure the receive-side characteristics of
1105  * the ppp interface.
1106  */
1107
1108 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1109 {
1110     SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1111 /*
1112  * If we were called because the link has gone down then there is nothing
1113  * which may be done. Just return without incident.
1114  */
1115     if (!still_ppp())
1116         return;
1117 /*
1118  * Set the receiver parameters
1119  */
1120     if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1121         if ( ! ok_error (errno))
1122             error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1123     }
1124     if (new_style_driver && ifunit >= 0
1125         && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1126         error("Couldn't set MRU in generic PPP layer: %m");
1127
1128     SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1129     if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1130         if (!ok_error(errno))
1131             error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1132     }
1133 }
1134
1135 /********************************************************************
1136  *
1137  * ccp_test - ask kernel whether a given compression method
1138  * is acceptable for use.
1139  */
1140
1141 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1142 {
1143     struct ppp_option_data data;
1144
1145     memset (&data, '\0', sizeof (data));
1146     data.ptr      = opt_ptr;
1147     data.length   = opt_len;
1148     data.transmit = for_transmit;
1149
1150     if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1151         return 1;
1152
1153     return (errno == ENOBUFS)? 0: -1;
1154 }
1155
1156 /********************************************************************
1157  *
1158  * ccp_flags_set - inform kernel about the current state of CCP.
1159  */
1160
1161 void ccp_flags_set (int unit, int isopen, int isup)
1162 {
1163     if (still_ppp()) {
1164         int x = get_flags(ppp_dev_fd);
1165         x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1166         x = isup?   x | SC_CCP_UP   : x &~ SC_CCP_UP;
1167         set_flags (ppp_dev_fd, x);
1168     }
1169 }
1170
1171 #ifdef PPP_FILTER
1172 /*
1173  * set_filters - set the active and pass filters in the kernel driver.
1174  */
1175 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1176 {
1177         struct sock_fprog fp;
1178
1179         fp.len = pass->bf_len;
1180         fp.filter = (struct sock_filter *) pass->bf_insns;
1181         if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1182                 if (errno == ENOTTY)
1183                         warn("kernel does not support PPP filtering");
1184                 else
1185                         error("Couldn't set pass-filter in kernel: %m");
1186                 return 0;
1187         }
1188         fp.len = active->bf_len;
1189         fp.filter = (struct sock_filter *) active->bf_insns;
1190         if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1191                 error("Couldn't set active-filter in kernel: %m");
1192                 return 0;
1193         }
1194         return 1;
1195 }
1196 #endif /* PPP_FILTER */
1197
1198 /********************************************************************
1199  *
1200  * get_idle_time - return how long the link has been idle.
1201  */
1202 int
1203 get_idle_time(u, ip)
1204     int u;
1205     struct ppp_idle *ip;
1206 {
1207     return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1208
1209
1210 /********************************************************************
1211  *
1212  * get_ppp_stats - return statistics for the link.
1213  */
1214 int
1215 get_ppp_stats(u, stats)
1216     int u;
1217     struct pppd_stats *stats;
1218 {
1219     struct ifpppstatsreq req;
1220
1221     memset (&req, 0, sizeof (req));
1222
1223     req.stats_ptr = (caddr_t) &req.stats;
1224     strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1225     if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1226         error("Couldn't get PPP statistics: %m");
1227         return 0;
1228     }
1229     stats->bytes_in = req.stats.p.ppp_ibytes;
1230     stats->bytes_out = req.stats.p.ppp_obytes;
1231     return 1;
1232 }
1233
1234 /********************************************************************
1235  *
1236  * ccp_fatal_error - returns 1 if decompression was disabled as a
1237  * result of an error detected after decompression of a packet,
1238  * 0 otherwise.  This is necessary because of patent nonsense.
1239  */
1240
1241 int ccp_fatal_error (int unit)
1242 {
1243     int x = get_flags(ppp_dev_fd);
1244
1245     return x & SC_DC_FERROR;
1246 }
1247
1248 /********************************************************************
1249  *
1250  * path_to_procfs - find the path to the proc file system mount point
1251  */
1252 static char proc_path[MAXPATHLEN];
1253 static int proc_path_len;
1254
1255 static char *path_to_procfs(const char *tail)
1256 {
1257     struct mntent *mntent;
1258     FILE *fp;
1259
1260     if (proc_path_len == 0) {
1261         /* Default the mount location of /proc */
1262         strlcpy (proc_path, "/proc", sizeof(proc_path));
1263         proc_path_len = 5;
1264         fp = fopen(MOUNTED, "r");
1265         if (fp != NULL) {
1266             while ((mntent = getmntent(fp)) != NULL) {
1267                 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1268                     continue;
1269                 if (strcmp(mntent->mnt_type, "proc") == 0) {
1270                     strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1271                     proc_path_len = strlen(proc_path);
1272                     break;
1273                 }
1274             }
1275             fclose (fp);
1276         }
1277     }
1278
1279     strlcpy(proc_path + proc_path_len, tail,
1280             sizeof(proc_path) - proc_path_len);
1281     return proc_path;
1282 }
1283
1284 /*
1285  * /proc/net/route parsing stuff.
1286  */
1287 #define ROUTE_MAX_COLS  12
1288 FILE *route_fd = (FILE *) 0;
1289 static char route_buffer[512];
1290 static int route_dev_col, route_dest_col, route_gw_col;
1291 static int route_flags_col, route_mask_col;
1292 static int route_num_cols;
1293
1294 static int open_route_table (void);
1295 static void close_route_table (void);
1296 static int read_route_table (struct rtentry *rt);
1297
1298 /********************************************************************
1299  *
1300  * close_route_table - close the interface to the route table
1301  */
1302
1303 static void close_route_table (void)
1304 {
1305     if (route_fd != (FILE *) 0) {
1306         fclose (route_fd);
1307         route_fd = (FILE *) 0;
1308     }
1309 }
1310
1311 /********************************************************************
1312  *
1313  * open_route_table - open the interface to the route table
1314  */
1315 static char route_delims[] = " \t\n";
1316
1317 static int open_route_table (void)
1318 {
1319     char *path;
1320
1321     close_route_table();
1322
1323     path = path_to_procfs("/net/route");
1324     route_fd = fopen (path, "r");
1325     if (route_fd == NULL) {
1326         error("can't open routing table %s: %m", path);
1327         return 0;
1328     }
1329
1330     route_dev_col = 0;          /* default to usual columns */
1331     route_dest_col = 1;
1332     route_gw_col = 2;
1333     route_flags_col = 3;
1334     route_mask_col = 7;
1335     route_num_cols = 8;
1336
1337     /* parse header line */
1338     if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1339         char *p = route_buffer, *q;
1340         int col;
1341         for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1342             int used = 1;
1343             if ((q = strtok(p, route_delims)) == 0)
1344                 break;
1345             if (strcasecmp(q, "iface") == 0)
1346                 route_dev_col = col;
1347             else if (strcasecmp(q, "destination") == 0)
1348                 route_dest_col = col;
1349             else if (strcasecmp(q, "gateway") == 0)
1350                 route_gw_col = col;
1351             else if (strcasecmp(q, "flags") == 0)
1352                 route_flags_col = col;
1353             else if (strcasecmp(q, "mask") == 0)
1354                 route_mask_col = col;
1355             else
1356                 used = 0;
1357             if (used && col >= route_num_cols)
1358                 route_num_cols = col + 1;
1359             p = NULL;
1360         }
1361     }
1362
1363     return 1;
1364 }
1365
1366 /********************************************************************
1367  *
1368  * read_route_table - read the next entry from the route table
1369  */
1370
1371 static int read_route_table(struct rtentry *rt)
1372 {
1373     char *cols[ROUTE_MAX_COLS], *p;
1374     int col;
1375         
1376     memset (rt, '\0', sizeof (struct rtentry));
1377
1378     if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1379         return 0;
1380
1381     p = route_buffer;
1382     for (col = 0; col < route_num_cols; ++col) {
1383         cols[col] = strtok(p, route_delims);
1384         if (cols[col] == NULL)
1385             return 0;           /* didn't get enough columns */
1386         p = NULL;
1387     }
1388
1389     SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1390     SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1391     SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1392
1393     rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1394     rt->rt_dev   = cols[route_dev_col];
1395
1396     return 1;
1397 }
1398
1399 /********************************************************************
1400  *
1401  * defaultroute_exists - determine if there is a default route
1402  */
1403
1404 static int defaultroute_exists (struct rtentry *rt)
1405 {
1406     int result = 0;
1407
1408     if (!open_route_table())
1409         return 0;
1410
1411     while (read_route_table(rt) != 0) {
1412         if ((rt->rt_flags & RTF_UP) == 0)
1413             continue;
1414
1415         if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1416             continue;
1417         if (SIN_ADDR(rt->rt_dst) == 0L) {
1418             result = 1;
1419             break;
1420         }
1421     }
1422
1423     close_route_table();
1424     return result;
1425 }
1426
1427 /*
1428  * have_route_to - determine if the system has any route to
1429  * a given IP address.  `addr' is in network byte order.
1430  * Return value is 1 if yes, 0 if no, -1 if don't know.
1431  * For demand mode to work properly, we have to ignore routes
1432  * through our own interface.
1433  */
1434 int have_route_to(u_int32_t addr)
1435 {
1436     struct rtentry rt;
1437     int result = 0;
1438
1439     if (!open_route_table())
1440         return -1;              /* don't know */
1441
1442     while (read_route_table(&rt)) {
1443         if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1444             continue;
1445         if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1446             result = 1;
1447             break;
1448         }
1449     }
1450
1451     close_route_table();
1452     return result;
1453 }
1454
1455 /********************************************************************
1456  *
1457  * sifdefaultroute - assign a default route through the address given.
1458  */
1459
1460 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1461 {
1462     struct rtentry rt;
1463
1464     if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1465         u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1466
1467         if (old_gateway != gateway)
1468             error("not replacing existing default route to %s [%I]",
1469                   rt.rt_dev, old_gateway);
1470         return 0;
1471     }
1472
1473     memset (&rt, '\0', sizeof (rt));
1474     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1475     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1476
1477     if (kernel_version > KVERSION(2,1,0)) {
1478         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1479         SIN_ADDR(rt.rt_genmask) = 0L;
1480     }
1481
1482     SIN_ADDR(rt.rt_gateway) = gateway;
1483     
1484     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1485     if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1486         if ( ! ok_error ( errno ))
1487             error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1488         return 0;
1489     }
1490
1491     default_route_gateway = gateway;
1492     return 1;
1493 }
1494
1495 /********************************************************************
1496  *
1497  * cifdefaultroute - delete a default route through the address given.
1498  */
1499
1500 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1501 {
1502     struct rtentry rt;
1503
1504     default_route_gateway = 0;
1505
1506     memset (&rt, '\0', sizeof (rt));
1507     SET_SA_FAMILY (rt.rt_dst,     AF_INET);
1508     SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1509
1510     if (kernel_version > KVERSION(2,1,0)) {
1511         SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1512         SIN_ADDR(rt.rt_genmask) = 0L;
1513     }
1514
1515     SIN_ADDR(rt.rt_gateway) = gateway;
1516     
1517     rt.rt_flags = RTF_UP | RTF_GATEWAY;
1518     if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1519         if (still_ppp()) {
1520             if ( ! ok_error ( errno ))
1521                 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1522             return 0;
1523         }
1524     }
1525
1526     return 1;
1527 }
1528
1529 /********************************************************************
1530  *
1531  * sifproxyarp - Make a proxy ARP entry for the peer.
1532  */
1533
1534 int sifproxyarp (int unit, u_int32_t his_adr)
1535 {
1536     struct arpreq arpreq;
1537     char *forw_path;
1538
1539     if (has_proxy_arp == 0) {
1540         memset (&arpreq, '\0', sizeof(arpreq));
1541     
1542         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1543         SIN_ADDR(arpreq.arp_pa) = his_adr;
1544         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1545 /*
1546  * Get the hardware address of an interface on the same subnet
1547  * as our local address.
1548  */
1549         if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1550                             sizeof(proxy_arp_dev))) {
1551             error("Cannot determine ethernet address for proxy ARP");
1552             return 0;
1553         }
1554         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1555
1556         if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1557             if ( ! ok_error ( errno ))
1558                 error("ioctl(SIOCSARP): %m(%d)", errno);
1559             return 0;
1560         }
1561         proxy_arp_addr = his_adr;
1562         has_proxy_arp = 1;
1563
1564         if (tune_kernel) {
1565             forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1566             if (forw_path != 0) {
1567                 int fd = open(forw_path, O_WRONLY);
1568                 if (fd >= 0) {
1569                     if (write(fd, "1", 1) != 1)
1570                         error("Couldn't enable IP forwarding: %m");
1571                     close(fd);
1572                 }
1573             }
1574         }
1575     }
1576
1577     return 1;
1578 }
1579
1580 /********************************************************************
1581  *
1582  * cifproxyarp - Delete the proxy ARP entry for the peer.
1583  */
1584
1585 int cifproxyarp (int unit, u_int32_t his_adr)
1586 {
1587     struct arpreq arpreq;
1588
1589     if (has_proxy_arp) {
1590         has_proxy_arp = 0;
1591         memset (&arpreq, '\0', sizeof(arpreq));
1592         SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1593         SIN_ADDR(arpreq.arp_pa) = his_adr;
1594         arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1595         strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1596
1597         if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1598             if ( ! ok_error ( errno ))
1599                 warn("ioctl(SIOCDARP): %m(%d)", errno);
1600             return 0;
1601         }
1602     }
1603     return 1;
1604 }
1605      
1606 /********************************************************************
1607  *
1608  * get_ether_addr - get the hardware address of an interface on the
1609  * the same subnet as ipaddr.
1610  */
1611
1612 static int get_ether_addr (u_int32_t ipaddr,
1613                            struct sockaddr *hwaddr,
1614                            char *name, int namelen)
1615 {
1616     struct ifreq *ifr, *ifend;
1617     u_int32_t ina, mask;
1618     char *aliasp;
1619     struct ifreq ifreq;
1620     struct ifconf ifc;
1621     struct ifreq ifs[MAX_IFS];
1622     
1623     ifc.ifc_len = sizeof(ifs);
1624     ifc.ifc_req = ifs;
1625     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1626         if ( ! ok_error ( errno ))
1627             error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1628         return 0;
1629     }
1630
1631     SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1632                 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1633 /*
1634  * Scan through looking for an interface with an Internet
1635  * address on the same subnet as `ipaddr'.
1636  */
1637     ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1638     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1639         if (ifr->ifr_addr.sa_family == AF_INET) {
1640             ina = SIN_ADDR(ifr->ifr_addr);
1641             strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1642             SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1643                         ifreq.ifr_name));
1644 /*
1645  * Check that the interface is up, and not point-to-point
1646  * nor loopback.
1647  */
1648             if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1649                 continue;
1650
1651             if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1652                 continue;
1653 /*
1654  * Get its netmask and check that it's on the right subnet.
1655  */
1656             if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1657                 continue;
1658
1659             mask = SIN_ADDR(ifreq.ifr_addr);
1660             SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1661                         ip_ntoa(ina), ntohl(mask)));
1662
1663             if (((ipaddr ^ ina) & mask) != 0)
1664                 continue;
1665             break;
1666         }
1667     }
1668     
1669     if (ifr >= ifend)
1670         return 0;
1671
1672     strlcpy(name, ifreq.ifr_name, namelen);
1673
1674     /* trim off the :1 in eth0:1 */
1675     aliasp = strchr(name, ':');
1676     if (aliasp != 0)
1677         *aliasp = 0;
1678
1679     info("found interface %s for proxy arp", name);
1680 /*
1681  * Now get the hardware address.
1682  */
1683     memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1684     if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1685         error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1686         return 0;
1687     }
1688
1689     memcpy (hwaddr,
1690             &ifreq.ifr_hwaddr,
1691             sizeof (struct sockaddr));
1692
1693     SYSDEBUG ((LOG_DEBUG,
1694            "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1695                 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1696                 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1697                 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1698                 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1699                 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1700                 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1701                 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1702                 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1703     return 1;
1704 }
1705
1706 /*
1707  * get_if_hwaddr - get the hardware address for the specified
1708  * network interface device.
1709  */
1710 int
1711 get_if_hwaddr(u_char *addr, char *name)
1712 {
1713         struct ifreq ifreq;
1714         int ret, sock_fd;
1715
1716         sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1717         if (sock_fd < 0)
1718                 return 0;
1719         memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1720         strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1721         ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1722         close(sock_fd);
1723         if (ret >= 0)
1724                 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1725         return ret;
1726 }
1727
1728 /*
1729  * get_first_ethernet - return the name of the first ethernet-style
1730  * interface on this system.
1731  */
1732 char *
1733 get_first_ethernet()
1734 {
1735         return "eth0";
1736 }
1737
1738 /********************************************************************
1739  *
1740  * Return user specified netmask, modified by any mask we might determine
1741  * for address `addr' (in network byte order).
1742  * Here we scan through the system's list of interfaces, looking for
1743  * any non-point-to-point interfaces which might appear to be on the same
1744  * network as `addr'.  If we find any, we OR in their netmask to the
1745  * user-specified netmask.
1746  */
1747
1748 u_int32_t GetMask (u_int32_t addr)
1749 {
1750     u_int32_t mask, nmask, ina;
1751     struct ifreq *ifr, *ifend, ifreq;
1752     struct ifconf ifc;
1753     struct ifreq ifs[MAX_IFS];
1754
1755     addr = ntohl(addr);
1756     
1757     if (IN_CLASSA(addr))        /* determine network mask for address class */
1758         nmask = IN_CLASSA_NET;
1759     else if (IN_CLASSB(addr))
1760             nmask = IN_CLASSB_NET;
1761     else
1762             nmask = IN_CLASSC_NET;
1763     
1764     /* class D nets are disallowed by bad_ip_adrs */
1765     mask = netmask | htonl(nmask);
1766 /*
1767  * Scan through the system's network interfaces.
1768  */
1769     ifc.ifc_len = sizeof(ifs);
1770     ifc.ifc_req = ifs;
1771     if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1772         if ( ! ok_error ( errno ))
1773             warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1774         return mask;
1775     }
1776     
1777     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1778     for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1779 /*
1780  * Check the interface's internet address.
1781  */
1782         if (ifr->ifr_addr.sa_family != AF_INET)
1783             continue;
1784         ina = SIN_ADDR(ifr->ifr_addr);
1785         if (((ntohl(ina) ^ addr) & nmask) != 0)
1786             continue;
1787 /*
1788  * Check that the interface is up, and not point-to-point nor loopback.
1789  */
1790         strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1791         if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1792             continue;
1793         
1794         if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1795             continue;
1796 /*
1797  * Get its netmask and OR it into our mask.
1798  */
1799         if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1800             continue;
1801         mask |= SIN_ADDR(ifreq.ifr_addr);
1802         break;
1803     }
1804     return mask;
1805 }
1806
1807 /********************************************************************
1808  *
1809  * Internal routine to decode the version.modification.patch level
1810  */
1811
1812 static void decode_version (char *buf, int *version,
1813                             int *modification, int *patch)
1814 {
1815     char *endp;
1816
1817     *version      = (int) strtoul (buf, &endp, 10);
1818     *modification = 0;
1819     *patch        = 0;
1820     
1821     if (endp != buf && *endp == '.') {
1822         buf = endp + 1;
1823         *modification = (int) strtoul (buf, &endp, 10);
1824         if (endp != buf && *endp == '.') {
1825             buf = endp + 1;
1826             *patch = (int) strtoul (buf, &buf, 10);
1827         }
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 | CLOCAL;
2479         tios.c_iflag  = IGNPAR;
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 }