added stuff to print outgoing packets in readable form;
[ppp.git] / pppd / sys-str.c
1 /*
2  * sys-str.c - System-dependent procedures for setting up
3  * PPP interfaces on systems which use the STREAMS ppp interface.
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 /*
22  * TODO:
23  */
24
25 #include <stdio.h>
26 #include <errno.h>
27 #include <syslog.h>
28 #include <fcntl.h>
29 #include <sys/ioctl.h>
30 #include <sys/types.h>
31 #include <sys/socket.h>
32 #include <sys/time.h>
33 #include <sys/stream.h>
34 #include <sys/stropts.h>
35 #include <sys/wait.h>
36
37 #include <net/if.h>
38 #include <net/route.h>
39 #include <net/if_arp.h>
40 #include <netinet/in.h>
41
42 #include "pppd.h"
43 #include "ppp.h"
44 #include <net/ppp_str.h>
45
46 #ifndef ifr_mtu
47 #define ifr_mtu         ifr_metric
48 #endif
49
50 #define MAXMODULES      10      /* max number of module names to save */
51 static struct   modlist {
52     char        modname[FMNAMESZ+1];
53 } str_modules[MAXMODULES];
54 static int      str_module_count = 0;
55
56 extern int hungup;              /* has the physical layer been disconnected? */
57
58 /*
59  * ppp_available - check if this kernel supports PPP.
60  */
61 int
62 ppp_available()
63 {
64     int fd, ret;
65
66     fd = open("/dev/tty", O_RDONLY, 0);
67     if (fd < 0)
68         return 1;               /* can't find out - assume we have ppp */
69     ret = ioctl(fd, I_FIND, "pppasync") >= 0;
70     close(fd);
71     return ret;
72 }
73
74
75 /*
76  * establish_ppp - Turn the serial port into a ppp interface.
77  */
78 void
79 establish_ppp()
80 {
81     /* go through and save the name of all the modules, then pop em */
82     for (;;) { 
83         if (ioctl(fd, I_LOOK, str_modules[str_module_count].modname) < 0 ||
84             ioctl(fd, I_POP, 0) < 0)
85             break;
86         MAINDEBUG((LOG_DEBUG, "popped stream module : %s",
87                    str_modules[str_module_count].modname));
88         str_module_count++;
89     }
90
91     MAINDEBUG((LOG_INFO, "about to push modules..."));
92
93     /* now push the async/fcs module */
94     if (ioctl(fd, I_PUSH, "pppasync") < 0) {
95         syslog(LOG_ERR, "ioctl(I_PUSH, ppp_async): %m");
96         die(1);
97     }
98     /* finally, push the ppp_if module that actually handles the */
99     /* network interface */ 
100     if (ioctl(fd, I_PUSH, "pppif") < 0) {
101         syslog(LOG_ERR, "ioctl(I_PUSH, ppp_if): %m");
102         die(1);
103     }
104     if (ioctl(fd, I_SETSIG, S_INPUT) < 0) {
105         syslog(LOG_ERR, "ioctl(I_SETSIG, S_INPUT): %m");
106         die(1);
107     }
108     /* read mode, message non-discard mode */
109     if (ioctl(fd, I_SRDOPT, RMSGN) < 0) {
110         syslog(LOG_ERR, "ioctl(I_SRDOPT, RMSGN): %m");
111         die(1);
112     }
113     /* Flush any waiting messages, or we'll never get SIGPOLL */
114     if (ioctl(fd, I_FLUSH, FLUSHRW) < 0) {
115         syslog(LOG_ERR, "ioctl(I_FLUSH, FLUSHRW): %m");
116         die(1);
117     }
118     /*
119      * Find out which interface we were given.
120      * (ppp_if handles this ioctl)
121      */
122     if (ioctl(fd, SIOCGETU, &ifunit) < 0) {
123         syslog(LOG_ERR, "ioctl(SIOCGETU): %m");
124         die(1);
125     }
126
127     /* if debug, set debug flags in driver */
128     {
129         int flags = debug ? 0x3 : 0;
130         if (ioctl(fd, SIOCSIFDEBUG, &flags) < 0) {
131             syslog(LOG_ERR, "ioctl(SIOCSIFDEBUG): %m");
132         }
133     }
134
135     MAINDEBUG((LOG_INFO, "done pushing modules, ifunit %d", ifunit));
136 }
137
138 /*
139  * disestablish_ppp - Restore the serial port to normal operation.
140  * It attempts to reconstruct the stream with the previously popped
141  * modules.  This shouldn't call die() because it's called from die().
142  */
143 void
144 disestablish_ppp()
145 {
146     /*EMPTY*/
147
148     if (hungup) {
149         /* we can't push or pop modules after the stream has hung up */
150         str_module_count = 0;
151         return;
152     }
153
154     while (ioctl(fd, I_POP, 0) == 0)    /* pop any we pushed */
155         ;
156   
157     for (; str_module_count > 0; str_module_count--) {
158         if (ioctl(fd, I_PUSH, str_modules[str_module_count-1].modname)) {
159             syslog(LOG_ERR, "str_restore: couldn't push module %s: %m",
160                    str_modules[str_module_count-1].modname);
161         } else {
162             MAINDEBUG((LOG_INFO, "str_restore: pushed module %s",
163                        str_modules[str_module_count-1].modname));
164         }
165     }
166 }
167
168
169 /*
170  * output - Output PPP packet.
171  */
172 void
173 output(unit, p, len)
174     int unit;
175     u_char *p;
176     int len;
177 {
178     struct strbuf       str;
179
180     if (unit != 0)
181         MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
182     if (debug)
183         log_packet(p, len, "sent ");
184
185     str.len = len;
186     str.buf = (caddr_t) p;
187     if(putmsg(fd, NULL, &str, 0) < 0) {
188         syslog(LOG_ERR, "putmsg: %m");
189         die(1);
190     }
191 }
192
193
194 /*
195  * read_packet - get a PPP packet from the serial device.
196  */
197 int
198 read_packet(buf)
199     u_char *buf;
200 {
201     struct strbuf str;
202     int len, i;
203
204     str.maxlen = MTU+DLLHEADERLEN;
205     str.buf = (caddr_t) buf;
206     i = 0;
207     len = getmsg(fd, NULL, &str, &i);
208     if (len < 0) {
209         if (errno == EAGAIN || errno == EWOULDBLOCK) {
210             return -1;
211         }
212         syslog(LOG_ERR, "getmsg(fd) %m");
213         die(1);
214     }
215     if (len) 
216         MAINDEBUG((LOG_DEBUG, "getmsg returned 0x%x",len));
217
218     if (str.len < 0) {
219         MAINDEBUG((LOG_DEBUG, "getmsg short return length %d", str.len));
220         return -1;
221     }
222
223     return str.len;
224 }
225
226
227 /*
228  * ppp_send_config - configure the transmit characteristics of
229  * the ppp interface.
230  */
231 void
232 ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
233     int unit, mtu;
234     u_long asyncmap;
235     int pcomp, accomp;
236 {
237     char c;
238     struct ifreq ifr;
239
240     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
241     ifr.ifr_mtu = mtu;
242     if (ioctl(s, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
243         syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
244         quit();
245     }
246
247     if(ioctl(fd, SIOCSIFASYNCMAP, (caddr_t) &asyncmap) < 0) {
248         syslog(LOG_ERR, "ioctl(SIOCSIFASYNCMAP): %m");
249         quit();
250     }
251
252     c = pcomp;
253     if(ioctl(fd, SIOCSIFCOMPPROT, &c) < 0) {
254         syslog(LOG_ERR, "ioctl(SIOCSIFCOMPPROT): %m");
255         quit();
256     }
257
258     c = accomp;
259     if(ioctl(fd, SIOCSIFCOMPAC, &c) < 0) {
260         syslog(LOG_ERR, "ioctl(SIOCSIFCOMPAC): %m");
261         quit();
262     }
263 }
264
265 /*
266  * ppp_recv_config - configure the receive-side characteristics of
267  * the ppp interface.  At present this just sets the MRU.
268  */
269 void
270 ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
271     int unit, mru;
272     u_long asyncmap;
273     int pcomp, accomp;
274 {
275     char c;
276
277     if (ioctl(fd, SIOCSIFMRU, &mru) < 0) {
278         syslog(LOG_ERR, "ioctl(SIOCSIFMRU): %m");
279     }
280
281 #ifdef notyet
282     if(ioctl(fd, SIOCSIFRASYNCMAP, (caddr_t) &asyncmap) < 0) {
283         syslog(LOG_ERR, "ioctl(SIOCSIFRASYNCMAP): %m");
284     }
285
286     c = accomp;
287     if(ioctl(fd, SIOCSIFRCOMPAC, &c) < 0) {
288         syslog(LOG_ERR, "ioctl(SIOCSIFRCOMPAC): %m");
289         quit();
290     }
291 #endif  /* notyet */
292 }
293
294 /*
295  * sifvjcomp - config tcp header compression
296  */
297 int
298 sifvjcomp(u, vjcomp, cidcomp, maxcid)
299     int u, vjcomp, cidcomp, maxcid;
300 {
301     char x = vjcomp;
302
303     if(ioctl(fd, SIOCSIFVJCOMP, (caddr_t) &x) < 0) {
304         syslog(LOG_ERR, "ioctl(SIOCSIFVJCOMP): %m");
305         return 0;
306     }
307     return 1;
308 }
309
310 /*
311  * sifup - Config the interface up.
312  */
313 int
314 sifup(u)
315 {
316     struct ifreq ifr;
317
318     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
319     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
320         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
321         return 0;
322     }
323     ifr.ifr_flags |= IFF_UP;
324     if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
325         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
326         return 0;
327     }
328     return 1;
329 }
330
331 /*
332  * sifdown - Config the interface down.
333  */
334 int
335 sifdown(u)
336 {
337     struct ifreq ifr;
338     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
339     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
340         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
341         return 0;
342     }
343     ifr.ifr_flags &= ~IFF_UP;
344     if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
345         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
346         return 0;
347     }
348     return 1;
349 }
350
351 /*
352  * SET_SA_FAMILY - initialize a struct sockaddr, setting the sa_family field.
353  */
354 #define SET_SA_FAMILY(addr, family)             \
355     BZERO((char *) &(addr), sizeof(addr));      \
356     addr.sa_family = (family);
357
358 /*
359  * sifaddr - Config the interface IP addresses and netmask.
360  */
361 int
362 sifaddr(u, o, h, m)
363 {
364     int ret;
365     struct ifreq ifr;
366
367     ret = 1;
368     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
369     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
370     ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = o;
371     if (ioctl(s, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
372         syslog(LOG_ERR, "ioctl(SIOCSIFADDR): %m");
373         ret = 0;
374     }
375     ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = h;
376     if (ioctl(s, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
377         syslog(LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m");
378         ret = 0;
379     }
380     if (m != 0) {
381         ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = m;
382         syslog(LOG_INFO, "Setting interface mask to %s\n", ip_ntoa(m));
383         if (ioctl(s, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
384             syslog(LOG_ERR, "ioctl(SIOCSIFNETMASK): %m");
385             ret = 0;
386         }
387     }
388     return ret;
389 }
390
391 /*
392  * cifaddr - Clear the interface IP addresses, and delete routes
393  * through the interface if possible.
394  */
395 int
396 cifaddr(u, o, h)
397 {
398     struct rtentry rt;
399
400     SET_SA_FAMILY(rt.rt_dst, AF_INET);
401     ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = h;
402     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
403     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = o;
404     rt.rt_flags = RTF_HOST;
405     if (ioctl(s, SIOCDELRT, (caddr_t) &rt) < 0) {
406         syslog(LOG_ERR, "ioctl(SIOCDELRT): %m");
407         return 0;
408     }
409     return 1;
410 }
411
412 /*
413  * sifdefaultroute - assign a default route through the address given.
414  */
415 int
416 sifdefaultroute(u, g)
417 {
418     struct rtentry rt;
419
420     SET_SA_FAMILY(rt.rt_dst, AF_INET);
421     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
422     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
423     rt.rt_flags = RTF_GATEWAY;
424     if (ioctl(s, SIOCADDRT, &rt) < 0) {
425         syslog(LOG_ERR, "default route ioctl(SIOCADDRT): %m");
426         return 0;
427     }
428     return 1;
429 }
430
431 /*
432  * cifdefaultroute - delete a default route through the address given.
433  */
434 int
435 cifdefaultroute(u, g)
436 {
437     struct rtentry rt;
438
439     SET_SA_FAMILY(rt.rt_dst, AF_INET);
440     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
441     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
442     rt.rt_flags = RTF_GATEWAY;
443     if (ioctl(s, SIOCDELRT, &rt) < 0) {
444         syslog(LOG_ERR, "default route ioctl(SIOCDELRT): %m");
445         return 0;
446     }
447     return 1;
448 }
449
450 /*
451  * sifproxyarp - Make a proxy ARP entry for the peer.
452  */
453 int
454 sifproxyarp(unit, hisaddr)
455     int unit;
456     u_long hisaddr;
457 {
458     struct arpreq arpreq;
459
460     BZERO(&arpreq, sizeof(arpreq));
461
462     /*
463      * Get the hardware address of an interface on the same subnet
464      * as our local address.
465      */
466     if (!get_ether_addr(hisaddr, &arpreq.arp_ha)) {
467         syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
468         return 0;
469     }
470
471     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
472     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
473     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
474     if (ioctl(s, SIOCSARP, (caddr_t)&arpreq) < 0) {
475         syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
476         return 0;
477     }
478
479     return 1;
480 }
481
482 /*
483  * cifproxyarp - Delete the proxy ARP entry for the peer.
484  */
485 int
486 cifproxyarp(unit, hisaddr)
487     int unit;
488     u_long hisaddr;
489 {
490     struct arpreq arpreq;
491
492     BZERO(&arpreq, sizeof(arpreq));
493     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
494     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
495     if (ioctl(s, SIOCDARP, (caddr_t)&arpreq) < 0) {
496         syslog(LOG_ERR, "ioctl(SIOCDARP): %m");
497         return 0;
498     }
499     return 1;
500 }
501
502 /*
503  * get_ether_addr - get the hardware address of an interface on the
504  * the same subnet as ipaddr.  Code borrowed from myetheraddr.c
505  * in the cslip-2.6 distribution, which is subject to the following
506  * copyright notice:
507  *
508  * Copyright (c) 1990, 1992 The Regents of the University of California.
509  * All rights reserved.
510  *
511  * Redistribution and use in source and binary forms, with or without
512  * modification, are permitted provided that: (1) source code distributions
513  * retain the above copyright notice and this paragraph in its entirety, (2)
514  * distributions including binary code include the above copyright notice and
515  * this paragraph in its entirety in the documentation or other materials
516  * provided with the distribution, and (3) all advertising materials mentioning
517  * features or use of this software display the following acknowledgement:
518  * ``This product includes software developed by the University of California,
519  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
520  * the University nor the names of its contributors may be used to endorse
521  * or promote products derived from this software without specific prior
522  * written permission.
523  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
524  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
525  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
526  */
527
528 #include <fcntl.h>
529 #include <nlist.h>
530 #include <kvm.h>
531 #include <arpa/inet.h>
532
533 /* XXX SunOS 4.1 defines this and 3.5 doesn't... */
534 #ifdef _nlist_h
535 #define SUNOS4
536 #endif
537
538 #ifdef SUNOS4
539 #include <netinet/in_var.h>
540 #endif
541 #include <netinet/if_ether.h>
542
543 /* Cast a struct sockaddr to a structaddr_in */
544 #define SATOSIN(sa) ((struct sockaddr_in *)(sa))
545
546 /* Determine if "bits" is set in "flag" */
547 #define ALLSET(flag, bits) (((flag) & (bits)) == (bits))
548
549 static struct nlist nl[] = {
550 #define N_IFNET 0
551         { "_ifnet" },
552         0
553 };
554
555 static void kread();
556
557 int
558 get_ether_addr(ipaddr, hwaddr)
559     u_long ipaddr;
560     struct sockaddr *hwaddr;
561 {
562     register kvm_t *kd;
563     register struct ifnet *ifp;
564     register struct arpcom *ac;
565     struct arpcom arpcom;
566     struct in_addr *inp;
567 #ifdef SUNOS4
568     register struct ifaddr *ifa;
569     register struct in_ifaddr *in;
570     union {
571         struct ifaddr ifa;
572         struct in_ifaddr in;
573     } ifaddr;
574 #endif
575     u_long addr, mask;
576
577     /* Open kernel memory for reading */
578     kd = kvm_open(0, 0, 0, O_RDONLY, NULL);
579     if (kd == 0) {
580         syslog(LOG_ERR, "kvm_open: %m");
581         return 0;
582     }
583
584     /* Fetch namelist */
585     if (kvm_nlist(kd, nl) != 0) {
586         syslog(LOG_ERR, "kvm_nlist failed");
587         return 0;
588     }
589
590     ac = &arpcom;
591     ifp = &arpcom.ac_if;
592 #ifdef SUNOS4
593     ifa = &ifaddr.ifa;
594     in = &ifaddr.in;
595 #endif
596
597     if (kvm_read(kd, nl[N_IFNET].n_value, (char *)&addr, sizeof(addr))
598         != sizeof(addr)) {
599         syslog(LOG_ERR, "error reading ifnet addr");
600         return 0;
601     }
602     for ( ; addr; addr = (u_long)ifp->if_next) {
603         if (kvm_read(kd, addr, (char *)ac, sizeof(*ac)) != sizeof(*ac)) {
604             syslog(LOG_ERR, "error reading ifnet");
605             return 0;
606         }
607
608         /* Only look at configured, broadcast interfaces */
609         if (!ALLSET(ifp->if_flags, IFF_UP | IFF_BROADCAST))
610             continue;
611 #ifdef SUNOS4
612         /* This probably can't happen... */
613         if (ifp->if_addrlist == 0)
614             continue;
615 #endif
616
617         /* Get interface ip address */
618 #ifdef SUNOS4
619         if (kvm_read(kd, (u_long)ifp->if_addrlist, (char *)&ifaddr,
620                      sizeof(ifaddr)) != sizeof(ifaddr)) {
621             syslog(LOG_ERR, "error reading ifaddr");
622             return 0;
623         }
624         inp = &SATOSIN(&ifa->ifa_addr)->sin_addr;
625 #else
626         inp = &SATOSIN(&ifp->if_addr)->sin_addr;
627 #endif
628
629         /* Check if this interface on the right subnet */
630 #ifdef SUNOS4
631         mask = in->ia_subnetmask;
632 #else
633         mask = ifp->if_subnetmask;
634 #endif
635         if ((ipaddr & mask) != (inp->s_addr & mask))
636             continue;
637
638         /* Copy out the local ethernet address */
639         hwaddr->sa_family = AF_UNSPEC;
640         BCOPY((caddr_t) &arpcom.ac_enaddr, hwaddr->sa_data,
641               sizeof(arpcom.ac_enaddr));
642         return 1;               /* success! */
643     }
644
645     /* couldn't find one */
646     return 0;
647 }
648
649
650 /*
651  * run-program - execute a program with given arguments,
652  * but don't wait for it.
653  * If the program can't be executed, logs an error unless
654  * must_exist is 0 and the program file doesn't exist.
655  */
656 static int n_children;
657
658 int
659 run_program(prog, args, must_exist)
660     char *prog;
661     char **args;
662     int must_exist;
663 {
664     int pid;
665
666     pid = fork();
667     if (pid == -1) {
668         syslog(LOG_ERR, "can't fork to run %s: %m", prog);
669         return -1;
670     }
671     if (pid == 0) {
672         execv(prog, args);
673         if (must_exist || errno != ENOENT)
674             syslog(LOG_WARNING, "can't execute %s: %m", prog);
675         _exit(-1);
676     }
677     MAINDEBUG(("Script %s started; pid = %d", prog, pid));
678     ++n_children;
679     return 0;
680 }
681
682
683 /*
684  * reap_kids - get status from any dead child processes,
685  * and log a message for abnormal terminations.
686  */
687 void
688 reap_kids()
689 {
690     int pid, status;
691
692     if (n_children == 0)
693         return;
694     if ((pid = waitpid(-1, &status, WNOHANG)) == -1) {
695         if (errno != ECHILD)
696             syslog(LOG_ERR, "waitpid: %m");
697         return;
698     }
699     --n_children;
700     if (WIFSIGNALED(status)) {
701         syslog(LOG_WARNING, "child process %d terminated with signal %d",
702                pid, WTERMSIG(status));
703     }
704 }