use idn2.h or idna.h depending on HAVE_LIBIDN/HAVE_LIBIDN
[oweals/gnunet.git] / src / util / gnunet-service-resolver.c
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
21 /**
22  * @file util/gnunet-service-resolver.c
23  * @brief code to do DNS resolution
24  * @author Christian Grothoff
25  */
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_protocols.h"
29 #include "gnunet_statistics_service.h"
30 #include "resolver.h"
31
32
33 /**
34  * How long do we wait for DNS answers?
35  */
36 #define DNS_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
37
38 /**
39  * Maximum number of hostnames we cache results for.
40  */
41 #define MAX_CACHE 1024
42
43 /**
44  * Entry in list of cached DNS records for a hostname.
45  */
46 struct RecordListEntry
47 {
48   /**
49    * This is a doubly linked list.
50    */
51   struct RecordListEntry *next;
52
53   /**
54    * This is a doubly linked list.
55    */
56   struct RecordListEntry *prev;
57
58   /**
59    * Cached data.
60    */
61   struct GNUNET_DNSPARSER_Record *record;
62
63 };
64
65
66 /**
67  * A cached DNS lookup result.
68  */
69 struct ResolveCache
70 {
71   /**
72    * This is a doubly linked list.
73    */
74   struct ResolveCache *next;
75
76   /**
77    * This is a doubly linked list.
78    */
79   struct ResolveCache *prev;
80
81   /**
82    * Which hostname is this cache for?
83    */
84   char *hostname;
85
86   /**
87    * head of a double linked list containing the lookup results
88    */
89   struct RecordListEntry *records_head;
90
91   /**
92    * tail of a double linked list containing the lookup results
93    */
94   struct RecordListEntry *records_tail;
95
96 };
97
98
99 /**
100  * Information about pending lookups.
101  */
102 struct ActiveLookup
103 {
104   /**
105    * Stored in a DLL.
106    */
107   struct ActiveLookup *next;
108
109   /**
110    * Stored in a DLL.
111    */
112   struct ActiveLookup *prev;
113
114   /**
115    * The client that queried the records contained in this cache entry.
116    */
117   struct GNUNET_SERVICE_Client *client;
118
119   /**
120    * handle for cancelling a request
121    */
122   struct GNUNET_DNSSTUB_RequestSocket *resolve_handle;
123
124   /**
125    * handle for the resolution timeout task
126    */
127   struct GNUNET_SCHEDULER_Task *timeout_task;
128
129   /**
130    * Which hostname are we resolving?
131    */
132   char *hostname;
133
134   /**
135    * If @a record_type is #GNUNET_DNSPARSER_TYPE_ALL, did we go again
136    * for the AAAA records yet?
137    */
138   int did_aaaa;
139
140   /**
141    * type of queried DNS record
142    */
143   uint16_t record_type;
144
145   /**
146    * Unique request ID of a client if a query for this hostname/record_type
147    * is currently pending, undefined otherwise.
148    */
149   uint32_t client_request_id;
150
151   /**
152    * Unique DNS request ID of a client if a query for this hostname/record_type
153    * is currently pending, undefined otherwise.
154    */
155   uint16_t dns_id;
156
157 };
158
159
160 /**
161  * Start of the linked list of cached DNS lookup results.
162  */
163 static struct ResolveCache *cache_head;
164
165 /**
166  * Tail of the linked list of cached DNS lookup results.
167  */
168 static struct ResolveCache *cache_tail;
169
170 /**
171  * Head of the linked list of DNS lookup results from /etc/hosts.
172  */
173 static struct ResolveCache *hosts_head;
174
175 /**
176  * Tail of the linked list of DNS lookup results from /etc/hosts.
177  */
178 static struct ResolveCache *hosts_tail;
179
180 /**
181  * Start of the linked list of active DNS lookups.
182  */
183 static struct ActiveLookup *lookup_head;
184
185 /**
186  * Tail of the linked list of active DNS lookups.
187  */
188 static struct ActiveLookup *lookup_tail;
189
190 /**
191  * context of dnsstub library
192  */
193 static struct GNUNET_DNSSTUB_Context *dnsstub_ctx;
194
195 /**
196  * My domain, to be appended to the hostname to get a FQDN.
197  */
198 static char *my_domain;
199
200 /**
201  * How many entries do we have in #cache_head DLL?
202  */
203 static unsigned int cache_size;
204
205
206 /**
207  * Remove @a entry from cache.
208  *
209  * @param rc entry to free
210  */
211 static void
212 free_cache_entry (struct ResolveCache *rc)
213 {
214   struct RecordListEntry *pos;
215
216   while (NULL != (pos = rc->records_head))
217   {
218     GNUNET_CONTAINER_DLL_remove (rc->records_head,
219                                  rc->records_tail,
220                                  pos);
221     GNUNET_DNSPARSER_free_record (pos->record);
222     GNUNET_free (pos->record);
223     GNUNET_free (pos);
224   }
225   GNUNET_free_non_null (rc->hostname);
226   GNUNET_CONTAINER_DLL_remove (cache_head,
227                                cache_tail,
228                                rc);
229   cache_size--;
230   GNUNET_free (rc);
231 }
232
233
234 /**
235  * Remove @a entry from cache.
236  *
237  * @param rc entry to free
238  */
239 static void
240 free_hosts_entry (struct ResolveCache *rc)
241 {
242   struct RecordListEntry *pos;
243
244   while (NULL != (pos = rc->records_head))
245   {
246     GNUNET_CONTAINER_DLL_remove (rc->records_head,
247                                  rc->records_tail,
248                                  pos);
249     GNUNET_DNSPARSER_free_record (pos->record);
250     GNUNET_free (pos->record);
251     GNUNET_free (pos);
252   }
253   GNUNET_free_non_null (rc->hostname);
254   GNUNET_CONTAINER_DLL_remove (hosts_head,
255                                hosts_tail,
256                                rc);
257   cache_size--;
258   GNUNET_free (rc);
259 }
260
261
262 /**
263  * Release resources associated with @a al
264  *
265  * @param al an active lookup
266  */
267 static void
268 free_active_lookup (struct ActiveLookup *al)
269 {
270   GNUNET_CONTAINER_DLL_remove (lookup_head,
271                                lookup_tail,
272                                al);
273   if (NULL != al->resolve_handle)
274   {
275     GNUNET_DNSSTUB_resolve_cancel (al->resolve_handle);
276     al->resolve_handle = NULL;
277   }
278   if (NULL != al->timeout_task)
279   {
280     GNUNET_SCHEDULER_cancel (al->timeout_task);
281     al->timeout_task = NULL;
282   }
283   GNUNET_free_non_null (al->hostname);
284   GNUNET_free (al);
285 }
286
287
288
289 /**
290  * Find out if the configuration file line contains a string
291  * starting with "nameserver ", and if so, return a copy of
292  * the nameserver's IP.
293  *
294  * @param line line to parse
295  * @param line_len number of characters in @a line
296  * @return NULL if no nameserver is configured in this @a line
297  */
298 static char *
299 extract_dns_server (const char* line,
300                     size_t line_len)
301 {
302   if (0 == strncmp (line,
303                     "nameserver ",
304                     strlen ("nameserver ")))
305     return GNUNET_strndup (line + strlen ("nameserver "),
306                            line_len - strlen ("nameserver "));
307   return NULL;
308 }
309
310
311 /**
312  * Find out if the configuration file line contains a string
313  * starting with "search ", and if so, return a copy of
314  * the machine's search domain.
315  *
316  * @param line line to parse
317  * @param line_len number of characters in @a line
318  * @return NULL if no nameserver is configured in this @a line
319  */
320 static char *
321 extract_search_domain (const char* line,
322                        size_t line_len)
323 {
324   if (0 == strncmp (line,
325                     "search ",
326                     strlen ("search ")))
327     return GNUNET_strndup (line + strlen ("search "),
328                            line_len - strlen ("search "));
329   return NULL;
330 }
331
332
333 /**
334  * Reads the list of nameservers from /etc/resolve.conf
335  *
336  * @param server_addrs[out] a list of null-terminated server address strings
337  * @return the number of server addresses in @server_addrs, -1 on error
338  */
339 static int
340 lookup_dns_servers (char ***server_addrs)
341 {
342   struct GNUNET_DISK_FileHandle *fh;
343   struct GNUNET_DISK_MapHandle *mh;
344   off_t bytes_read;
345   const char *buf;
346   size_t read_offset;
347   unsigned int num_dns_servers;
348
349   fh = GNUNET_DISK_file_open ("/etc/resolv.conf",
350                               GNUNET_DISK_OPEN_READ,
351                               GNUNET_DISK_PERM_NONE);
352   if (NULL == fh)
353   {
354     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
355                 "Could not open /etc/resolv.conf. "
356                 "DNS resolution will not be possible.\n");
357     return -1;
358   }
359   if (GNUNET_OK !=
360       GNUNET_DISK_file_handle_size (fh,
361                                     &bytes_read))
362   {
363     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
364                 "Could not determine size of /etc/resolv.conf. "
365                 "DNS resolution will not be possible.\n");
366     GNUNET_DISK_file_close (fh);
367     return -1;
368   }
369   if ((size_t) bytes_read > SIZE_MAX)
370   {
371     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
372                 "/etc/resolv.conf file too large to mmap. "
373                 "DNS resolution will not be possible.\n");
374     GNUNET_DISK_file_close (fh);
375     return -1;
376   }
377   buf = GNUNET_DISK_file_map (fh,
378                               &mh,
379                               GNUNET_DISK_MAP_TYPE_READ,
380                               (size_t) bytes_read);
381   *server_addrs = NULL;
382   read_offset = 0;
383   num_dns_servers = 0;
384   while (read_offset < (size_t) bytes_read)
385   {
386     const char *newline;
387     size_t line_len;
388     char *dns_server;
389
390     newline = strchr (buf + read_offset,
391                       '\n');
392     if (NULL == newline)
393       break;
394     line_len = newline - buf - read_offset;
395     dns_server = extract_dns_server (buf + read_offset,
396                                      line_len);
397     if (NULL != dns_server)
398     {
399       GNUNET_array_append (*server_addrs,
400                            num_dns_servers,
401                            dns_server);
402     }
403     else if (NULL == my_domain)
404     {
405       my_domain = extract_search_domain (buf + read_offset,
406                                          line_len);
407     }
408     read_offset += line_len + 1;
409   }
410   GNUNET_DISK_file_unmap (mh);
411   GNUNET_DISK_file_close (fh);
412   return (int) num_dns_servers;
413 }
414
415
416 /**
417  * Compute name to use for DNS reverse lookups from @a ip.
418  *
419  * @param ip IP address to resolve, in binary format, network byte order
420  * @param af address family of @a ip, AF_INET or AF_INET6
421  */
422 static char *
423 make_reverse_hostname (const void *ip,
424                        int af)
425 {
426   char *buf = GNUNET_new_array (80,
427                                 char);
428   int pos = 0;
429
430   if (AF_INET == af)
431   {
432     struct in_addr *addr = (struct in_addr *)ip;
433     uint32_t ip_int = addr->s_addr;
434
435     for (int i = 3; i >= 0; i--)
436     {
437       int n = GNUNET_snprintf (buf + pos,
438                                80 - pos,
439                                "%u.",
440                                ((uint8_t *)&ip_int)[i]);
441       if (n < 0)
442       {
443         GNUNET_free (buf);
444         return NULL;
445       }
446       pos += n;
447     }
448     pos += GNUNET_snprintf (buf + pos,
449                             80 - pos,
450                             "in-addr.arpa");
451   }
452   else if (AF_INET6 == af)
453   {
454     struct in6_addr *addr = (struct in6_addr *)ip;
455     for (int i = 15; i >= 0; i--)
456     {
457       int n = GNUNET_snprintf (buf + pos,
458                                80 - pos,
459                                "%x.",
460                                addr->s6_addr[i] & 0xf);
461       if (n < 0)
462       {
463         GNUNET_free (buf);
464         return NULL;
465       }
466       pos += n;
467       n = GNUNET_snprintf (buf + pos,
468                            80 - pos,
469                            "%x.",
470                            addr->s6_addr[i] >> 4);
471       if (n < 0)
472       {
473         GNUNET_free (buf);
474         return NULL;
475       }
476       pos += n;
477     }
478     pos += GNUNET_snprintf (buf + pos,
479                             80 - pos,
480                             "ip6.arpa");
481   }
482   buf[pos] = '\0';
483   return buf;
484 }
485
486
487 /**
488  * Send DNS @a record back to our @a client.
489  *
490  * @param record information to transmit
491  * @param record_type requested record type from client
492  * @param client_request_id to which request are we responding
493  * @param client where to send @a record
494  * @return #GNUNET_YES if we sent a reply,
495  *         #GNUNET_NO if the record type is not understood or
496  *         does not match @a record_type
497  */
498 static int
499 send_reply (struct GNUNET_DNSPARSER_Record *record,
500             uint16_t record_type,
501             uint32_t client_request_id,
502             struct GNUNET_SERVICE_Client *client)
503 {
504   struct GNUNET_RESOLVER_ResponseMessage *msg;
505   struct GNUNET_MQ_Envelope *env;
506   const void *payload;
507   size_t payload_len;
508
509   switch (record->type)
510   {
511   case GNUNET_DNSPARSER_TYPE_CNAME:
512     if (GNUNET_DNSPARSER_TYPE_CNAME != record_type)
513       return GNUNET_NO;
514     payload = record->data.hostname;
515     payload_len = strlen (record->data.hostname) + 1;
516     break;
517   case GNUNET_DNSPARSER_TYPE_PTR:
518     if (GNUNET_DNSPARSER_TYPE_PTR != record_type)
519       return GNUNET_NO;
520     payload = record->data.hostname;
521     payload_len = strlen (record->data.hostname) + 1;
522     break;
523   case GNUNET_DNSPARSER_TYPE_A:
524     if ( (GNUNET_DNSPARSER_TYPE_A != record_type) &&
525          (GNUNET_DNSPARSER_TYPE_ALL != record_type) )
526       return GNUNET_NO;
527     payload = record->data.raw.data;
528     payload_len = record->data.raw.data_len;
529     break;
530   case GNUNET_DNSPARSER_TYPE_AAAA:
531     if ( (GNUNET_DNSPARSER_TYPE_AAAA != record_type) &&
532          (GNUNET_DNSPARSER_TYPE_ALL != record_type) )
533       return GNUNET_NO;
534     payload = record->data.raw.data;
535     payload_len = record->data.raw.data_len;
536     break;
537   default:
538     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
539                 "Cannot handle DNS response type %u: not supported here\n",
540                 record->type);
541     return GNUNET_NO;
542   }
543   env = GNUNET_MQ_msg_extra (msg,
544                              payload_len,
545                              GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
546   msg->client_id = client_request_id;
547   GNUNET_memcpy (&msg[1],
548                  payload,
549                  payload_len);
550   GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
551                   env);
552   return GNUNET_YES;
553 }
554
555
556 /**
557  * Send message to @a client that we transmitted all
558  * responses for @a client_request_id
559  *
560  * @param client_request_id to which request are we responding
561  * @param client where to send @a record
562  */
563 static void
564 send_end_msg (uint32_t client_request_id,
565               struct GNUNET_SERVICE_Client *client)
566 {
567   struct GNUNET_RESOLVER_ResponseMessage *msg;
568   struct GNUNET_MQ_Envelope *env;
569
570   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
571               "Sending END message\n");
572   env = GNUNET_MQ_msg (msg,
573                        GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
574   msg->client_id = client_request_id;
575   GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
576                   env);
577 }
578
579
580 /**
581  * Remove expired entries from @a rc
582  *
583  * @param rc entry in resolver cache
584  * @return #GNUNET_YES if @a rc was completely expired
585  *         #GNUNET_NO if some entries are left
586  */
587 static int
588 remove_expired (struct ResolveCache *rc)
589 {
590   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
591   struct RecordListEntry *n;
592
593   for (struct RecordListEntry *pos = rc->records_head;
594        NULL != pos;
595        pos = n)
596   {
597     n = pos->next;
598     if (now.abs_value_us > pos->record->expiration_time.abs_value_us)
599     {
600       GNUNET_CONTAINER_DLL_remove (rc->records_head,
601                                    rc->records_tail,
602                                    pos);
603       GNUNET_DNSPARSER_free_record (pos->record);
604       GNUNET_free (pos->record);
605       GNUNET_free (pos);
606     }
607   }
608   if (NULL == rc->records_head)
609   {
610     free_cache_entry (rc);
611     return GNUNET_YES;
612   }
613   return GNUNET_NO;
614 }
615
616
617 /**
618  * Process DNS request for @a hostname with request ID @a request_id
619  * from @a client demanding records of type @a record_type.
620  *
621  * @param hostname DNS name to resolve
622  * @param record_type desired record type
623  * @param client_request_id client's request ID
624  * @param client who should get the result?
625  */
626 static void
627 process_get (const char *hostname,
628              uint16_t record_type,
629              uint32_t client_request_id,
630              struct GNUNET_SERVICE_Client *client);
631
632
633 /**
634  * Get an IP address as a string (works for both IPv4 and IPv6).  Note
635  * that the resolution happens asynchronously and that the first call
636  * may not immediately result in the FQN (but instead in a
637  * human-readable IP address).
638  *
639  * @param hostname what hostname was to be resolved
640  * @param record_type what type of record was requested
641  * @param client_request_id unique identification of the client's request
642  * @param client handle to the client making the request (for sending the reply)
643  */
644 static int
645 try_cache (const char *hostname,
646            uint16_t record_type,
647            uint32_t client_request_id,
648            struct GNUNET_SERVICE_Client *client)
649 {
650   struct ResolveCache *pos;
651   struct ResolveCache *next;
652   int found;
653   int in_hosts;
654
655   in_hosts = GNUNET_NO;
656   for (pos = hosts_head; NULL != pos; pos = pos->next)
657     if (0 == strcmp (pos->hostname,
658                      hostname))
659     {
660       in_hosts = GNUNET_YES;
661       break;
662     }
663   if (NULL == pos)
664   {
665     next = cache_head;
666     for (pos = next; NULL != pos; pos = next)
667     {
668       next = pos->next;
669       if (GNUNET_YES == remove_expired (pos))
670         continue;
671       if (0 == strcmp (pos->hostname,
672                        hostname))
673         break;
674     }
675   }
676   if (NULL == pos)
677   {
678     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
679                 "No cache entry for '%s'\n",
680                 hostname);
681     return GNUNET_NO;
682   }
683   if ( (GNUNET_NO == in_hosts) &&
684        (cache_head != pos) )
685   {
686     /* move result to head to achieve LRU for cache eviction */
687     GNUNET_CONTAINER_DLL_remove (cache_head,
688                                  cache_tail,
689                                  pos);
690     GNUNET_CONTAINER_DLL_insert (cache_head,
691                                  cache_tail,
692                                  pos);
693   }
694   found = GNUNET_NO;
695   for (struct RecordListEntry *rle = pos->records_head;
696        NULL != rle;
697        rle = rle->next)
698   {
699     const struct GNUNET_DNSPARSER_Record *record = rle->record;
700
701     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
702                 "Found cache entry for '%s', record type '%u'\n",
703                 hostname,
704                 record_type);
705     if ( (GNUNET_DNSPARSER_TYPE_CNAME == record->type) &&
706          (GNUNET_DNSPARSER_TYPE_CNAME != record_type) &&
707          (GNUNET_NO == found) )
708     {
709       const char *hostname = record->data.hostname;
710
711       process_get (hostname,
712                    record_type,
713                    client_request_id,
714                    client);
715       return GNUNET_YES; /* counts as a cache "hit" */
716     }
717     found |= send_reply (rle->record,
718                          record_type,
719                          client_request_id,
720                          client);
721   }
722   if (GNUNET_NO == found)
723     return GNUNET_NO; /* had records, but none matched! */
724   send_end_msg (client_request_id,
725                 client);
726   return GNUNET_YES;
727 }
728
729
730 /**
731  * Create DNS query for @a hostname of type @a type
732  * with DNS request ID @a dns_id.
733  *
734  * @param hostname DNS name to query
735  * @param type requested DNS record type
736  * @param dns_id what should be the DNS request ID
737  * @param packet_buf[out] where to write the request packet
738  * @param packet_size[out] set to size of @a packet_buf on success
739  * @return #GNUNET_OK on success
740  */
741 static int
742 pack (const char *hostname,
743       uint16_t type,
744       uint16_t dns_id,
745       char **packet_buf,
746       size_t *packet_size)
747 {
748   struct GNUNET_DNSPARSER_Query query;
749   struct GNUNET_DNSPARSER_Packet packet;
750
751   query.name = (char *)hostname;
752   query.type = type;
753   query.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
754   memset (&packet,
755           0,
756           sizeof (packet));
757   packet.num_queries = 1;
758   packet.queries = &query;
759   packet.id = htons (dns_id);
760   packet.flags.recursion_desired = 1;
761   if (GNUNET_OK !=
762       GNUNET_DNSPARSER_pack (&packet,
763                              UINT16_MAX,
764                              packet_buf,
765                              packet_size))
766   {
767     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
768                 "Failed to pack query for hostname `%s'\n",
769                 hostname);
770     packet_buf = NULL;
771     return GNUNET_SYSERR;
772   }
773   return GNUNET_OK;
774 }
775
776
777 /**
778  * We got a result from DNS. Add it to the cache and
779  * see if we can make our client happy...
780  *
781  * @param cls the `struct ActiveLookup`
782  * @param dns the DNS response
783  * @param dns_len number of bytes in @a dns
784  */
785 static void
786 handle_resolve_result (void *cls,
787                        const struct GNUNET_TUN_DnsHeader *dns,
788                        size_t dns_len)
789 {
790   struct ActiveLookup *al = cls;
791   struct GNUNET_DNSPARSER_Packet *parsed;
792   struct ResolveCache *rc;
793
794   parsed = GNUNET_DNSPARSER_parse ((const char *)dns,
795                                    dns_len);
796   if (NULL == parsed)
797   {
798     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
799                 "Failed to parse DNS reply (hostname %s, request ID %u)\n",
800                 al->hostname,
801                 al->dns_id);
802     return;
803   }
804   if (al->dns_id != ntohs (parsed->id))
805   {
806     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
807                 "Request ID in DNS reply does not match\n");
808     GNUNET_DNSPARSER_free_packet (parsed);
809     return;
810   }
811   if (0 == parsed->num_answers + parsed->num_authority_records + parsed->num_additional_records)
812   {
813     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
814                 "DNS reply (hostname %s, request ID %u) contains no answers\n",
815                 al->hostname,
816                 (unsigned int) al->client_request_id);
817     GNUNET_DNSPARSER_free_packet (parsed);
818     send_end_msg (al->client_request_id,
819                   al->client);
820     free_active_lookup (al);
821     return;
822   }
823   /* LRU-based cache eviction: we remove from tail */
824   while (cache_size > MAX_CACHE)
825     free_cache_entry (cache_tail);
826
827   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
828               "Got reply for hostname %s and request ID %u\n",
829               al->hostname,
830               (unsigned int) al->client_request_id);
831   /* add to cache */
832   for (unsigned int i = 0; i != parsed->num_answers; i++)
833   {
834     struct GNUNET_DNSPARSER_Record *record = &parsed->answers[i];
835     struct RecordListEntry *rle;
836
837     for (rc = cache_head; NULL != rc; rc = rc->next)
838       if (0 == strcasecmp (rc->hostname,
839                            record->name))
840         break;
841     if (NULL == rc)
842     {
843       rc = GNUNET_new (struct ResolveCache);
844       rc->hostname = GNUNET_strdup (record->name);
845       GNUNET_CONTAINER_DLL_insert (cache_head,
846                                    cache_tail,
847                                    rc);
848       cache_size++;
849     }
850     /* TODO: ought to check first if we have this exact record
851        already in the cache! */
852     rle = GNUNET_new (struct RecordListEntry);
853     rle->record = GNUNET_DNSPARSER_duplicate_record (record);
854     GNUNET_CONTAINER_DLL_insert (rc->records_head,
855                                  rc->records_tail,
856                                  rle);
857   }
858   for (unsigned int i = 0; i != parsed->num_authority_records; i++)
859   {
860     struct GNUNET_DNSPARSER_Record *record = &parsed->authority_records[i];
861     struct RecordListEntry *rle;
862
863     for (rc = cache_head; NULL != rc; rc = rc->next)
864       if (0 == strcasecmp (rc->hostname,
865                            record->name))
866         break;
867     if (NULL == rc)
868     {
869       rc = GNUNET_new (struct ResolveCache);
870       rc->hostname = GNUNET_strdup (record->name);
871       GNUNET_CONTAINER_DLL_insert (cache_head,
872                                    cache_tail,
873                                    rc);
874       cache_size++;
875     }
876     /* TODO: ought to check first if we have this exact record
877        already in the cache! */
878     rle = GNUNET_new (struct RecordListEntry);
879     rle->record = GNUNET_DNSPARSER_duplicate_record (record);
880     GNUNET_CONTAINER_DLL_insert (rc->records_head,
881                                  rc->records_tail,
882                                  rle);
883   }
884   for (unsigned int i = 0; i != parsed->num_additional_records; i++)
885   {
886     struct GNUNET_DNSPARSER_Record *record = &parsed->additional_records[i];
887     struct RecordListEntry *rle;
888
889     for (rc = cache_head; NULL != rc; rc = rc->next)
890       if (0 == strcasecmp (rc->hostname,
891                            record->name))
892         break;
893     if (NULL == rc)
894     {
895       rc = GNUNET_new (struct ResolveCache);
896       rc->hostname = GNUNET_strdup (record->name);
897       GNUNET_CONTAINER_DLL_insert (cache_head,
898                                    cache_tail,
899                                    rc);
900       cache_size++;
901     }
902     /* TODO: ought to check first if we have this exact record
903        already in the cache! */
904     rle = GNUNET_new (struct RecordListEntry);
905     rle->record = GNUNET_DNSPARSER_duplicate_record (record);
906     GNUNET_CONTAINER_DLL_insert (rc->records_head,
907                                  rc->records_tail,
908                                  rle);
909   }
910   /* see if we need to do the 2nd request for AAAA records */
911   if ( (GNUNET_DNSPARSER_TYPE_ALL == al->record_type) &&
912        (GNUNET_NO == al->did_aaaa) )
913   {
914     char *packet_buf;
915     size_t packet_size;
916     uint16_t dns_id;
917
918     dns_id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
919                                                   UINT16_MAX);
920     if (GNUNET_OK ==
921         pack (al->hostname,
922               GNUNET_DNSPARSER_TYPE_AAAA,
923               dns_id,
924               &packet_buf,
925               &packet_size))
926     {
927       al->did_aaaa = GNUNET_YES;
928       al->dns_id = dns_id;
929       GNUNET_DNSSTUB_resolve_cancel (al->resolve_handle);
930       al->resolve_handle =
931         GNUNET_DNSSTUB_resolve (dnsstub_ctx,
932                                 packet_buf,
933                                 packet_size,
934                                 &handle_resolve_result,
935                                 al);
936       GNUNET_free (packet_buf);
937       GNUNET_DNSPARSER_free_packet (parsed);
938       return;
939     }
940   }
941
942   /* resume by trying again from cache */
943   if (GNUNET_NO ==
944       try_cache (al->hostname,
945                  al->record_type,
946                  al->client_request_id,
947                  al->client))
948     /* cache failed, tell client we could not get an answer */
949   {
950     send_end_msg (al->client_request_id,
951                   al->client);
952   }
953   free_active_lookup (al);
954   GNUNET_DNSPARSER_free_packet (parsed);
955 }
956
957
958 /**
959  * We encountered a timeout trying to perform a
960  * DNS lookup.
961  *
962  * @param cls a `struct ActiveLookup`
963  */
964 static void
965 handle_resolve_timeout (void *cls)
966 {
967   struct ActiveLookup *al = cls;
968
969   al->timeout_task = NULL;
970   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
971               "DNS lookup timeout!\n");
972   send_end_msg (al->client_request_id,
973                 al->client);
974   free_active_lookup (al);
975 }
976
977
978 /**
979  * Initiate an active lookup, then cache the result and
980  * try to then complete the resolution.
981  *
982  * @param hostname DNS name to resolve
983  * @param record_type record type to locate
984  * @param client_request_id client request ID
985  * @param client handle to the client
986  * @return #GNUNET_OK if the DNS query is now pending
987  */
988 static int
989 resolve_and_cache (const char* hostname,
990                    uint16_t record_type,
991                    uint32_t client_request_id,
992                    struct GNUNET_SERVICE_Client *client)
993 {
994   char *packet_buf;
995   size_t packet_size;
996   struct ActiveLookup *al;
997   uint16_t dns_id;
998   uint16_t type;
999
1000   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1001               "resolve_and_cache `%s'\n",
1002               hostname);
1003   dns_id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
1004                                                 UINT16_MAX);
1005
1006   if (GNUNET_DNSPARSER_TYPE_ALL == record_type)
1007     type = GNUNET_DNSPARSER_TYPE_A;
1008   else
1009     type = record_type;
1010   if (GNUNET_OK !=
1011       pack (hostname,
1012             type,
1013             dns_id,
1014             &packet_buf,
1015             &packet_size))
1016   {
1017     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1018                 "Failed to pack query for hostname `%s'\n",
1019                 hostname);
1020     return GNUNET_SYSERR;
1021   }
1022
1023   al = GNUNET_new (struct ActiveLookup);
1024   al->hostname = GNUNET_strdup (hostname);
1025   al->record_type = record_type;
1026   al->client_request_id = client_request_id;
1027   al->dns_id = dns_id;
1028   al->client = client;
1029   al->timeout_task = GNUNET_SCHEDULER_add_delayed (DNS_TIMEOUT,
1030                                                    &handle_resolve_timeout,
1031                                                    al);
1032   al->resolve_handle =
1033     GNUNET_DNSSTUB_resolve (dnsstub_ctx,
1034                             packet_buf,
1035                             packet_size,
1036                             &handle_resolve_result,
1037                             al);
1038   GNUNET_free (packet_buf);
1039   GNUNET_CONTAINER_DLL_insert (lookup_head,
1040                                lookup_tail,
1041                                al);
1042   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1043               "Resolving %s, client_request_id = %u, dns_id = %u\n",
1044               hostname,
1045               (unsigned int) client_request_id,
1046               (unsigned int) dns_id);
1047   return GNUNET_OK;
1048 }
1049
1050
1051 /**
1052  * Process DNS request for @a hostname with request ID @a client_request_id
1053  * from @a client demanding records of type @a record_type.
1054  *
1055  * @param hostname DNS name to resolve
1056  * @param record_type desired record type
1057  * @param client_request_id client's request ID
1058  * @param client who should get the result?
1059  */
1060 static void
1061 process_get (const char *hostname,
1062              uint16_t record_type,
1063              uint32_t client_request_id,
1064              struct GNUNET_SERVICE_Client *client)
1065 {
1066   char fqdn[255];
1067
1068   if (  (NULL != my_domain) &&
1069         (NULL == strchr (hostname,
1070                          (unsigned char) '.')) &&
1071         (strlen (hostname) + strlen (my_domain) <= 253) )
1072   {
1073     GNUNET_snprintf (fqdn,
1074                      sizeof (fqdn),
1075                      "%s.%s",
1076                      hostname,
1077                      my_domain);
1078   }
1079   else if (strlen (hostname) < 255)
1080   {
1081     GNUNET_snprintf (fqdn,
1082                      sizeof (fqdn),
1083                      "%s",
1084                      hostname);
1085   }
1086   else
1087   {
1088     GNUNET_break (0);
1089     GNUNET_SERVICE_client_drop (client);
1090     return;
1091   }
1092   if (GNUNET_NO ==
1093       try_cache (fqdn,
1094                  record_type,
1095                  client_request_id,
1096                  client))
1097   {
1098     if (GNUNET_OK !=
1099         resolve_and_cache (fqdn,
1100                            record_type,
1101                            client_request_id,
1102                            client))
1103     {
1104       send_end_msg (client_request_id,
1105                     client);
1106     }
1107   }
1108 }
1109
1110
1111 /**
1112  * Verify well-formedness of GET-message.
1113  *
1114  * @param cls closure, unused
1115  * @param get the actual message
1116  * @return #GNUNET_OK if @a get is well-formed
1117  */
1118 static int
1119 check_get (void *cls,
1120            const struct GNUNET_RESOLVER_GetMessage *get)
1121 {
1122   uint16_t size;
1123   int direction;
1124   int af;
1125
1126   (void) cls;
1127   size = ntohs (get->header.size) - sizeof (*get);
1128   direction = ntohl (get->direction);
1129   if (GNUNET_NO == direction)
1130   {
1131     GNUNET_MQ_check_zero_termination (get);
1132     return GNUNET_OK;
1133   }
1134   af = ntohl (get->af);
1135   switch (af)
1136   {
1137   case AF_INET:
1138     if (size != sizeof (struct in_addr))
1139     {
1140       GNUNET_break (0);
1141       return GNUNET_SYSERR;
1142     }
1143     break;
1144   case AF_INET6:
1145     if (size != sizeof (struct in6_addr))
1146     {
1147       GNUNET_break (0);
1148       return GNUNET_SYSERR;
1149     }
1150     break;
1151   default:
1152     GNUNET_break (0);
1153     return GNUNET_SYSERR;
1154   }
1155   return GNUNET_OK;
1156 }
1157
1158
1159 /**
1160  * Handle GET-message.
1161  *
1162  * @param cls identification of the client
1163  * @param msg the actual message
1164  */
1165 static void
1166 handle_get (void *cls,
1167             const struct GNUNET_RESOLVER_GetMessage *msg)
1168 {
1169   struct GNUNET_SERVICE_Client *client = cls;
1170   int direction;
1171   int af;
1172   uint32_t client_request_id;
1173   char *hostname;
1174
1175   direction = ntohl (msg->direction);
1176   af = ntohl (msg->af);
1177   client_request_id = msg->client_id;
1178   GNUNET_SERVICE_client_continue (client);
1179   if (GNUNET_NO == direction)
1180   {
1181     /* IP from hostname */
1182     hostname = GNUNET_strdup ((const char *) &msg[1]);
1183     switch (af)
1184     {
1185       case AF_UNSPEC:
1186       {
1187         process_get (hostname,
1188                      GNUNET_DNSPARSER_TYPE_ALL,
1189                      client_request_id,
1190                      client);
1191         break;
1192       }
1193       case AF_INET:
1194       {
1195         process_get (hostname,
1196                      GNUNET_DNSPARSER_TYPE_A,
1197                      client_request_id,
1198                      client);
1199         break;
1200       }
1201       case AF_INET6:
1202       {
1203         process_get (hostname,
1204                      GNUNET_DNSPARSER_TYPE_AAAA,
1205                      client_request_id,
1206                      client);
1207         break;
1208       }
1209       default:
1210       {
1211         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1212                     "got invalid af: %d\n",
1213                     af);
1214         GNUNET_assert (0);
1215       }
1216     }
1217   }
1218   else
1219   {
1220     /* hostname from IP */
1221     hostname = make_reverse_hostname (&msg[1],
1222                                       af);
1223     process_get (hostname,
1224                  GNUNET_DNSPARSER_TYPE_PTR,
1225                  client_request_id,
1226                  client);
1227   }
1228   GNUNET_free_non_null (hostname);
1229 }
1230
1231
1232 /**
1233  * Service is shutting down, clean up.
1234  *
1235  * @param cls NULL, unused
1236  */
1237 static void
1238 shutdown_task (void *cls)
1239 {
1240   (void) cls;
1241
1242   while (NULL != lookup_head)
1243     free_active_lookup (lookup_head);
1244   while (NULL != cache_head)
1245     free_cache_entry (cache_head);
1246   while (NULL != hosts_head)
1247     free_hosts_entry (hosts_head);
1248   GNUNET_DNSSTUB_stop (dnsstub_ctx);
1249   GNUNET_free (my_domain);
1250 }
1251
1252
1253 /**
1254  * Add information about a host from /etc/hosts
1255  * to our cache.
1256  *
1257  * @param hostname the name of the host
1258  * @param rec_type DNS record type to use
1259  * @param data payload
1260  * @param data_size number of bytes in @a data
1261  */
1262 static void
1263 add_host (const char *hostname,
1264           uint16_t rec_type,
1265           const void *data,
1266           size_t data_size)
1267 {
1268   struct ResolveCache *rc;
1269   struct RecordListEntry *rle;
1270   struct GNUNET_DNSPARSER_Record *rec;
1271
1272   rec = GNUNET_malloc (sizeof (struct GNUNET_DNSPARSER_Record));
1273   rec->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS;
1274   rec->type = rec_type;
1275   rec->dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
1276   rec->name = GNUNET_strdup (hostname);
1277   rec->data.raw.data = GNUNET_memdup (data,
1278                                       data_size);
1279   rec->data.raw.data_len = data_size;
1280   rle = GNUNET_new (struct RecordListEntry);
1281   rle->record = rec;
1282   rc = GNUNET_new (struct ResolveCache);
1283   rc->hostname = GNUNET_strdup (hostname);
1284   GNUNET_CONTAINER_DLL_insert (rc->records_head,
1285                                rc->records_tail,
1286                                rle);
1287   GNUNET_CONTAINER_DLL_insert (hosts_head,
1288                                hosts_tail,
1289                                rc);
1290 }
1291
1292
1293 /**
1294  * Extract host information from a line in /etc/hosts
1295  *
1296  * @param line the line to parse
1297  * @param line_len number of bytes in @a line
1298  */
1299 static void
1300 extract_hosts (const char *line,
1301                size_t line_len)
1302 {
1303   const char *c;
1304   struct in_addr v4;
1305   struct in6_addr v6;
1306   char *tbuf;
1307   char *tok;
1308
1309   /* ignore everything after '#' */
1310   c = memrchr (line,
1311                (unsigned char) '#',
1312                line_len);
1313   if (NULL != c)
1314     line_len = c - line;
1315   /* ignore leading whitespace */
1316   while ( (0 < line_len) &&
1317           isspace ((unsigned char) *line) )
1318   {
1319     line++;
1320     line_len--;
1321   }
1322   tbuf = GNUNET_strndup (line,
1323                          line_len);
1324   tok = strtok (tbuf, " \t");
1325   if (NULL == tok)
1326   {
1327     GNUNET_free (tbuf);
1328     return;
1329   }
1330   if (1 == inet_pton (AF_INET,
1331                       tok,
1332                       &v4))
1333   {
1334     while (NULL != (tok = strtok (NULL, " \t")))
1335       add_host (tok,
1336                 GNUNET_DNSPARSER_TYPE_A,
1337                 &v4,
1338                 sizeof (struct in_addr));
1339   }
1340   else if (1 == inet_pton (AF_INET6,
1341                            tok,
1342                            &v6))
1343   {
1344     while (NULL != (tok = strtok (NULL, " \t")))
1345       add_host (tok,
1346                 GNUNET_DNSPARSER_TYPE_AAAA,
1347                 &v6,
1348                 sizeof (struct in6_addr));
1349   }
1350   GNUNET_free (tbuf);
1351 }
1352
1353
1354 /**
1355  * Reads the list of hosts from /etc/hosts.
1356  */
1357 static void
1358 load_etc_hosts (void)
1359 {
1360   struct GNUNET_DISK_FileHandle *fh;
1361   struct GNUNET_DISK_MapHandle *mh;
1362   off_t bytes_read;
1363   const char *buf;
1364   size_t read_offset;
1365
1366   fh = GNUNET_DISK_file_open ("/etc/hosts",
1367                               GNUNET_DISK_OPEN_READ,
1368                               GNUNET_DISK_PERM_NONE);
1369   if (NULL == fh)
1370   {
1371     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1372                 "Failed to open /etc/hosts");
1373     return;
1374   }
1375   if (GNUNET_OK !=
1376       GNUNET_DISK_file_handle_size (fh,
1377                                     &bytes_read))
1378   {
1379     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1380                 "Could not determin size of /etc/hosts. "
1381                 "DNS resolution will not be possible.\n");
1382     GNUNET_DISK_file_close (fh);
1383     return;
1384   }
1385   if ((size_t) bytes_read > SIZE_MAX)
1386   {
1387     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1388                 "/etc/hosts file too large to mmap. "
1389                 "DNS resolution will not be possible.\n");
1390     GNUNET_DISK_file_close (fh);
1391     return;
1392   }
1393   buf = GNUNET_DISK_file_map (fh,
1394                               &mh,
1395                               GNUNET_DISK_MAP_TYPE_READ,
1396                               (size_t) bytes_read);
1397   read_offset = 0;
1398   while (read_offset < (size_t) bytes_read)
1399   {
1400     const char *newline;
1401     size_t line_len;
1402
1403     newline = strchr (buf + read_offset,
1404                       '\n');
1405     if (NULL == newline)
1406       break;
1407     line_len = newline - buf - read_offset;
1408     extract_hosts (buf + read_offset,
1409                    line_len);
1410     read_offset += line_len + 1;
1411   }
1412   GNUNET_DISK_file_unmap (mh);
1413   GNUNET_DISK_file_close (fh);
1414 }
1415
1416
1417 /**
1418  * Service is starting, initialize everything.
1419  *
1420  * @param cls NULL, unused
1421  * @param cfg our configuration
1422  * @param sh service handle
1423  */
1424 static void
1425 init_cb (void *cls,
1426          const struct GNUNET_CONFIGURATION_Handle *cfg,
1427          struct GNUNET_SERVICE_Handle *sh)
1428 {
1429   char **dns_servers;
1430   int num_dns_servers;
1431
1432   (void) cfg;
1433   (void) sh;
1434   load_etc_hosts ();
1435   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
1436                                  cls);
1437   dnsstub_ctx = GNUNET_DNSSTUB_start (128);
1438   dns_servers = NULL;
1439   num_dns_servers = lookup_dns_servers (&dns_servers);
1440   if (0 >= num_dns_servers)
1441   {
1442     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1443                 _("No DNS server available. DNS resolution will not be possible.\n"));
1444     return;
1445   }
1446   for (int i = 0; i < num_dns_servers; i++)
1447   {
1448     int result = GNUNET_DNSSTUB_add_dns_ip (dnsstub_ctx, dns_servers[i]);
1449     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1450                 "Adding DNS server '%s': %s\n",
1451                 dns_servers[i],
1452                 GNUNET_OK == result ? "success" : "failure");
1453     GNUNET_free (dns_servers[i]);
1454   }
1455   GNUNET_free_non_null (dns_servers);
1456 }
1457
1458
1459 /**
1460  * Callback called when a client connects to the service.
1461  *
1462  * @param cls closure for the service, unused
1463  * @param c the new client that connected to the service
1464  * @param mq the message queue used to send messages to the client
1465  * @return @a c
1466  */
1467 static void *
1468 connect_cb (void *cls,
1469             struct GNUNET_SERVICE_Client *c,
1470             struct GNUNET_MQ_Handle *mq)
1471 {
1472   (void) cls;
1473   (void) mq;
1474
1475   return c;
1476 }
1477
1478
1479 /**
1480  * Callback called when a client disconnected from the service
1481  *
1482  * @param cls closure for the service
1483  * @param c the client that disconnected
1484  * @param internal_cls should be equal to @a c
1485  */
1486 static void
1487 disconnect_cb (void *cls,
1488                struct GNUNET_SERVICE_Client *c,
1489                void *internal_cls)
1490 {
1491   struct ActiveLookup *n;
1492   (void) cls;
1493
1494   GNUNET_assert (c == internal_cls);
1495   n = lookup_head;
1496   for (struct ActiveLookup *al = n;
1497        NULL != al;
1498        al = n)
1499   {
1500     n = al->next;
1501     if (al->client == c)
1502       free_active_lookup (al);
1503   }
1504 }
1505
1506
1507 /**
1508  * Define "main" method using service macro.
1509  */
1510 GNUNET_SERVICE_MAIN
1511 ("resolver",
1512  GNUNET_SERVICE_OPTION_NONE,
1513  &init_cb,
1514  &connect_cb,
1515  &disconnect_cb,
1516  NULL,
1517  GNUNET_MQ_hd_var_size (get,
1518                         GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST,
1519                         struct GNUNET_RESOLVER_GetMessage,
1520                         NULL),
1521  GNUNET_MQ_handler_end ());
1522
1523
1524 #if defined(LINUX) && defined(__GLIBC__)
1525 #include <malloc.h>
1526
1527 /**
1528  * MINIMIZE heap size (way below 128k) since this process doesn't need much.
1529  */
1530 void __attribute__ ((constructor))
1531 GNUNET_RESOLVER_memory_init ()
1532 {
1533   mallopt (M_TRIM_THRESHOLD, 4 * 1024);
1534   mallopt (M_TOP_PAD, 1 * 1024);
1535   malloc_trim (0);
1536 }
1537 #endif
1538
1539
1540 /* end of gnunet-service-resolver.c */