GNUnet 0.21.0
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_gns_service.h>
28#include "gnunet_vpn_service.h"
29#include "gns.h"
30
34#define TIMEOUT GNUNET_TIME_UNIT_MINUTES
35
39#define VPN_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
40
41
42struct Request;
43
48{
53
58
62 unsigned int rd_count;
63
67 char *rd_data;
68
72 ssize_t rd_data_size;
73};
74
75
79struct Request
80{
85
89 const void *addr;
90
96
101
106
112
117
121 char *udp_msg;
122
126 size_t addr_len;
127
132
137
138};
139
143static in_addr_t address;
144
148static struct in6_addr address6;
149
150
155
160
165
170
175
180
185
189static char *dns_ip;
190
194static unsigned long long listen_port = 53;
195
199static const struct GNUNET_CONFIGURATION_Handle *cfg;
200
201
207static void
208do_shutdown (void *cls)
209{
210 (void) cls;
211 if (NULL != t4)
212 {
214 t4 = NULL;
215 }
216 if (NULL != t6)
217 {
219 t6 = NULL;
220 }
221 if (NULL != listen_socket4)
222 {
224 listen_socket4 = NULL;
225 }
226 if (NULL != listen_socket6)
227 {
229 listen_socket6 = NULL;
230 }
231 if (NULL != gns)
232 {
234 gns = NULL;
235 }
236 if (NULL != vpn_handle)
237 {
239 vpn_handle = NULL;
240 }
241 if (NULL != dns_stub)
242 {
244 dns_stub = NULL;
245 }
246}
247
248
255static void
257{
258 unsigned int idx = request->packet->num_answers;
259 unsigned int r_idx;
260 struct GNUNET_DNSPARSER_Record tmp_answer;
261
262 while (0 != idx)
263 {
265 request->packet->num_answers);
266 idx--;
267 tmp_answer = request->packet->answers[idx];
268 memcpy (&request->packet->answers[idx], &request->packet->answers[r_idx],
269 sizeof (struct GNUNET_DNSPARSER_Record));
270 memcpy (&request->packet->answers[r_idx], &tmp_answer,
271 sizeof (struct GNUNET_DNSPARSER_Record));
272 }
273}
274
275
281static void
283{
284 char *buf;
285 size_t size;
286 ssize_t sret;
287
289 if (GNUNET_SYSERR ==
291 UINT16_MAX /* is this not too much? */,
292 &buf,
293 &size))
294 {
296 _ ("Failed to pack DNS response into UDP packet!\n"));
297 }
298 else
299 {
301 buf,
302 size,
303 request->addr,
304 request->addr_len);
305 if ((sret < 0) ||
306 (size != (size_t) sret))
308 "sendto");
309 GNUNET_free (buf);
310 }
311 GNUNET_SCHEDULER_cancel (request->timeout_task);
313 GNUNET_free (request->udp_msg);
315}
316
317
323static void
324do_timeout (void *cls)
325{
326 struct Request *request = cls;
327 struct VpnContext *vpn_ctx;
328
329 if (NULL != request->packet)
331 if (NULL != request->lookup)
333 if (NULL != request->dns_lookup)
335 GNUNET_free (request->udp_msg);
336 if (NULL != (vpn_ctx = request->vpn_ctx))
337 {
339 GNUNET_free (vpn_ctx->rd_data);
340 GNUNET_free (vpn_ctx);
341 }
343}
344
345
353static void
355 const struct GNUNET_TUN_DnsHeader *dns,
356 size_t r)
357{
358 struct Request *request = cls;
359
360 if (NULL == dns)
361 {
362 /* DNSSTUB gave up, so we trigger timeout early */
363 GNUNET_SCHEDULER_cancel (request->timeout_task);
365 return;
366 }
367 if (request->original_request_id != dns->id)
368 {
369 /* for a another query, ignore */
370 return;
371 }
372 request->packet = GNUNET_DNSPARSER_parse ((char *) dns,
373 r);
374 if (NULL == request->packet)
375 {
377 _ ("Failed to parse DNS response!\n"));
378 GNUNET_SCHEDULER_cancel (request->timeout_task);
380 return;
381 }
384}
385
400static void
402 int af,
403 const void *address)
404{
405 struct VpnContext *vpn_ctx = cls;
406 struct Request *request = vpn_ctx->request;
407 struct GNUNET_GNSRECORD_Data rd[vpn_ctx->rd_count];
408 unsigned int i;
409
410 vpn_ctx->vpn_request = NULL;
411 request->vpn_ctx = NULL;
414 (size_t) vpn_ctx->rd_data_size,
415 vpn_ctx->rd_data,
416 vpn_ctx->rd_count,
417 rd));
418 for (i = 0; i < vpn_ctx->rd_count; i++)
419 {
421 {
422 switch (af)
423 {
424 case AF_INET:
426 rd[i].data_size = sizeof(struct in_addr);
429 rd[i].flags = 0;
430 rd[i].data = address;
431 break;
432
433 case AF_INET6:
437 rd[i].flags = 0;
438 rd[i].data = address;
439 rd[i].data_size = sizeof(struct in6_addr);
440 break;
441
442 default:
443 GNUNET_assert (0);
444 }
445 break;
446 }
447 }
448 GNUNET_assert (i < vpn_ctx->rd_count);
449 if (0 == vpn_ctx->rd_count)
451 _ ("VPN returned empty result for `%s'\n"),
452 request->packet->queries[0].name);
454 GNUNET_free (vpn_ctx->rd_data);
455 GNUNET_free (vpn_ctx);
456}
457
458
459
468static void
470 int was_gns,
471 uint32_t rd_count,
472 const struct GNUNET_GNSRECORD_Data *rd)
473{
474 struct Request *request = cls;
475 struct GNUNET_DNSPARSER_Packet *packet;
476 struct GNUNET_DNSPARSER_Record rec;
477 struct VpnContext *vpn_ctx;
478 const struct GNUNET_TUN_GnsVpnRecord *vpn;
479 const char *vname;
480 struct GNUNET_HashCode vhash;
481 int af;
482
483 request->lookup = NULL;
484 if (GNUNET_NO == was_gns)
485 {
486 /* TLD not configured for GNS, fall back to DNS */
488 "Using DNS resolver IP `%s' to resolve `%s'\n",
489 dns_ip,
490 request->packet->queries[0].name);
491 request->original_request_id = request->packet->id;
493 request->packet = NULL;
495 request->udp_msg,
496 request->udp_msg_size,
498 request);
499 return;
500 }
501 packet = request->packet;
502 packet->flags.query_or_response = 1;
504 packet->flags.checking_disabled = 0;
505 packet->flags.authenticated_data = 1;
506 packet->flags.zero = 0;
507 packet->flags.recursion_available = 1;
508 packet->flags.message_truncated = 0;
509 packet->flags.authoritative_answer = 0;
510 // packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ???
511 for (uint32_t i = 0; i < rd_count; i++)
512 {
514 switch (rd[i].record_type)
515 {
517 GNUNET_assert (sizeof(struct in_addr) == rd[i].data_size);
518 rec.name = GNUNET_strdup (packet->queries[0].name);
521 rec.data.raw.data = GNUNET_new (struct in_addr);
523 rd[i].data,
524 rd[i].data_size);
525 rec.data.raw.data_len = sizeof(struct in_addr);
527 packet->num_answers,
528 rec);
529 break;
530
532 GNUNET_assert (sizeof(struct in6_addr) == rd[i].data_size);
533 rec.name = GNUNET_strdup (packet->queries[0].name);
534 rec.data.raw.data = GNUNET_new (struct in6_addr);
538 rd[i].data,
539 rd[i].data_size);
540 rec.data.raw.data_len = sizeof(struct in6_addr);
542 packet->num_answers,
543 rec);
544 break;
545
547 rec.name = GNUNET_strdup (packet->queries[0].name);
548 rec.data.hostname = GNUNET_strdup (rd[i].data);
552 rd[i].data,
553 rd[i].data_size);
555 packet->num_answers,
556 rec);
557 break;
559 if ((GNUNET_DNSPARSER_TYPE_A != request->packet->queries[0].type) &&
560 (GNUNET_DNSPARSER_TYPE_AAAA != request->packet->queries[0].type))
561 break;
562 af = (GNUNET_DNSPARSER_TYPE_A == request->packet->queries[0].type) ?
563 AF_INET :
564 AF_INET6;
565 if (sizeof(struct GNUNET_TUN_GnsVpnRecord) >
566 rd[i].data_size)
567 {
568 GNUNET_break_op (0);
569 break;
570 }
571 vpn = (const struct GNUNET_TUN_GnsVpnRecord *) rd[i].data;
572 vname = (const char *) &vpn[1];
573 if ('\0' != vname[rd[i].data_size - 1 - sizeof(struct
575 ])
576 {
577 GNUNET_break_op (0);
578 break;
579 }
581 &vhash);
583 "Attempting VPN allocation for %s-%s (AF: %d, proto %d)\n",
584 GNUNET_i2s (&vpn->peer),
585 vname,
586 (int) af,
587 (int) ntohs (vpn->proto));
588 vpn_ctx = GNUNET_new (struct VpnContext);
589 request->vpn_ctx = vpn_ctx;
590 vpn_ctx->request = request;
592 rd);
593 if (vpn_ctx->rd_data_size < 0)
594 {
595 GNUNET_break_op (0);
596 GNUNET_free (vpn_ctx);
597 break;
598 }
599 vpn_ctx->rd_data = GNUNET_malloc ((size_t) vpn_ctx->rd_data_size);
600 vpn_ctx->rd_count = rd_count;
601 GNUNET_assert (vpn_ctx->rd_data_size ==
603 rd,
604 (size_t) vpn_ctx
605 ->rd_data_size,
606 vpn_ctx->rd_data));
608 af,
609 ntohs (
610 vpn->proto),
611 &vpn->peer,
612 &vhash,
615 &
617 vpn_ctx);
618 return;
619
620
621 default:
622 /* skip */
623 break;
624 }
625 }
627}
628
629
639static void
641 const void *addr,
642 size_t addr_len,
643 const char *udp_msg,
644 size_t udp_msg_size)
645{
646 struct Request *request;
647 struct GNUNET_DNSPARSER_Packet *packet;
648
649 packet = GNUNET_DNSPARSER_parse (udp_msg,
650 udp_msg_size);
651 if (NULL == packet)
652 {
654 _ ("Cannot parse DNS request from %s\n"),
655 GNUNET_a2s (addr, addr_len));
656 return;
657 }
659 "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n",
660 packet->queries[0].name,
661 (unsigned int) packet->flags.query_or_response,
662 (int) packet->num_answers,
663 (int) packet->num_authority_records,
664 (int) packet->num_additional_records);
665 if ((0 != packet->flags.query_or_response) ||
666 (0 != packet->num_answers) ||
667 (0 != packet->num_authority_records))
668 {
670 _ ("Received malformed DNS request from %s\n"),
671 GNUNET_a2s (addr, addr_len));
673 return;
674 }
675 if ((1 != packet->num_queries))
676 {
678 _ ("Received unsupported DNS request from %s\n"),
679 GNUNET_a2s (addr,
680 addr_len));
682 return;
683 }
684 request = GNUNET_malloc (sizeof(struct Request) + addr_len);
685 request->lsock = lsock;
686 request->packet = packet;
687 request->addr = &request[1];
688 request->addr_len = addr_len;
690 addr,
691 addr_len);
692 request->udp_msg_size = udp_msg_size;
693 request->udp_msg = GNUNET_memdup (udp_msg,
694 udp_msg_size);
696 &do_timeout,
697 request);
699 "Calling GNS on `%s'\n",
700 packet->queries[0].name);
702 packet->queries[0].name,
703 packet->queries[0].type,
706 request);
707}
708
709
715static void
716read_dns4 (void *cls)
717{
718 struct sockaddr_in v4;
719 socklen_t addrlen;
720 ssize_t size;
721 const struct GNUNET_SCHEDULER_TaskContext *tc;
722
726 &read_dns4,
730 return; /* shutdown? */
732 if (0 > size)
733 {
734 GNUNET_break (0);
735 return; /* read error!? */
736 }
737 {
738 char buf[size + 1];
739 ssize_t sret;
740
741 addrlen = sizeof(v4);
743 buf,
744 size + 1,
745 (struct sockaddr *) &v4,
746 &addrlen);
747 if (0 > sret)
748 {
750 "recvfrom");
751 return;
752 }
753 GNUNET_break (size != sret);
755 &v4,
756 addrlen,
757 buf,
758 size);
759 }
760}
761
762
768static void
769read_dns6 (void *cls)
770{
771 struct sockaddr_in6 v6;
772 socklen_t addrlen;
773 ssize_t size;
774 const struct GNUNET_SCHEDULER_TaskContext *tc;
775
779 &read_dns6,
783 return; /* shutdown? */
785 if (0 > size)
786 {
787 GNUNET_break (0);
788 return; /* read error!? */
789 }
790 {
791 char buf[size];
792 ssize_t sret;
793
794 addrlen = sizeof(v6);
796 buf,
797 size,
798 (struct sockaddr *) &v6,
799 &addrlen);
800 if (0 > sret)
801 {
803 "recvfrom");
804 return;
805 }
806 GNUNET_break (size != sret);
808 &v6,
809 addrlen,
810 buf,
811 size);
812 }
813}
814
815
824static void
825run (void *cls,
826 char *const *args,
827 const char *cfgfile,
828 const struct GNUNET_CONFIGURATION_Handle *c)
829{
830 char *addr_str;
831
832 (void) cls;
833 (void) args;
834 (void) cfgfile;
835 cfg = c;
836 if (NULL == dns_ip)
837 {
839 _ ("No DNS server specified!\n"));
840 return;
841 }
843 NULL);
844 if (NULL == (gns = GNUNET_GNS_connect (cfg)))
845 return;
846 if (NULL == (vpn_handle = GNUNET_VPN_connect (cfg)))
847 return;
848 GNUNET_assert (NULL != (dns_stub = GNUNET_DNSSTUB_start (128)));
849 if (GNUNET_OK !=
851 dns_ip))
852 {
855 gns = NULL;
857 vpn_handle = NULL;
858 return;
859 }
860
861 /* Get address to bind to */
863 "BIND_TO",
864 &addr_str))
865 {
866 // No address specified
868 "Don't know what to bind to...\n");
869 GNUNET_free (addr_str);
871 return;
872 }
873 if (1 != inet_pton (AF_INET, addr_str, &address))
874 {
876 "Unable to parse address %s\n",
877 addr_str);
878 GNUNET_free (addr_str);
880 return;
881 }
882 GNUNET_free (addr_str);
883 /* Get address to bind to */
885 "BIND_TO6",
886 &addr_str))
887 {
888 // No address specified
890 "Don't know what to bind6 to...\n");
891 GNUNET_free (addr_str);
893 return;
894 }
895 if (1 != inet_pton (AF_INET6, addr_str, &address6))
896 {
898 "Unable to parse IPv6 address %s\n",
899 addr_str);
900 GNUNET_free (addr_str);
902 return;
903 }
904 GNUNET_free (addr_str);
906 "PORT",
907 &listen_port))
909 "Listening on %llu\n", listen_port);
910
912 SOCK_DGRAM,
913 IPPROTO_UDP);
914 if (NULL != listen_socket4)
915 {
916 struct sockaddr_in v4;
917
918 memset (&v4, 0, sizeof(v4));
919 v4.sin_family = AF_INET;
920 v4.sin_addr.s_addr = address;
921#if HAVE_SOCKADDR_IN_SIN_LEN
922 v4.sin_len = sizeof(v4);
923#endif
924 v4.sin_port = htons (listen_port);
925 if (GNUNET_OK !=
927 (struct sockaddr *) &v4,
928 sizeof(v4)))
929 {
932 listen_socket4 = NULL;
933 }
934 }
936 SOCK_DGRAM,
937 IPPROTO_UDP);
938 if (NULL != listen_socket6)
939 {
940 struct sockaddr_in6 v6;
941
942 memset (&v6, 0, sizeof(v6));
943 v6.sin6_family = AF_INET6;
944 v6.sin6_addr = address6;
945#if HAVE_SOCKADDR_IN_SIN_LEN
946 v6.sin6_len = sizeof(v6);
947#endif
948 v6.sin6_port = htons (listen_port);
949 if (GNUNET_OK !=
951 (struct sockaddr *) &v6,
952 sizeof(v6)))
953 {
956 listen_socket6 = NULL;
957 }
958 }
959 if ((NULL == listen_socket4) &&
960 (NULL == listen_socket6))
961 {
963 gns = NULL;
965 vpn_handle = NULL;
967 dns_stub = NULL;
968 return;
969 }
970 if (NULL != listen_socket4)
973 &read_dns4,
975 if (NULL != listen_socket6)
978 &read_dns6,
980}
981
982
990int
991main (int argc,
992 char *const *argv)
993{
996 "dns",
997 "IP",
999 "IP of recursive DNS resolver to use (required)"),
1000 &dns_ip),
1002 };
1003 int ret;
1004
1005 if (GNUNET_OK !=
1006 GNUNET_STRINGS_get_utf8_args (argc, argv,
1007 &argc, &argv))
1008 return 2;
1009 GNUNET_log_setup ("gnunet-dns2gns",
1010 "WARNING",
1011 NULL);
1012 ret =
1013 (GNUNET_OK ==
1014 GNUNET_PROGRAM_run (argc, argv,
1015 "gnunet-dns2gns",
1016 _ ("GNUnet DNS-to-GNS proxy (a DNS server)"),
1017 options,
1018 &run, NULL)) ? 0 : 1;
1019 GNUNET_free_nz ((void *) argv);
1020 return ret;
1021}
1022
1023
1024/* 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:70
IPC messages between GNS API and GNS service.
static int ret
Final status code.
Definition: gnunet-arm.c:94
static char * data
The data to insert into the dht.
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 unsigned long long listen_port
UDP Port we listen on for inbound DNS requests.
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 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.
static unsigned int rd_count
Number of records for currently parsed set.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static size_t data_size
Number of bytes in data.
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:40
API to the GNS service.
API to access the VPN service.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
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:947
#define GNUNET_DNSPARSER_TYPE_A
#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:1392
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:727
struct GNUNET_DNSSTUB_Context * GNUNET_DNSSTUB_start(unsigned int num_sockets)
Start a DNS stub resolver.
Definition: dnsstub.c:586
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:613
void GNUNET_DNSSTUB_stop(struct GNUNET_DNSSTUB_Context *ctx)
Cleanup DNSSTUB resolver.
Definition: dnsstub.c:705
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:526
void GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs)
Cancel DNS resolution.
Definition: dnsstub.c:562
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:289
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:240
void * GNUNET_GNS_lookup_with_tld_cancel(struct GNUNET_GNS_LookupWithTldRequest *ltr)
Cancel pending lookup request.
Definition: gns_tld_api.c:331
struct GNUNET_GNS_Handle * GNUNET_GNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the GNS service.
Definition: gns_api.c:267
@ 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.
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
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
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.
enum GNUNET_GenericReturnValue GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
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).
#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...
@ 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:687
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:832
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:670
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:771
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:400
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
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:1506
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:752
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:1334
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1272
@ 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:1230
#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:316
#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:772
#define GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR
RFC 1035 codes.
struct GNUNET_VPN_Handle * GNUNET_VPN_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the VPN service.
Definition: vpn_api.c:490
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:388
void GNUNET_VPN_cancel_request(struct GNUNET_VPN_RedirectionRequest *rr)
Cancel redirection request with the service.
Definition: vpn_api.c:375
void GNUNET_VPN_disconnect(struct GNUNET_VPN_Handle *vh)
Disconnect from the VPN service.
Definition: vpn_api.c:512
static unsigned int size
Size of the "table".
Definition: peer.c:68
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:431
#define GNUNET_GNSRECORD_TYPE_VPN
VPN resolution.
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?
char * name
Name of the record that the query is for (0-terminated).
struct GNUNET_DNSPARSER_RawRecord raw
Raw data for all other types.
union GNUNET_DNSPARSER_Record::@20 data
Payload of the record (which one of these is valid depends on the 'type').
Handle to the stub resolver.
Definition: dnsstub.c:125
UDP socket we are using for sending DNS requests to the Internet.
Definition: dnsstub.c:46
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:44
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:136
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.