src/gns/gnunet-dns2gns.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012-2013 GNUnet e.V.
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file gnunet-dns2gns.c
  22  * @brief DNS server that translates DNS requests to GNS
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include <gnunet_util_lib.h>
  27 #include <gnunet_dnsparser_lib.h>
  28 #include <gnunet_gns_service.h>
  29 #include <gnunet_dnsstub_lib.h>
  30 #include "gns.h"
  31
  32 /**
  33  * Timeout for DNS requests.
  34  */
  35 #define TIMEOUT GNUNET_TIME_UNIT_MINUTES
  36
  37 /**
  38  * Data kept per request.
  39  */
  40 struct Request
  41 {
  42   /**
  43    * Socket to use for sending the reply.
  44    */
  45   struct GNUNET_NETWORK_Handle *lsock;
  46
  47   /**
  48    * Destination address to use.
  49    */
  50   const void *addr;
  51
  52   /**
  53    * Initially, this is the DNS request, it will then be
  54    * converted to the DNS response.
  55    */
  56   struct GNUNET_DNSPARSER_Packet *packet;
  57
  58   /**
  59    * Our GNS request handle.
  60    */
  61   struct GNUNET_GNS_LookupWithTldRequest *lookup;
  62
  63   /**
  64    * Our DNS request handle
  65    */
  66   struct GNUNET_DNSSTUB_RequestSocket *dns_lookup;
  67
  68   /**
  69    * Task run on timeout or shutdown to clean up without
  70    * response.
  71    */
  72   struct GNUNET_SCHEDULER_Task *timeout_task;
  73
  74   /**
  75    * Original UDP request message.
  76    */
  77   char *udp_msg;
  78
  79   /**
  80    * Number of bytes in @e addr.
  81    */
  82   size_t addr_len;
  83
  84   /**
  85    * Number of bytes in @e udp_msg.
  86    */
  87   size_t udp_msg_size;
  88
  89   /**
  90    * ID of the original request.
  91    */
  92   uint16_t original_request_id;
  93 };
  94
  95
  96 /**
  97  * Handle to GNS resolver.
  98  */
  99 struct GNUNET_GNS_Handle *gns;
 100
 101 /**
 102  * Stub resolver
 103  */
 104 struct GNUNET_DNSSTUB_Context *dns_stub;
 105
 106 /**
 107  * Listen socket for IPv4.
 108  */
 109 static struct GNUNET_NETWORK_Handle *listen_socket4;
 110
 111 /**
 112  * Listen socket for IPv6.
 113  */
 114 static struct GNUNET_NETWORK_Handle *listen_socket6;
 115
 116 /**
 117  * Task for IPv4 socket.
 118  */
 119 static struct GNUNET_SCHEDULER_Task *t4;
 120
 121 /**
 122  * Task for IPv6 socket.
 123  */
 124 static struct GNUNET_SCHEDULER_Task *t6;
 125
 126 /**
 127  * IP of DNS server
 128  */
 129 static char *dns_ip;
 130
 131 /**
 132  * UDP Port we listen on for inbound DNS requests.
 133  */
 134 static unsigned int listen_port = 53;
 135
 136 /**
 137  * Configuration to use.
 138  */
 139 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 140
 141
 142 /**
 143  * Task run on shutdown.  Cleans up everything.
 144  *
 145  * @param cls unused
 146  */
 147 static void
 148 do_shutdown (void *cls)
 149 {
 150   (void) cls;
 151   if (NULL != t4)
 152   {
 153     GNUNET_SCHEDULER_cancel (t4);
 154     t4 = NULL;
 155   }
 156   if (NULL != t6)
 157   {
 158     GNUNET_SCHEDULER_cancel (t6);
 159     t6 = NULL;
 160   }
 161   if (NULL != listen_socket4)
 162   {
 163     GNUNET_NETWORK_socket_close (listen_socket4);
 164     listen_socket4 = NULL;
 165   }
 166   if (NULL != listen_socket6)
 167   {
 168     GNUNET_NETWORK_socket_close (listen_socket6);
 169     listen_socket6 = NULL;
 170   }
 171   if (NULL != gns)
 172   {
 173     GNUNET_GNS_disconnect (gns);
 174     gns = NULL;
 175   }
 176   if (NULL != dns_stub)
 177   {
 178     GNUNET_DNSSTUB_stop (dns_stub);
 179     dns_stub = NULL;
 180   }
 181 }
 182
 183
 184 /**
 185  * Send the response for the given request and clean up.
 186  *
 187  * @param request context for the request.
 188  */
 189 static void
 190 send_response (struct Request *request)
 191 {
 192   char *buf;
 193   size_t size;
 194   ssize_t sret;
 195
 196   if (GNUNET_SYSERR ==
 197       GNUNET_DNSPARSER_pack (request->packet,
 198                              UINT16_MAX /* is this not too much? */,
 199                              &buf,
 200                              &size))
 201     {
 202       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 203                   _("Failed to pack DNS response into UDP packet!\n"));
 204     }
 205   else
 206     {
 207       sret = GNUNET_NETWORK_socket_sendto (request->lsock,
 208                                            buf,
 209                                            size,
 210                                            request->addr,
 211                                            request->addr_len);
 212       if ( (sret < 0) ||
 213            (size != (size_t) sret) )
 214         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 215                              "sendto");
 216       GNUNET_free (buf);
 217     }
 218   GNUNET_SCHEDULER_cancel (request->timeout_task);
 219   GNUNET_DNSPARSER_free_packet (request->packet);
 220   GNUNET_free (request->udp_msg);
 221   GNUNET_free (request);
 222 }
 223
 224
 225 /**
 226  * Task run on timeout.  Cleans up request.
 227  *
 228  * @param cls `struct Request *` of the request to clean up
 229  */
 230 static void
 231 do_timeout (void *cls)
 232 {
 233   struct Request *request = cls;
 234
 235   if (NULL != request->packet)
 236     GNUNET_DNSPARSER_free_packet (request->packet);
 237   if (NULL != request->lookup)
 238     GNUNET_GNS_lookup_with_tld_cancel (request->lookup);
 239   if (NULL != request->dns_lookup)
 240     GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup);
 241   GNUNET_free (request->udp_msg);
 242   GNUNET_free (request);
 243 }
 244
 245
 246 /**
 247  * Iterator called on obtained result for a DNS lookup
 248  *
 249  * @param cls closure
 250  * @param rs the request socket
 251  * @param dns the DNS udp payload
 252  * @param r size of the DNS payload
 253  */
 254 static void
 255 dns_result_processor (void *cls,
 256                       struct GNUNET_DNSSTUB_RequestSocket *rs,
 257                       const struct GNUNET_TUN_DnsHeader *dns,
 258                       size_t r)
 259 {
 260   struct Request *request = cls;
 261
 262   (void) rs;
 263   if (NULL == dns)
 264   {
 265     /* DNSSTUB gave up, so we trigger timeout early */
 266     GNUNET_SCHEDULER_cancel (request->timeout_task);
 267     do_timeout (request);
 268     return;
 269   }
 270   if (request->original_request_id != dns->id)
 271   {
 272     /* for a another query, ignore */
 273     return;
 274   }
 275   request->packet = GNUNET_DNSPARSER_parse ((char*)dns,
 276                                             r);
 277   send_response (request);
 278 }
 279
 280
 281 /**
 282  * Iterator called on obtained result for a GNS lookup.
 283  *
 284  * @param cls closure
 285  * @param was_gns #GNUNET_NO if the TLD is not configured for GNS
 286  * @param rd_count number of records in @a rd
 287  * @param rd the records in reply
 288  */
 289 static void
 290 result_processor (void *cls,
 291                   int was_gns,
 292                   uint32_t rd_count,
 293                   const struct GNUNET_GNSRECORD_Data *rd)
 294 {
 295   struct Request *request = cls;
 296   struct GNUNET_DNSPARSER_Packet *packet;
 297   struct GNUNET_DNSPARSER_Record rec;
 298
 299   request->lookup = NULL;
 300   if (GNUNET_NO == was_gns)
 301   {
 302     /* TLD not configured for GNS, fall back to DNS */
 303     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 304                 "Using DNS resolver IP `%s' to resolve `%s'\n",
 305                 dns_ip,
 306                 request->packet->queries[0].name);
 307     request->original_request_id = request->packet->id;
 308     GNUNET_DNSPARSER_free_packet (request->packet);
 309     request->packet = NULL;
 310     request->dns_lookup = GNUNET_DNSSTUB_resolve2 (dns_stub,
 311                                                    request->udp_msg,
 312                                                    request->udp_msg_size,
 313                                                    &dns_result_processor,
 314                                                    request);
 315     return;
 316   }
 317   packet = request->packet;
 318   packet->flags.query_or_response = 1;
 319   packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR;
 320   packet->flags.checking_disabled = 0;
 321   packet->flags.authenticated_data = 1;
 322   packet->flags.zero = 0;
 323   packet->flags.recursion_available = 1;
 324   packet->flags.message_truncated = 0;
 325   packet->flags.authoritative_answer = 0;
 326   //packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ???
 327   for (uint32_t i=0;i<rd_count;i++)
 328     {
 329       // FIXME: do we need to hanlde #GNUNET_GNSRECORD_RF_SHADOW_RECORD
 330       // here? Or should we do this in libgnunetgns?
 331       rec.expiration_time.abs_value_us = rd[i].expiration_time;
 332       switch (rd[i].record_type)
 333         {
 334         case GNUNET_DNSPARSER_TYPE_A:
 335           GNUNET_assert (sizeof (struct in_addr) == rd[i].data_size);
 336           rec.name = GNUNET_strdup (packet->queries[0].name);
 337           rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
 338           rec.type = GNUNET_DNSPARSER_TYPE_A;
 339           rec.data.raw.data = GNUNET_new (struct in_addr);
 340           GNUNET_memcpy (rec.data.raw.data,
 341                   rd[i].data,
 342                   rd[i].data_size);
 343           rec.data.raw.data_len = sizeof (struct in_addr);
 344           GNUNET_array_append (packet->answers,
 345                                packet->num_answers,
 346                                rec);
 347           break;
 348         case GNUNET_DNSPARSER_TYPE_AAAA:
 349           GNUNET_assert (sizeof (struct in6_addr) == rd[i].data_size);
 350           rec.name = GNUNET_strdup (packet->queries[0].name);
 351           rec.data.raw.data = GNUNET_new (struct in6_addr);
 352           rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
 353           rec.type = GNUNET_DNSPARSER_TYPE_AAAA;
 354           GNUNET_memcpy (rec.data.raw.data,
 355                   rd[i].data,
 356                   rd[i].data_size);
 357           rec.data.raw.data_len = sizeof (struct in6_addr);
 358           GNUNET_array_append (packet->answers,
 359                                packet->num_answers,
 360                                rec);
 361           break;
 362         case GNUNET_DNSPARSER_TYPE_CNAME:
 363           rec.name = GNUNET_strdup (packet->queries[0].name);
 364           rec.data.hostname = GNUNET_strdup (rd[i].data);
 365           rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
 366           rec.type = GNUNET_DNSPARSER_TYPE_CNAME;
 367           GNUNET_memcpy (rec.data.hostname,
 368                   rd[i].data,
 369                   rd[i].data_size);
 370           GNUNET_array_append (packet->answers,
 371                                packet->num_answers,
 372                                rec);
 373           break;
 374         default:
 375           /* skip */
 376           break;
 377         }
 378     }
 379   send_response (request);
 380 }
 381
 382
 383 /**
 384  * Handle DNS request.
 385  *
 386  * @param lsock socket to use for sending the reply
 387  * @param addr address to use for sending the reply
 388  * @param addr_len number of bytes in @a addr
 389  * @param udp_msg DNS request payload
 390  * @param udp_msg_size number of bytes in @a udp_msg
 391  */
 392 static void
 393 handle_request (struct GNUNET_NETWORK_Handle *lsock,
 394                 const void *addr,
 395                 size_t addr_len,
 396                 const char *udp_msg,
 397                 size_t udp_msg_size)
 398 {
 399   struct Request *request;
 400   struct GNUNET_DNSPARSER_Packet *packet;
 401
 402   packet = GNUNET_DNSPARSER_parse (udp_msg,
 403                                    udp_msg_size);
 404   if (NULL == packet)
 405   {
 406     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 407                 _("Cannot parse DNS request from %s\n"),
 408                 GNUNET_a2s (addr, addr_len));
 409     return;
 410   }
 411   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 412               "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n",
 413               packet->queries[0].name,
 414               (unsigned int) packet->flags.query_or_response,
 415               (int) packet->num_answers,
 416               (int) packet->num_authority_records,
 417               (int) packet->num_additional_records);
 418   if ( (0 != packet->flags.query_or_response) ||
 419        (0 != packet->num_answers) ||
 420        (0 != packet->num_authority_records))
 421   {
 422     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 423                 _("Received malformed DNS request from %s\n"),
 424                 GNUNET_a2s (addr, addr_len));
 425     GNUNET_DNSPARSER_free_packet (packet);
 426     return;
 427   }
 428   if ( (1 != packet->num_queries) )
 429   {
 430     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 431                 _("Received unsupported DNS request from %s\n"),
 432                 GNUNET_a2s (addr,
 433                             addr_len));
 434     GNUNET_DNSPARSER_free_packet (packet);
 435     return;
 436   }
 437   request = GNUNET_malloc (sizeof (struct Request) + addr_len);
 438   request->lsock = lsock;
 439   request->packet = packet;
 440   request->addr = &request[1];
 441   request->addr_len = addr_len;
 442   GNUNET_memcpy (&request[1],
 443                  addr,
 444                  addr_len);
 445   request->udp_msg_size = udp_msg_size;
 446   request->udp_msg = GNUNET_memdup (udp_msg,
 447                                     udp_msg_size);
 448   request->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 449                                                         &do_timeout,
 450                                                         request);
 451   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 452               "Calling GNS on `%s'\n",
 453               packet->queries[0].name);
 454   request->lookup = GNUNET_GNS_lookup_with_tld (gns,
 455                                                 packet->queries[0].name,
 456                                                 packet->queries[0].type,
 457                                                 GNUNET_NO,
 458                                                 &result_processor,
 459                                                 request);
 460 }
 461
 462
 463 /**
 464  * Task to read IPv4 DNS packets.
 465  *
 466  * @param cls the 'listen_socket4'
 467  */
 468 static void
 469 read_dns4 (void *cls)
 470 {
 471   struct sockaddr_in v4;
 472   socklen_t addrlen;
 473   ssize_t size;
 474   const struct GNUNET_SCHEDULER_TaskContext *tc;
 475
 476   GNUNET_assert (listen_socket4 == cls);
 477   t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 478                                       listen_socket4,
 479                                       &read_dns4,
 480                                       listen_socket4);
 481   tc = GNUNET_SCHEDULER_get_task_context ();
 482   if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
 483     return; /* shutdown? */
 484   size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket4);
 485   if (0 > size)
 486     {
 487       GNUNET_break (0);
 488       return; /* read error!? */
 489     }
 490   {
 491     char buf[size + 1];
 492     ssize_t sret;
 493
 494     addrlen = sizeof (v4);
 495     sret = GNUNET_NETWORK_socket_recvfrom (listen_socket4,
 496                                            buf,
 497                                            size + 1,
 498                                            (struct sockaddr *) &v4,
 499                                            &addrlen);
 500     if (0 > sret)
 501     {
 502       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 503                            "recvfrom");
 504       return;
 505     }
 506     GNUNET_break (size == sret);
 507     handle_request (listen_socket4,
 508                     &v4,
 509                     addrlen,
 510                     buf,
 511                     size);
 512   }
 513 }
 514
 515
 516 /**
 517  * Task to read IPv6 DNS packets.
 518  *
 519  * @param cls the 'listen_socket6'
 520  */
 521 static void
 522 read_dns6 (void *cls)
 523 {
 524   struct sockaddr_in6 v6;
 525   socklen_t addrlen;
 526   ssize_t size;
 527   const struct GNUNET_SCHEDULER_TaskContext *tc;
 528
 529   GNUNET_assert (listen_socket6 == cls);
 530   t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 531                                       listen_socket6,
 532                                       &read_dns6,
 533                                       listen_socket6);
 534   tc = GNUNET_SCHEDULER_get_task_context ();
 535   if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
 536     return; /* shutdown? */
 537   size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket6);
 538   if (0 > size)
 539     {
 540       GNUNET_break (0);
 541       return; /* read error!? */
 542     }
 543   {
 544     char buf[size];
 545     ssize_t sret;
 546
 547     addrlen = sizeof (v6);
 548     sret = GNUNET_NETWORK_socket_recvfrom (listen_socket6,
 549                                            buf,
 550                                            size,
 551                                            (struct sockaddr *) &v6,
 552                                            &addrlen);
 553     if (0 > sret)
 554     {
 555       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 556                            "recvfrom");
 557       return;
 558     }
 559     GNUNET_break (size == sret);
 560     handle_request (listen_socket6,
 561                     &v6,
 562                     addrlen,
 563                     buf,
 564                     size);
 565   }
 566 }
 567
 568
 569 /**
 570  * Main function that will be run.
 571  *
 572  * @param cls closure
 573  * @param args remaining command-line arguments
 574  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 575  * @param c configuration
 576  */
 577 static void
 578 run (void *cls,
 579      char *const *args,
 580      const char *cfgfile,
 581      const struct GNUNET_CONFIGURATION_Handle *c)
 582 {
 583   (void) cls;
 584   (void) args;
 585   (void) cfgfile;
 586   cfg = c;
 587   if (NULL == dns_ip)
 588   {
 589     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 590                 _("No DNS server specified!\n"));
 591     return;
 592   }
 593   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
 594                                  NULL);
 595   if (NULL == (gns = GNUNET_GNS_connect (cfg)))
 596     return;
 597   if (NULL == (dns_stub = GNUNET_DNSSTUB_start (dns_ip)))
 598   {
 599     GNUNET_GNS_disconnect (gns);
 600     gns = NULL;
 601     return;
 602   }
 603   listen_socket4 = GNUNET_NETWORK_socket_create (PF_INET,
 604                                                  SOCK_DGRAM,
 605                                                  IPPROTO_UDP);
 606   if (NULL != listen_socket4)
 607   {
 608     struct sockaddr_in v4;
 609
 610     memset (&v4, 0, sizeof (v4));
 611     v4.sin_family = AF_INET;
 612 #if HAVE_SOCKADDR_IN_SIN_LEN
 613     v4.sin_len = sizeof (v4);
 614 #endif
 615     v4.sin_port = htons (listen_port);
 616     if (GNUNET_OK !=
 617         GNUNET_NETWORK_socket_bind (listen_socket4,
 618                                     (struct sockaddr *) &v4,
 619                                     sizeof (v4)))
 620     {
 621       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 622       GNUNET_NETWORK_socket_close (listen_socket4);
 623       listen_socket4 = NULL;
 624     }
 625   }
 626   listen_socket6 = GNUNET_NETWORK_socket_create (PF_INET6,
 627                                                 SOCK_DGRAM,
 628                                                 IPPROTO_UDP);
 629   if (NULL != listen_socket6)
 630   {
 631     struct sockaddr_in6 v6;
 632
 633     memset (&v6, 0, sizeof (v6));
 634     v6.sin6_family = AF_INET6;
 635 #if HAVE_SOCKADDR_IN_SIN_LEN
 636     v6.sin6_len = sizeof (v6);
 637 #endif
 638     v6.sin6_port = htons (listen_port);
 639     if (GNUNET_OK !=
 640         GNUNET_NETWORK_socket_bind (listen_socket6,
 641                                     (struct sockaddr *) &v6,
 642                                     sizeof (v6)))
 643     {
 644       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 645       GNUNET_NETWORK_socket_close (listen_socket6);
 646       listen_socket6 = NULL;
 647     }
 648   }
 649   if ( (NULL == listen_socket4) &&
 650        (NULL == listen_socket6) )
 651   {
 652     GNUNET_GNS_disconnect (gns);
 653     gns = NULL;
 654     GNUNET_DNSSTUB_stop (dns_stub);
 655     dns_stub = NULL;
 656     return;
 657   }
 658   if (NULL != listen_socket4)
 659     t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 660                                         listen_socket4,
 661                                         &read_dns4,
 662                                         listen_socket4);
 663   if (NULL != listen_socket6)
 664     t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 665                                         listen_socket6,
 666                                         &read_dns6,
 667                                         listen_socket6);
 668 }
 669
 670
 671 /**
 672  * The main function for the dns2gns daemon.
 673  *
 674  * @param argc number of arguments from the command line
 675  * @param argv command line arguments
 676  * @return 0 ok, 1 on error
 677  */
 678 int
 679 main (int argc,
 680       char *const *argv)
 681 {
 682   struct GNUNET_GETOPT_CommandLineOption options[] = {
 683     GNUNET_GETOPT_option_string ('d',
 684                                  "dns",
 685                                  "IP",
 686                                  gettext_noop ("IP of recursive DNS resolver to use (required)"),
 687                                  &dns_ip),
 688     GNUNET_GETOPT_option_uint ('p',
 689                                "port",
 690                                "UDPPORT",
 691                                gettext_noop ("UDP port to listen on for inbound DNS requests; default: 2853"),
 692                                &listen_port),
 693     GNUNET_GETOPT_OPTION_END
 694   };
 695   int ret;
 696
 697   if (GNUNET_OK !=
 698       GNUNET_STRINGS_get_utf8_args (argc, argv,
 699                                     &argc, &argv))
 700     return 2;
 701   GNUNET_log_setup ("gnunet-dns2gns",
 702                     "WARNING",
 703                     NULL);
 704   ret =
 705       (GNUNET_OK ==
 706        GNUNET_PROGRAM_run (argc, argv,
 707                            "gnunet-dns2gns",
 708                            _("GNUnet DNS-to-GNS proxy (a DNS server)"),
 709                            options,
 710                            &run, NULL)) ? 0 : 1;
 711   GNUNET_free ((void*) argv);
 712   return ret;
 713 }
 714
 715 /* end of gnunet-dns2gns.c */