src/gns/gnunet-service-gns.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
   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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  *
  23  * TODO:
  24  *    - Write xquery and block plugin
  25  *    - The smaller FIXME issues all around
  26  *
  27  * @file gns/gnunet-service-gns.c
  28  * @brief GNUnet GNS service
  29  * @author Martin Schanzenbach
  30  */
  31 #include "platform.h"
  32 #include "gnunet_util_lib.h"
  33 #include "gnunet_transport_service.h"
  34 #include "gnunet_dns_service.h"
  35 #include "gnunet_dnsparser_lib.h"
  36 #include "gnunet_dht_service.h"
  37 #include "gnunet_namestore_service.h"
  38 #include "gnunet_gns_service.h"
  39 #include "block_gns.h"
  40 #include "gns.h"
  41
  42 #define DHT_OPERATION_TIMEOUT  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  43 #define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT
  44 #define DHT_GNS_REPLICATION_LEVEL 5
  45
  46 /* Ignore for now not used anyway and probably never will */
  47 #define GNUNET_MESSAGE_TYPE_GNS_CLIENT_LOOKUP 23
  48 #define GNUNET_MESSAGE_TYPE_GNS_CLIENT_RESULT 24
  49
  50 /**
  51  * Handle to a currenty pending resolution
  52  */
  53 struct GNUNET_GNS_ResolverHandle
  54 {
  55   /* The name to resolve */
  56   char *name;
  57
  58   /* the request handle to reply to */
  59   struct GNUNET_DNS_RequestHandle *request_handle;
  60
  61   /* the dns parser packet received */
  62   struct GNUNET_DNSPARSER_Packet *packet;
  63
  64   /* the query parsed from the packet */
  65
  66   struct GNUNET_DNSPARSER_Query *query;
  67
  68   /* has this query been answered? how many matches */
  69   int answered;
  70
  71   /* the authoritative zone to query */
  72   GNUNET_HashCode authority;
  73
  74   /* the name of the authoritative zone to query */
  75   char *authority_name;
  76
  77   /**
  78    * we have an authority in namestore that
  79    * may be able to resolve
  80    */
  81   int authority_found;
  82
  83   /* a handle for dht lookups. should be NULL if no lookups are in progress */
  84   struct GNUNET_DHT_GetHandle *get_handle;
  85
  86   /* timeout task for dht lookups */
  87   GNUNET_SCHEDULER_TaskIdentifier dht_timeout_task;
  88
  89 };
  90
  91
  92 /**
  93  * Our handle to the DNS handler library
  94  */
  95 struct GNUNET_DNS_Handle *dns_handle;
  96
  97 /**
  98  * Our handle to the DHT
  99  */
 100 struct GNUNET_DHT_Handle *dht_handle;
 101
 102 /**
 103  * Our zone's private key
 104  */
 105 struct GNUNET_CRYPTO_RsaPrivateKey *zone_key;
 106
 107 /**
 108  * Our handle to the namestore service
 109  * FIXME maybe need a second handle for iteration
 110  */
 111 struct GNUNET_NAMESTORE_Handle *namestore_handle;
 112
 113 /**
 114  * Handle to iterate over our authoritative zone in namestore
 115  */
 116 struct GNUNET_NAMESTORE_ZoneIterator *namestore_iter;
 117
 118 /**
 119  * The configuration the GNS service is running with
 120  */
 121 const struct GNUNET_CONFIGURATION_Handle *GNS_cfg;
 122
 123 /**
 124  * Our notification context.
 125  */
 126 static struct GNUNET_SERVER_NotificationContext *nc;
 127
 128 /**
 129  * Our zone hash
 130  */
 131 GNUNET_HashCode zone_hash;
 132
 133 /**
 134  * Our tld. Maybe get from config file
 135  */
 136 const char* gnunet_tld = ".gnunet";
 137
 138 /**
 139  * Useful for zone update for DHT put
 140  */
 141 static int num_public_records =  3600;
 142 struct GNUNET_TIME_Relative dht_update_interval;
 143 GNUNET_SCHEDULER_TaskIdentifier zone_update_taskid = GNUNET_SCHEDULER_NO_TASK;
 144
 145 /* Prototypes */
 146 static void reply_to_dns(struct GNUNET_GNS_ResolverHandle *answer,
 147                          uint32_t rd_count,
 148                          const struct GNUNET_NAMESTORE_RecordData *rd);
 149 static void resolve_name(struct GNUNET_GNS_ResolverHandle *rh);
 150
 151 /**
 152  * Task run during shutdown.
 153  *
 154  * @param cls unused
 155  * @param tc unused
 156  */
 157 static void
 158 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 159 {
 160   /* Kill zone task for it may make the scheduler hang */
 161   if (zone_update_taskid)
 162     GNUNET_SCHEDULER_cancel(zone_update_taskid);
 163
 164   GNUNET_DNS_disconnect(dns_handle);
 165   GNUNET_NAMESTORE_disconnect(namestore_handle, 1);
 166   GNUNET_DHT_disconnect(dht_handle);
 167 }
 168
 169 /**
 170  * Callback when record data is put into namestore
 171  *
 172  * @param cls the closure
 173  * @param success GNUNET_OK on success
 174  * @param emsg the error message. NULL if SUCCESS==GNUNET_OK
 175  */
 176 void
 177 on_namestore_record_put_result(void *cls,
 178                                int32_t success,
 179                                const char *emsg)
 180 {
 181   if (GNUNET_NO == success)
 182   {
 183     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "records already in namestore\n");
 184     return;
 185   }
 186   else if (GNUNET_YES == success)
 187   {
 188     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 189                "records successfully put in namestore\n");
 190     return;
 191   }
 192
 193   GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 194              "Error putting records into namestore: %s\n", emsg);
 195 }
 196
 197 /**
 198  * Handle timeout for DHT requests
 199  *
 200  * @param cls the request handle as closure
 201  * @param tc the task context
 202  */
 203 static void
 204 dht_lookup_timeout(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 205 {
 206   struct GNUNET_GNS_ResolverHandle *rh = cls;
 207
 208   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 209              "dht lookup for query %s (type=%d) timed out.\n",
 210              rh->name, rh->query->type);
 211
 212   GNUNET_DHT_get_stop (rh->get_handle);
 213   reply_to_dns(rh, 0, NULL);
 214 }
 215
 216 /**
 217  * Function called when we get a result from the dht
 218  * for our query
 219  *
 220  * @param cls the request handle
 221  * @param exp lifetime
 222  * @param key the key the record was stored under
 223  * @param get_path get path
 224  * @param get_path_length get path length
 225  * @param put_path put path
 226  * @param put_path_length put path length
 227  * @param type the block type
 228  * @param size the size of the record
 229  * @param data the record data
 230  */
 231 static void
 232 process_authority_dht_result(void* cls,
 233                  struct GNUNET_TIME_Absolute exp,
 234                  const GNUNET_HashCode * key,
 235                  const struct GNUNET_PeerIdentity *get_path,
 236                  unsigned int get_path_length,
 237                  const struct GNUNET_PeerIdentity *put_path,
 238                  unsigned int put_path_length,
 239                  enum GNUNET_BLOCK_Type type,
 240                  size_t size, const void *data)
 241 {
 242   struct GNUNET_GNS_ResolverHandle *rh;
 243   struct GNSNameRecordBlock *nrb;
 244   uint32_t num_records;
 245   char* name = NULL;
 246   char* rd_data = (char*) data;
 247   int i;
 248   int rd_size;
 249   GNUNET_HashCode zone, name_hash;
 250
 251   if (data == NULL)
 252     return;
 253
 254   //FIXME check expiration?
 255
 256   rh = (struct GNUNET_GNS_ResolverHandle *)cls;
 257   nrb = (struct GNSNameRecordBlock*)data;
 258
 259   /* stop dht lookup and timeout task */
 260   GNUNET_DHT_get_stop (rh->get_handle);
 261   GNUNET_SCHEDULER_cancel(rh->dht_timeout_task);
 262
 263   rh->get_handle = NULL;
 264   num_records = ntohl(nrb->rd_count);
 265   name = (char*)&nrb[1];
 266   {
 267     struct GNUNET_NAMESTORE_RecordData rd[num_records];
 268
 269     rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock);
 270     rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock);
 271
 272     if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
 273                                                                rd_data,
 274                                                                num_records,
 275                                                                rd))
 276     {
 277       GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error deserializing data!\n");
 278       return;
 279     }
 280
 281     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 282                "Got name: %s (wanted %s)\n", name, rh->authority_name);
 283     for (i=0; i<num_records; i++)
 284     {
 285
 286       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 287                 "Got name: %s (wanted %s)\n", name, rh->authority_name);
 288       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 289                  "Got type: %d (wanted %d)\n",
 290                  rd[i].record_type, GNUNET_GNS_RECORD_PKEY);
 291       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 292                  "Got data length: %d\n", rd[i].data_size);
 293       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 294                  "Got flag %d\n", rd[i].flags);
 295
 296       if ((strcmp(name, rh->authority_name) == 0) &&
 297           (rd[i].record_type == GNUNET_GNS_RECORD_PKEY))
 298       {
 299         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Authority found in DHT\n");
 300         rh->answered = 1;
 301         GNUNET_CRYPTO_hash(
 302                    (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *)rd[i].data,
 303                    rd[i].data_size,
 304                    &rh->authority);
 305       }
 306
 307     }
 308
 309
 310     GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
 311     GNUNET_CRYPTO_hash_xor(key, &name_hash, &zone);
 312
 313     /* Save to namestore */
 314     if (0 == GNUNET_CRYPTO_hash_cmp(&zone_hash, &zone))
 315     {
 316       GNUNET_NAMESTORE_record_put (namestore_handle,
 317                                  &nrb->public_key,
 318                                  name,
 319                                  exp,
 320                                  num_records,
 321                                  rd,
 322                                  &nrb->signature,
 323                                  &on_namestore_record_put_result, //cont
 324                                  NULL); //cls
 325     }
 326   }
 327
 328   if (rh->answered)
 329   {
 330     rh->answered = 0;
 331     resolve_name(rh);
 332     return;
 333   }
 334   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "No authority in records\n");
 335   reply_to_dns(rh, 0, NULL);
 336 }
 337
 338 /**
 339  * Start DHT lookup for a name -> PKEY (compare NS) record in
 340  * query->authority's zone
 341  *
 342  * @param rh the pending gns query
 343  * @param name the name of the PKEY record
 344  */
 345 static void
 346 resolve_authority_dht(struct GNUNET_GNS_ResolverHandle *rh)
 347 {
 348   uint32_t xquery;
 349   GNUNET_HashCode name_hash;
 350   GNUNET_HashCode lookup_key;
 351
 352   GNUNET_CRYPTO_hash(rh->authority_name,
 353                      strlen(rh->authority_name),
 354                      &name_hash);
 355   GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key);
 356
 357   rh->dht_timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
 358                                                        &dht_lookup_timeout, rh);
 359
 360   xquery = htonl(GNUNET_GNS_RECORD_PKEY);
 361   //FIXME how long to wait for results?
 362   rh->get_handle = GNUNET_DHT_get_start(dht_handle,
 363                        DHT_OPERATION_TIMEOUT,
 364                        GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
 365                        &lookup_key,
 366                        DHT_GNS_REPLICATION_LEVEL,
 367                        GNUNET_DHT_RO_NONE,
 368                        &xquery,
 369                        sizeof(xquery),
 370                        &process_authority_dht_result,
 371                        rh);
 372
 373 }
 374
 375 /**
 376  * Function called when we get a result from the dht
 377  * for our query
 378  *
 379  * @param cls the request handle
 380  * @param exp lifetime
 381  * @param key the key the record was stored under
 382  * @param get_path get path
 383  * @param get_path_length get path length
 384  * @param put_path put path
 385  * @param put_path_length put path length
 386  * @param type the block type
 387  * @param size the size of the record
 388  * @param data the record data
 389  */
 390 static void
 391 process_name_dht_result(void* cls,
 392                  struct GNUNET_TIME_Absolute exp,
 393                  const GNUNET_HashCode * key,
 394                  const struct GNUNET_PeerIdentity *get_path,
 395                  unsigned int get_path_length,
 396                  const struct GNUNET_PeerIdentity *put_path,
 397                  unsigned int put_path_length,
 398                  enum GNUNET_BLOCK_Type type,
 399                  size_t size, const void *data)
 400 {
 401   struct GNUNET_GNS_ResolverHandle *rh;
 402   struct GNSNameRecordBlock *nrb;
 403   uint32_t num_records;
 404   char* name = NULL;
 405   char* rd_data = (char*)data;
 406   int i;
 407   int rd_size;
 408
 409   GNUNET_HashCode zone, name_hash;
 410   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "got dht result (size=%d)\n", size);
 411
 412   if (data == NULL)
 413     return;
 414
 415   //FIXME maybe check expiration here, check block type
 416
 417   rh = (struct GNUNET_GNS_ResolverHandle *)cls;
 418   nrb = (struct GNSNameRecordBlock*)data;
 419
 420   /* stop lookup and timeout task */
 421   GNUNET_DHT_get_stop (rh->get_handle);
 422   GNUNET_SCHEDULER_cancel(rh->dht_timeout_task);
 423
 424   rh->get_handle = NULL;
 425   name = (char*)&nrb[1];
 426   num_records = ntohl(nrb->rd_count);
 427   {
 428     struct GNUNET_NAMESTORE_RecordData rd[num_records];
 429
 430     rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock);
 431     rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock);
 432
 433     if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
 434                                                                rd_data,
 435                                                                num_records,
 436                                                                rd))
 437     {
 438       GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error deserializing data!\n");
 439       return;
 440     }
 441
 442     for (i=0; i<num_records; i++)
 443     {
 444       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 445                "Got name: %s (wanted %s)\n", name, rh->name);
 446       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 447                "Got type: %d (wanted %d)\n",
 448                rd[i].record_type, rh->query->type);
 449       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 450                "Got data length: %d\n", rd[i].data_size);
 451       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 452                "Got flag %d\n", rd[i].flags);
 453
 454      if ((strcmp(name, rh->name) == 0) &&
 455          (rd[i].record_type == rh->query->type))
 456       {
 457         rh->answered++;
 458       }
 459
 460     }
 461
 462     GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
 463     GNUNET_CRYPTO_hash_xor(key, &name_hash, &zone);
 464
 465     /**
 466      * FIXME check pubkey against existing key in namestore?
 467      * https://gnunet.org/bugs/view.php?id=2179
 468      */
 469
 470     /* Save to namestore */
 471     GNUNET_NAMESTORE_record_put (namestore_handle,
 472                                  &nrb->public_key,
 473                                  name,
 474                                  exp,
 475                                  num_records,
 476                                  rd,
 477                                  &nrb->signature,
 478                                  &on_namestore_record_put_result, //cont
 479                                  NULL); //cls
 480
 481     if (rh->answered)
 482       reply_to_dns(rh, num_records, rd);
 483     else
 484       reply_to_dns(rh, 0, NULL);
 485   }
 486
 487 }
 488
 489
 490
 491
 492 /**
 493  * Start DHT lookup for a (name -> query->record_type) record in
 494  * query->authority's zone
 495  *
 496  * @param rh the pending gns query context
 497  * @param name the name to query record
 498  */
 499 static void
 500 resolve_name_dht(struct GNUNET_GNS_ResolverHandle *rh, const char* name)
 501 {
 502   uint32_t xquery;
 503   GNUNET_HashCode name_hash;
 504   GNUNET_HashCode lookup_key;
 505   struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string;
 506
 507   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 508              "A\n");
 509
 510   GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
 511   GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key);
 512   GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string);
 513
 514   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 515              "starting dht lookup for %s with key: %s\n",
 516              name, (char*)&lookup_key_string);
 517
 518   rh->dht_timeout_task = GNUNET_SCHEDULER_add_delayed(DHT_LOOKUP_TIMEOUT,
 519                                                       &dht_lookup_timeout, rh);
 520
 521   xquery = htonl(rh->query->type);
 522   //FIXME how long to wait for results?
 523   rh->get_handle = GNUNET_DHT_get_start(dht_handle,
 524                        DHT_OPERATION_TIMEOUT,
 525                        GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
 526                        &lookup_key,
 527                        DHT_GNS_REPLICATION_LEVEL,
 528                        GNUNET_DHT_RO_NONE,
 529                        &xquery,
 530                        sizeof(xquery),
 531                        &process_name_dht_result,
 532                        rh);
 533
 534 }
 535
 536 //Prototype
 537 static void
 538 resolve_name(struct GNUNET_GNS_ResolverHandle *rh);
 539
 540 /**
 541  * This is a callback function that should give us only PKEY
 542  * records. Used to query the namestore for the authority (PKEY)
 543  * for 'name'
 544  *
 545  * @param cls the pending query
 546  * @param key the key of the zone we did the lookup
 547  * @param expiration expiration date of the record data set in the namestore
 548  * @param name the name for which we need an authority
 549  * @param rd_count the number of records with 'name'
 550  * @param rd the record data
 551  * @param signature the signature of the authority for the record data
 552  */
 553 static void
 554 process_authority_lookup(void* cls,
 555                    const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
 556                    struct GNUNET_TIME_Absolute expiration,
 557                    const char *name,
 558                    unsigned int rd_count,
 559                    const struct GNUNET_NAMESTORE_RecordData *rd,
 560                    const struct GNUNET_CRYPTO_RsaSignature *signature)
 561 {
 562   struct GNUNET_GNS_ResolverHandle *rh;
 563   struct GNUNET_TIME_Relative remaining_time;
 564   GNUNET_HashCode zone;
 565
 566   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got %d records from authority lookup\n",
 567              rd_count);
 568
 569   rh = (struct GNUNET_GNS_ResolverHandle *)cls;
 570   GNUNET_CRYPTO_hash(key,
 571                      sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 572                      &zone);
 573   remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
 574
 575   /**
 576    * No authority found in namestore.
 577    */
 578   if (rd_count == 0)
 579   {
 580     /**
 581      * We did not find an authority in the namestore
 582      * _IF_ the current authoritative zone is us we cannot resolve
 583      * _ELSE_ we can still check the _expired_ dht
 584      */
 585     if ((0 != GNUNET_CRYPTO_hash_cmp(&rh->authority, &zone_hash)) &&
 586         (remaining_time.rel_value == 0))
 587     {
 588       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 589                  "Authority %s unknown in namestore, trying dht\n",
 590                  rh->authority_name);
 591       resolve_authority_dht(rh);
 592       return;
 593     }
 594     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Authority %s unknown\n",
 595                rh->authority_name);
 596     reply_to_dns(rh, 0, NULL);
 597     return;
 598   }
 599
 600   //Note only 1 pkey should have been returned.. anything else would be strange
 601   /**
 602    * We found an authority that may be able to help us
 603    * move on with query
 604    */
 605   int i;
 606   for (i=0; i<rd_count;i++)
 607   {
 608
 609     if (rd[i].record_type != GNUNET_GNS_RECORD_PKEY)
 610       continue;
 611
 612     if ((GNUNET_TIME_absolute_get_remaining (rd[i].expiration)).rel_value
 613          == 0)
 614     {
 615       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "This pkey is expired.\n");
 616       if (remaining_time.rel_value == 0)
 617       {
 618         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 619                    "This dht entry is expired. Refreshing\n");
 620         resolve_authority_dht(rh);
 621       }
 622
 623       continue;
 624     }
 625
 626     /**
 627      * Resolve rest of query with new authority
 628      */
 629     GNUNET_assert(rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
 630     GNUNET_CRYPTO_hash(rd[i].data,
 631                        sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 632                        &rh->authority);
 633     resolve_name(rh);
 634     return;
 635   }
 636
 637   /**
 638    * no answers found
 639    */
 640   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 641              "Authority lookup successful but no PKEY... never get here\n");
 642   reply_to_dns(rh, 0, NULL);
 643 }
 644
 645
 646 /**
 647  * Reply to client with the result from our lookup.
 648  *
 649  * @param rh the request handle of the lookup
 650  * @param rd_count the number of records to return
 651  * @param rd the record data
 652  */
 653 static void
 654 reply_to_dns(struct GNUNET_GNS_ResolverHandle *rh, uint32_t rd_count,
 655              const struct GNUNET_NAMESTORE_RecordData *rd)
 656 {
 657   int i;
 658   size_t len;
 659   int ret;
 660   char *buf;
 661   struct GNUNET_DNSPARSER_Packet *packet = rh->packet;
 662   struct GNUNET_DNSPARSER_Record answer_records[rh->answered];
 663   struct GNUNET_DNSPARSER_Record additional_records[rd_count-(rh->answered)];
 664   packet->answers = answer_records;
 665   packet->additional_records = additional_records;
 666
 667   /**
 668    * Put records in the DNS packet and modify it
 669    * to a response
 670    */
 671   len = sizeof(struct GNUNET_DNSPARSER_Record*);
 672   for (i=0; i < rd_count; i++)
 673   {
 674
 675     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 676                "Adding type %d to DNS response\n", rd[i].record_type);
 677     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Name: %s\n", rh->name);
 678     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "QName: %s\n", rh->query->name);
 679     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Record %d/%d\n", i+1, rd_count);
 680     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Record len %d\n", rd[i].data_size);
 681
 682     if (rd[i].record_type == rh->query->type)
 683     {
 684       answer_records[i].name = rh->query->name;
 685       answer_records[i].type = rd[i].record_type;
 686       answer_records[i].data.raw.data_len = rd[i].data_size;
 687       answer_records[i].data.raw.data = (char*)rd[i].data;
 688       answer_records[i].expiration_time = rd[i].expiration;
 689       answer_records[i].class = GNUNET_DNSPARSER_CLASS_INTERNET;//hmmn
 690     }
 691     else
 692     {
 693       additional_records[i].name = rh->query->name;
 694       additional_records[i].type = rd[i].record_type;
 695       additional_records[i].data.raw.data_len = rd[i].data_size;
 696       additional_records[i].data.raw.data = (char*)rd[i].data;
 697       additional_records[i].expiration_time = rd[i].expiration;
 698       additional_records[i].class = GNUNET_DNSPARSER_CLASS_INTERNET;//hmmn
 699     }
 700   }
 701
 702   packet->num_answers = rh->answered;
 703   packet->num_additional_records = rd_count-(rh->answered);
 704
 705   if (0 == GNUNET_CRYPTO_hash_cmp(&rh->authority, &zone_hash))
 706     packet->flags.authoritative_answer = 1;
 707   else
 708     packet->flags.authoritative_answer = 0;
 709
 710   if (rd == NULL)
 711     packet->flags.return_code = GNUNET_DNSPARSER_RETURN_CODE_NAME_ERROR;
 712   else
 713     packet->flags.return_code = GNUNET_DNSPARSER_RETURN_CODE_NO_ERROR;
 714
 715   packet->flags.query_or_response = 1;
 716
 717
 718   /**
 719    * Reply to DNS
 720    */
 721   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 722              "Building DNS response\n");
 723   ret = GNUNET_DNSPARSER_pack (packet,
 724                                1024, /* FIXME magic from dns redirector */
 725                                &buf,
 726                                &len);
 727   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 728              "Built DNS response! (ret=%d,len=%d)\n", ret, len);
 729   if (ret == GNUNET_OK)
 730   {
 731     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 732                "Answering DNS request\n");
 733     GNUNET_DNS_request_answer(rh->request_handle,
 734                               len,
 735                               buf);
 736     //GNUNET_free(answer);
 737     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Answered DNS request\n");
 738   }
 739   else
 740   {
 741     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 742                "Error building DNS response! (ret=%d)", ret);
 743   }
 744
 745   GNUNET_free(rh->name);
 746   GNUNET_free(rh);
 747 }
 748
 749
 750 /**
 751  * Namestore calls this function if we have record for this name.
 752  * (or with rd_count=0 to indicate no matches)
 753  *
 754  * @param cls the pending query
 755  * @param key the key of the zone we did the lookup
 756  * @param expiration expiration date of the namestore entry
 757  * @param name the name for which we need an authority
 758  * @param rd_count the number of records with 'name'
 759  * @param rd the record data
 760  * @param signature the signature of the authority for the record data
 761  */
 762 static void
 763 process_authoritative_result(void* cls,
 764                   const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
 765                   struct GNUNET_TIME_Absolute expiration,
 766                   const char *name, unsigned int rd_count,
 767                   const struct GNUNET_NAMESTORE_RecordData *rd,
 768                   const struct GNUNET_CRYPTO_RsaSignature *signature)
 769 {
 770   struct GNUNET_GNS_ResolverHandle *rh;
 771   struct GNUNET_TIME_Relative remaining_time;
 772   GNUNET_HashCode zone;
 773
 774   rh = (struct GNUNET_GNS_ResolverHandle *) cls;
 775   GNUNET_CRYPTO_hash(key,
 776                      sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 777                      &zone);
 778   remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
 779
 780   if (rd_count == 0)
 781   {
 782     /**
 783      * Lookup terminated and no results
 784      * -> DHT Phase unless data is recent
 785      */
 786     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 787                "Namestore lookup for %s terminated without results\n", name);
 788
 789     /**
 790      * if this is not our zone we cannot rely on the namestore to be
 791      * complete. -> Query DHT
 792      */
 793     if (GNUNET_CRYPTO_hash_cmp(&zone, &zone_hash))
 794     {
 795       if (remaining_time.rel_value == 0)
 796       {
 797         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 798                    "trying dht...\n");
 799         resolve_name_dht(rh, rh->name);
 800         return;
 801       }
 802       else
 803       {
 804         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 805                    "Record is still recent. No DHT lookup\n");
 806       }
 807     }
 808
 809     /**
 810      * Our zone and no result? Cannot resolve TT
 811      */
 812     GNUNET_assert(rh->answered == 0);
 813     reply_to_dns(rh, 0, NULL);
 814     return;
 815
 816   }
 817   else
 818   {
 819
 820     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 821                "Processing additional result %s from namestore\n", name);
 822     int i;
 823     for (i=0; i<rd_count;i++)
 824     {
 825
 826       if ((strcmp(name, rh->query->name) == 0)
 827           && (rd[i].record_type != rh->query->type))
 828         continue;
 829
 830       if ((GNUNET_TIME_absolute_get_remaining (rd[i].expiration)).rel_value
 831           == 0)
 832       {
 833         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "This record is expired. Skipping\n");
 834         continue;
 835       }
 836
 837       rh->answered++;
 838
 839     }
 840
 841     /**
 842      * no answers found
 843      * consult dht if expired
 844      */
 845     if ((remaining_time.rel_value == 0) && (rh->answered == 0))
 846     {
 847       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 848                  "This dht entry is old. Refreshing.\n");
 849       resolve_name_dht(rh, name);
 850       return;
 851     }
 852
 853     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found %d answer(s) to query!\n",
 854                rh->answered);
 855
 856     reply_to_dns(rh, rd_count, rd);
 857   }
 858 }
 859
 860 /**
 861  * Determine if this name is canonical.
 862  * i.e.
 863  * a.b.gnunet  = not canonical
 864  * a           = canonical
 865  *
 866  * @param name the name to test
 867  * @return 1 if canonical
 868  */
 869 static int
 870 is_canonical(char* name)
 871 {
 872   uint32_t len = strlen(name);
 873   int i;
 874
 875   for (i=0; i<len; i++)
 876   {
 877     if (*(name+i) == '.')
 878       return 0;
 879   }
 880   return 1;
 881 }
 882
 883 /**
 884  * Move one level up in the domain hierarchy and return the
 885  * passed top level domain.
 886  *
 887  * @param name the domain
 888  * @return the tld
 889  */
 890 static char*
 891 pop_tld(char* name)
 892 {
 893   uint32_t len;
 894
 895   if (is_canonical(name))
 896     return NULL;
 897
 898   for (len = strlen(name); len > 0; len--)
 899   {
 900     if (*(name+len) == '.')
 901       break;
 902   }
 903
 904   if (len == 0)
 905     return NULL;
 906
 907   name[len] = '\0';
 908
 909   return (name+len+1);
 910 }
 911
 912
 913 /**
 914  * The first phase of resolution.
 915  * First check if the name is canonical.
 916  * If it is then try to resolve directly.
 917  * If not then we first have to resolve the authoritative entities.
 918  *
 919  * @param rh the pending lookup
 920  */
 921 static void
 922 resolve_name(struct GNUNET_GNS_ResolverHandle *rh)
 923 {
 924   if (is_canonical(rh->name))
 925   {
 926     /* We only need to check the current zone's ns */
 927     GNUNET_NAMESTORE_lookup_record(namestore_handle,
 928                                &rh->authority,
 929                                rh->name,
 930                                rh->query->type,
 931                                &process_authoritative_result,
 932                                rh);
 933   }
 934   else
 935   {
 936     /* We have to resolve the authoritative entity first */
 937     rh->authority_name = pop_tld(rh->name);
 938     GNUNET_NAMESTORE_lookup_record(namestore_handle,
 939                                  &rh->authority,
 940                                  rh->authority_name,
 941                                  GNUNET_GNS_RECORD_PKEY,
 942                                  &process_authority_lookup,
 943                                  rh);
 944   }
 945 }
 946
 947 /**
 948  * Entry point for name resolution
 949  * Setup a new query and try to resolve
 950  *
 951  * @param request the request handle of the DNS request from a client
 952  * @param p the DNS query packet we received
 953  * @param q the DNS query we received parsed from p
 954  */
 955 static void
 956 start_resolution(struct GNUNET_DNS_RequestHandle *request,
 957                  struct GNUNET_DNSPARSER_Packet *p,
 958                  struct GNUNET_DNSPARSER_Query *q)
 959 {
 960   struct GNUNET_GNS_ResolverHandle *rh;
 961
 962   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 963               "Starting resolution for %s (type=%d)!\n",
 964               q->name, q->type);
 965
 966   rh = GNUNET_malloc(sizeof (struct GNUNET_GNS_ResolverHandle));
 967   rh->packet = p;
 968   rh->query = q;
 969   rh->authority = zone_hash;
 970
 971   rh->name = GNUNET_malloc(strlen(q->name)
 972                               - strlen(gnunet_tld) + 1);
 973   memset(rh->name, 0,
 974          strlen(q->name)-strlen(gnunet_tld) + 1);
 975   memcpy(rh->name, q->name,
 976          strlen(q->name)-strlen(gnunet_tld));
 977
 978   rh->request_handle = request;
 979
 980   /* Start resolution in our zone */
 981   resolve_name(rh);
 982 }
 983
 984 /**
 985  * The DNS request handler
 986  * Called for every incoming DNS request.
 987  *
 988  * @param cls closure
 989  * @param rh request handle to user for reply
 990  * @param request_length number of bytes in request
 991  * @param request udp payload of the DNS request
 992  */
 993 static void
 994 handle_dns_request(void *cls,
 995                    struct GNUNET_DNS_RequestHandle *rh,
 996                    size_t request_length,
 997                    const char *request)
 998 {
 999   struct GNUNET_DNSPARSER_Packet *p;
1000   char *tldoffset;
1001
1002   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hijacked a DNS request...processing\n");
1003   p = GNUNET_DNSPARSER_parse (request, request_length);
1004
1005   if (NULL == p)
1006   {
1007     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1008                 "Received malformed DNS packet, leaving it untouched\n");
1009     GNUNET_DNS_request_forward (rh);
1010     return;
1011   }
1012
1013   /**
1014    * Check tld and decide if we or
1015    * legacy dns is responsible
1016    *
1017    * FIXME now in theory there could be more than 1 query in the request
1018    * but if this is case we get into trouble:
1019    * either we query the GNS or the DNS. We cannot do both!
1020    * So I suggest to either only allow a single query per request or
1021    * only allow GNS or DNS requests.
1022    * The way it is implemented here now is buggy and will lead to erratic
1023    * behaviour (if multiple queries are present).
1024    */
1025   if (p->num_queries == 0)
1026   {
1027     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1028                 "No Queries in DNS packet... forwarding\n");
1029     GNUNET_DNS_request_forward (rh);
1030   }
1031
1032   if (p->num_queries > 1)
1033   {
1034     /* Note: We could also look for .gnunet */
1035     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1036                 ">1 queriy in DNS packet... odd. We only process #1\n");
1037   }
1038
1039
1040   /**
1041    * Check for .gnunet
1042    */
1043   tldoffset = p->queries[0].name + strlen(p->queries[0].name);
1044
1045   while ((*tldoffset) != '.')
1046     tldoffset--;
1047
1048   if (0 == strcmp(tldoffset, gnunet_tld))
1049   {
1050     start_resolution(rh, p, p->queries);
1051   }
1052   else
1053   {
1054     /**
1055      * This request does not concern us. Forward to real DNS.
1056      */
1057     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1058                "Request for %s is forwarded to DNS\n", p->queries[0].name);
1059     GNUNET_DNS_request_forward (rh);
1060   }
1061
1062 }
1063
1064 /**
1065  * test function that stores some data in the namestore
1066  * This will also be replaced by a test progrm that
1067  * directl interfaces with the namestore
1068  */
1069 static void
1070 put_some_records(void)
1071 {
1072   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Populating namestore\n");
1073   /* put an A record into namestore FIXME use gnunet.org */
1074   char* ipB = "5.6.7.8";
1075
1076   struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
1077   struct GNUNET_NAMESTORE_RecordData rdb_web;
1078
1079   GNUNET_assert(1 == inet_pton (AF_INET, ipB, web));
1080
1081   rdb_web.data_size = sizeof(struct in_addr);
1082   rdb_web.data = web;
1083   rdb_web.record_type = GNUNET_DNSPARSER_TYPE_A;
1084   rdb_web.expiration = GNUNET_TIME_absolute_get_forever ();
1085
1086   GNUNET_NAMESTORE_record_create (namestore_handle,
1087                                   zone_key,
1088                                   "www",
1089                                   &rdb_web,
1090                                   NULL,
1091                                   NULL);
1092 }
1093
1094 /**
1095  * Method called periodicattluy that triggers
1096  * iteration over root zone
1097  *
1098  * @param cls closure
1099  * @param tc task context
1100  */
1101 static void
1102 update_zone_dht_next(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1103 {
1104   GNUNET_NAMESTORE_zone_iterator_next(namestore_iter);
1105 }
1106
1107 /**
1108  * Continuation for DHT put
1109  *
1110  * @param cls closure
1111  * @param tc task context
1112  */
1113 static void
1114 record_dht_put(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1115 {
1116   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "put request transmitted\n");
1117 }
1118
1119 /* prototype */
1120 static void
1121 update_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
1122
1123 /**
1124  * Function used to put all records successively into the DHT.
1125  *
1126  * @param cls the closure (NULL)
1127  * @param key the public key of the authority (ours)
1128  * @param expiration lifetime of the namestore entry
1129  * @param name the name of the records
1130  * @param rd_count the number of records in data
1131  * @param rd the record data
1132  * @param signature the signature for the record data
1133  */
1134 static void
1135 put_gns_record(void *cls,
1136                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
1137                 struct GNUNET_TIME_Absolute expiration,
1138                 const char *name,
1139                 unsigned int rd_count,
1140                 const struct GNUNET_NAMESTORE_RecordData *rd,
1141                 const struct GNUNET_CRYPTO_RsaSignature *signature)
1142 {
1143
1144   struct GNSNameRecordBlock *nrb;
1145   GNUNET_HashCode name_hash;
1146   GNUNET_HashCode xor_hash;
1147   struct GNUNET_CRYPTO_HashAsciiEncoded xor_hash_string;
1148   uint32_t rd_payload_length;
1149   char* nrb_data = NULL;
1150
1151   /* we're done */
1152   if (NULL == name)
1153   {
1154     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Zone iteration finished\n");
1155     GNUNET_NAMESTORE_zone_iteration_stop (namestore_iter);
1156     zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_start,
1157                                                    NULL);
1158     return;
1159   }
1160
1161   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1162              "Putting records for %s into the DHT\n", name);
1163
1164   rd_payload_length = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
1165
1166   nrb = GNUNET_malloc(rd_payload_length + strlen(name) + 1
1167                       + sizeof(struct GNSNameRecordBlock));
1168
1169   if (signature != NULL)
1170     nrb->signature = *signature;
1171
1172   nrb->public_key = *key;
1173
1174   nrb->rd_count = htonl(rd_count);
1175
1176   memset(&nrb[1], 0, strlen(name) + 1);
1177   memcpy(&nrb[1], name, strlen(name));
1178
1179   nrb_data = (char*)&nrb[1];
1180   nrb_data += strlen(name) + 1;
1181
1182   rd_payload_length += sizeof(struct GNSNameRecordBlock) +
1183     strlen(name) + 1;
1184
1185   if (-1 == GNUNET_NAMESTORE_records_serialize (rd_count,
1186                                                 rd,
1187                                                 rd_payload_length,
1188                                                 nrb_data))
1189   {
1190     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Record serialization failed!\n");
1191     return;
1192     //FIXME what to do
1193   }
1194
1195
1196   /*
1197    * calculate DHT key: H(name) xor H(pubkey)
1198    */
1199   GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
1200   GNUNET_CRYPTO_hash_xor(&zone_hash, &name_hash, &xor_hash);
1201   GNUNET_CRYPTO_hash_to_enc (&xor_hash, &xor_hash_string);
1202   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1203              "putting records for %s under key: %s with size %d\n",
1204              name, (char*)&xor_hash_string, rd_payload_length);
1205
1206   GNUNET_DHT_put (dht_handle, &xor_hash,
1207                   DHT_GNS_REPLICATION_LEVEL,
1208                   GNUNET_DHT_RO_NONE,
1209                   GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
1210                   rd_payload_length,
1211                   (char*)nrb,
1212                   expiration,
1213                   DHT_OPERATION_TIMEOUT,
1214                   &record_dht_put,
1215                   NULL); //cls for cont
1216
1217   num_public_records++;
1218
1219   /**
1220    * Reschedule periodic put
1221    */
1222   zone_update_taskid = GNUNET_SCHEDULER_add_delayed (dht_update_interval,
1223                                 &update_zone_dht_next,
1224                                 NULL);
1225
1226 }
1227
1228 /**
1229  * Puts a single trusted entity into the
1230  * namestore. Will be replaced in a testcase
1231  * that directly interacts with a persistent
1232  * namestore.
1233  *
1234  * @param name name of entity
1235  * @param keyfile keyfile
1236  */
1237 static void
1238 put_trusted(char* name, char* keyfile)
1239 {
1240   struct GNUNET_NAMESTORE_RecordData rd;
1241   struct GNUNET_CRYPTO_RsaPrivateKey *key;
1242   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey;
1243   pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
1244
1245   key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
1246   GNUNET_CRYPTO_rsa_key_get_public (key, pkey);
1247   rd.data = pkey;
1248   rd.expiration = GNUNET_TIME_absolute_get_forever ();
1249   rd.data_size = sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);
1250   rd.record_type = GNUNET_GNS_RECORD_PKEY;
1251
1252   GNUNET_NAMESTORE_record_create (namestore_handle,
1253                                   zone_key,
1254                                   name,
1255                                   &rd,
1256                                   NULL,
1257                                   NULL);
1258 }
1259
1260
1261
1262 /**
1263  * Periodically iterate over our zone and store everything in dht
1264  *
1265  * @param cls NULL
1266  * @param tc task context
1267  */
1268 static void
1269 update_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1270 {
1271   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Starting DHT zone update!\n");
1272   if (0 == num_public_records)
1273   {
1274     dht_update_interval = GNUNET_TIME_relative_multiply(
1275                                                       GNUNET_TIME_UNIT_SECONDS,
1276                                                       1);
1277   }
1278   else
1279   {
1280     dht_update_interval = GNUNET_TIME_relative_multiply(
1281                                                       GNUNET_TIME_UNIT_SECONDS,
1282                                                      (3600/num_public_records));
1283   }
1284   num_public_records = 0; //start counting again
1285   namestore_iter = GNUNET_NAMESTORE_zone_iteration_start (namestore_handle,
1286                                                           &zone_hash,
1287                                                           GNUNET_NAMESTORE_RF_AUTHORITY,
1288                                                           GNUNET_NAMESTORE_RF_PRIVATE,
1289                                                           &put_gns_record,
1290                                                           NULL);
1291 }
1292
1293 /**
1294  * Process GNS requests.
1295  *
1296  * @param cls closure
1297  * @param server the initialized server
1298  * @param c configuration to use
1299  */
1300 static void
1301 run (void *cls, struct GNUNET_SERVER_Handle *server,
1302      const struct GNUNET_CONFIGURATION_Handle *c)
1303 {
1304
1305   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Initializing GNS\n");
1306
1307   char* keyfile;
1308   char* trusted_entities;
1309   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
1310
1311   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "gns",
1312                                              "ZONEKEY", &keyfile))
1313   {
1314     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1315                 "No private key for root zone specified%s!\n", keyfile);
1316     GNUNET_SCHEDULER_shutdown(0);
1317     return;
1318   }
1319
1320   zone_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
1321   GNUNET_CRYPTO_rsa_key_get_public (zone_key, &pkey);
1322
1323   GNUNET_CRYPTO_hash(&pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
1324                      &zone_hash);
1325
1326   nc = GNUNET_SERVER_notification_context_create (server, 1);
1327
1328   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
1329                                 NULL);
1330
1331   if (GNUNET_YES ==
1332       GNUNET_CONFIGURATION_get_value_yesno (c, "gns",
1333                                             "HIJACK_DNS"))
1334   {
1335     GNUNET_log(GNUNET_ERROR_TYPE_INFO,
1336                "DNS hijacking enabled... connecting to service.\n");
1337     /**
1338      * Do gnunet dns init here
1339      */
1340     dns_handle = GNUNET_DNS_connect(c,
1341                                     GNUNET_DNS_FLAG_PRE_RESOLUTION,
1342                                     &handle_dns_request, /* rh */
1343                                     NULL); /* Closure */
1344     if (NULL == dns_handle)
1345     {
1346       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
1347                "Failed to connect to the dnsservice!\n");
1348     }
1349   }
1350
1351
1352
1353   /**
1354    * handle to our local namestore
1355    */
1356   namestore_handle = GNUNET_NAMESTORE_connect(c);
1357
1358   if (NULL == namestore_handle)
1359   {
1360     //FIXME do error handling;
1361     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
1362                "Failed to connect to the namestore!\n");
1363     GNUNET_SCHEDULER_shutdown(0);
1364     return;
1365   }
1366
1367   /**
1368    * handle to the dht
1369    */
1370   dht_handle = GNUNET_DHT_connect(c, 1); //FIXME get ht_len from cfg
1371
1372   if (NULL == dht_handle)
1373   {
1374     GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Could not connect to DHT!\n");
1375   }
1376
1377   //put_some_records(); //FIXME for testing
1378
1379   /**
1380    * Schedule periodic put
1381    * for our records
1382    * We have roughly an hour for all records;
1383    */
1384   dht_update_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
1385                                                       1);
1386   //zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_start, NULL);
1387
1388 }
1389
1390
1391 /**
1392  * The main function for the GNS service.
1393  *
1394  * @param argc number of arguments from the command line
1395  * @param argv command line arguments
1396  * @return 0 ok, 1 on error
1397  */
1398 int
1399 main (int argc, char *const *argv)
1400 {
1401   int ret;
1402
1403   ret =
1404       (GNUNET_OK ==
1405        GNUNET_SERVICE_run (argc, argv, "gns", GNUNET_SERVICE_OPTION_NONE, &run,
1406                            NULL)) ? 0 : 1;
1407   return ret;
1408 }
1409
1410 /* end of gnunet-service-gns.c */