GNUnet  0.19.2
gnunet-service-resolver.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2007-2016 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  */
20 
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_protocols.h"
31 #include "resolver.h"
32 
33 
37 #define DNS_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
38 
42 #define MAX_CACHE 1024
43 
48 {
53 
58 
63 };
64 
65 
70 {
74  struct ResolveCache *next;
75 
79  struct ResolveCache *prev;
80 
84  char *hostname;
85 
90 
95 };
96 
97 
102 {
107 
112 
117 
122 
127 
131  char *hostname;
132 
137  int did_aaaa;
138 
142  uint16_t record_type;
143 
149 
154  uint16_t dns_id;
155 };
156 
157 
161 static struct ResolveCache *cache_head;
162 
166 static struct ResolveCache *cache_tail;
167 
171 static struct ResolveCache *hosts_head;
172 
176 static struct ResolveCache *hosts_tail;
177 
181 static struct ActiveLookup *lookup_head;
182 
186 static struct ActiveLookup *lookup_tail;
187 
192 
196 static char *my_domain;
197 
201 static unsigned int cache_size;
202 
203 
209 static void
211 {
212  struct RecordListEntry *pos;
213 
214  while (NULL != (pos = rc->records_head))
215  {
218  GNUNET_free (pos->record);
219  GNUNET_free (pos);
220  }
221  GNUNET_free (rc->hostname);
223  cache_size--;
224  GNUNET_free (rc);
225 }
226 
227 
233 static void
235 {
236  struct RecordListEntry *pos;
237 
238  while (NULL != (pos = rc->records_head))
239  {
242  GNUNET_free (pos->record);
243  GNUNET_free (pos);
244  }
245  GNUNET_free (rc->hostname);
247  cache_size--;
248  GNUNET_free (rc);
249 }
250 
251 
257 static void
259 {
261  if (NULL != al->resolve_handle)
262  {
264  al->resolve_handle = NULL;
265  }
266  if (NULL != al->timeout_task)
267  {
269  al->timeout_task = NULL;
270  }
271  GNUNET_free (al->hostname);
272  GNUNET_free (al);
273 }
274 
275 
285 static char *
286 extract_dns_server (const char *line, size_t line_len)
287 {
288  if (0 == strncmp (line, "nameserver ", strlen ("nameserver ")))
289  return GNUNET_strndup (line + strlen ("nameserver "),
290  line_len - strlen ("nameserver "));
291  return NULL;
292 }
293 
294 
304 static char *
305 extract_search_domain (const char *line, size_t line_len)
306 {
307  if (0 == strncmp (line, "search ", strlen ("search ")))
308  return GNUNET_strndup (line + strlen ("search "),
309  line_len - strlen ("search "));
310  return NULL;
311 }
312 
313 
320 static int
321 lookup_dns_servers (char ***server_addrs)
322 {
323  struct GNUNET_DISK_FileHandle *fh;
324  struct GNUNET_DISK_MapHandle *mh;
325  off_t bytes_read;
326  const char *buf;
327  size_t read_offset;
328  unsigned int num_dns_servers;
329 
330  fh = GNUNET_DISK_file_open ("/etc/resolv.conf",
333  if (NULL == fh)
334  {
336  "Could not open /etc/resolv.conf. "
337  "DNS resolution will not be possible.\n");
338  return -1;
339  }
340  if (GNUNET_OK != GNUNET_DISK_file_handle_size (fh, &bytes_read))
341  {
343  "Could not determine size of /etc/resolv.conf. "
344  "DNS resolution will not be possible.\n");
346  return -1;
347  }
348  if (((unsigned long long) bytes_read) > (unsigned long long) SIZE_MAX)
349  {
351  "/etc/resolv.conf file too large to mmap. "
352  "DNS resolution will not be possible.\n");
354  return -1;
355  }
357  &mh,
359  (size_t) bytes_read);
360  *server_addrs = NULL;
361  read_offset = 0;
362  num_dns_servers = 0;
363  while (read_offset < (size_t) bytes_read)
364  {
365  const char *newline;
366  size_t line_len;
367  char *dns_server;
368 
369  newline = strchr (buf + read_offset, '\n');
370  if (NULL == newline)
371  break;
372  line_len = newline - buf - read_offset;
373  dns_server = extract_dns_server (buf + read_offset, line_len);
374  if (NULL != dns_server)
375  {
376  GNUNET_array_append (*server_addrs, num_dns_servers, dns_server);
377  }
378  else if (NULL == my_domain)
379  {
380  my_domain = extract_search_domain (buf + read_offset, line_len);
381  }
382  read_offset += line_len + 1;
383  }
386  return (int) num_dns_servers;
387 }
388 
389 
396 static char *
397 make_reverse_hostname (const void *ip, int af)
398 {
399  char *buf = GNUNET_new_array (80, char);
400  int pos = 0;
401 
402  if (AF_INET == af)
403  {
404  struct in_addr *addr = (struct in_addr *) ip;
405  uint32_t ip_int = addr->s_addr;
406 
407  for (int i = 3; i >= 0; i--)
408  {
409  int n =
410  GNUNET_snprintf (buf + pos, 80 - pos, "%u.", ((uint8_t *) &ip_int)[i]);
411  if (n < 0)
412  {
413  GNUNET_free (buf);
414  return NULL;
415  }
416  pos += n;
417  }
418  pos += GNUNET_snprintf (buf + pos, 80 - pos, "in-addr.arpa");
419  }
420  else if (AF_INET6 == af)
421  {
422  struct in6_addr *addr = (struct in6_addr *) ip;
423  for (int i = 15; i >= 0; i--)
424  {
425  int n =
426  GNUNET_snprintf (buf + pos, 80 - pos, "%x.", addr->s6_addr[i] & 0xf);
427  if (n < 0)
428  {
429  GNUNET_free (buf);
430  return NULL;
431  }
432  pos += n;
433  n = GNUNET_snprintf (buf + pos, 80 - pos, "%x.", addr->s6_addr[i] >> 4);
434  if (n < 0)
435  {
436  GNUNET_free (buf);
437  return NULL;
438  }
439  pos += n;
440  }
441  pos += GNUNET_snprintf (buf + pos, 80 - pos, "ip6.arpa");
442  }
443  buf[pos] = '\0';
444  return buf;
445 }
446 
447 
459 static int
461  uint16_t record_type,
462  uint32_t client_request_id,
463  struct GNUNET_SERVICE_Client *client)
464 {
466  struct GNUNET_MQ_Envelope *env;
467  const void *payload;
468  size_t payload_len;
469 
470  switch (record->type)
471  {
473  if (GNUNET_DNSPARSER_TYPE_CNAME != record_type)
474  return GNUNET_NO;
475  payload = record->data.hostname;
476  payload_len = strlen (record->data.hostname) + 1;
477  break;
478 
480  if (GNUNET_DNSPARSER_TYPE_PTR != record_type)
481  return GNUNET_NO;
482  payload = record->data.hostname;
483  payload_len = strlen (record->data.hostname) + 1;
484  break;
485 
487  if ((GNUNET_DNSPARSER_TYPE_A != record_type) &&
488  (GNUNET_DNSPARSER_TYPE_ALL != record_type))
489  return GNUNET_NO;
490  payload = record->data.raw.data;
491  payload_len = record->data.raw.data_len;
492  break;
493 
495  if ((GNUNET_DNSPARSER_TYPE_AAAA != record_type) &&
496  (GNUNET_DNSPARSER_TYPE_ALL != record_type))
497  return GNUNET_NO;
498  payload = record->data.raw.data;
499  payload_len = record->data.raw.data_len;
500  break;
501 
502  default:
504  "Cannot handle DNS response type %u: not supported here\n",
505  record->type);
506  return GNUNET_NO;
507  }
509  payload_len,
511  msg->client_id = client_request_id;
512  GNUNET_memcpy (&msg[1], payload, payload_len);
514  return GNUNET_YES;
515 }
516 
517 
525 static void
526 send_end_msg (uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
527 {
529  struct GNUNET_MQ_Envelope *env;
530 
531  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending END message\n");
533  msg->client_id = client_request_id;
535 }
536 
537 
545 static int
547 {
549  struct RecordListEntry *n;
550 
551  for (struct RecordListEntry *pos = rc->records_head; NULL != pos; pos = n)
552  {
553  n = pos->next;
554  if (now.abs_value_us > pos->record->expiration_time.abs_value_us)
555  {
557  GNUNET_DNSPARSER_free_record (pos->record);
558  GNUNET_free (pos->record);
559  GNUNET_free (pos);
560  }
561  }
562  if (NULL == rc->records_head)
563  {
564  free_cache_entry (rc);
565  return GNUNET_YES;
566  }
567  return GNUNET_NO;
568 }
569 
570 
580 static void
581 process_get (const char *hostname,
582  uint16_t record_type,
583  uint32_t client_request_id,
584  struct GNUNET_SERVICE_Client *client);
585 
586 
598 static int
599 try_cache (const char *hostname,
600  uint16_t record_type,
601  uint32_t client_request_id,
602  struct GNUNET_SERVICE_Client *client)
603 {
604  struct ResolveCache *pos;
605  struct ResolveCache *next;
606  int found;
607  int in_hosts;
608 
609  in_hosts = GNUNET_NO;
610  for (pos = hosts_head; NULL != pos; pos = pos->next)
611  if (0 == strcmp (pos->hostname, hostname))
612  {
613  in_hosts = GNUNET_YES;
614  break;
615  }
616  if (NULL == pos)
617  {
618  next = cache_head;
619  for (pos = next; NULL != pos; pos = next)
620  {
621  next = pos->next;
622  if (GNUNET_YES == remove_expired (pos))
623  continue;
624  if (0 == strcmp (pos->hostname, hostname))
625  break;
626  }
627  }
628  if (NULL == pos)
629  {
630  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No cache entry for '%s'\n", hostname);
631  return GNUNET_NO;
632  }
633  if ((GNUNET_NO == in_hosts) && (cache_head != pos))
634  {
635  /* move result to head to achieve LRU for cache eviction */
638  }
639  found = GNUNET_NO;
640  for (struct RecordListEntry *rle = pos->records_head; NULL != rle;
641  rle = rle->next)
642  {
643  const struct GNUNET_DNSPARSER_Record *record = rle->record;
644 
646  "Checking cache entry for '%s', record is for '%s'\n",
647  hostname,
648  record->name);
649  if ((GNUNET_DNSPARSER_TYPE_CNAME == record->type) &&
650  (GNUNET_DNSPARSER_TYPE_CNAME != record_type) && (GNUNET_NO == found))
651  {
652  const char *hostname = record->data.hostname;
653 
654  process_get (hostname, record_type, client_request_id, client);
655  return GNUNET_YES; /* counts as a cache "hit" */
656  }
657  if (0 == strcmp (record->name, hostname))
658  found |= send_reply (rle->record, record_type, client_request_id, client);
659  }
660  if (GNUNET_NO == found)
661  return GNUNET_NO; /* had records, but none matched! */
662  send_end_msg (client_request_id, client);
663  return GNUNET_YES;
664 }
665 
666 
678 static int
679 pack (const char *hostname,
680  uint16_t type,
681  uint16_t dns_id,
682  char **packet_buf,
683  size_t *packet_size)
684 {
685  struct GNUNET_DNSPARSER_Query query;
686  struct GNUNET_DNSPARSER_Packet packet;
687 
688  query.name = (char *) hostname;
689  query.type = type;
691  memset (&packet, 0, sizeof(packet));
692  packet.num_queries = 1;
693  packet.queries = &query;
694  packet.id = htons (dns_id);
695  packet.flags.recursion_desired = 1;
696  if (GNUNET_OK !=
697  GNUNET_DNSPARSER_pack (&packet, UINT16_MAX, packet_buf, packet_size))
698  {
700  "Failed to pack query for hostname `%s'\n",
701  hostname);
702  packet_buf = NULL;
703  return GNUNET_SYSERR;
704  }
705  return GNUNET_OK;
706 }
707 
708 
709 static void
710 cache_answers (const char *name,
712  unsigned int num_records)
713 {
714  struct ResolveCache *rc;
716  struct RecordListEntry *rle;
717 
718  for (unsigned int i = 0; i != num_records; i++)
719  {
720  record = &records[i];
721 
722  for (rc = cache_head; NULL != rc; rc = rc->next)
723  if (0 == strcasecmp (rc->hostname, name))
724  break;
725  if (NULL == rc)
726  {
727  rc = GNUNET_new (struct ResolveCache);
728  rc->hostname = GNUNET_strdup (name);
730  "Caching record for name %s under %s\n",
731  record->name, name);
733  cache_size++;
734  }
735  /* TODO: ought to check first if we have this exact record
736  already in the cache! */
737  rle = GNUNET_new (struct RecordListEntry);
740  }
741 }
742 
743 
752 static void
754  const struct GNUNET_TUN_DnsHeader *dns,
755  size_t dns_len)
756 {
757  struct ActiveLookup *al = cls;
758  struct GNUNET_DNSPARSER_Packet *parsed;
759 
760  parsed = GNUNET_DNSPARSER_parse ((const char *) dns, dns_len);
761  if (NULL == parsed)
762  {
764  "Failed to parse DNS reply (hostname %s, request ID %u)\n",
765  al->hostname,
766  al->dns_id);
767  return;
768  }
769  if (al->dns_id != ntohs (parsed->id))
770  {
772  "Request ID in DNS reply does not match\n");
774  return;
775  }
776  if (0 == parsed->num_answers + parsed->num_authority_records
777  + parsed->num_additional_records)
778  {
780  "DNS reply (hostname %s, request ID %u) contains no answers\n",
781  al->hostname,
782  (unsigned int) al->client_request_id);
783  /* resume by trying again from cache */
784  if (GNUNET_NO == try_cache (al->hostname,
785  al->record_type,
786  al->client_request_id,
787  al->client))
788  /* cache failed, tell client we could not get an answer */
789  {
791  }
793  free_active_lookup (al);
794  return;
795  }
796  /* LRU-based cache eviction: we remove from tail */
797  while (cache_size > MAX_CACHE)
799 
801  "Got reply for hostname %s and request ID %u\n",
802  al->hostname,
803  (unsigned int) al->client_request_id);
804  /* add to cache */
805  cache_answers (al->hostname, parsed->answers, parsed->num_answers);
806  cache_answers (al->hostname,
807  parsed->authority_records,
808  parsed->num_authority_records);
809  cache_answers (al->hostname,
810  parsed->additional_records,
811  parsed->num_additional_records);
812 
813  /* see if we need to do the 2nd request for AAAA records */
814  if ((GNUNET_DNSPARSER_TYPE_ALL == al->record_type) &&
815  (GNUNET_NO == al->did_aaaa))
816  {
817  char *packet_buf;
818  size_t packet_size;
819  uint16_t dns_id;
820 
822  UINT16_MAX);
823  if (GNUNET_OK == pack (al->hostname,
825  dns_id,
826  &packet_buf,
827  &packet_size))
828  {
829  al->did_aaaa = GNUNET_YES;
830  al->dns_id = dns_id;
833  packet_buf,
834  packet_size,
836  al);
837  GNUNET_free (packet_buf);
839  return;
840  }
841  }
842 
843  /* resume by trying again from cache */
844  if (GNUNET_NO == try_cache (al->hostname,
845  al->record_type,
846  al->client_request_id,
847  al->client))
848  /* cache failed, tell client we could not get an answer */
849  {
851  }
852  free_active_lookup (al);
854 }
855 
856 
863 static void
865 {
866  struct ActiveLookup *al = cls;
867 
868  al->timeout_task = NULL;
869  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DNS lookup timeout!\n");
871  free_active_lookup (al);
872 }
873 
874 
885 static int
887  uint16_t record_type,
888  uint32_t client_request_id,
890 {
891  char *packet_buf;
892  size_t packet_size;
893  struct ActiveLookup *al;
894  uint16_t dns_id;
895  uint16_t type;
896 
897  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "resolve_and_cache `%s'\n", hostname);
899  UINT16_MAX);
900 
903  else
904  type = record_type;
905  if (GNUNET_OK != pack (hostname, type, dns_id, &packet_buf, &packet_size))
906  {
908  "Failed to pack query for hostname `%s'\n",
909  hostname);
910  return GNUNET_SYSERR;
911  }
912 
913  al = GNUNET_new (struct ActiveLookup);
915  al->record_type = record_type;
917  al->dns_id = dns_id;
918  al->client = client;
919  al->timeout_task =
922  packet_buf,
923  packet_size,
925  al);
926  GNUNET_free (packet_buf);
929  "Resolving %s, client_request_id = %u, dns_id = %u\n",
930  hostname,
931  (unsigned int) client_request_id,
932  (unsigned int) dns_id);
933  return GNUNET_OK;
934 }
935 
936 
946 static void
947 process_get (const char *hostname,
948  uint16_t record_type,
949  uint32_t client_request_id,
951 {
952  char fqdn[255];
953 
955  return;
956  if ((NULL != my_domain) && (NULL == strchr (hostname, (unsigned char) '.')) &&
957  (strlen (hostname) + strlen (my_domain) <= 253))
958  {
959  GNUNET_snprintf (fqdn, sizeof(fqdn), "%s.%s", hostname, my_domain);
960  }
961  else if (strlen (hostname) < 255)
962  {
963  GNUNET_snprintf (fqdn, sizeof(fqdn), "%s", hostname);
964  }
965  else
966  {
967  GNUNET_break (0);
969  return;
970  }
972  {
973  if (GNUNET_OK !=
975  {
977  }
978  }
979 }
980 
981 
989 static int
990 check_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *get)
991 {
992  uint16_t size;
993  int direction;
994  int af;
995 
996  (void) cls;
997  size = ntohs (get->header.size) - sizeof(*get);
998  direction = ntohl (get->direction);
999  if (GNUNET_NO == direction)
1000  {
1002  return GNUNET_OK;
1003  }
1004  af = ntohl (get->af);
1005  switch (af)
1006  {
1007  case AF_INET:
1008  if (size != sizeof(struct in_addr))
1009  {
1010  GNUNET_break (0);
1011  return GNUNET_SYSERR;
1012  }
1013  break;
1014 
1015  case AF_INET6:
1016  if (size != sizeof(struct in6_addr))
1017  {
1018  GNUNET_break (0);
1019  return GNUNET_SYSERR;
1020  }
1021  break;
1022 
1023  default:
1024  GNUNET_break (0);
1025  return GNUNET_SYSERR;
1026  }
1027  return GNUNET_OK;
1028 }
1029 
1030 
1037 static void
1038 handle_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *msg)
1039 {
1040  struct GNUNET_SERVICE_Client *client = cls;
1041  int direction;
1042  int af;
1043  uint32_t client_request_id;
1044  char *hostname;
1045 
1046  direction = ntohl (msg->direction);
1047  af = ntohl (msg->af);
1048  client_request_id = msg->client_id;
1050  if (GNUNET_NO == direction)
1051  {
1052  /* IP from hostname */
1053  hostname = GNUNET_strdup ((const char *) &msg[1]);
1055  "Client asks to resolve `%s'\n",
1056  hostname);
1057  switch (af)
1058  {
1059  case AF_UNSPEC: {
1062  client_request_id,
1063  client);
1064  break;
1065  }
1066 
1067  case AF_INET: {
1070  client_request_id,
1071  client);
1072  break;
1073  }
1074 
1075  case AF_INET6: {
1078  client_request_id,
1079  client);
1080  break;
1081  }
1082 
1083  default: {
1084  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got invalid af: %d\n", af);
1085  GNUNET_assert (0);
1086  }
1087  }
1088  }
1089  else
1090  {
1091  /* hostname from IP */
1092  hostname = make_reverse_hostname (&msg[1], af);
1095  client_request_id,
1096  client);
1097  }
1099 }
1100 
1101 
1107 static void
1108 shutdown_task (void *cls)
1109 {
1110  (void) cls;
1111 
1112  while (NULL != lookup_head)
1114  while (NULL != cache_head)
1116  while (NULL != hosts_head)
1120 }
1121 
1122 
1132 static void
1133 add_host (const char *hostname,
1134  uint16_t rec_type,
1135  const void *data,
1136  size_t data_size)
1137 {
1138  struct ResolveCache *rc;
1139  struct RecordListEntry *rle;
1140  struct GNUNET_DNSPARSER_Record *rec;
1141 
1142  rec = GNUNET_malloc (sizeof(struct GNUNET_DNSPARSER_Record));
1144  rec->type = rec_type;
1146  rec->name = GNUNET_strdup (hostname);
1148  rec->data.raw.data_len = data_size;
1149  rle = GNUNET_new (struct RecordListEntry);
1150  rle->record = rec;
1151  rc = GNUNET_new (struct ResolveCache);
1155 }
1156 
1157 
1164 static void
1165 extract_hosts (const char *line, size_t line_len)
1166 {
1167  const char *c;
1168  struct in_addr v4;
1169  struct in6_addr v6;
1170  char *tbuf;
1171  char *tok;
1172 
1173  /* ignore everything after '#' */
1174  c = memrchr (line, (unsigned char) '#', line_len);
1175  if (NULL != c)
1176  line_len = c - line;
1177  /* ignore leading whitespace */
1178  while ((0 < line_len) && isspace ((unsigned char) *line))
1179  {
1180  line++;
1181  line_len--;
1182  }
1183  tbuf = GNUNET_strndup (line, line_len);
1184  tok = strtok (tbuf, " \t");
1185  if (NULL == tok)
1186  {
1187  GNUNET_free (tbuf);
1188  return;
1189  }
1190  if (1 == inet_pton (AF_INET, tok, &v4))
1191  {
1192  while (NULL != (tok = strtok (NULL, " \t")))
1193  add_host (tok, GNUNET_DNSPARSER_TYPE_A, &v4, sizeof(struct in_addr));
1194  }
1195  else if (1 == inet_pton (AF_INET6, tok, &v6))
1196  {
1197  while (NULL != (tok = strtok (NULL, " \t")))
1198  add_host (tok, GNUNET_DNSPARSER_TYPE_AAAA, &v6, sizeof(struct in6_addr));
1199  }
1200  GNUNET_free (tbuf);
1201 }
1202 
1203 
1207 static void
1209 {
1210  struct GNUNET_DISK_FileHandle *fh;
1211  struct GNUNET_DISK_MapHandle *mh;
1212  off_t bytes_read;
1213  const char *buf;
1214  size_t read_offset;
1215 
1216  fh = GNUNET_DISK_file_open ("/etc/hosts",
1219  if (NULL == fh)
1220  {
1221  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Failed to open /etc/hosts");
1222  return;
1223  }
1224  if (GNUNET_OK != GNUNET_DISK_file_handle_size (fh, &bytes_read))
1225  {
1227  "Could not determine size of /etc/hosts. "
1228  "DNS resolution will not be possible.\n");
1230  return;
1231  }
1232  if (((unsigned long long) bytes_read) > (unsigned long long) SIZE_MAX)
1233  {
1235  "/etc/hosts file too large to mmap. "
1236  "DNS resolution will not be possible.\n");
1238  return;
1239  }
1241  &mh,
1243  (size_t) bytes_read);
1244  read_offset = 0;
1245  while (read_offset < (size_t) bytes_read)
1246  {
1247  const char *newline;
1248  size_t line_len;
1249 
1250  newline = strchr (buf + read_offset, '\n');
1251  if (NULL == newline)
1252  break;
1253  line_len = newline - buf - read_offset;
1254  extract_hosts (buf + read_offset, line_len);
1255  read_offset += line_len + 1;
1256  }
1259 }
1260 
1261 
1269 static void
1270 init_cb (void *cls,
1271  const struct GNUNET_CONFIGURATION_Handle *cfg,
1272  struct GNUNET_SERVICE_Handle *sh)
1273 {
1274  char **dns_servers;
1275  int num_dns_servers;
1276 
1277  (void) cfg;
1278  (void) sh;
1279  load_etc_hosts ();
1282  dns_servers = NULL;
1283  num_dns_servers = lookup_dns_servers (&dns_servers);
1284  if (0 >= num_dns_servers)
1285  {
1286  GNUNET_log (
1288  _ ("No DNS server available. DNS resolution will not be possible.\n"));
1289  return;
1290  }
1291  for (int i = 0; i < num_dns_servers; i++)
1292  {
1293  int result = GNUNET_DNSSTUB_add_dns_ip (dnsstub_ctx, dns_servers[i]);
1295  "Adding DNS server '%s': %s\n",
1296  dns_servers[i],
1297  GNUNET_OK == result ? "success" : "failure");
1298  GNUNET_free (dns_servers[i]);
1299  }
1300  GNUNET_free (dns_servers);
1301 }
1302 
1303 
1312 static void *
1313 connect_cb (void *cls,
1314  struct GNUNET_SERVICE_Client *c,
1315  struct GNUNET_MQ_Handle *mq)
1316 {
1317  (void) cls;
1318  (void) mq;
1319 
1320  return c;
1321 }
1322 
1323 
1331 static void
1332 disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
1333 {
1334  struct ActiveLookup *n;
1335 
1336  (void) cls;
1337 
1338  GNUNET_assert (c == internal_cls);
1339  n = lookup_head;
1340  for (struct ActiveLookup *al = n; NULL != al; al = n)
1341  {
1342  n = al->next;
1343  if (al->client == c)
1344  free_active_lookup (al);
1345  }
1346 }
1347 
1348 
1353  "resolver",
1355  &init_cb,
1356  &connect_cb,
1357  &disconnect_cb,
1358  NULL,
1362  NULL),
1364 
1365 
1366 #if defined(__linux__) && defined(__GLIBC__)
1367 #include <malloc.h>
1368 
1372 void __attribute__ ((constructor))
1373 GNUNET_RESOLVER_memory_init ()
1374 {
1375  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
1376  mallopt (M_TOP_PAD, 1 * 1024);
1377  malloc_trim (0);
1378 }
1379 
1380 
1381 #endif
1382 
1383 
1384 /* end of gnunet-service-resolver.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define memrchr(s, c, n)
Definition: compat.h:49
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
enum GNUNET_ABD_AlgoDirectionFlags direction
API enum, filled and passed for collect/verify.
Definition: gnunet-abd.c:172
static struct SolverHandle * sh
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static char * line
Desired phone line (string to be converted to a hash).
static int get
Get DID Documement for DID Flag.
Definition: gnunet-did.c:66
uint32_t data
The data value.
enum RadiotapType __attribute__
static int result
Global testing status.
static unsigned long long payload
How much data are we currently storing in the database?
static char * make_reverse_hostname(const void *ip, int af)
Compute name to use for DNS reverse lookups from ip.
#define MAX_CACHE
Maximum number of hostnames we cache results for.
static struct ResolveCache * cache_head
Start of the linked list of cached DNS lookup results.
static void free_cache_entry(struct ResolveCache *rc)
Remove entry from cache.
static void cache_answers(const char *name, struct GNUNET_DNSPARSER_Record *records, unsigned int num_records)
static void send_end_msg(uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
Send message to client that we transmitted all responses for client_request_id.
static void disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
Callback called when a client disconnected from the service.
static int send_reply(struct GNUNET_DNSPARSER_Record *record, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
Send DNS record back to our client.
static int remove_expired(struct ResolveCache *rc)
Remove expired entries from rc.
static int pack(const char *hostname, uint16_t type, uint16_t dns_id, char **packet_buf, size_t *packet_size)
Create DNS query for hostname of type type with DNS request ID dns_id.
static struct ResolveCache * hosts_head
Head of the linked list of DNS lookup results from /etc/hosts.
static void init_cb(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *sh)
Service is starting, initialize everything.
static struct ActiveLookup * lookup_head
Start of the linked list of active DNS lookups.
static char * my_domain
My domain, to be appended to the hostname to get a FQDN.
GNUNET_SERVICE_MAIN("resolver", GNUNET_SERVICE_OPTION_NONE, &init_cb, &connect_cb, &disconnect_cb, NULL, GNUNET_MQ_hd_var_size(get, GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST, struct GNUNET_RESOLVER_GetMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static char * extract_dns_server(const char *line, size_t line_len)
Find out if the configuration file line contains a string starting with "nameserver ",...
static void shutdown_task(void *cls)
Service is shutting down, clean up.
static int resolve_and_cache(const char *hostname, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
Initiate an active lookup, then cache the result and try to then complete the resolution.
static void add_host(const char *hostname, uint16_t rec_type, const void *data, size_t data_size)
Add information about a host from /etc/hosts to our cache.
static unsigned int cache_size
How many entries do we have in cache_head DLL?
#define DNS_TIMEOUT
How long do we wait for DNS answers?
static void handle_resolve_timeout(void *cls)
We encountered a timeout trying to perform a DNS lookup.
static void load_etc_hosts(void)
Reads the list of hosts from /etc/hosts.
static struct ResolveCache * hosts_tail
Tail of the linked list of DNS lookup results from /etc/hosts.
static void free_hosts_entry(struct ResolveCache *rc)
Remove entry from cache.
static struct ActiveLookup * lookup_tail
Tail of the linked list of active DNS lookups.
static int check_get(void *cls, const struct GNUNET_RESOLVER_GetMessage *get)
Verify well-formedness of GET-message.
static void free_active_lookup(struct ActiveLookup *al)
Release resources associated with al.
static void extract_hosts(const char *line, size_t line_len)
Extract host information from a line in /etc/hosts.
static char * extract_search_domain(const char *line, size_t line_len)
Find out if the configuration file line contains a string starting with "search ",...
static int lookup_dns_servers(char ***server_addrs)
Reads the list of nameservers from /etc/resolve.conf.
static void handle_get(void *cls, const struct GNUNET_RESOLVER_GetMessage *msg)
Handle GET-message.
static void process_get(const char *hostname, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
Process DNS request for hostname with request ID request_id from client demanding records of type rec...
static void handle_resolve_result(void *cls, const struct GNUNET_TUN_DnsHeader *dns, size_t dns_len)
We got a result from DNS.
static void * connect_cb(void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
Callback called when a client connects to the service.
static int try_cache(const char *hostname, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
Get an IP address as a string (works for both IPv4 and IPv6).
static struct ResolveCache * cache_tail
Tail of the linked list of cached DNS lookup results.
static struct GNUNET_DNSSTUB_Context * dnsstub_ctx
context of dnsstub library
static char * hostname
Our hostname; we give this to all the peers we start.
static char buf[2048]
static struct GNUNET_DISK_FileHandle * fh
File handle to STDIN, for reading restart/quit commands.
static unsigned int records
Number of records we found.
Constants for network protocols.
API to create, modify and access statistics.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1234
void * GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h, struct GNUNET_DISK_MapHandle **m, enum GNUNET_DISK_MapType access, size_t len)
Map a file into memory.
Definition: disk.c:1377
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1305
enum GNUNET_GenericReturnValue GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
Get the size of an open file.
Definition: disk.c:192
enum GNUNET_GenericReturnValue GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
Unmap a file.
Definition: disk.c:1408
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.
@ GNUNET_DISK_MAP_TYPE_READ
Read-only memory map.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
void GNUNET_DNSPARSER_free_packet(struct GNUNET_DNSPARSER_Packet *p)
Free memory taken by a packet.
Definition: dnsparser.c:854
#define GNUNET_DNSPARSER_TYPE_ALL
void GNUNET_DNSPARSER_free_record(struct GNUNET_DNSPARSER_Record *r)
Free the given DNS record.
Definition: dnsparser.c:169
#define GNUNET_DNSPARSER_TYPE_A
#define GNUNET_DNSPARSER_TYPE_PTR
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:1259
struct GNUNET_DNSPARSER_Record * GNUNET_DNSPARSER_duplicate_record(const struct GNUNET_DNSPARSER_Record *r)
Duplicate (deep-copy) the given DNS record.
Definition: dnsparser.c:737
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_Context * GNUNET_DNSSTUB_start(unsigned int num_sockets)
Start a DNS stub resolver.
Definition: dnsstub.c:586
void GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs)
Cancel DNS resolution.
Definition: dnsstub.c:562
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
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#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.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#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_memdup(buf, size)
Allocate and initialize a block of memory.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:62
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST
Request DNS resolution.
#define GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE
Response to a DNS resolution request.
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:1303
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:944
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:1241
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2443
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#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...
static unsigned int size
Size of the "table".
Definition: peer.c:68
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
#define SIZE_MAX
Definition: platform.h:207
const char * name
Information about pending lookups.
char * hostname
Which hostname are we resolving?
struct GNUNET_SERVICE_Client * client
The client that queried the records contained in this cache entry.
struct GNUNET_SCHEDULER_Task * timeout_task
handle for the resolution timeout task
uint16_t record_type
type of queried DNS record
uint16_t dns_id
Unique DNS request ID of a client if a query for this hostname/record_type is currently pending,...
struct ActiveLookup * next
Stored in a DLL.
uint32_t client_request_id
Unique request ID of a client if a query for this hostname/record_type is currently pending,...
int did_aaaa
If record_type is GNUNET_DNSPARSER_TYPE_ALL, did we go again for the AAAA records yet?
struct ActiveLookup * prev
Stored in a DLL.
struct GNUNET_DNSSTUB_RequestSocket * resolve_handle
handle for cancelling a request
Handle used to access files (and pipes).
Handle for a memory-mapping operation.
Definition: disk.c:1358
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.
struct GNUNET_DNSPARSER_Record * additional_records
Array of all additional answers in the packet, must contain "num_additional_records" entries.
struct GNUNET_DNSPARSER_Record * authority_records
Array of all authority records in the packet, must contain "num_authority_records" entries.
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 id
DNS ID (to match replies to requests).
uint16_t dns_traffic_class
See GNUNET_TUN_DNS_CLASS_*.
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_*.
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:125
UDP socket we are using for sending DNS requests to the Internet.
Definition: dnsstub.c:46
Handle to a message queue.
Definition: mq.c:87
Request for the resolver.
Definition: resolver.h:44
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle to a client that is connected to a service.
Definition: service.c:252
Handle to a service.
Definition: service.c:118
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
unsigned int recursion_desired
Set to 1 if recursion is desired (client -> server)
Entry in list of cached DNS records for a hostname.
struct RecordListEntry * next
This is a doubly linked list.
struct GNUNET_DNSPARSER_Record * record
Cached data.
struct RecordListEntry * prev
This is a doubly linked list.
A cached DNS lookup result.
struct RecordListEntry * records_tail
tail of a double linked list containing the lookup results
struct ResolveCache * next
This is a doubly linked list.
struct RecordListEntry * records_head
head of a double linked list containing the lookup results
char * hostname
Which hostname is this cache for?
struct ResolveCache * prev
This is a doubly linked list.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model