-exit helper when either direction breaks
[oweals/gnunet.git] / src / vpn / gnunet-helper-vpn.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2010, 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 vpn/gnunet-helper-vpn.c
23  * @brief the helper for the VPN service. Opens a virtual network-interface,
24  * sends data received on the if to stdout, sends data received on stdin to the
25  * interface
26  * @author Philipp Tölke
27  * @author Christian Grothoff
28  *
29  * The following list of people have reviewed this code and considered
30  * it safe since the last modification (if you reviewed it, please
31  * have your name added to the list):
32  *
33  * - Philipp Tölke
34  */
35 #include "platform.h"
36 #include <linux/if_tun.h>
37
38 /**
39  * Need 'struct GNUNET_MessageHeader'.
40  */
41 #include "gnunet_crypto_lib.h"
42 #include "gnunet_common.h"
43
44 /**
45  * Need VPN message types.
46  */
47 #include "gnunet_protocols.h"
48
49 /**
50  * Should we print (interesting|debug) messages that can happen during
51  * normal operation?
52  */
53 #define DEBUG GNUNET_NO
54
55 /**
56  * Maximum size of a GNUnet message (GNUNET_SERVER_MAX_MESSAGE_SIZE)
57  */
58 #define MAX_SIZE 65536
59
60 #ifndef _LINUX_IN6_H
61 /**
62  * This is in linux/include/net/ipv6.h, but not always exported...
63  */
64 struct in6_ifreq
65 {
66   struct in6_addr ifr6_addr;
67   uint32_t ifr6_prefixlen;
68   unsigned int ifr6_ifindex;
69 };
70 #endif
71
72
73 /**
74  * Creates a tun-interface called dev;
75  *
76  * @param dev is asumed to point to a char[IFNAMSIZ]
77  *        if *dev == '\\0', uses the name supplied by the kernel;
78  * @return the fd to the tun or -1 on error
79  */
80 static int
81 init_tun (char *dev)
82 {
83   struct ifreq ifr;
84   int fd;
85
86   if (NULL == dev)
87   {
88     errno = EINVAL;
89     return -1;
90   }
91
92   if (-1 == (fd = open ("/dev/net/tun", O_RDWR)))
93   {
94     fprintf (stderr, "Error opening `%s': %s\n", "/dev/net/tun",
95              strerror (errno));
96     return -1;
97   }
98
99   if (fd >= FD_SETSIZE)
100   {
101     fprintf (stderr, "File descriptor to large: %d", fd);
102     (void) close (fd);
103     return -1;
104   }
105
106   memset (&ifr, 0, sizeof (ifr));
107   ifr.ifr_flags = IFF_TUN;
108
109   if ('\0' != *dev)
110     strncpy (ifr.ifr_name, dev, IFNAMSIZ);
111
112   if (-1 == ioctl (fd, TUNSETIFF, (void *) &ifr))
113   {
114     fprintf (stderr,
115              "Error with ioctl on `%s': %s\n",
116              "/dev/net/tun",
117              strerror (errno));
118     (void) close (fd);
119     return -1;
120   }
121   strcpy (dev, ifr.ifr_name);
122   return fd;
123 }
124
125
126 /**
127  * @brief Sets the IPv6-Address given in address on the interface dev
128  *
129  * @param dev the interface to configure
130  * @param address the IPv6-Address
131  * @param prefix_len the length of the network-prefix
132  */
133 static void
134 set_address6 (const char *dev, const char *address, unsigned long prefix_len)
135 {
136   struct ifreq ifr;
137   struct in6_ifreq ifr6;
138   struct sockaddr_in6 sa6;
139   int fd;
140
141   /*
142    * parse the new address
143    */
144   memset (&sa6, 0, sizeof (struct sockaddr_in6));
145   sa6.sin6_family = AF_INET6;
146   if (1 != inet_pton (AF_INET6, address, sa6.sin6_addr.s6_addr))
147   {
148     fprintf (stderr,
149              "Failed to parse IPv6 address `%s'\n",
150              address);
151     exit (1);
152   }
153
154   if (-1 == (fd = socket (PF_INET6, SOCK_DGRAM, 0)))
155   {
156     fprintf (stderr,
157              "Error creating socket: %s\n",
158              strerror (errno));
159     exit (1);
160   }
161
162   memset (&ifr, 0, sizeof (struct ifreq));
163   /*
164    * Get the index of the if
165    */
166   strncpy (ifr.ifr_name, dev, IFNAMSIZ);
167   if (-1 == ioctl (fd, SIOGIFINDEX, &ifr))
168   {
169     fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno));
170     (void) close (fd);
171     exit (1);
172   }
173
174   memset (&ifr6, 0, sizeof (struct in6_ifreq));
175   ifr6.ifr6_addr = sa6.sin6_addr;
176   ifr6.ifr6_ifindex = ifr.ifr_ifindex;
177   ifr6.ifr6_prefixlen = prefix_len;
178
179   /*
180    * Set the address
181    */
182   if (-1 == ioctl (fd, SIOCSIFADDR, &ifr6))
183   {
184     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
185              strerror (errno));
186     (void) close (fd);
187     exit (1);
188   }
189
190   /*
191    * Get the flags
192    */
193   if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
194   {
195     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
196              strerror (errno));
197     (void) close (fd);
198     exit (1);
199   }
200
201   /*
202    * Add the UP and RUNNING flags
203    */
204   ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
205   if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
206   {
207     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
208              strerror (errno));
209     (void) close (fd);
210     exit (1);
211   }
212
213   if (0 != close (fd))
214   {
215     fprintf (stderr, "close failed: %s\n", strerror (errno));
216     exit (1);
217   }
218 }
219
220
221 /**
222  * @brief Sets the IPv4-Address given in address on the interface dev
223  *
224  * @param dev the interface to configure
225  * @param address the IPv4-Address
226  * @param mask the netmask
227  */
228 static void
229 set_address4 (const char *dev, const char *address, const char *mask)
230 {
231   int fd;
232   struct sockaddr_in *addr;
233   struct ifreq ifr;
234
235   memset (&ifr, 0, sizeof (struct ifreq));
236   addr = (struct sockaddr_in *) &(ifr.ifr_addr);
237   addr->sin_family = AF_INET;
238
239   /*
240    * Parse the address
241    */
242   if (1 != inet_pton (AF_INET, address, &addr->sin_addr.s_addr))
243   {
244     fprintf (stderr,
245              "Failed to parse IPv4 address `%s'\n",
246              address);
247     exit (1);
248   }
249
250   if (-1 == (fd = socket (PF_INET, SOCK_DGRAM, 0)))
251   {
252     fprintf (stderr,
253              "Error creating socket: %s\n",
254              strerror (errno));
255     exit (1);
256   }
257
258   strncpy (ifr.ifr_name, dev, IFNAMSIZ);
259
260   /*
261    * Set the address
262    */
263   if (-1 == ioctl (fd, SIOCSIFADDR, &ifr))
264   {
265     fprintf (stderr,
266              "ioctl failed at %d: %s\n",
267              __LINE__,
268              strerror (errno));
269     (void) close (fd);
270     exit (1);
271   }
272
273   /*
274    * Parse the netmask
275    */
276   addr = (struct sockaddr_in *) &(ifr.ifr_netmask);
277   if (1 != inet_pton (AF_INET, mask, &addr->sin_addr.s_addr))
278   {
279     fprintf (stderr,
280              "Failed to parse IPv4 address mask `%s'\n",
281              mask);
282     (void) close (fd);
283     exit (1);
284   }
285
286   /*
287    * Set the netmask
288    */
289   if (-1 == ioctl (fd, SIOCSIFNETMASK, &ifr))
290   {
291     fprintf (stderr,
292              "ioctl failed at line %d: %s\n",
293              __LINE__,
294              strerror (errno));
295     (void) close (fd);
296     exit (1);
297   }
298
299   /*
300    * Get the flags
301    */
302   if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
303   {
304     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
305              strerror (errno));
306     (void) close (fd);
307     exit (1);
308   }
309
310   /*
311    * Add the UP and RUNNING flags
312    */
313   ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
314   if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
315   {
316     fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
317              strerror (errno));
318     (void) close (fd);
319     exit (1);
320   }
321
322   if (0 != close (fd))
323   {
324     fprintf (stderr, "close failed: %s\n", strerror (errno));
325     (void) close (fd);
326     exit (1);
327   }
328 }
329
330
331 /**
332  * Start forwarding to and from the tunnel.
333  *
334  * @param fd_tun tunnel FD
335  */
336 static void
337 run (int fd_tun)
338 {
339   /*
340    * The buffer filled by reading from fd_tun
341    */
342   unsigned char buftun[MAX_SIZE];
343   ssize_t buftun_size = 0;
344   unsigned char *buftun_read = NULL;
345
346   /*
347    * The buffer filled by reading from stdin
348    */
349   unsigned char bufin[MAX_SIZE];
350   ssize_t bufin_size = 0;
351   size_t bufin_rpos = 0;
352   unsigned char *bufin_read = NULL;
353
354   fd_set fds_w;
355   fd_set fds_r;
356
357   /* read refers to reading from fd_tun, writing to stdout */
358   int read_open = 1;
359
360   /* write refers to reading from stdin, writing to fd_tun */
361   int write_open = 1;
362
363   while ((1 == read_open) && (1 == write_open))
364   {
365     FD_ZERO (&fds_w);
366     FD_ZERO (&fds_r);
367
368     /*
369      * We are supposed to read and the buffer is empty
370      * -> select on read from tun
371      */
372     if (read_open && (0 == buftun_size))
373       FD_SET (fd_tun, &fds_r);
374
375     /*
376      * We are supposed to read and the buffer is not empty
377      * -> select on write to stdout
378      */
379     if (read_open && (0 != buftun_size))
380       FD_SET (1, &fds_w);
381
382     /*
383      * We are supposed to write and the buffer is empty
384      * -> select on read from stdin
385      */
386     if (write_open && (NULL == bufin_read))
387       FD_SET (0, &fds_r);
388
389     /*
390      * We are supposed to write and the buffer is not empty
391      * -> select on write to tun
392      */
393     if (write_open && (NULL != bufin_read))
394       FD_SET (fd_tun, &fds_w);
395
396     int r = select (fd_tun + 1, &fds_r, &fds_w, NULL, NULL);
397
398     if (-1 == r)
399     {
400       if (EINTR == errno)
401         continue;
402       fprintf (stderr, "select failed: %s\n", strerror (errno));
403       exit (1);
404     }
405
406     if (r > 0)
407     {
408       if (FD_ISSET (fd_tun, &fds_r))
409       {
410         buftun_size =
411             read (fd_tun, buftun + sizeof (struct GNUNET_MessageHeader),
412                   MAX_SIZE - sizeof (struct GNUNET_MessageHeader));
413         if (-1 == buftun_size)
414         {
415           fprintf (stderr, "read-error: %s\n", strerror (errno));
416           shutdown (fd_tun, SHUT_RD);
417           shutdown (1, SHUT_WR);
418           read_open = 0;
419           buftun_size = 0;
420         }
421         else if (0 == buftun_size)
422         {
423           fprintf (stderr, "EOF on tun\n");
424           shutdown (fd_tun, SHUT_RD);
425           shutdown (1, SHUT_WR);
426           read_open = 0;
427           buftun_size = 0;
428         }
429         else
430         {
431           buftun_read = buftun;
432           struct GNUNET_MessageHeader *hdr =
433               (struct GNUNET_MessageHeader *) buftun;
434           buftun_size += sizeof (struct GNUNET_MessageHeader);
435           hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
436           hdr->size = htons (buftun_size);
437         }
438       }
439       else if (FD_ISSET (1, &fds_w))
440       {
441         ssize_t written = write (1, buftun_read, buftun_size);
442
443         if (-1 == written)
444         {
445 #if !DEBUG
446           if (errno != EPIPE)
447 #endif
448             fprintf (stderr, "write-error to stdout: %s\n", strerror (errno));
449           shutdown (fd_tun, SHUT_RD);
450           shutdown (1, SHUT_WR);
451           read_open = 0;
452           buftun_size = 0;
453         }
454         else if (0 == written)
455         {
456           fprintf (stderr, "write returned 0!?\n");
457           exit (1);
458         }
459         else
460         {
461           buftun_size -= written;
462           buftun_read += written;
463         }
464       }
465
466       if (FD_ISSET (0, &fds_r))
467       {
468         bufin_size = read (0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos);
469         if (-1 == bufin_size)
470         {
471           fprintf (stderr, "read-error: %s\n", strerror (errno));
472           shutdown (0, SHUT_RD);
473           shutdown (fd_tun, SHUT_WR);
474           write_open = 0;
475           bufin_size = 0;
476         }
477         else if (0 == bufin_size)
478         {
479 #if DEBUG
480           fprintf (stderr, "EOF on stdin\n");
481 #endif
482           shutdown (0, SHUT_RD);
483           shutdown (fd_tun, SHUT_WR);
484           write_open = 0;
485           bufin_size = 0;
486         }
487         else
488         {
489           struct GNUNET_MessageHeader *hdr;
490
491 PROCESS_BUFFER:
492           bufin_rpos += bufin_size;
493           if (bufin_rpos < sizeof (struct GNUNET_MessageHeader))
494             continue;
495           hdr = (struct GNUNET_MessageHeader *) bufin;
496           if (ntohs (hdr->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER)
497           {
498             fprintf (stderr, "protocol violation!\n");
499             exit (1);
500           }
501           if (ntohs (hdr->size) > bufin_rpos)
502             continue;
503           bufin_read = bufin + sizeof (struct GNUNET_MessageHeader);
504           bufin_size = ntohs (hdr->size) - sizeof (struct GNUNET_MessageHeader);
505           bufin_rpos -= bufin_size + sizeof (struct GNUNET_MessageHeader);
506         }
507       }
508       else if (FD_ISSET (fd_tun, &fds_w))
509       {
510         ssize_t written = write (fd_tun, bufin_read, bufin_size);
511
512         if (-1 == written)
513         {
514           fprintf (stderr, "write-error to tun: %s\n", strerror (errno));
515           shutdown (0, SHUT_RD);
516           shutdown (fd_tun, SHUT_WR);
517           write_open = 0;
518           bufin_size = 0;
519         }
520         else if (0 == written)
521         {
522           fprintf (stderr, "write returned 0!?\n");
523           exit (1);
524         }
525         else
526         {
527           bufin_size -= written;
528           bufin_read += written;
529           if (0 == bufin_size)
530           {
531             memmove (bufin, bufin_read, bufin_rpos);
532             bufin_read = NULL;  /* start reading again */
533             bufin_size = 0;
534             goto PROCESS_BUFFER;
535           }
536         }
537       }
538     }
539   }
540 }
541
542
543 /**
544  * Open VPN tunnel interface.
545  *
546  * @param argc must be 6
547  * @param argv 0: binary name (gnunet-helper-vpn)
548  *             1: tunnel interface name (gnunet-vpn)
549  *             2: IPv6 address (::1), "-" to disable
550  *             3: IPv6 netmask length in bits (64), ignored if #2 is "-"
551  *             4: IPv4 address (1.2.3.4), "-" to disable
552  *             5: IPv4 netmask (255.255.0.0), ignored if #4 is "-"
553  */
554 int
555 main (int argc, char **argv)
556 {
557   char dev[IFNAMSIZ];
558   int fd_tun;
559   int global_ret;
560
561   if (6 != argc)
562   {
563     fprintf (stderr, "Fatal: must supply 5 arguments!\n");
564     return 1;
565   }
566
567   strncpy (dev, argv[1], IFNAMSIZ);
568   dev[IFNAMSIZ - 1] = '\0';
569
570   if (-1 == (fd_tun = init_tun (dev)))
571   {
572     fprintf (stderr, "Fatal: could not initialize tun-interface `%s'  with IPv6 %s/%s and IPv4 %s/%s\n",
573              dev,
574              argv[2],
575              argv[3],
576              argv[4],
577              argv[5]);
578     return 1;
579   }
580
581   if (0 != strcmp (argv[2], "-"))
582   {
583     const char *address = argv[2];
584     long prefix_len = atol (argv[3]);
585
586     if ((prefix_len < 1) || (prefix_len > 127))
587     {
588       fprintf (stderr, "Fatal: prefix_len out of range\n");
589       return 1;
590     }
591
592     set_address6 (dev, address, prefix_len);
593   }
594
595   if (0 != strcmp (argv[4], "-"))
596   {
597     const char *address = argv[4];
598     const char *mask = argv[5];
599
600     set_address4 (dev, address, mask);
601   }
602
603   uid_t uid = getuid ();
604 #ifdef HAVE_SETRESUID
605   if (0 != setresuid (uid, uid, uid))
606   {
607     fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
608     global_ret = 2;
609     goto cleanup;
610   }
611 #else
612   if (0 != (setuid (uid) | seteuid (uid)))
613   {
614     fprintf (stderr, "Failed to setuid: %s\n", strerror (errno));
615     global_ret = 2;
616     goto cleanup;
617   }
618 #endif
619
620   if (SIG_ERR == signal (SIGPIPE, SIG_IGN))
621   {
622     fprintf (stderr, "Failed to protect against SIGPIPE: %s\n",
623              strerror (errno));
624     /* no exit, we might as well die with SIGPIPE should it ever happen */
625   }
626   run (fd_tun);
627   global_ret = 0;
628  cleanup:
629   close (fd_tun);
630   return global_ret;
631 }