src/util/dnsstub.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012, 2018 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  * @file dns/dnsstub.c
  22  * @brief DNS stub resolver which sends DNS requests to an actual resolver
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27
  28 /**
  29  * Timeout for retrying DNS queries.
  30  */
  31 #define DNS_RETRANSMIT_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
  32
  33
  34 /**
  35  * DNS Server used for resolution.
  36  */
  37 struct DnsServer;
  38
  39
  40 /**
  41  * UDP socket we are using for sending DNS requests to the Internet.
  42  */
  43 struct GNUNET_DNSSTUB_RequestSocket
  44 {
  45
  46   /**
  47    * UDP socket we use for this request for IPv4
  48    */
  49   struct GNUNET_NETWORK_Handle *dnsout4;
  50
  51   /**
  52    * UDP socket we use for this request for IPv6
  53    */
  54   struct GNUNET_NETWORK_Handle *dnsout6;
  55
  56   /**
  57    * Function to call with result.
  58    */
  59   GNUNET_DNSSTUB_ResultCallback rc;
  60
  61   /**
  62    * Closure for @e rc.
  63    */
  64   void *rc_cls;
  65
  66   /**
  67    * Task for reading from dnsout4 and dnsout6.
  68    */
  69   struct GNUNET_SCHEDULER_Task *read_task;
  70
  71   /**
  72    * Task for retrying transmission of the query.
  73    */
  74   struct GNUNET_SCHEDULER_Task *retry_task;
  75
  76   /**
  77    * Next address we sent the DNS request to.
  78    */
  79   struct DnsServer *ds_pos;
  80
  81   /**
  82    * Context this request executes in.
  83    */
  84   struct GNUNET_DNSSTUB_Context *ctx;
  85
  86   /**
  87    * Query we sent to @e addr.
  88    */
  89   void *request;
  90
  91   /**
  92    * Number of bytes in @a request.
  93    */
  94   size_t request_len;
  95
  96 };
  97
  98
  99 /**
 100  * DNS Server used for resolution.
 101  */
 102 struct DnsServer
 103 {
 104
 105   /**
 106    * Kept in a DLL.
 107    */
 108   struct DnsServer *next;
 109
 110   /**
 111    * Kept in a DLL.
 112    */
 113   struct DnsServer *prev;
 114
 115   /**
 116    * IP address of the DNS resolver.
 117    */
 118   struct sockaddr_storage ss;
 119 };
 120
 121
 122 /**
 123  * Handle to the stub resolver.
 124  */
 125 struct GNUNET_DNSSTUB_Context
 126 {
 127
 128   /**
 129    * Array of all open sockets for DNS requests.
 130    */
 131   struct GNUNET_DNSSTUB_RequestSocket *sockets;
 132
 133   /**
 134    * DLL of DNS resolvers we use.
 135    */
 136   struct DnsServer *dns_head;
 137
 138   /**
 139    * DLL of DNS resolvers we use.
 140    */
 141   struct DnsServer *dns_tail;
 142
 143   /**
 144    * How frequently do we retry requests?
 145    */
 146   struct GNUNET_TIME_Relative retry_freq;
 147
 148   /**
 149    * Length of @e sockets array.
 150    */
 151   unsigned int num_sockets;
 152
 153 };
 154
 155
 156 /**
 157  * We're done with a `struct GNUNET_DNSSTUB_RequestSocket`, close it for now.
 158  *
 159  * @param rs request socket to clean up
 160  */
 161 static void
 162 cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
 163 {
 164   if (NULL != rs->dnsout4)
 165   {
 166     GNUNET_NETWORK_socket_close (rs->dnsout4);
 167     rs->dnsout4 = NULL;
 168   }
 169   if (NULL != rs->dnsout6)
 170   {
 171     GNUNET_NETWORK_socket_close (rs->dnsout6);
 172     rs->dnsout6 = NULL;
 173   }
 174   if (NULL != rs->read_task)
 175   {
 176     GNUNET_SCHEDULER_cancel (rs->read_task);
 177     rs->read_task = NULL;
 178   }
 179   if (NULL != rs->retry_task)
 180   {
 181     GNUNET_SCHEDULER_cancel (rs->retry_task);
 182     rs->retry_task = NULL;
 183   }
 184   if (NULL != rs->request)
 185   {
 186     GNUNET_free (rs->request);
 187     rs->request = NULL;
 188   }
 189 }
 190
 191
 192 /**
 193  * Open source port for sending DNS requests
 194  *
 195  * @param af AF_INET or AF_INET6
 196  * @return #GNUNET_OK on success
 197  */
 198 static struct GNUNET_NETWORK_Handle *
 199 open_socket (int af)
 200 {
 201   struct sockaddr_in a4;
 202   struct sockaddr_in6 a6;
 203   struct sockaddr *sa;
 204   socklen_t alen;
 205   struct GNUNET_NETWORK_Handle *ret;
 206
 207   ret = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, 0);
 208   if (NULL == ret)
 209     return NULL;
 210   switch (af)
 211   {
 212   case AF_INET:
 213     memset (&a4, 0, alen = sizeof (struct sockaddr_in));
 214     sa = (struct sockaddr *) &a4;
 215     break;
 216   case AF_INET6:
 217     memset (&a6, 0, alen = sizeof (struct sockaddr_in6));
 218     sa = (struct sockaddr *) &a6;
 219     break;
 220   default:
 221     GNUNET_break (0);
 222     GNUNET_NETWORK_socket_close (ret);
 223     return NULL;
 224   }
 225   sa->sa_family = af;
 226   if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret,
 227                                                sa,
 228                                                alen))
 229   {
 230     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 231                 _("Could not bind to any port: %s\n"),
 232                 STRERROR (errno));
 233     GNUNET_NETWORK_socket_close (ret);
 234     return NULL;
 235   }
 236   return ret;
 237 }
 238
 239
 240 /**
 241  * Get a socket of the specified address family to send out a
 242  * UDP DNS request to the Internet.
 243  *
 244  * @param ctx the DNSSTUB context
 245  * @return NULL on error
 246  */
 247 static struct GNUNET_DNSSTUB_RequestSocket *
 248 get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
 249 {
 250   struct GNUNET_DNSSTUB_RequestSocket *rs;
 251
 252   for (unsigned int i=0;i<256;i++)
 253   {
 254     rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
 255                                                  ctx->num_sockets)];
 256     if (NULL == rs->rc)
 257       break;
 258   }
 259   if (NULL != rs->rc)
 260   {
 261     /* signal "failure" */
 262     rs->rc (rs->rc_cls,
 263             NULL,
 264             0);
 265     rs->rc = NULL;
 266   }
 267   if (NULL != rs->read_task)
 268   {
 269     GNUNET_SCHEDULER_cancel (rs->read_task);
 270     rs->read_task = NULL;
 271   }
 272   if (NULL != rs->retry_task)
 273   {
 274     GNUNET_SCHEDULER_cancel (rs->retry_task);
 275     rs->retry_task = NULL;
 276   }
 277   if (NULL != rs->request)
 278   {
 279     GNUNET_free (rs->request);
 280     rs->request = NULL;
 281   }
 282   rs->ctx = ctx;
 283   return rs;
 284 }
 285
 286
 287 /**
 288  * Actually do the reading of a DNS packet from our UDP socket and see
 289  * if we have a valid, matching, pending request.
 290  *
 291  * @param rs request socket with callback details
 292  * @param dnsout socket to read from
 293  * @return #GNUNET_OK on success, #GNUNET_NO on drop, #GNUNET_SYSERR on IO-errors (closed socket)
 294  */
 295 static int
 296 do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
 297              struct GNUNET_NETWORK_Handle *dnsout)
 298 {
 299   struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
 300   ssize_t r;
 301   int len;
 302
 303 #ifndef MINGW
 304   if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout),
 305                   FIONREAD,
 306                   &len))
 307   {
 308     /* conservative choice: */
 309     len = UINT16_MAX;
 310   }
 311 #else
 312   /* port the code above? */
 313   len = UINT16_MAX;
 314 #endif
 315   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 316               "Receiving %d byte DNS reply\n",
 317               len);
 318   {
 319     unsigned char buf[len] GNUNET_ALIGN;
 320     int found;
 321     struct sockaddr_storage addr;
 322     socklen_t addrlen;
 323     struct GNUNET_TUN_DnsHeader *dns;
 324
 325     addrlen = sizeof (addr);
 326     memset (&addr,
 327             0,
 328             sizeof (addr));
 329     r = GNUNET_NETWORK_socket_recvfrom (dnsout,
 330                                         buf,
 331                                         sizeof (buf),
 332                                         (struct sockaddr*) &addr,
 333                                         &addrlen);
 334     if (-1 == r)
 335     {
 336       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
 337                            "recvfrom");
 338       GNUNET_NETWORK_socket_close (dnsout);
 339       return GNUNET_SYSERR;
 340     }
 341     found = GNUNET_NO;
 342     for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next)
 343     {
 344       if (0 == memcmp (&addr,
 345                        &ds->ss,
 346                        GNUNET_MIN (sizeof (struct sockaddr_storage),
 347                                    addrlen)))
 348       {
 349         found = GNUNET_YES;
 350         break;
 351       }
 352     }
 353     if (GNUNET_NO == found)
 354     {
 355       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 356                   "Received DNS response from server we never asked (ignored)");
 357       return GNUNET_NO;
 358     }
 359     if (sizeof (struct GNUNET_TUN_DnsHeader) > (size_t) r)
 360     {
 361       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 362                   _("Received DNS response that is too small (%u bytes)"),
 363                   (unsigned int) r);
 364       return GNUNET_NO;
 365     }
 366     dns = (struct GNUNET_TUN_DnsHeader *) buf;
 367     if (NULL == rs->rc)
 368     {
 369       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 370                   "Request timeout or cancelled; ignoring reply\n");
 371       return GNUNET_NO;
 372     }
 373     rs->rc (rs->rc_cls,
 374             dns,
 375             r);
 376   }
 377   return GNUNET_OK;
 378 }
 379
 380
 381 /**
 382  * Read a DNS response from the (unhindered) UDP-Socket
 383  *
 384  * @param cls socket to read from
 385  */
 386 static void
 387 read_response (void *cls);
 388
 389
 390 /**
 391  * Schedule #read_response() task for @a rs.
 392  *
 393  * @param rs request to schedule read operation for
 394  */
 395 static void
 396 schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
 397 {
 398   struct GNUNET_NETWORK_FDSet *rset;
 399
 400   if (NULL != rs->read_task)
 401     GNUNET_SCHEDULER_cancel (rs->read_task);
 402   rset = GNUNET_NETWORK_fdset_create ();
 403   if (NULL != rs->dnsout4)
 404     GNUNET_NETWORK_fdset_set (rset,
 405                               rs->dnsout4);
 406   if (NULL != rs->dnsout6)
 407     GNUNET_NETWORK_fdset_set (rset,
 408                               rs->dnsout6);
 409   rs->read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 410                                                GNUNET_TIME_UNIT_FOREVER_REL,
 411                                                rset,
 412                                                NULL,
 413                                                &read_response,
 414                                                rs);
 415   GNUNET_NETWORK_fdset_destroy (rset);
 416 }
 417
 418
 419 /**
 420  * Read a DNS response from the (unhindered) UDP-Socket
 421  *
 422  * @param cls `struct GNUNET_DNSSTUB_RequestSocket` to read from
 423  */
 424 static void
 425 read_response (void *cls)
 426 {
 427   struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
 428   const struct GNUNET_SCHEDULER_TaskContext *tc;
 429
 430   rs->read_task = NULL;
 431   tc = GNUNET_SCHEDULER_get_task_context ();
 432   /* read and process ready sockets */
 433   if ( (NULL != rs->dnsout4) &&
 434        (GNUNET_NETWORK_fdset_isset (tc->read_ready,
 435                                     rs->dnsout4)) &&
 436        (GNUNET_SYSERR ==
 437         do_dns_read (rs,
 438                      rs->dnsout4)) )
 439     rs->dnsout4 = NULL;
 440   if ( (NULL != rs->dnsout6) &&
 441        (GNUNET_NETWORK_fdset_isset (tc->read_ready,
 442                                     rs->dnsout6)) &&
 443        (GNUNET_SYSERR ==
 444         do_dns_read (rs,
 445                      rs->dnsout6)) )
 446     rs->dnsout6 = NULL;
 447   /* re-schedule read task */
 448   schedule_read (rs);
 449 }
 450
 451
 452 /**
 453  * Task to (re)transmit the DNS query, possibly repeatedly until
 454  * we succeed.
 455  *
 456  * @param cls our `struct GNUNET_DNSSTUB_RequestSocket *`
 457  */
 458 static void
 459 transmit_query (void *cls)
 460 {
 461   struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
 462   struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
 463   const struct sockaddr *sa;
 464   socklen_t salen;
 465   struct DnsServer *ds;
 466   struct GNUNET_NETWORK_Handle *dnsout;
 467
 468   rs->retry_task = GNUNET_SCHEDULER_add_delayed (ctx->retry_freq,
 469                                                  &transmit_query,
 470                                                  rs);
 471   ds = rs->ds_pos;
 472   rs->ds_pos = ds->next;
 473   if (NULL == rs->ds_pos)
 474     rs->ds_pos = ctx->dns_head;
 475   GNUNET_assert (NULL != ds);
 476   dnsout = NULL;
 477   switch (ds->ss.ss_family)
 478   {
 479   case AF_INET:
 480     if (NULL == rs->dnsout4)
 481       rs->dnsout4 = open_socket (AF_INET);
 482     dnsout = rs->dnsout4;
 483     sa = (const struct sockaddr *) &ds->ss;
 484     salen = sizeof (struct sockaddr_in);
 485     break;
 486   case AF_INET6:
 487     if (NULL == rs->dnsout6)
 488       rs->dnsout6 = open_socket (AF_INET6);
 489     dnsout = rs->dnsout6;
 490     sa = (const struct sockaddr *) &ds->ss;
 491     salen = sizeof (struct sockaddr_in6);
 492     break;
 493   default:
 494     return;
 495   }
 496   if (NULL == dnsout)
 497   {
 498     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 499                 "Unable to use configure DNS server, skipping\n");
 500     return;
 501   }
 502   if (GNUNET_SYSERR ==
 503       GNUNET_NETWORK_socket_sendto (dnsout,
 504                                     rs->request,
 505                                     rs->request_len,
 506                                     sa,
 507                                     salen))
 508     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 509                 _("Failed to send DNS request to %s: %s\n"),
 510                 GNUNET_a2s (sa,
 511                             salen),
 512                 STRERROR (errno));
 513   else
 514     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 515                 _("Sent DNS request to %s\n"),
 516                 GNUNET_a2s (sa,
 517                             salen));
 518   schedule_read (rs);
 519 }
 520
 521
 522 /**
 523  * Perform DNS resolution using our default IP from init.
 524  *
 525  * @param ctx stub resolver to use
 526  * @param request DNS request to transmit
 527  * @param request_len number of bytes in msg
 528  * @param rc function to call with result
 529  * @param rc_cls closure for 'rc'
 530  * @return socket used for the request, NULL on error
 531  */
 532 struct GNUNET_DNSSTUB_RequestSocket *
 533 GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx,
 534                          const void *request,
 535                          size_t request_len,
 536                          GNUNET_DNSSTUB_ResultCallback rc,
 537                          void *rc_cls)
 538 {
 539   struct GNUNET_DNSSTUB_RequestSocket *rs;
 540
 541   if (NULL == ctx->dns_head)
 542   {
 543     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 544                 "No DNS server configured for resolution\n");
 545     return NULL;
 546   }
 547   if (NULL == (rs = get_request_socket (ctx)))
 548   {
 549     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 550                 "No request socket available for DNS resolution\n");
 551     return NULL;
 552   }
 553   rs->ds_pos = ctx->dns_head;
 554   rs->rc = rc;
 555   rs->rc_cls = rc_cls;
 556   rs->request = GNUNET_memdup (request,
 557                                request_len);
 558   rs->request_len = request_len;
 559   rs->retry_task = GNUNET_SCHEDULER_add_now (&transmit_query,
 560                                              rs);
 561   return rs;
 562 }
 563
 564
 565 /**
 566  * Cancel DNS resolution.
 567  *
 568  * @param rs resolution to cancel
 569  */
 570 void
 571 GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
 572 {
 573   rs->rc = NULL;
 574   if (NULL != rs->retry_task)
 575   {
 576     GNUNET_SCHEDULER_cancel (rs->retry_task);
 577     rs->retry_task = NULL;
 578   }
 579   if (NULL != rs->read_task)
 580   {
 581     GNUNET_SCHEDULER_cancel (rs->read_task);
 582     rs->read_task = NULL;
 583   }
 584 }
 585
 586
 587 /**
 588  * Start a DNS stub resolver.
 589  *
 590  * @param num_sockets how many sockets should we open
 591  *        in parallel for DNS queries for this stub?
 592  * @return NULL on error
 593  */
 594 struct GNUNET_DNSSTUB_Context *
 595 GNUNET_DNSSTUB_start (unsigned int num_sockets)
 596 {
 597   struct GNUNET_DNSSTUB_Context *ctx;
 598
 599   if (0 == num_sockets)
 600   {
 601     GNUNET_break (0);
 602     return NULL;
 603   }
 604   ctx = GNUNET_new (struct GNUNET_DNSSTUB_Context);
 605   ctx->num_sockets = num_sockets;
 606   ctx->sockets = GNUNET_new_array (num_sockets,
 607                                    struct GNUNET_DNSSTUB_RequestSocket);
 608   ctx->retry_freq = DNS_RETRANSMIT_DELAY;
 609   return ctx;
 610 }
 611
 612
 613 /**
 614  * Add nameserver for use by the DNSSTUB.  We will use
 615  * all provided nameservers for resolution (round-robin).
 616  *
 617  * @param ctx resolver context to modify
 618  * @param dns_ip target IP address to use (as string)
 619  * @return #GNUNET_OK on success
 620  */
 621 int
 622 GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx,
 623                            const char *dns_ip)
 624 {
 625   struct DnsServer *ds;
 626   struct in_addr i4;
 627   struct in6_addr i6;
 628
 629   ds = GNUNET_new (struct DnsServer);
 630   if (1 == inet_pton (AF_INET,
 631                       dns_ip,
 632                       &i4))
 633   {
 634     struct sockaddr_in *s4 = (struct sockaddr_in *) &ds->ss;
 635
 636     s4->sin_family = AF_INET;
 637     s4->sin_port = htons (53);
 638     s4->sin_addr = i4;
 639 #if HAVE_SOCKADDR_IN_SIN_LEN
 640     s4->sin_len = (u_char) sizeof (struct sockaddr_in);
 641 #endif
 642   }
 643   else if (1 == inet_pton (AF_INET6,
 644                            dns_ip,
 645                            &i6))
 646   {
 647     struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &ds->ss;
 648
 649     s6->sin6_family = AF_INET6;
 650     s6->sin6_port = htons (53);
 651     s6->sin6_addr = i6;
 652 #if HAVE_SOCKADDR_IN_SIN_LEN
 653     s6->sin6_len = (u_char) sizeof (struct sockaddr_in6);
 654 #endif
 655   }
 656   else
 657   {
 658     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 659                 "Malformed IP address `%s' for DNS server\n",
 660                 dns_ip);
 661     GNUNET_free (ds);
 662     return GNUNET_SYSERR;
 663   }
 664   GNUNET_CONTAINER_DLL_insert (ctx->dns_head,
 665                                ctx->dns_tail,
 666                                ds);
 667   return GNUNET_OK;
 668 }
 669
 670
 671 /**
 672  * Add nameserver for use by the DNSSTUB.  We will use
 673  * all provided nameservers for resolution (round-robin).
 674  *
 675  * @param ctx resolver context to modify
 676  * @param sa socket address of DNS resolver to use
 677  * @return #GNUNET_OK on success
 678  */
 679 int
 680 GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx,
 681                            const struct sockaddr *sa)
 682 {
 683   struct DnsServer *ds;
 684
 685   ds = GNUNET_new (struct DnsServer);
 686   switch (sa->sa_family)
 687   {
 688   case AF_INET:
 689     GNUNET_memcpy (&ds->ss,
 690                    sa,
 691                    sizeof (struct sockaddr_in));
 692     break;
 693   case AF_INET6:
 694     GNUNET_memcpy (&ds->ss,
 695                    sa,
 696                    sizeof (struct sockaddr_in6));
 697     break;
 698   default:
 699     GNUNET_break (0);
 700     GNUNET_free (ds);
 701     return GNUNET_SYSERR;
 702   }
 703   GNUNET_CONTAINER_DLL_insert (ctx->dns_head,
 704                                ctx->dns_tail,
 705                                ds);
 706   return GNUNET_OK;
 707 }
 708
 709
 710 /**
 711  * How long should we try requests before timing out?
 712  * Only effective for requests issued after this call.
 713  *
 714  * @param ctx resolver context to modify
 715  * @param retry_freq how long to wait between retries
 716  */
 717 void
 718 GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx,
 719                           struct GNUNET_TIME_Relative retry_freq)
 720 {
 721   ctx->retry_freq = retry_freq;
 722 }
 723
 724
 725 /**
 726  * Cleanup DNSSTUB resolver.
 727  *
 728  * @param ctx stub resolver to clean up
 729  */
 730 void
 731 GNUNET_DNSSTUB_stop (struct GNUNET_DNSSTUB_Context *ctx)
 732 {
 733   struct DnsServer *ds;
 734
 735   while (NULL != (ds = ctx->dns_head))
 736   {
 737     GNUNET_CONTAINER_DLL_remove (ctx->dns_head,
 738                                  ctx->dns_tail,
 739                                  ds);
 740     GNUNET_free (ds);
 741   }
 742   for (unsigned int i=0;i<ctx->num_sockets;i++)
 743     cleanup_rs (&ctx->sockets[i]);
 744   GNUNET_free (ctx->sockets);
 745   GNUNET_free (ctx);
 746 }
 747
 748
 749 /* end of dnsstub.c */