- improve handling of duplicate connection_create
[oweals/gnunet.git] / src / dns / gnunet-helper-dns.c
1 /*
2    This file is part of GNUnet.
3    (C) 2010, 2011, 2012 Christian Grothoff
4
5    GNUnet is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published
7    by the Free Software Foundation; either version 3, or (at your
8    option) any later version.
9
10    GNUnet is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with GNUnet; see the file COPYING.  If not, write to the
17    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.
19 */
20
21 /**
22  * @file dns/gnunet-helper-dns.c
23  * @brief helper to install firewall rules to hijack all DNS traffic
24  *        and send it to our virtual interface (except for DNS traffic
25  *        that originates on the specified port).  We then
26  *        allow interacting with our virtual interface via stdin/stdout.
27  * @author Philipp Tölke
28  * @author Christian Grothoff
29  *
30  * This program alters the Linux firewall rules so that DNS traffic
31  * that ordinarily exits the system can be intercepted and managed by
32  * a virtual interface.  In order to achieve this, DNS traffic is
33  * marked with the DNS_MARK given in below and re-routed to a custom
34  * table with the DNS_TABLE ID given below.  Systems and
35  * administrators must take care to not cause conflicts with these
36  * values (it was deemed safest to hardcode them as passing these
37  * values as arguments might permit messing with arbitrary firewall
38  * rules, which would be dangerous).  Traffic coming from the same
39  * group ID as the effective group ID that this process is running
40  * as is not intercepted.
41  *
42  * The code first sets up the virtual interface, then begins to
43  * redirect the DNS traffic to it, and then on errors or SIGTERM shuts
44  * down the virtual interface and removes the rules for the traffic
45  * redirection.
46  *
47  *
48  * Note that having this binary SUID is only partially safe: it will
49  * allow redirecting (and intercepting / mangling) of all DNS traffic
50  * originating from this system by any user who is able to run it.
51  * Furthermore, this code will make it trivial to DoS all DNS traffic
52  * originating from the current system, simply by sending it to
53  * nowhere (redirect stdout to /dev/null).
54  *
55  * Naturally, neither of these problems can be helped as this is the
56  * fundamental purpose of the binary.  Certifying that this code is
57  * "safe" thus only means that it doesn't allow anything else (such
58  * as local priv. escalation, etc.).
59  *
60  * The following list of people have reviewed this code and considered
61  * it safe (within specifications) since the last modification (if you
62  * reviewed it, please have your name added to the list):
63  *
64  * - Christian Grothoff
65  */
66 #include "platform.h"
67
68 #include <linux/if_tun.h>
69
70 /**
71  * Need 'struct GNUNET_MessageHeader'.
72  */
73 #include "gnunet_crypto_lib.h"
74 #include "gnunet_common.h"
75
76 /**
77  * Need DNS message types.
78  */
79 #include "gnunet_protocols.h"
80
81 /**
82  * Maximum size of a GNUnet message (GNUNET_SERVER_MAX_MESSAGE_SIZE)
83  */
84 #define MAX_SIZE 65536
85
86 #ifndef _LINUX_IN6_H
87 /**
88  * This is in linux/include/net/ipv6.h, but not always exported...
89  */
90 struct in6_ifreq
91 {
92   struct in6_addr ifr6_addr;
93   uint32_t ifr6_prefixlen;
94   unsigned int ifr6_ifindex;
95 };
96 #endif
97
98 /**
99  * Name and full path of IPTABLES binary.
100  */
101 static const char *sbin_iptables;
102
103 /**
104  * Name and full path of sysctl binary
105  */
106 static const char *sbin_sysctl;
107
108 /**
109  * Name and full path of IPTABLES binary.
110  */
111 static const char *sbin_ip;
112
113 /**
114  * Port for DNS traffic.
115  */
116 #define DNS_PORT "53"
117
118 /**
119  * Marker we set for our hijacked DNS traffic.  We use GNUnet's
120  * port (2086) plus the DNS port (53) in HEX to make a 32-bit mark
121  * (which is hopefully long enough to not collide); so
122  * 0x08260035 = 136708149 (hopefully unique enough...).
123  */
124 #define DNS_MARK "136708149"
125
126 /**
127  * Table we use for our DNS rules.  0-255 is the range and
128  * 0, 253, 254 and 255 are already reserved.  As this is about
129  * DNS and as "53" is likely (fingers crossed!) high enough to
130  * not usually conflict with a normal user's setup, we use 53
131  * to give a hint that this has something to do with DNS.
132  */
133 #define DNS_TABLE "53"
134
135
136 /**
137  * Control pipe for shutdown via signal. [0] is the read end,
138  * [1] is the write end.
139  */
140 static int cpipe[2];
141
142
143 /**
144  * Signal handler called to initiate "nice" shutdown.  Signals select
145  * loop via non-bocking pipe 'cpipe'.
146  *
147  * @param signal signal number of the signal (not used)
148  */
149 static void
150 signal_handler (int signal)
151 {
152   /* ignore return value, as the signal handler could theoretically
153      be called many times before the shutdown can actually happen */
154   (void) write (cpipe[1], "K", 1);
155 }
156
157
158 /**
159  * Open '/dev/null' and make the result the given
160  * file descriptor.
161  *
162  * @param target_fd desired FD to point to /dev/null
163  * @param flags open flags (O_RDONLY, O_WRONLY)
164  */
165 static void
166 open_dev_null (int target_fd,
167                int flags)
168 {
169   int fd;
170
171   fd = open ("/dev/null", flags);
172   if (-1 == fd)
173     abort ();
174   if (fd == target_fd)
175     return;
176   if (-1 == dup2 (fd, target_fd))
177   {
178     (void) close (fd);
179     abort ();
180   }
181   (void) close (fd);
182 }
183
184
185 /**
186  * Run the given command and wait for it to complete.
187  *
188  * @param file name of the binary to run
189  * @param cmd command line arguments (as given to 'execv')
190  * @return 0 on success, 1 on any error
191  */
192 static int
193 fork_and_exec (const char *file,
194                char *const cmd[])
195 {
196   int status;
197   pid_t pid;
198   pid_t ret;
199
200   pid = fork ();
201   if (-1 == pid)
202   {
203     fprintf (stderr,
204              "fork failed: %s\n",
205              strerror (errno));
206     return 1;
207   }
208   if (0 == pid)
209   {
210     /* we are the child process */
211     /* close stdin/stdout to not cause interference
212        with the helper's main protocol! */
213     (void) close (0);
214     open_dev_null (0, O_RDONLY);
215     (void) close (1);
216     open_dev_null (1, O_WRONLY);
217     (void) execv (file, cmd);
218     /* can only get here on error */
219     fprintf (stderr,
220              "exec `%s' failed: %s\n",
221              file,
222              strerror (errno));
223     _exit (1);
224   }
225   /* keep running waitpid as long as the only error we get is 'EINTR' */
226   while ( (-1 == (ret = waitpid (pid, &status, 0))) &&
227           (errno == EINTR) );
228   if (-1 == ret)
229   {
230     fprintf (stderr,
231              "waitpid failed: %s\n",
232              strerror (errno));
233     return 1;
234   }
235   if (! (WIFEXITED (status) && (0 == WEXITSTATUS (status))))
236     return 1;
237   /* child process completed and returned success, we're happy */
238   return 0;
239 }
240
241
242 /**
243  * Creates a tun-interface called dev;
244  *
245  * @param dev is asumed to point to a char[IFNAMSIZ]
246  *        if *dev == '\\0', uses the name supplied by the kernel;
247  * @return the fd to the tun or -1 on error
248  */
249 static int
250 init_tun (char *dev)
251 {
252   struct ifreq ifr;
253   int fd;
254
255   if (NULL == dev)
256   {
257     errno = EINVAL;
258     return -1;
259   }
260
261   if (-1 == (fd = open ("/dev/net/tun", O_RDWR)))
262   {
263     fprintf (stderr, "Error opening `%s': %s\n", "/dev/net/tun",
264              strerror (errno));
265     return -1;
266   }
267
268   if (fd >= FD_SETSIZE)
269   {
270     fprintf (stderr, "File descriptor to large: %d", fd);
271     (void) close (fd);
272     return -1;
273   }
274
275   memset (&ifr, 0, sizeof (ifr));
276   ifr.ifr_flags = IFF_TUN;
277
278   if ('\0' != *dev)
279     strncpy (ifr.ifr_name, dev, IFNAMSIZ);
280
281   if (-1 == ioctl (fd, TUNSETIFF, (void *) &ifr))
282   {
283     fprintf (stderr, "Error with ioctl on `%s': %s\n", "/dev/net/tun",
284              strerror (errno));
285     (void) close (fd);
286     return -1;
287   }
288   strcpy (dev, ifr.ifr_name);
289   return fd;
290 }
291
292
293 /**
294  * @brief Sets the IPv6-Address given in address on the interface dev
295  *
296  * @param dev the interface to configure
297  * @param address the IPv6-Address
298  * @param prefix_len the length of the network-prefix
299  */
300 static void
301 set_address6 (const char *dev, const char *address, unsigned long prefix_len)
302 {
303   struct ifreq ifr;
304   struct in6_ifreq ifr6;
305   struct sockaddr_in6 sa6;
306   int fd;
307
308   /*
309    * parse the new address
310    */
311   memset (&sa6, 0, sizeof (struct sockaddr_in6));
312   sa6.sin6_family = AF_INET6;
313   if (1 != inet_pton (AF_INET6, address, sa6.sin6_addr.s6_addr))
314   {
315     fprintf (stderr,
316              "Failed to parse IPv6 address `%s': %s\n",
317              address,
318              strerror (errno));
319     exit (1);
320   }
321
322   if (-1 == (fd = socket (PF_INET6, SOCK_DGRAM, 0)))
323   {
324     fprintf (stderr,
325              "Error creating IPv6 socket: %s (ignored)\n",
326              strerror (errno));
327     /* ignore error, maybe only IPv4 works on this system! */
328     return;
329   }
330
331   memset (&ifr, 0, sizeof (struct ifreq));
332   /*
333    * Get the index of the if
334    */
335   strncpy (ifr.ifr_name, dev, IFNAMSIZ);
336   if (-1 == ioctl (fd, SIOGIFINDEX, &ifr))
337   {
338     fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno));
339     (void) close (fd);
340     exit (1);
341   }
342
343   memset (&ifr6, 0, sizeof (struct in6_ifreq));
344   ifr6.ifr6_addr = sa6.sin6_addr;
345   ifr6.ifr6_ifindex = ifr.ifr_ifindex;
346   ifr6.ifr6_prefixlen = prefix_len;
347
348   /*
349    * Set the address
350    */
351   if (-1 == ioctl (fd, SIOCSIFADDR, &ifr6))
352   {
353     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
354              strerror (errno));
355     (void) close (fd);
356     exit (1);
357   }
358
359   /*
360    * Get the flags
361    */
362   if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
363   {
364     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
365              strerror (errno));
366     (void) close (fd);
367     exit (1);
368   }
369
370   /*
371    * Add the UP and RUNNING flags
372    */
373   ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
374   if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
375   {
376     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
377              strerror (errno));
378     (void) close (fd);
379     exit (1);
380   }
381
382   if (0 != close (fd))
383   {
384     fprintf (stderr, "close failed: %s\n", strerror (errno));
385     exit (1);
386   }
387 }
388
389
390 /**
391  * @brief Sets the IPv4-Address given in address on the interface dev
392  *
393  * @param dev the interface to configure
394  * @param address the IPv4-Address
395  * @param mask the netmask
396  */
397 static void
398 set_address4 (const char *dev, const char *address, const char *mask)
399 {
400   int fd;
401   struct sockaddr_in *addr;
402   struct ifreq ifr;
403
404   memset (&ifr, 0, sizeof (struct ifreq));
405   addr = (struct sockaddr_in *) &(ifr.ifr_addr);
406   addr->sin_family = AF_INET;
407
408   /*
409    * Parse the address
410    */
411   if (1 != inet_pton (AF_INET, address, &addr->sin_addr.s_addr))
412   {
413     fprintf (stderr,
414              "Failed to parse IPv4 address `%s': %s\n",
415              address,
416              strerror (errno));
417     exit (1);
418   }
419
420   if (-1 == (fd = socket (PF_INET, SOCK_DGRAM, 0)))
421   {
422     fprintf (stderr,
423              "Error creating IPv4 socket: %s\n",
424              strerror (errno));
425     exit (1);
426   }
427
428   strncpy (ifr.ifr_name, dev, IFNAMSIZ);
429
430   /*
431    * Set the address
432    */
433   if (-1 == ioctl (fd, SIOCSIFADDR, &ifr))
434   {
435     fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno));
436     (void) close (fd);
437     exit (1);
438   }
439
440   /*
441    * Parse the netmask
442    */
443   addr = (struct sockaddr_in *) &(ifr.ifr_netmask);
444   if (1 != inet_pton (AF_INET, mask, &addr->sin_addr.s_addr))
445   {
446     fprintf (stderr, "Failed to parse address `%s': %s\n", mask,
447              strerror (errno));
448     (void) close (fd);
449     exit (1);
450   }
451
452   /*
453    * Set the netmask
454    */
455   if (-1 == ioctl (fd, SIOCSIFNETMASK, &ifr))
456   {
457     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
458              strerror (errno));
459     (void) close (fd);
460     exit (1);
461   }
462
463   /*
464    * Get the flags
465    */
466   if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
467   {
468     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
469              strerror (errno));
470     (void) close (fd);
471     exit (1);
472   }
473
474   /*
475    * Add the UP and RUNNING flags
476    */
477   ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
478   if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
479   {
480     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
481              strerror (errno));
482     (void) close (fd);
483     exit (1);
484   }
485
486   if (0 != close (fd))
487   {
488     fprintf (stderr, "close failed: %s\n", strerror (errno));
489     (void) close (fd);
490     exit (1);
491   }
492 }
493
494
495 /**
496  * Start forwarding to and from the tunnel.  This function runs with
497  * "reduced" priviledges (saved UID is still 0, but effective UID is
498  * the real user ID).
499  *
500  * @param fd_tun tunnel FD
501  */
502 static void
503 run (int fd_tun)
504 {
505   /*
506    * The buffer filled by reading from fd_tun
507    */
508   unsigned char buftun[MAX_SIZE];
509   ssize_t buftun_size = 0;
510   unsigned char *buftun_read = NULL;
511
512   /*
513    * The buffer filled by reading from stdin
514    */
515   unsigned char bufin[MAX_SIZE];
516   ssize_t bufin_size = 0;
517   size_t bufin_rpos = 0;
518   unsigned char *bufin_read = NULL;
519   fd_set fds_w;
520   fd_set fds_r;
521   int max;
522
523   while (1)
524   {
525     FD_ZERO (&fds_w);
526     FD_ZERO (&fds_r);
527
528     /*
529      * We are supposed to read and the buffer is empty
530      * -> select on read from tun
531      */
532     if (0 == buftun_size)
533       FD_SET (fd_tun, &fds_r);
534
535     /*
536      * We are supposed to read and the buffer is not empty
537      * -> select on write to stdout
538      */
539     if (0 < buftun_size)
540       FD_SET (1, &fds_w);
541
542     /*
543      * We are supposed to write and the buffer is empty
544      * -> select on read from stdin
545      */
546     if (NULL == bufin_read)
547       FD_SET (0, &fds_r);
548
549     /*
550      * We are supposed to write and the buffer is not empty
551      * -> select on write to tun
552      */
553     if (NULL != bufin_read)
554       FD_SET (fd_tun, &fds_w);
555
556     FD_SET (cpipe[0], &fds_r);
557     max = (fd_tun > cpipe[0]) ? fd_tun : cpipe[0];
558
559     int r = select (max + 1, &fds_r, &fds_w, NULL, NULL);
560
561     if (-1 == r)
562     {
563       if (EINTR == errno)
564         continue;
565       fprintf (stderr, "select failed: %s\n", strerror (errno));
566       return;
567     }
568
569     if (r > 0)
570     {
571       if (FD_ISSET (cpipe[0], &fds_r))
572         return; /* aborted by signal */
573
574       if (FD_ISSET (fd_tun, &fds_r))
575       {
576         buftun_size =
577             read (fd_tun, buftun + sizeof (struct GNUNET_MessageHeader),
578                   MAX_SIZE - sizeof (struct GNUNET_MessageHeader));
579         if (-1 == buftun_size)
580         {
581           if ( (errno == EINTR) ||
582                (errno == EAGAIN) )
583             {
584               buftun_size = 0;
585               continue;
586             }
587           fprintf (stderr, "read-error: %s\n", strerror (errno));
588           return;
589         }
590         if (0 == buftun_size)
591         {
592           fprintf (stderr, "EOF on tun\n");
593           return;
594         }
595         buftun_read = buftun;
596         {
597           struct GNUNET_MessageHeader *hdr =
598               (struct GNUNET_MessageHeader *) buftun;
599           buftun_size += sizeof (struct GNUNET_MessageHeader);
600           hdr->type = htons (GNUNET_MESSAGE_TYPE_DNS_HELPER);
601           hdr->size = htons (buftun_size);
602         }
603       }
604       else if (FD_ISSET (1, &fds_w))
605       {
606         ssize_t written = write (1, buftun_read, buftun_size);
607
608         if (-1 == written)
609         {
610           if ( (errno == EINTR) ||
611                (errno == EAGAIN) )
612             continue;
613           fprintf (stderr, "write-error to stdout: %s\n", strerror (errno));
614           return;
615         }
616         if (0 == written)
617         {
618           fprintf (stderr, "write returned 0\n");
619           return;
620         }
621         buftun_size -= written;
622         buftun_read += written;
623       }
624
625       if (FD_ISSET (0, &fds_r))
626       {
627         bufin_size = read (0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos);
628         if (-1 == bufin_size)
629         {
630           bufin_read = NULL;
631           if ( (errno == EINTR) ||
632                (errno == EAGAIN) )
633             continue;
634           fprintf (stderr, "read-error: %s\n", strerror (errno));
635           return;
636         }
637         if (0 == bufin_size)
638         {
639           bufin_read = NULL;
640           fprintf (stderr, "EOF on stdin\n");
641           return;
642         }
643         {
644           struct GNUNET_MessageHeader *hdr;
645
646 PROCESS_BUFFER:
647           bufin_rpos += bufin_size;
648           if (bufin_rpos < sizeof (struct GNUNET_MessageHeader))
649             continue;
650           hdr = (struct GNUNET_MessageHeader *) bufin;
651           if (ntohs (hdr->type) != GNUNET_MESSAGE_TYPE_DNS_HELPER)
652           {
653             fprintf (stderr, "protocol violation!\n");
654             return;
655           }
656           if (ntohs (hdr->size) > bufin_rpos)
657             continue;
658           bufin_read = bufin + sizeof (struct GNUNET_MessageHeader);
659           bufin_size = ntohs (hdr->size) - sizeof (struct GNUNET_MessageHeader);
660           bufin_rpos -= bufin_size + sizeof (struct GNUNET_MessageHeader);
661         }
662       }
663       else if (FD_ISSET (fd_tun, &fds_w))
664       {
665         ssize_t written = write (fd_tun, bufin_read, bufin_size);
666
667         if (-1 == written)
668         {
669           if ( (errno == EINTR) ||
670                (errno == EAGAIN) )
671             continue;
672           fprintf (stderr, "write-error to tun: %s\n", strerror (errno));
673           return;
674         }
675         if (0 == written)
676         {
677           fprintf (stderr, "write returned 0\n");
678           return;
679         }
680         {
681           bufin_size -= written;
682           bufin_read += written;
683           if (0 == bufin_size)
684           {
685             memmove (bufin, bufin_read, bufin_rpos);
686             bufin_read = NULL;  /* start reading again */
687             bufin_size = 0;
688             goto PROCESS_BUFFER;
689           }
690         }
691       }
692     }
693   }
694 }
695
696
697 /**
698  * Main function of "gnunet-helper-dns", which opens a VPN tunnel interface,
699  * redirects all outgoing DNS traffic (except from the specified port) to that
700  * interface and then passes traffic from and to the interface via stdin/stdout.
701  *
702  * Once stdin/stdout close or have other errors, the tunnel is closed and the
703  * DNS traffic redirection is stopped.
704  *
705  * @param argc number of arguments
706  * @param argv 0: binary name (should be "gnunet-helper-vpn")
707  *             1: tunnel interface name (typically "gnunet-dns")
708  *             2: IPv6 address for the tunnel ("FE80::1")
709  *             3: IPv6 netmask length in bits ("64")
710  *             4: IPv4 address for the tunnel ("1.2.3.4")
711  *             5: IPv4 netmask ("255.255.0.0")
712  * @return 0 on success, otherwise code indicating type of error:
713  *         1 wrong number of arguments
714  *         2 invalid arguments (i.e. port number / prefix length wrong)
715  *         3 iptables not executable
716  *         4 ip not executable
717  *         5 failed to initialize tunnel interface
718  *         6 failed to initialize control pipe
719  *         8 failed to change routing table, cleanup successful
720  *         9-23 failed to change routing table and failed to undo some changes to routing table
721  *         24 failed to drop privs
722  *         25-39 failed to drop privs and then failed to undo some changes to routing table
723  *         40 failed to regain privs
724  *         41-55 failed to regain prisv and then failed to undo some changes to routing table
725  *         254 insufficient priviledges
726  *         255 failed to handle kill signal properly
727  */
728 int
729 main (int argc, char *const*argv)
730 {
731   int r;
732   char dev[IFNAMSIZ];
733   char mygid[32];
734   int fd_tun;
735   uid_t uid;
736
737   if (6 != argc)
738   {
739     fprintf (stderr, "Fatal: must supply 6 arguments!\n");
740     return 1;
741   }
742
743   /* assert privs so we can modify the firewall rules! */
744   uid = getuid ();
745 #ifdef HAVE_SETRESUID
746   if (0 != setresuid (uid, 0, 0))
747   {
748     fprintf (stderr, "Failed to setresuid to root: %s\n", strerror (errno));
749     return 254;
750   }
751 #else
752   if (0 != seteuid (0))
753   {
754     fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno));
755     return 254;
756   }
757 #endif
758
759   /* verify that the binaries were care about are executable */
760   if (0 == access ("/sbin/iptables", X_OK))
761     sbin_iptables = "/sbin/iptables";
762   else if (0 == access ("/usr/sbin/iptables", X_OK))
763     sbin_iptables = "/usr/sbin/iptables";
764   else
765   {
766     fprintf (stderr,
767              "Fatal: executable iptables not found in approved directories: %s\n",
768              strerror (errno));
769     return 3;
770   }
771   if (0 == access ("/sbin/ip", X_OK))
772     sbin_ip = "/sbin/ip";
773   else if (0 == access ("/usr/sbin/ip", X_OK))
774     sbin_ip = "/usr/sbin/ip";
775   else
776   {
777     fprintf (stderr,
778              "Fatal: executable ip not found in approved directories: %s\n",
779              strerror (errno));
780     return 4;
781   }
782   if (0 == access ("/sbin/sysctl", X_OK))
783     sbin_sysctl = "/sbin/sysctl";
784   else if (0 == access ("/usr/sbin/sysctl", X_OK))
785     sbin_sysctl = "/usr/sbin/sysctl";
786   else
787   {
788     fprintf (stderr,
789              "Fatal: executable sysctl not found in approved directories: %s\n",
790              strerror (errno));
791     return 5;
792   }
793
794   /* setup 'mygid' string */
795   snprintf (mygid, sizeof (mygid), "%d", (int) getegid());
796
797   /* do not die on SIGPIPE */
798   if (SIG_ERR == signal (SIGPIPE, SIG_IGN))
799   {
800     fprintf (stderr, "Failed to protect against SIGPIPE: %s\n",
801              strerror (errno));
802     return 7;
803   }
804
805   /* setup pipe to shutdown nicely on SIGINT */
806   if (0 != pipe (cpipe))
807   {
808     fprintf (stderr,
809              "Fatal: could not setup control pipe: %s\n",
810              strerror (errno));
811     return 6;
812   }
813   if (cpipe[0] >= FD_SETSIZE)
814   {
815     fprintf (stderr, "Pipe file descriptor to large: %d", cpipe[0]);
816     (void) close (cpipe[0]);
817     (void) close (cpipe[1]);
818     return 6;
819   }
820   {
821     /* make pipe non-blocking, as we theoretically could otherwise block
822        in the signal handler */
823     int flags = fcntl (cpipe[1], F_GETFL);
824     if (-1 == flags)
825     {
826       fprintf (stderr, "Failed to read flags for pipe: %s", strerror (errno));
827       (void) close (cpipe[0]);
828       (void) close (cpipe[1]);
829       return 6;
830     }
831     flags |= O_NONBLOCK;
832     if (0 != fcntl (cpipe[1], F_SETFL, flags))
833     {
834       fprintf (stderr, "Failed to make pipe non-blocking: %s", strerror (errno));
835       (void) close (cpipe[0]);
836       (void) close (cpipe[1]);
837       return 6;
838     }
839   }
840   if ( (SIG_ERR == signal (SIGTERM, &signal_handler)) ||
841 #if (SIGTERM != GNUNET_TERM_SIG)
842        (SIG_ERR == signal (GNUNET_TERM_SIG, &signal_handler)) ||
843 #endif
844        (SIG_ERR == signal (SIGINT, &signal_handler)) ||
845        (SIG_ERR == signal (SIGHUP, &signal_handler)) )
846   {
847     fprintf (stderr,
848              "Fatal: could not initialize signal handler: %s\n",
849              strerror (errno));
850     (void) close (cpipe[0]);
851     (void) close (cpipe[1]);
852     return 7;
853   }
854
855
856   /* get interface name */
857   strncpy (dev, argv[1], IFNAMSIZ);
858   dev[IFNAMSIZ - 1] = '\0';
859
860   /* Disable rp filtering */
861   {
862     char *const sysctl_args[] = {"sysctl", "-w",
863       "net.ipv4.conf.all.rp_filter=0", NULL};
864     char *const sysctl_args2[] = {"sysctl", "-w",
865       "net.ipv4.conf.default.rp_filter=0", NULL};
866     if ((0 != fork_and_exec (sbin_sysctl, sysctl_args)) ||
867         (0 != fork_and_exec (sbin_sysctl, sysctl_args2)))
868     {
869       fprintf (stderr,
870                "Failed to disable rp filtering.\n");
871       return 5;
872     }
873   }
874
875
876   /* now open virtual interface (first part that requires root) */
877   if (-1 == (fd_tun = init_tun (dev)))
878   {
879     fprintf (stderr, "Fatal: could not initialize tun-interface\n");
880     (void) signal (SIGTERM, SIG_IGN);
881 #if (SIGTERM != GNUNET_TERM_SIG)
882     (void) signal (GNUNET_TERM_SIG, SIG_IGN);
883 #endif
884     (void) signal (SIGINT, SIG_IGN);
885     (void) signal (SIGHUP, SIG_IGN);
886     (void) close (cpipe[0]);
887     (void) close (cpipe[1]);
888     return 5;
889   }
890
891   /* now set interface addresses */
892   {
893     const char *address = argv[2];
894     long prefix_len = atol (argv[3]);
895
896     if ((prefix_len < 1) || (prefix_len > 127))
897     {
898       fprintf (stderr, "Fatal: prefix_len out of range\n");
899       (void) signal (SIGTERM, SIG_IGN);
900 #if (SIGTERM != GNUNET_TERM_SIG)
901     (void) signal (GNUNET_TERM_SIG, SIG_IGN);
902 #endif
903       (void) signal (SIGINT, SIG_IGN);
904       (void) signal (SIGHUP, SIG_IGN);
905       (void) close (cpipe[0]);
906       (void) close (cpipe[1]);
907       return 2;
908     }
909     set_address6 (dev, address, prefix_len);
910   }
911
912   {
913     const char *address = argv[4];
914     const char *mask = argv[5];
915
916     set_address4 (dev, address, mask);
917   }
918
919
920   /* update routing tables -- next part why we need SUID! */
921   /* Forward everything from our EGID (which should only be held
922      by the 'gnunet-service-dns') and with destination
923      to port 53 on UDP, without hijacking */
924   r = 8; /* failed to fully setup routing table */
925   {
926     char *const mangle_args[] =
927       {
928         "iptables", "-m", "owner", "-t", "mangle", "-I", "OUTPUT", "1", "-p",
929         "udp", "--gid-owner", mygid, "--dport", DNS_PORT, "-j",
930         "ACCEPT", NULL
931       };
932     if (0 != fork_and_exec (sbin_iptables, mangle_args))
933       goto cleanup_rest;
934   }
935   /* Mark all of the other DNS traffic using our mark DNS_MARK */
936   {
937     char *const mark_args[] =
938       {
939         "iptables", "-t", "mangle", "-I", "OUTPUT", "2", "-p",
940         "udp", "--dport", DNS_PORT, "-j", "MARK", "--set-mark", DNS_MARK,
941         NULL
942       };
943     if (0 != fork_and_exec (sbin_iptables, mark_args))
944       goto cleanup_mangle_1;
945   }
946   /* Forward all marked DNS traffic to our DNS_TABLE */
947   {
948     char *const forward_args[] =
949       {
950         "ip", "rule", "add", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL
951       };
952     if (0 != fork_and_exec (sbin_ip, forward_args))
953       goto cleanup_mark_2;
954   }
955   /* Finally, add rule in our forwarding table to pass to our virtual interface */
956   {
957     char *const route_args[] =
958       {
959         "ip", "route", "add", "default", "dev", dev,
960         "table", DNS_TABLE, NULL
961       };
962     if (0 != fork_and_exec (sbin_ip, route_args))
963       goto cleanup_forward_3;
964   }
965
966   /* drop privs *except* for the saved UID; this is not perfect, but better
967      than doing nothing */
968 #ifdef HAVE_SETRESUID
969   if (0 != setresuid (uid, uid, 0))
970   {
971     fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
972     r = 24;
973     goto cleanup_route_4;
974   }
975 #else
976   /* Note: no 'setuid' here as we must keep our saved UID as root */
977   if (0 != seteuid (uid))
978   {
979     fprintf (stderr, "Failed to seteuid: %s\n", strerror (errno));
980     r = 24;
981     goto cleanup_route_4;
982   }
983 #endif
984
985   r = 0; /* did fully setup routing table (if nothing else happens, we were successful!) */
986
987   /* now forward until we hit a problem */
988    run (fd_tun);
989
990   /* now need to regain privs so we can remove the firewall rules we added! */
991 #ifdef HAVE_SETRESUID
992   if (0 != setresuid (uid, 0, 0))
993   {
994     fprintf (stderr, "Failed to setresuid back to root: %s\n", strerror (errno));
995     r = 40;
996     goto cleanup_route_4;
997   }
998 #else
999   if (0 != seteuid (0))
1000   {
1001     fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno));
1002     r = 40;
1003     goto cleanup_route_4;
1004   }
1005 #endif
1006
1007   /* update routing tables again -- this is why we could not fully drop privs */
1008   /* now undo updating of routing tables; normal exit or clean-up-on-error case */
1009  cleanup_route_4:
1010   {
1011     char *const route_clean_args[] =                    
1012       {
1013         "ip", "route", "del", "default", "dev", dev,
1014         "table", DNS_TABLE, NULL
1015       };
1016     if (0 != fork_and_exec (sbin_ip, route_clean_args))
1017       r += 1;
1018   }
1019  cleanup_forward_3:
1020   {
1021     char *const forward_clean_args[] =
1022       {
1023         "ip", "rule", "del", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL
1024       };
1025     if (0 != fork_and_exec (sbin_ip, forward_clean_args))
1026       r += 2;   
1027   }
1028  cleanup_mark_2:
1029   {
1030     char *const mark_clean_args[] =
1031       {
1032         "iptables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp",
1033         "--dport", DNS_PORT, "-j", "MARK", "--set-mark", DNS_MARK, NULL
1034       };
1035     if (0 != fork_and_exec (sbin_iptables, mark_clean_args))
1036       r += 4;
1037   }     
1038  cleanup_mangle_1:
1039   {
1040     char *const mangle_clean_args[] =
1041       {
1042         "iptables", "-m", "owner", "-t", "mangle", "-D", "OUTPUT", "-p", "udp",
1043          "--gid-owner", mygid, "--dport", DNS_PORT, "-j", "ACCEPT",
1044         NULL
1045       };
1046     if (0 != fork_and_exec (sbin_iptables, mangle_clean_args))
1047       r += 8;
1048   }
1049
1050  cleanup_rest:
1051   /* close virtual interface */
1052   (void) close (fd_tun);
1053   /* remove signal handler so we can close the pipes */
1054   (void) signal (SIGTERM, SIG_IGN);
1055 #if (SIGTERM != GNUNET_TERM_SIG)
1056     (void) signal (GNUNET_TERM_SIG, SIG_IGN);
1057 #endif
1058   (void) signal (SIGINT, SIG_IGN);
1059   (void) signal (SIGHUP, SIG_IGN);
1060   (void) close (cpipe[0]);
1061   (void) close (cpipe[1]);
1062   return r;
1063 }
1064
1065 /* end of gnunet-helper-dns.c */