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