GNUnet  0.17.6
gnunet-dns2gns.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012-2013 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your 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  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
25 #include "platform.h"
26 #include <gnunet_util_lib.h>
27 #include <gnunet_dnsparser_lib.h>
28 #include <gnunet_gns_service.h>
29 #include <gnunet_dnsstub_lib.h>
30 #include "gnunet_vpn_service.h"
31 #include "gns.h"
32 
36 #define TIMEOUT GNUNET_TIME_UNIT_MINUTES
37 
41 #define VPN_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
42 
43 
44 struct Request;
45 
49 struct VpnContext
50 {
54  struct Request *request;
55 
60 
64  unsigned int rd_count;
65 
69  char *rd_data;
70 
74  ssize_t rd_data_size;
75 };
76 
77 
81 struct Request
82 {
87 
91  const void *addr;
92 
98 
103 
108 
114 
119 
123  char *udp_msg;
124 
128  size_t addr_len;
129 
133  size_t udp_msg_size;
134 
139 
140 };
141 
145 static in_addr_t address;
146 
150 static struct in6_addr address6;
151 
152 
157 
162 
167 
172 
177 
181 static struct GNUNET_SCHEDULER_Task *t4;
182 
186 static struct GNUNET_SCHEDULER_Task *t6;
187 
191 static char *dns_ip;
192 
196 static unsigned int listen_port = 53;
197 
201 static const struct GNUNET_CONFIGURATION_Handle *cfg;
202 
203 
209 static void
210 do_shutdown (void *cls)
211 {
212  (void) cls;
213  if (NULL != t4)
214  {
216  t4 = NULL;
217  }
218  if (NULL != t6)
219  {
221  t6 = NULL;
222  }
223  if (NULL != listen_socket4)
224  {
226  listen_socket4 = NULL;
227  }
228  if (NULL != listen_socket6)
229  {
231  listen_socket6 = NULL;
232  }
233  if (NULL != gns)
234  {
236  gns = NULL;
237  }
238  if (NULL != vpn_handle)
239  {
241  vpn_handle = NULL;
242  }
243  if (NULL != dns_stub)
244  {
246  dns_stub = NULL;
247  }
248 }
249 
250 
257 static void
259 {
260  unsigned int idx = request->packet->num_answers;
261  unsigned int r_idx;
262  struct GNUNET_DNSPARSER_Record tmp_answer;
263 
264  while (0 != idx)
265  {
267  request->packet->num_answers);
268  idx--;
269  tmp_answer = request->packet->answers[idx];
270  memcpy (&request->packet->answers[idx], &request->packet->answers[r_idx],
271  sizeof (struct GNUNET_DNSPARSER_Record));
272  memcpy (&request->packet->answers[r_idx], &tmp_answer,
273  sizeof (struct GNUNET_DNSPARSER_Record));
274  }
275 }
276 
277 
283 static void
285 {
286  char *buf;
287  size_t size;
288  ssize_t sret;
289 
291  if (GNUNET_SYSERR ==
293  UINT16_MAX /* is this not too much? */,
294  &buf,
295  &size))
296  {
298  _ ("Failed to pack DNS response into UDP packet!\n"));
299  }
300  else
301  {
302  sret = GNUNET_NETWORK_socket_sendto (request->lsock,
303  buf,
304  size,
305  request->addr,
306  request->addr_len);
307  if ((sret < 0) ||
308  (size != (size_t) sret))
310  "sendto");
311  GNUNET_free (buf);
312  }
313  GNUNET_SCHEDULER_cancel (request->timeout_task);
315  GNUNET_free (request->udp_msg);
317 }
318 
319 
325 static void
326 do_timeout (void *cls)
327 {
328  struct Request *request = cls;
329  struct VpnContext *vpn_ctx;
330 
331  if (NULL != request->packet)
333  if (NULL != request->lookup)
335  if (NULL != request->dns_lookup)
337  GNUNET_free (request->udp_msg);
338  if (NULL != (vpn_ctx = request->vpn_ctx))
339  {
341  GNUNET_free (vpn_ctx->rd_data);
342  GNUNET_free (vpn_ctx);
343  }
345 }
346 
347 
355 static void
357  const struct GNUNET_TUN_DnsHeader *dns,
358  size_t r)
359 {
360  struct Request *request = cls;
361 
362  if (NULL == dns)
363  {
364  /* DNSSTUB gave up, so we trigger timeout early */
365  GNUNET_SCHEDULER_cancel (request->timeout_task);
367  return;
368  }
369  if (request->original_request_id != dns->id)
370  {
371  /* for a another query, ignore */
372  return;
373  }
374  request->packet = GNUNET_DNSPARSER_parse ((char *) dns,
375  r);
376  if (NULL == request->packet)
377  {
379  _ ("Failed to parse DNS response!\n"));
380  GNUNET_SCHEDULER_cancel (request->timeout_task);
382  return;
383  }
386 }
387 
402 static void
403 vpn_allocation_cb (void *cls,
404  int af,
405  const void *address)
406 {
407  struct VpnContext *vpn_ctx = cls;
408  struct Request *request = vpn_ctx->request;
409  struct GNUNET_GNSRECORD_Data rd[vpn_ctx->rd_count];
410  unsigned int i;
411 
412  vpn_ctx->vpn_request = NULL;
413  request->vpn_ctx = NULL;
416  (size_t) vpn_ctx->rd_data_size,
417  vpn_ctx->rd_data,
418  vpn_ctx->rd_count,
419  rd));
420  for (i = 0; i < vpn_ctx->rd_count; i++)
421  {
423  {
424  switch (af)
425  {
426  case AF_INET:
428  rd[i].data_size = sizeof(struct in_addr);
431  rd[i].flags = 0;
432  rd[i].data = address;
433  break;
434 
435  case AF_INET6:
439  rd[i].flags = 0;
440  rd[i].data = address;
441  rd[i].data_size = sizeof(struct in6_addr);
442  break;
443 
444  default:
445  GNUNET_assert (0);
446  }
447  break;
448  }
449  }
450  GNUNET_assert (i < vpn_ctx->rd_count);
451  if (0 == vpn_ctx->rd_count)
453  _ ("VPN returned empty result for `%s'\n"),
454  request->packet->queries[0].name);
456  GNUNET_free (vpn_ctx->rd_data);
457  GNUNET_free (vpn_ctx);
458 }
459 
460 
461 
470 static void
471 result_processor (void *cls,
472  int was_gns,
473  uint32_t rd_count,
474  const struct GNUNET_GNSRECORD_Data *rd)
475 {
476  struct Request *request = cls;
477  struct GNUNET_DNSPARSER_Packet *packet;
478  struct GNUNET_DNSPARSER_Record rec;
479  struct VpnContext *vpn_ctx;
480  const struct GNUNET_TUN_GnsVpnRecord *vpn;
481  const char *vname;
482  struct GNUNET_HashCode vhash;
483  int af;
484 
485  request->lookup = NULL;
486  if (GNUNET_NO == was_gns)
487  {
488  /* TLD not configured for GNS, fall back to DNS */
490  "Using DNS resolver IP `%s' to resolve `%s'\n",
491  dns_ip,
492  request->packet->queries[0].name);
493  request->original_request_id = request->packet->id;
495  request->packet = NULL;
496  request->dns_lookup = GNUNET_DNSSTUB_resolve (dns_stub,
497  request->udp_msg,
498  request->udp_msg_size,
500  request);
501  return;
502  }
503  packet = request->packet;
504  packet->flags.query_or_response = 1;
506  packet->flags.checking_disabled = 0;
507  packet->flags.authenticated_data = 1;
508  packet->flags.zero = 0;
509  packet->flags.recursion_available = 1;
510  packet->flags.message_truncated = 0;
511  packet->flags.authoritative_answer = 0;
512  // packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ???
513  for (uint32_t i = 0; i < rd_count; i++)
514  {
516  switch (rd[i].record_type)
517  {
519  GNUNET_assert (sizeof(struct in_addr) == rd[i].data_size);
520  rec.name = GNUNET_strdup (packet->queries[0].name);
523  rec.data.raw.data = GNUNET_new (struct in_addr);
524  GNUNET_memcpy (rec.data.raw.data,
525  rd[i].data,
526  rd[i].data_size);
527  rec.data.raw.data_len = sizeof(struct in_addr);
528  GNUNET_array_append (packet->answers,
529  packet->num_answers,
530  rec);
531  break;
532 
534  GNUNET_assert (sizeof(struct in6_addr) == rd[i].data_size);
535  rec.name = GNUNET_strdup (packet->queries[0].name);
536  rec.data.raw.data = GNUNET_new (struct in6_addr);
539  GNUNET_memcpy (rec.data.raw.data,
540  rd[i].data,
541  rd[i].data_size);
542  rec.data.raw.data_len = sizeof(struct in6_addr);
543  GNUNET_array_append (packet->answers,
544  packet->num_answers,
545  rec);
546  break;
547 
549  rec.name = GNUNET_strdup (packet->queries[0].name);
550  rec.data.hostname = GNUNET_strdup (rd[i].data);
554  rd[i].data,
555  rd[i].data_size);
556  GNUNET_array_append (packet->answers,
557  packet->num_answers,
558  rec);
559  break;
561  if ((GNUNET_DNSPARSER_TYPE_A != request->packet->queries[0].type) &&
562  (GNUNET_DNSPARSER_TYPE_AAAA != request->packet->queries[0].type))
563  break;
564  af = (GNUNET_DNSPARSER_TYPE_A == request->packet->queries[0].type) ? AF_INET :
565  AF_INET6;
566  if (sizeof(struct GNUNET_TUN_GnsVpnRecord) >
567  rd[i].data_size)
568  {
569  GNUNET_break_op (0);
570  break;
571  }
572  vpn = (const struct GNUNET_TUN_GnsVpnRecord *) rd[i].data;
573  vname = (const char *) &vpn[1];
574  if ('\0' != vname[rd[i].data_size - 1 - sizeof(struct
576  ])
577  {
578  GNUNET_break_op (0);
579  break;
580  }
582  &vhash);
584  "Attempting VPN allocation for %s-%s (AF: %d, proto %d)\n",
585  GNUNET_i2s (&vpn->peer),
586  vname,
587  (int) af,
588  (int) ntohs (vpn->proto));
589  vpn_ctx = GNUNET_new (struct VpnContext);
590  request->vpn_ctx = vpn_ctx;
591  vpn_ctx->request = request;
592  vpn_ctx->rd_data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
593  rd);
594  if (vpn_ctx->rd_data_size < 0)
595  {
596  GNUNET_break_op (0);
597  GNUNET_free (vpn_ctx);
598  break;
599  }
600  vpn_ctx->rd_data = GNUNET_malloc ((size_t) vpn_ctx->rd_data_size);
601  vpn_ctx->rd_count = rd_count;
602  GNUNET_assert (vpn_ctx->rd_data_size ==
604  rd,
605  (size_t) vpn_ctx
606  ->rd_data_size,
607  vpn_ctx->rd_data));
609  af,
610  ntohs (
611  vpn->proto),
612  &vpn->peer,
613  &vhash,
615  VPN_TIMEOUT),
616  &
618  vpn_ctx);
619  return;
620 
621 
622  default:
623  /* skip */
624  break;
625  }
626  }
628 }
629 
630 
640 static void
642  const void *addr,
643  size_t addr_len,
644  const char *udp_msg,
645  size_t udp_msg_size)
646 {
647  struct Request *request;
648  struct GNUNET_DNSPARSER_Packet *packet;
649 
650  packet = GNUNET_DNSPARSER_parse (udp_msg,
651  udp_msg_size);
652  if (NULL == packet)
653  {
655  _ ("Cannot parse DNS request from %s\n"),
656  GNUNET_a2s (addr, addr_len));
657  return;
658  }
660  "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n",
661  packet->queries[0].name,
662  (unsigned int) packet->flags.query_or_response,
663  (int) packet->num_answers,
664  (int) packet->num_authority_records,
665  (int) packet->num_additional_records);
666  if ((0 != packet->flags.query_or_response) ||
667  (0 != packet->num_answers) ||
668  (0 != packet->num_authority_records))
669  {
671  _ ("Received malformed DNS request from %s\n"),
672  GNUNET_a2s (addr, addr_len));
674  return;
675  }
676  if ((1 != packet->num_queries))
677  {
679  _ ("Received unsupported DNS request from %s\n"),
680  GNUNET_a2s (addr,
681  addr_len));
683  return;
684  }
685  request = GNUNET_malloc (sizeof(struct Request) + addr_len);
686  request->lsock = lsock;
687  request->packet = packet;
688  request->addr = &request[1];
689  request->addr_len = addr_len;
690  GNUNET_memcpy (&request[1],
691  addr,
692  addr_len);
693  request->udp_msg_size = udp_msg_size;
694  request->udp_msg = GNUNET_memdup (udp_msg,
695  udp_msg_size);
697  &do_timeout,
698  request);
700  "Calling GNS on `%s'\n",
701  packet->queries[0].name);
703  packet->queries[0].name,
704  packet->queries[0].type,
707  request);
708 }
709 
710 
716 static void
717 read_dns4 (void *cls)
718 {
719  struct sockaddr_in v4;
720  socklen_t addrlen;
721  ssize_t size;
722  const struct GNUNET_SCHEDULER_TaskContext *tc;
723 
724  GNUNET_assert (listen_socket4 == cls);
727  &read_dns4,
731  return; /* shutdown? */
733  if (0 > size)
734  {
735  GNUNET_break (0);
736  return; /* read error!? */
737  }
738  {
739  char buf[size + 1];
740  ssize_t sret;
741 
742  addrlen = sizeof(v4);
744  buf,
745  size + 1,
746  (struct sockaddr *) &v4,
747  &addrlen);
748  if (0 > sret)
749  {
751  "recvfrom");
752  return;
753  }
754  GNUNET_break (size == sret);
756  &v4,
757  addrlen,
758  buf,
759  size);
760  }
761 }
762 
763 
769 static void
770 read_dns6 (void *cls)
771 {
772  struct sockaddr_in6 v6;
773  socklen_t addrlen;
774  ssize_t size;
775  const struct GNUNET_SCHEDULER_TaskContext *tc;
776 
777  GNUNET_assert (listen_socket6 == cls);
780  &read_dns6,
784  return; /* shutdown? */
786  if (0 > size)
787  {
788  GNUNET_break (0);
789  return; /* read error!? */
790  }
791  {
792  char buf[size];
793  ssize_t sret;
794 
795  addrlen = sizeof(v6);
797  buf,
798  size,
799  (struct sockaddr *) &v6,
800  &addrlen);
801  if (0 > sret)
802  {
804  "recvfrom");
805  return;
806  }
807  GNUNET_break (size == sret);
809  &v6,
810  addrlen,
811  buf,
812  size);
813  }
814 }
815 
816 
825 static void
826 run (void *cls,
827  char *const *args,
828  const char *cfgfile,
829  const struct GNUNET_CONFIGURATION_Handle *c)
830 {
831  char *addr_str;
832 
833  (void) cls;
834  (void) args;
835  (void) cfgfile;
836  cfg = c;
837  if (NULL == dns_ip)
838  {
840  _ ("No DNS server specified!\n"));
841  return;
842  }
844  NULL);
845  if (NULL == (gns = GNUNET_GNS_connect (cfg)))
846  return;
847  if (NULL == (vpn_handle = GNUNET_VPN_connect (cfg)))
848  return;
849  GNUNET_assert (NULL != (dns_stub = GNUNET_DNSSTUB_start (128)));
850  if (GNUNET_OK !=
852  dns_ip))
853  {
856  gns = NULL;
858  vpn_handle = NULL;
859  return;
860  }
861 
862  /* Get address to bind to */
864  "BIND_TO",
865  &addr_str))
866  {
867  // No address specified
869  "Don't know what to bind to...\n");
870  GNUNET_free (addr_str);
872  return;
873  }
874  if (1 != inet_pton (AF_INET, addr_str, &address))
875  {
877  "Unable to parse address %s\n",
878  addr_str);
879  GNUNET_free (addr_str);
881  return;
882  }
883  GNUNET_free (addr_str);
884  /* Get address to bind to */
886  "BIND_TO6",
887  &addr_str))
888  {
889  // No address specified
891  "Don't know what to bind6 to...\n");
892  GNUNET_free (addr_str);
894  return;
895  }
896  if (1 != inet_pton (AF_INET6, addr_str, &address6))
897  {
899  "Unable to parse IPv6 address %s\n",
900  addr_str);
901  GNUNET_free (addr_str);
903  return;
904  }
905  GNUNET_free (addr_str);
906 
908  SOCK_DGRAM,
909  IPPROTO_UDP);
910  if (NULL != listen_socket4)
911  {
912  struct sockaddr_in v4;
913 
914  memset (&v4, 0, sizeof(v4));
915  v4.sin_family = AF_INET;
916  v4.sin_addr.s_addr = address;
917 #if HAVE_SOCKADDR_IN_SIN_LEN
918  v4.sin_len = sizeof(v4);
919 #endif
920  v4.sin_port = htons (listen_port);
921  if (GNUNET_OK !=
923  (struct sockaddr *) &v4,
924  sizeof(v4)))
925  {
928  listen_socket4 = NULL;
929  }
930  }
932  SOCK_DGRAM,
933  IPPROTO_UDP);
934  if (NULL != listen_socket6)
935  {
936  struct sockaddr_in6 v6;
937 
938  memset (&v6, 0, sizeof(v6));
939  v6.sin6_family = AF_INET6;
940  v6.sin6_addr = address6;
941 #if HAVE_SOCKADDR_IN_SIN_LEN
942  v6.sin6_len = sizeof(v6);
943 #endif
944  v6.sin6_port = htons (listen_port);
945  if (GNUNET_OK !=
947  (struct sockaddr *) &v6,
948  sizeof(v6)))
949  {
952  listen_socket6 = NULL;
953  }
954  }
955  if ((NULL == listen_socket4) &&
956  (NULL == listen_socket6))
957  {
959  gns = NULL;
961  vpn_handle = NULL;
963  dns_stub = NULL;
964  return;
965  }
966  if (NULL != listen_socket4)
969  &read_dns4,
971  if (NULL != listen_socket6)
974  &read_dns6,
976 }
977 
978 
986 int
987 main (int argc,
988  char *const *argv)
989 {
992  "dns",
993  "IP",
994  gettext_noop (
995  "IP of recursive DNS resolver to use (required)"),
996  &dns_ip),
998  "port",
999  "UDPPORT",
1000  gettext_noop (
1001  "UDP port to listen on for inbound DNS requests; default: 2853"),
1002  &listen_port),
1004  };
1005  int ret;
1006 
1007  if (GNUNET_OK !=
1008  GNUNET_STRINGS_get_utf8_args (argc, argv,
1009  &argc, &argv))
1010  return 2;
1011  GNUNET_log_setup ("gnunet-dns2gns",
1012  "WARNING",
1013  NULL);
1014  ret =
1015  (GNUNET_OK ==
1016  GNUNET_PROGRAM_run (argc, argv,
1017  "gnunet-dns2gns",
1018  _ ("GNUnet DNS-to-GNS proxy (a DNS server)"),
1019  options,
1020  &run, NULL)) ? 0 : 1;
1021  GNUNET_free_nz ((void *) argv);
1022  return ret;
1023 }
1024 
1025 
1026 /* end of gnunet-dns2gns.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:69
IPC messages between GNS API and GNS service.
#define GNUNET_GNSRECORD_TYPE_VPN
VPN resolution.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
struct GNUNET_GNS_Handle * gns
Handle to GNS resolver.
static void dns_result_processor(void *cls, const struct GNUNET_TUN_DnsHeader *dns, size_t r)
Iterator called on obtained result for a DNS lookup.
static void read_dns6(void *cls)
Task to read IPv6 DNS packets.
static struct GNUNET_VPN_Handle * vpn_handle
Our handle to the vpn service.
static struct GNUNET_NETWORK_Handle * listen_socket6
Listen socket for IPv6.
static void do_timeout(void *cls)
Task run on timeout.
#define TIMEOUT
Timeout for DNS requests.
static char * dns_ip
IP of DNS server.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
static struct GNUNET_SCHEDULER_Task * t4
Task for IPv4 socket.
static void shuffle_answers(struct Request *request)
Shuffle answers Fisher-Yates (aka Knuth) Shuffle.
static void handle_request(struct GNUNET_NETWORK_Handle *lsock, const void *addr, size_t addr_len, const char *udp_msg, size_t udp_msg_size)
Handle DNS request.
static struct in6_addr address6
The IPv6 address to bind to.
static void do_shutdown(void *cls)
Task run on shutdown.
static void vpn_allocation_cb(void *cls, int af, const void *address)
Callback invoked from the VPN service once a redirection is available.
struct GNUNET_DNSSTUB_Context * dns_stub
Stub resolver.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run.
#define VPN_TIMEOUT
Default timeout for VPN redirections.
static void read_dns4(void *cls)
Task to read IPv4 DNS packets.
static struct GNUNET_NETWORK_Handle * listen_socket4
Listen socket for IPv4.
static unsigned int listen_port
UDP Port we listen on for inbound DNS requests.
static void result_processor(void *cls, int was_gns, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Iterator called on obtained result for a GNS lookup.
int main(int argc, char *const *argv)
The main function for the dns2gns daemon.
static in_addr_t address
The address to bind to.
static void send_response(struct Request *request)
Send the response for the given request and clean up.
static struct GNUNET_SCHEDULER_Task * t6
Task for IPv6 socket.
uint32_t data
The data value.
static char buf[2048]
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
API for helper library to parse DNS packets.
API for helper library to send DNS requests to DNS resolver.
API to the GNS service.
API to access the VPN service.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
void GNUNET_DNSPARSER_free_packet(struct GNUNET_DNSPARSER_Packet *p)
Free memory taken by a packet.
Definition: dnsparser.c:854
#define GNUNET_DNSPARSER_TYPE_A
struct GNUNET_DNSPARSER_Packet * GNUNET_DNSPARSER_parse(const char *udp_payload, size_t udp_payload_length)
Parse a UDP payload of a DNS packet in to a nice struct for further processing and manipulation.
Definition: dnsparser.c:656
#define GNUNET_DNSPARSER_TYPE_CNAME
#define GNUNET_DNSPARSER_TYPE_AAAA
int GNUNET_DNSPARSER_pack(const struct GNUNET_DNSPARSER_Packet *p, uint16_t max, char **buf, size_t *buf_length)
Given a DNS packet p, generate the corresponding UDP payload.
Definition: dnsparser.c:1257
int GNUNET_DNSSTUB_add_dns_ip(struct GNUNET_DNSSTUB_Context *ctx, const char *dns_ip)
Add nameserver for use by the DNSSTUB.
Definition: dnsstub.c:617
void GNUNET_DNSSTUB_stop(struct GNUNET_DNSSTUB_Context *ctx)
Cleanup DNSSTUB resolver.
Definition: dnsstub.c:716
struct GNUNET_DNSSTUB_Context * GNUNET_DNSSTUB_start(unsigned int num_sockets)
Start a DNS stub resolver.
Definition: dnsstub.c:590
void GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs)
Cancel DNS resolution.
Definition: dnsstub.c:566
struct GNUNET_DNSSTUB_RequestSocket * GNUNET_DNSSTUB_resolve(struct GNUNET_DNSSTUB_Context *ctx, const void *request, size_t request_len, GNUNET_DNSSTUB_ResultCallback rc, void *rc_cls)
Perform DNS resolution using our default IP from init.
Definition: dnsstub.c:530
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned int *val)
Allow user to specify an unsigned int.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
void GNUNET_GNS_disconnect(struct GNUNET_GNS_Handle *handle)
Shutdown connection with the GNS service.
Definition: gns_api.c:290
void * GNUNET_GNS_lookup_with_tld_cancel(struct GNUNET_GNS_LookupWithTldRequest *ltr)
Cancel pending lookup request.
Definition: gns_tld_api.c:332
struct GNUNET_GNS_LookupWithTldRequest * GNUNET_GNS_lookup_with_tld(struct GNUNET_GNS_Handle *handle, const char *name, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor2 proc, void *proc_cls)
Perform an asynchronous lookup operation on the GNS, determining the zone using the TLD of the given ...
Definition: gns_tld_api.c:241
struct GNUNET_GNS_Handle * GNUNET_GNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the GNS service.
Definition: gns_api.c:268
@ GNUNET_GNS_LO_DEFAULT
Defaults, look in cache, then in DHT.
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:508
ssize_t GNUNET_NETWORK_socket_recvfrom(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length, struct sockaddr *src_addr, socklen_t *addrlen)
Read data from a socket (always non-blocking).
Definition: network.c:702
ssize_t GNUNET_NETWORK_socket_recvfrom_amount(const struct GNUNET_NETWORK_Handle *desc)
How much data is available to be read on this descriptor?
Definition: network.c:675
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:855
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_bind(struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Bind a socket to a particular address.
Definition: network.c:439
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:794
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:399
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:533
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1502
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1316
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:737
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
@ GNUNET_SCHEDULER_REASON_READ_READY
The reading socket is ready.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1223
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:315
#define GNUNET_TUN_DNS_CLASS_INTERNET
A few common DNS classes (ok, only one is common, but I list a couple more to make it clear what we'r...
void GNUNET_TUN_service_name_to_hash(const char *service_name, struct GNUNET_HashCode *hc)
Hash the service name of a hosted service to the hash code that is used to identify the service on th...
Definition: regex.c:814
#define GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR
RFC 1035 codes.
void GNUNET_VPN_cancel_request(struct GNUNET_VPN_RedirectionRequest *rr)
Cancel redirection request with the service.
Definition: vpn_api.c:375
struct GNUNET_VPN_Handle * GNUNET_VPN_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the VPN service.
Definition: vpn_api.c:512
struct GNUNET_VPN_RedirectionRequest * GNUNET_VPN_redirect_to_peer(struct GNUNET_VPN_Handle *vh, int result_af, uint8_t protocol, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HashCode *serv, struct GNUNET_TIME_Absolute expiration_time, GNUNET_VPN_AllocationCallback cb, void *cb_cls)
Tell the VPN that a forwarding to a particular peer offering a particular service is requested.
Definition: vpn_api.c:410
void GNUNET_VPN_disconnect(struct GNUNET_VPN_Handle *vh)
Disconnect from the VPN service.
Definition: vpn_api.c:534
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:423
Easy-to-process, parsed version of a DNS packet.
struct GNUNET_DNSPARSER_Query * queries
Array of all queries in the packet, must contain "num_queries" entries.
unsigned int num_answers
Number of answers in the packet, should be 0 for queries.
struct GNUNET_TUN_DnsFlags flags
Bitfield of DNS flags.
struct GNUNET_DNSPARSER_Record * answers
Array of all answers in the packet, must contain "num_answers" entries.
unsigned int num_additional_records
Number of additional records in the packet, should be 0 for queries.
unsigned int num_authority_records
Number of authoritative answers in the packet, should be 0 for queries.
unsigned int num_queries
Number of queries in the packet.
uint16_t type
See GNUNET_DNSPARSER_TYPE_*.
char * name
Name of the record that the query is for (0-terminated).
void * data
Binary record data.
size_t data_len
Number of bytes in data.
A DNS response record.
uint16_t dns_traffic_class
See GNUNET_TUN_DNS_CLASS_*.
char * hostname
For NS, CNAME and PTR records, this is the uncompressed 0-terminated hostname.
uint16_t type
See GNUNET_DNSPARSER_TYPE_*.
struct GNUNET_TIME_Absolute expiration_time
When does the record expire?
union GNUNET_DNSPARSER_Record::@24 data
Payload of the record (which one of these is valid depends on the 'type').
char * name
Name of the record that the query is for (0-terminated).
struct GNUNET_DNSPARSER_RawRecord raw
Raw data for all other types.
Handle to the stub resolver.
Definition: dnsstub.c:124
UDP socket we are using for sending DNS requests to the Internet.
Definition: dnsstub.c:45
Definition of a command line option.
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
size_t data_size
Number of bytes in data.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
Connection to the GNS service.
Definition: gns_api.h:36
Handle to a lookup request.
Definition: gns_tld_api.c:45
A 512-bit hashcode.
handle to a socket
Definition: network.c:53
Context information passed to each scheduler task.
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
Entry in list of pending tasks.
Definition: scheduler.c:135
uint64_t abs_value_us
The actual value.
unsigned int checking_disabled
See RFC 4035.
unsigned int zero
Always zero.
unsigned int message_truncated
Set to 1 if message is truncated.
unsigned int query_or_response
query:0, response:1
unsigned int return_code
See GNUNET_TUN_DNS_RETURN_CODE_ defines.
unsigned int recursion_available
Set to 1 if recursion is available (server -> client)
unsigned int authenticated_data
Response has been cryptographically verified, RFC 4035.
unsigned int authoritative_answer
Set to 1 if this is an authoritative answer.
uint16_t id
Unique identifier for the request/response.
Payload of GNS VPN record.
struct GNUNET_PeerIdentity peer
The peer to contact.
uint16_t proto
The protocol to use.
Opaque VPN handle.
Definition: vpn_api.c:35
Opaque redirection request handle.
Definition: vpn_api.c:77
const void * addr
Target IP address for the redirection, or NULL for redirection to service.
Definition: vpn_api.c:97
Request we should make.
struct GNUNET_NETWORK_Handle * lsock
Socket to use for sending the reply.
size_t udp_msg_size
Number of bytes in udp_msg.
struct GNUNET_SCHEDULER_Task * timeout_task
Task run on timeout or shutdown to clean up without response.
uint16_t original_request_id
ID of the original request.
struct GNUNET_DNSPARSER_Packet * packet
Initially, this is the DNS request, it will then be converted to the DNS response.
const void * addr
Destination address to use.
struct VpnContext * vpn_ctx
Vpn resulution context.
struct GNUNET_DNSSTUB_RequestSocket * dns_lookup
Our DNS request handle.
size_t addr_len
Number of bytes in addr.
struct GNUNET_GNS_LookupWithTldRequest * lookup
Our GNS request handle.
char * udp_msg
Original UDP request message.
Closure for vpn_allocation_cb.
struct GNUNET_VPN_RedirectionRequest * vpn_request
Handle to the VPN request that we were performing.
ssize_t rd_data_size
Number of bytes in rd_data.
struct Request * request
Which resolution process are we processing.
char * rd_data
Serialized records.
unsigned int rd_count
Number of records serialized in rd_data.