src/gns/gnunet-service-gns_resolver.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  *
  24  * @file gns/gnunet-service-gns_resolver.c
  25  * @brief GNUnet GNS resolver logic
  26  * @author Martin Schanzenbach
  27  */
  28 #include "platform.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_transport_service.h"
  31 #include "gnunet_dns_service.h"
  32 #include "gnunet_dht_service.h"
  33 #include "gnunet_namestore_service.h"
  34 #include "gnunet_dns_service.h"
  35 #include "gnunet_dnsparser_lib.h"
  36 #include "gnunet_gns_service.h"
  37 #include "block_gns.h"
  38 #include "gns.h"
  39 #include "gnunet-service-gns_resolver.h"
  40
  41 #define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT
  42 #define DHT_GNS_REPLICATION_LEVEL 5
  43 #define MAX_DNS_LABEL_LENGTH 63
  44
  45
  46 /**
  47  * Our handle to the namestore service
  48  */
  49 static struct GNUNET_NAMESTORE_Handle *namestore_handle;
  50
  51 /**
  52  * Resolver handle to the dht
  53  */
  54 static struct GNUNET_DHT_Handle *dht_handle;
  55
  56 /**
  57  * Heap for parallel DHT lookups
  58  */
  59 static struct GNUNET_CONTAINER_Heap *dht_lookup_heap;
  60
  61 /**
  62  * Maximum amount of parallel queries in background
  63  */
  64 static unsigned long long max_allowed_background_queries;
  65
  66 /**
  67  * Wheather or not to ignore pending records
  68  */
  69 static int ignore_pending_records;
  70
  71 /**
  72  * Our local zone
  73  */
  74 static struct GNUNET_CRYPTO_ShortHashCode local_zone;
  75
  76 /**
  77  * a resolution identifier pool variable
  78  * FIXME overflow?
  79  * This is a non critical identifier useful for debugging
  80  */
  81 static unsigned long long rid = 0;
  82
  83 /**
  84  * Namestore calls this function if we have record for this name.
  85  * (or with rd_count=0 to indicate no matches)
  86  *
  87  * @param cls the pending query
  88  * @param key the key of the zone we did the lookup
  89  * @param expiration expiration date of the namestore entry
  90  * @param name the name for which we need an authority
  91  * @param rd_count the number of records with 'name'
  92  * @param rd the record data
  93  * @param signature the signature of the authority for the record data
  94  */
  95 static void
  96 process_pseu_lookup_ns(void* cls,
  97                       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
  98                       struct GNUNET_TIME_Absolute expiration,
  99                       const char *name, unsigned int rd_count,
 100                       const struct GNUNET_NAMESTORE_RecordData *rd,
 101                       const struct GNUNET_CRYPTO_RsaSignature *signature)
 102 {
 103   struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
 104   struct GNUNET_NAMESTORE_RecordData new_pkey;
 105
 106   if (rd_count > 0)
 107   {
 108     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 109                "GNS_AUTO_PSEU: Name %s already taken in NS!\n", name);
 110     if (0 == strcmp(gph->name, name))
 111     {
 112       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 113                  "GNS_AUTO_PSEU: Intelligent replacement not implemented\n",
 114                  name);
 115       GNUNET_free(gph);
 116       return;
 117     }
 118
 119     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 120                "GNS_AUTO_PSEU: Trying delegated name %s\n", gph->name);
 121     memcpy(gph->new_name, gph->name, strlen(gph->name)+1);
 122     GNUNET_NAMESTORE_lookup_record(namestore_handle,
 123                                    &gph->zone,
 124                                    gph->new_name,
 125                                    GNUNET_NAMESTORE_TYPE_ANY,
 126                                    &process_pseu_lookup_ns,
 127                                    gph);
 128     return;
 129   }
 130
 131   /** name is free */
 132   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 133              "GNS_AUTO_PSEU: Name %s not taken in NS! Adding\n", gph->new_name);
 134
 135   new_pkey.expiration = GNUNET_TIME_absolute_get_forever ();
 136   new_pkey.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
 137   new_pkey.data = &gph->new_zone;
 138   new_pkey.record_type = GNUNET_GNS_RECORD_PKEY;
 139   new_pkey.flags = GNUNET_NAMESTORE_RF_AUTHORITY
 140                  | GNUNET_NAMESTORE_RF_PRIVATE
 141                  | GNUNET_NAMESTORE_RF_PENDING;
 142   GNUNET_NAMESTORE_record_create (namestore_handle,
 143                                   gph->key,
 144                                   gph->new_name,
 145                                   &new_pkey,
 146                                   NULL, //cont
 147                                   NULL); //cls
 148   GNUNET_free(gph);
 149
 150 }
 151
 152 /**
 153  * process result of a dht pseu lookup
 154  *
 155  * @param gph the handle
 156  * @param name the pseu result or NULL
 157  */
 158 static void
 159 process_pseu_result(struct GetPseuAuthorityHandle* gph, char* name)
 160 {
 161   if (NULL == name)
 162   {
 163     memcpy(gph->new_name, gph->name, strlen(gph->name)+1);
 164   }
 165   else
 166   {
 167     memcpy(gph->new_name, name, strlen(name)+1);
 168   }
 169
 170   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 171              "GNS_AUTO_PSEU: Checking %s for collision in NS\n", gph->new_name);
 172
 173   /**
 174    * Check for collision
 175    */
 176   GNUNET_NAMESTORE_lookup_record(namestore_handle,
 177                                  &gph->zone,
 178                                  gph->new_name,
 179                                  GNUNET_NAMESTORE_TYPE_ANY,
 180                                  &process_pseu_lookup_ns,
 181                                  gph);
 182 }
 183
 184 /**
 185  * Handle timeout for dht request
 186  *
 187  * @param cls the request handle as closure
 188  * @param tc the task context
 189  */
 190 static void
 191 handle_auth_discovery_timeout(void *cls,
 192                               const struct GNUNET_SCHEDULER_TaskContext *tc)
 193 {
 194   struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
 195
 196   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 197              "GNS_GET_AUTH: dht lookup for query PSEU timed out.\n");
 198   GNUNET_DHT_get_stop (gph->get_handle);
 199   gph->get_handle = NULL;
 200   process_pseu_result(gph, NULL);
 201 }
 202
 203 /**
 204  * Function called when we find a PSEU entry in the DHT
 205  *
 206  * @param cls the request handle
 207  * @param exp lifetime
 208  * @param key the key the record was stored under
 209  * @param get_path get path
 210  * @param get_path_length get path length
 211  * @param put_path put path
 212  * @param put_path_length put path length
 213  * @param type the block type
 214  * @param size the size of the record
 215  * @param data the record data
 216  */
 217 static void
 218 process_auth_discovery_dht_result(void* cls,
 219                                   struct GNUNET_TIME_Absolute exp,
 220                                   const GNUNET_HashCode * key,
 221                                   const struct GNUNET_PeerIdentity *get_path,
 222                                   unsigned int get_path_length,
 223                                   const struct GNUNET_PeerIdentity *put_path,
 224                                   unsigned int put_path_length,
 225                                   enum GNUNET_BLOCK_Type type,
 226                                   size_t size, const void *data)
 227 {
 228   struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
 229   struct GNSNameRecordBlock *nrb;
 230   char* rd_data = (char*)data;
 231   char* name;
 232   int num_records;
 233   size_t rd_size;
 234   int i;
 235
 236   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 237              "GNS_GET_AUTH: got dht result (size=%d)\n", size);
 238
 239   if (data == NULL)
 240   {
 241     GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 242                "GNS_GET_AUTH: got dht result null!\n", size);
 243     GNUNET_break(0);
 244     GNUNET_free(gph);
 245     return;
 246   }
 247
 248   nrb = (struct GNSNameRecordBlock*)data;
 249
 250   /* stop lookup and timeout task */
 251   GNUNET_DHT_get_stop (gph->get_handle);
 252   gph->get_handle = NULL;
 253   GNUNET_SCHEDULER_cancel(gph->timeout);
 254
 255   gph->get_handle = NULL;
 256
 257   nrb = (struct GNSNameRecordBlock*)data;
 258
 259   name = (char*)&nrb[1];
 260   num_records = ntohl(nrb->rd_count);
 261   {
 262     struct GNUNET_NAMESTORE_RecordData rd[num_records];
 263
 264     rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock);
 265     rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock);
 266
 267     if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
 268                                                                rd_data,
 269                                                                num_records,
 270                                                                rd))
 271     {
 272       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 273                  "GNS_GET_AUTH: Error deserializing data!\n");
 274       GNUNET_break(0);
 275       GNUNET_free(gph);
 276       return;
 277     }
 278
 279     for (i=0; i<num_records; i++)
 280     {
 281       if ((strcmp(name, "+") == 0) &&
 282           (rd[i].record_type == GNUNET_GNS_RECORD_PSEU))
 283       {
 284         /* found pseu */
 285         process_pseu_result(gph, (char*)rd[i].data);
 286         return;
 287       }
 288     }
 289   }
 290
 291   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: no pseu in dht!\n");
 292   process_pseu_result(gph, NULL);
 293 }
 294
 295 static void
 296 process_auth_discovery_ns_result(void* cls,
 297                       const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
 298                       struct GNUNET_TIME_Absolute expiration,
 299                       const char *name, unsigned int rd_count,
 300                       const struct GNUNET_NAMESTORE_RecordData *rd,
 301                       const struct GNUNET_CRYPTO_RsaSignature *signature)
 302 {
 303   uint32_t xquery;
 304   struct GNUNET_CRYPTO_ShortHashCode name_hash;
 305   GNUNET_HashCode lookup_key;
 306   struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string;
 307   GNUNET_HashCode name_hash_double;
 308   GNUNET_HashCode zone_hash_double;
 309   int i;
 310   struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
 311
 312   /* no pseu found */
 313   if (rd_count == 0)
 314   {
 315     /**
 316      * check dht
 317      */
 318     GNUNET_CRYPTO_short_hash("+", strlen("+"), &name_hash);
 319     GNUNET_CRYPTO_short_hash_double (&name_hash, &name_hash_double);
 320     GNUNET_CRYPTO_short_hash_double (&gph->new_zone, &zone_hash_double);
 321     GNUNET_CRYPTO_hash_xor(&name_hash_double, &zone_hash_double, &lookup_key);
 322     GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string);
 323
 324     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 325                "GNS_AUTO_PSEU: starting dht lookup for %s with key: %s\n",
 326                "+", (char*)&lookup_key_string);
 327
 328     gph->timeout = GNUNET_SCHEDULER_add_delayed(DHT_LOOKUP_TIMEOUT,
 329                                          &handle_auth_discovery_timeout, gph);
 330
 331     xquery = htonl(GNUNET_GNS_RECORD_PSEU);
 332
 333     GNUNET_assert(gph->get_handle == NULL);
 334     gph->get_handle = GNUNET_DHT_get_start(dht_handle,
 335                                            GNUNET_TIME_UNIT_FOREVER_REL,
 336                                            GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
 337                                            &lookup_key,
 338                                            DHT_GNS_REPLICATION_LEVEL,
 339                                            GNUNET_DHT_RO_NONE,
 340                                            &xquery,
 341                                            sizeof(xquery),
 342                                            &process_auth_discovery_dht_result,
 343                                            gph);
 344     return;
 345   }
 346   for (i=0; i<rd_count; i++)
 347   {
 348     if ((strcmp(name, "+") == 0) &&
 349         (rd[i].record_type == GNUNET_GNS_RECORD_PSEU))
 350     {
 351       /* found pseu */
 352       process_pseu_result(gph, (char*)rd[i].data);
 353       return;
 354     }
 355   }
 356 }
 357
 358 /**
 359  * Callback called by namestore for a zone to name
 360  * result
 361  *
 362  * @param cls the closure
 363  * @param zone_key the zone we queried
 364  * @param expire the expiration time of the name
 365  * @param name the name found or NULL
 366  * @param rd_len number of records for the name
 367  * @param rd the record data (PKEY) for the name
 368  * @param signature the signature for the record data
 369  */
 370 static void
 371 process_zone_to_name_discover(void *cls,
 372                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
 373                  struct GNUNET_TIME_Absolute expire,
 374                  const char *name,
 375                  unsigned int rd_len,
 376                  const struct GNUNET_NAMESTORE_RecordData *rd,
 377                  const struct GNUNET_CRYPTO_RsaSignature *signature)
 378 {
 379   struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
 380
 381   /* we found a match in our own zone */
 382   if (rd_len != 0)
 383   {
 384     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 385                "GNS_AUTO_PSEU: name for zone in our root %s\n", name);
 386     GNUNET_free(gph);
 387   }
 388   else
 389   {
 390
 391     GNUNET_NAMESTORE_lookup_record(namestore_handle,
 392                                    &gph->new_zone,
 393                                    "+",
 394                                    GNUNET_GNS_RECORD_PSEU,
 395                                    &process_auth_discovery_ns_result,
 396                                    gph);
 397   }
 398
 399
 400 }
 401
 402
 403 /**
 404  * Callback for new authories
 405  *
 406  * @param name the name given by delegation
 407  * @param zone the authority
 408  * @param our_zone our local zone
 409  * @param key the private key of our authority
 410  */
 411 static void process_discovered_authority(char* name,
 412                                     struct GNUNET_CRYPTO_ShortHashCode zone,
 413                                     struct GNUNET_CRYPTO_ShortHashCode our_zone,
 414                                     struct GNUNET_CRYPTO_RsaPrivateKey *key)
 415 {
 416   struct GetPseuAuthorityHandle *gph;
 417   size_t namelen;
 418
 419   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 420              "GNS_AUTO_PSEU: New authority %s discovered\n",
 421              name);
 422
 423   gph = GNUNET_malloc(sizeof(struct GetPseuAuthorityHandle));
 424   namelen = strlen(name) + 1;
 425   memcpy(gph->name, name, namelen);
 426
 427   gph->new_zone = zone;
 428   gph->zone = our_zone;
 429   gph->key = key;
 430
 431   GNUNET_NAMESTORE_zone_to_name (namestore_handle,
 432                                  &our_zone,
 433                                  &gph->new_zone,
 434                                  &process_zone_to_name_discover,
 435                                  gph);
 436
 437 }
 438
 439 /**
 440  * Initialize the resolver
 441  *
 442  * @param nh the namestore handle
 443  * @param dh the dht handle
 444  * @param lz the local zone's hash
 445  * @param max_bg_queries maximum number of parallel background queries in dht
 446  * @param ignore_pending ignore records that still require user confirmation
 447  *        on lookup
 448  * @return GNUNET_OK on success
 449  */
 450 int
 451 gns_resolver_init(struct GNUNET_NAMESTORE_Handle *nh,
 452                   struct GNUNET_DHT_Handle *dh,
 453                   struct GNUNET_CRYPTO_ShortHashCode lz,
 454                   unsigned long long max_bg_queries,
 455                   int ignore_pending)
 456 {
 457   namestore_handle = nh;
 458   dht_handle = dh;
 459   local_zone = lz;
 460   dht_lookup_heap =
 461     GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
 462   max_allowed_background_queries = max_bg_queries;
 463   ignore_pending_records = ignore_pending;
 464
 465   if ((namestore_handle != NULL) && (dht_handle != NULL))
 466   {
 467     return GNUNET_OK;
 468   }
 469   return GNUNET_SYSERR;
 470 }
 471
 472 /**
 473  * Cleanup background lookups
 474  *
 475  * @param cls closure to iterator
 476  * @param node heap nodes
 477  * @param element the resolver handle
 478  * @param cost heap cost
 479  * @return always GNUNET_YES
 480  */
 481 static int
 482 cleanup_pending_background_queries(void* cls,
 483                                    struct GNUNET_CONTAINER_HeapNode *node,
 484                                    void *element,
 485                                    GNUNET_CONTAINER_HeapCostType cost)
 486 {
 487   struct ResolverHandle *rh = (struct ResolverHandle *)element;
 488   ResolverCleanupContinuation cont = cls;
 489
 490   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 491              "GNS_CLEANUP-%llu: Terminating background lookup for %s\n",
 492              rh->id, rh->name);
 493   GNUNET_DHT_get_stop(rh->get_handle);
 494   rh->get_handle = NULL;
 495   rh->proc(rh->proc_cls, rh, 0, NULL);
 496
 497   GNUNET_CONTAINER_heap_remove_node(node);
 498
 499   if (GNUNET_CONTAINER_heap_get_size(dht_lookup_heap) == 0)
 500     cont();
 501
 502
 503   return GNUNET_YES;
 504 }
 505
 506
 507 /**
 508  * Shutdown resolver
 509  */
 510 void
 511 gns_resolver_cleanup(ResolverCleanupContinuation cont)
 512 {
 513   unsigned int s = GNUNET_CONTAINER_heap_get_size(dht_lookup_heap);
 514   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 515              "GNS_CLEANUP: %d pending background queries to terminate\n", s);
 516
 517   if (0 != s)
 518     GNUNET_CONTAINER_heap_iterate (dht_lookup_heap,
 519                                    &cleanup_pending_background_queries,
 520                                    cont);
 521   else
 522     cont();
 523 }
 524
 525
 526 /**
 527  * Helper function to free resolver handle
 528  *
 529  * @param rh the handle to free
 530  */
 531 static void
 532 free_resolver_handle(struct ResolverHandle* rh)
 533 {
 534   struct AuthorityChain *ac;
 535   struct AuthorityChain *ac_next;
 536
 537   if (NULL == rh)
 538     return;
 539
 540   ac = rh->authority_chain_head;
 541
 542   while (NULL != ac)
 543   {
 544     ac_next = ac->next;
 545     GNUNET_free(ac);
 546     ac = ac_next;
 547   }
 548   GNUNET_free(rh);
 549 }
 550
 551
 552 /**
 553  * Callback when record data is put into namestore
 554  *
 555  * @param cls the closure
 556  * @param success GNUNET_OK on success
 557  * @param emsg the error message. NULL if SUCCESS==GNUNET_OK
 558  */
 559 void
 560 on_namestore_record_put_result(void *cls,
 561                                int32_t success,
 562                                const char *emsg)
 563 {
 564   if (GNUNET_NO == success)
 565   {
 566     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 567                "GNS_NS: records already in namestore\n");
 568     return;
 569   }
 570   else if (GNUNET_YES == success)
 571   {
 572     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 573                "GNS_NS: records successfully put in namestore\n");
 574     return;
 575   }
 576
 577   GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 578              "GNS_NS: Error putting records into namestore: %s\n", emsg);
 579 }
 580
 581 static void
 582 handle_lookup_timeout(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 583 {
 584   struct ResolverHandle *rh = cls;
 585
 586   if (rh->timeout_cont)
 587     rh->timeout_cont(rh->timeout_cont_cls, tc);
 588 }
 589
 590 /**
 591  * Processor for background lookups in the DHT
 592  *
 593  * @param cls closure (NULL)
 594  * @param rd_count number of records found (not 0)
 595  * @param rd record data
 596  */
 597 static void
 598 background_lookup_result_processor(void *cls,
 599                                    uint32_t rd_count,
 600                                    const struct GNUNET_NAMESTORE_RecordData *rd)
 601 {
 602   //We could do sth verbose/more useful here but it doesn't make any difference
 603   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 604              "GNS_BG: background dht lookup for finished. (%d results)\n",
 605              rd_count);
 606 }
 607
 608 /**
 609  * Handle timeout for DHT requests
 610  *
 611  * @param cls the request handle as closure
 612  * @param tc the task context
 613  */
 614 static void
 615 dht_lookup_timeout(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 616 {
 617   struct ResolverHandle *rh = cls;
 618   struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls;
 619   char new_name[MAX_DNS_NAME_LENGTH];
 620
 621   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 622              "GNS_PHASE_REC-%d: dht lookup for query %s (%ds)timed out.\n",
 623              rh->id, rh->name, rh->timeout.rel_value);
 624   /**
 625    * Start resolution in bg
 626    */
 627   //strcpy(new_name, rh->name);
 628   //memcpy(new_name+strlen(new_name), GNUNET_GNS_TLD, strlen(GNUNET_GNS_TLD));
 629   GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
 630                   rh->name, GNUNET_GNS_TLD);
 631
 632   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 633              "GNS_PHASE_REC-%d: Starting background lookup for %s type %d\n",
 634              rh->id, new_name, rlh->record_type);
 635
 636   gns_resolver_lookup_record(rh->authority,
 637                              rlh->record_type,
 638                              new_name,
 639                              rh->priv_key,
 640                              GNUNET_TIME_UNIT_FOREVER_REL,
 641                              &background_lookup_result_processor,
 642                              NULL);
 643   rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 644
 645   GNUNET_DHT_get_stop (rh->get_handle);
 646   rh->get_handle = NULL;
 647   rh->proc(rh->proc_cls, rh, 0, NULL);
 648 }
 649
 650
 651 /**
 652  * Function called when we get a result from the dht
 653  * for our record query
 654  *
 655  * @param cls the request handle
 656  * @param exp lifetime
 657  * @param key the key the record was stored under
 658  * @param get_path get path
 659  * @param get_path_length get path length
 660  * @param put_path put path
 661  * @param put_path_length put path length
 662  * @param type the block type
 663  * @param size the size of the record
 664  * @param data the record data
 665  */
 666 static void
 667 process_record_result_dht(void* cls,
 668                  struct GNUNET_TIME_Absolute exp,
 669                  const GNUNET_HashCode * key,
 670                  const struct GNUNET_PeerIdentity *get_path,
 671                  unsigned int get_path_length,
 672                  const struct GNUNET_PeerIdentity *put_path,
 673                  unsigned int put_path_length,
 674                  enum GNUNET_BLOCK_Type type,
 675                  size_t size, const void *data)
 676 {
 677   struct ResolverHandle *rh;
 678   struct RecordLookupHandle *rlh;
 679   struct GNSNameRecordBlock *nrb;
 680   uint32_t num_records;
 681   char* name = NULL;
 682   char* rd_data = (char*)data;
 683   int i;
 684   int rd_size;
 685
 686   rh = (struct ResolverHandle *)cls;
 687   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 688              "GNS_PHASE_REC-%d: got dht result (size=%d)\n", rh->id, size);
 689
 690   if (data == NULL)
 691     return;
 692
 693   //FIXME maybe check expiration here, check block type
 694
 695
 696   rlh = (struct RecordLookupHandle *) rh->proc_cls;
 697   nrb = (struct GNSNameRecordBlock*)data;
 698
 699   /* stop lookup and timeout task */
 700   GNUNET_DHT_get_stop (rh->get_handle);
 701   rh->get_handle = NULL;
 702
 703   if (rh->dht_heap_node != NULL)
 704   {
 705     GNUNET_CONTAINER_heap_remove_node(rh->dht_heap_node);
 706     rh->dht_heap_node = NULL;
 707   }
 708
 709   if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
 710   {
 711     GNUNET_SCHEDULER_cancel(rh->timeout_task);
 712     rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 713   }
 714
 715   rh->get_handle = NULL;
 716   name = (char*)&nrb[1];
 717   num_records = ntohl(nrb->rd_count);
 718   {
 719     struct GNUNET_NAMESTORE_RecordData rd[num_records];
 720
 721     rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock);
 722     rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock);
 723
 724     if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
 725                                                                rd_data,
 726                                                                num_records,
 727                                                                rd))
 728     {
 729       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 730                  "GNS_PHASE_REC-%d: Error deserializing data!\n", rh->id);
 731       return;
 732     }
 733
 734     for (i=0; i<num_records; i++)
 735     {
 736       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 737                "GNS_PHASE_REC-%d: Got name: %s (wanted %s)\n",
 738                rh->id, name, rh->name);
 739       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 740                "GNS_PHASE_REC-%d: Got type: %d\n",
 741                rh->id, rd[i].record_type);
 742       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 743                "GNS_PHASE_REC-%d: Got data length: %d\n",
 744                rh->id, rd[i].data_size);
 745       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 746                "GNS_PHASE_REC-%d: Got flag %d\n",
 747                rh->id, rd[i].flags);
 748
 749      if ((strcmp(name, rh->name) == 0) &&
 750          (rd[i].record_type == rlh->record_type))
 751       {
 752         rh->answered++;
 753       }
 754
 755     }
 756
 757     /**
 758      * FIXME check pubkey against existing key in namestore?
 759      * https://gnunet.org/bugs/view.php?id=2179
 760      */
 761
 762     /* Save to namestore */
 763     GNUNET_NAMESTORE_record_put (namestore_handle,
 764                                  &nrb->public_key,
 765                                  name,
 766                                  exp,
 767                                  num_records,
 768                                  rd,
 769                                  &nrb->signature,
 770                                  &on_namestore_record_put_result, //cont
 771                                  NULL); //cls
 772
 773
 774     if (rh->answered)
 775       rh->proc(rh->proc_cls, rh, num_records, rd);
 776     else
 777       rh->proc(rh->proc_cls, rh, 0, NULL);
 778   }
 779
 780 }
 781
 782
 783 /**
 784  * Start DHT lookup for a (name -> query->record_type) record in
 785  * rh->authority's zone
 786  *
 787  * @param rh the pending gns query context
 788  */
 789 static void
 790 resolve_record_dht(struct ResolverHandle *rh)
 791 {
 792   uint32_t xquery;
 793   struct GNUNET_CRYPTO_ShortHashCode name_hash;
 794   GNUNET_HashCode lookup_key;
 795   GNUNET_HashCode name_hash_double;
 796   GNUNET_HashCode zone_hash_double;
 797   struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string;
 798   struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls;
 799   struct ResolverHandle *rh_heap_root;
 800
 801   GNUNET_CRYPTO_short_hash(rh->name, strlen(rh->name), &name_hash);
 802   GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
 803   GNUNET_CRYPTO_short_hash_double(&rh->authority, &zone_hash_double);
 804   GNUNET_CRYPTO_hash_xor(&name_hash_double, &zone_hash_double, &lookup_key);
 805   GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string);
 806
 807   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 808              "GNS_PHASE_REC-%d: starting dht lookup for %s with key: %s\n",
 809              rh->id, rh->name, (char*)&lookup_key_string);
 810
 811   //rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 812   rh->dht_heap_node = NULL;
 813
 814   if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
 815   {
 816     /**
 817      * Update timeout if necessary
 818      */
 819     if (rh->timeout_task == GNUNET_SCHEDULER_NO_TASK)
 820     {
 821
 822     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 823                "GNS_PHASE_REC-%d: Adjusting timeout\n", rh->id);
 824     /*
 825      * Set timeout for authority lookup phase to 1/2
 826      */
 827       rh->timeout_task = GNUNET_SCHEDULER_add_delayed(
 828                                 GNUNET_TIME_relative_divide(rh->timeout, 2),
 829                                                 &handle_lookup_timeout,
 830                                                 rh);
 831     }
 832     //rh->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
 833     //                                                   &dht_lookup_timeout,
 834     //                                                   rh);
 835     rh->timeout_cont = &dht_lookup_timeout;
 836     rh->timeout_cont_cls = rh;
 837   }
 838   else
 839   {
 840     if (max_allowed_background_queries <=
 841         GNUNET_CONTAINER_heap_get_size (dht_lookup_heap))
 842     {
 843       rh_heap_root = GNUNET_CONTAINER_heap_remove_root (dht_lookup_heap);
 844       GNUNET_DHT_get_stop(rh_heap_root->get_handle);
 845       rh_heap_root->get_handle = NULL;
 846       rh_heap_root->dht_heap_node = NULL;
 847
 848       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 849            "GNS_PHASE_REC-%d: Replacing oldest background query for %s\n",
 850                  rh->id, rh_heap_root->name);
 851       rh_heap_root->proc(rh_heap_root->proc_cls,
 852                          rh_heap_root,
 853                          0,
 854                          NULL);
 855     }
 856     rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
 857                                          rh,
 858                                          GNUNET_TIME_absolute_get().abs_value);
 859   }
 860
 861   xquery = htonl(rlh->record_type);
 862
 863   GNUNET_assert(rh->get_handle == NULL);
 864   rh->get_handle = GNUNET_DHT_get_start(dht_handle,
 865                        GNUNET_TIME_UNIT_FOREVER_REL,
 866                        GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
 867                        &lookup_key,
 868                        DHT_GNS_REPLICATION_LEVEL,
 869                        GNUNET_DHT_RO_NONE,
 870                        &xquery,
 871                        sizeof(xquery),
 872                        &process_record_result_dht,
 873                        rh);
 874
 875 }
 876
 877
 878 /**
 879  * Namestore calls this function if we have record for this name.
 880  * (or with rd_count=0 to indicate no matches)
 881  *
 882  * @param cls the pending query
 883  * @param key the key of the zone we did the lookup
 884  * @param expiration expiration date of the namestore entry
 885  * @param name the name for which we need an authority
 886  * @param rd_count the number of records with 'name'
 887  * @param rd the record data
 888  * @param signature the signature of the authority for the record data
 889  */
 890 static void
 891 process_record_result_ns(void* cls,
 892                   const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
 893                   struct GNUNET_TIME_Absolute expiration,
 894                   const char *name, unsigned int rd_count,
 895                   const struct GNUNET_NAMESTORE_RecordData *rd,
 896                   const struct GNUNET_CRYPTO_RsaSignature *signature)
 897 {
 898   struct ResolverHandle *rh;
 899   struct RecordLookupHandle *rlh;
 900   struct GNUNET_TIME_Relative remaining_time;
 901   struct GNUNET_CRYPTO_ShortHashCode zone;
 902
 903   rh = (struct ResolverHandle *) cls;
 904   rlh = (struct RecordLookupHandle *)rh->proc_cls;
 905   GNUNET_CRYPTO_short_hash(key,
 906                      sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 907                      &zone);
 908   remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
 909
 910
 911
 912   rh->status = 0;
 913
 914   if (name != NULL)
 915   {
 916     rh->status |= RSL_RECORD_EXISTS;
 917   }
 918
 919   if (remaining_time.rel_value == 0)
 920   {
 921     rh->status |= RSL_RECORD_EXPIRED;
 922   }
 923
 924   if (rd_count == 0)
 925   {
 926     /**
 927      * Lookup terminated and no results
 928      */
 929     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 930       "GNS_PHASE_REC-%d: Namestore lookup for %s terminated without results\n",
 931          rh->id, name);
 932
 933     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 934                "GNS_PHASE_REC-%d: Record %s unknown in namestore\n",
 935                rh->id, rh->name);
 936     /**
 937      * Our zone and no result? Cannot resolve TT
 938      */
 939     rh->proc(rh->proc_cls, rh, 0, NULL);
 940     return;
 941
 942   }
 943   else
 944   {
 945
 946     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 947            "GNS_PHASE_REC-%d: Processing additional result %s from namestore\n",
 948               rh->id, name);
 949     int i;
 950     for (i=0; i<rd_count;i++)
 951     {
 952
 953       if (rd[i].record_type != rlh->record_type)
 954         continue;
 955
 956       if (ignore_pending_records &&
 957           (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
 958       {
 959         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 960         "GNS_PHASE_REC-%d: Record %s is awaiting user confirmation. Skipping\n",
 961         rh->id, name);
 962         continue;
 963       }
 964
 965       if ((GNUNET_TIME_absolute_get_remaining (rd[i].expiration)).rel_value
 966           == 0)
 967       {
 968         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 969                    "GNS_PHASE_REC-%d: This record is expired. Skipping\n",
 970                    rh->id);
 971         continue;
 972       }
 973
 974       rh->answered++;
 975
 976     }
 977
 978     /**
 979      * no answers found
 980      */
 981     if (rh->answered == 0)
 982     {
 983       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 984                  "GNS_PHASE_REC-%d: No answers found. This is odd!\n", rh->id);
 985       rh->proc(rh->proc_cls, rh, 0, NULL);
 986       return;
 987     }
 988
 989     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 990                "GNS_PHASE_REC-%d: Found %d answer(s) to query in %d records!\n",
 991                rh->id, rh->answered, rd_count);
 992
 993     rh->proc(rh->proc_cls, rh, rd_count, rd);
 994   }
 995 }
 996
 997
 998 /**
 999  * The final phase of resolution.
1000  * rh->name is a name that is canonical and we do not have a delegation.
1001  * Query namestore for this record
1002  *
1003  * @param rh the pending lookup
1004  */
1005 static void
1006 resolve_record_ns(struct ResolverHandle *rh)
1007 {
1008   struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls;
1009
1010   /* We cancel here as to not include the ns lookup in the timeout */
1011   if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
1012   {
1013     GNUNET_SCHEDULER_cancel(rh->timeout_task);
1014     rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1015   }
1016
1017   /**
1018    * Try to resolve this record in our namestore.
1019    * The name to resolve is now in rh->authority_name
1020    * since we tried to resolve it to an authority
1021    * and failed.
1022    **/
1023   GNUNET_NAMESTORE_lookup_record(namestore_handle,
1024                                  &rh->authority,
1025                                  rh->name,
1026                                  rlh->record_type,
1027                                  &process_record_result_ns,
1028                                  rh);
1029 }
1030
1031
1032
1033 /**
1034  * Handle timeout for DHT requests
1035  *
1036  * @param cls the request handle as closure
1037  * @param tc the task context
1038  */
1039 static void
1040 dht_authority_lookup_timeout(void *cls,
1041                              const struct GNUNET_SCHEDULER_TaskContext *tc)
1042 {
1043   struct ResolverHandle *rh = cls;
1044   struct RecordLookupHandle *rlh = rh->proc_cls;
1045   char new_name[MAX_DNS_NAME_LENGTH];
1046
1047   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1048          "GNS_PHASE_DELEGATE_DHT-%llu: dht lookup for query %s (%ds)timed out.\n",
1049          rh->id, rh->authority_name, rh->timeout.rel_value);
1050
1051   rh->status |= RSL_TIMED_OUT;
1052
1053   rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1054
1055   GNUNET_DHT_get_stop (rh->get_handle);
1056   rh->get_handle = NULL;
1057
1058   if (strcmp(rh->name, "") == 0)
1059   {
1060     /*
1061      * promote authority back to name and try to resolve record
1062      */
1063     strcpy(rh->name, rh->authority_name);
1064     rh->proc(rh->proc_cls, rh, 0, NULL);
1065     return;
1066   }
1067
1068   /**
1069    * Start resolution in bg
1070    */
1071   GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH,
1072                   "%s.%s.%s", rh->name, rh->authority_name, GNUNET_GNS_TLD);
1073   //strcpy(new_name, rh->name);
1074   //strcpy(new_name+strlen(new_name), ".");
1075   //memcpy(new_name+strlen(new_name), GNUNET_GNS_TLD, strlen(GNUNET_GNS_TLD));
1076
1077   strcpy(rh->name, new_name);
1078
1079   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1080         "GNS_PHASE_DELEGATE_DHT-%llu: Starting background query for %s type %d\n",
1081         rh->id, rh->name, rlh->record_type);
1082
1083   gns_resolver_lookup_record(rh->authority,
1084                              rlh->record_type,
1085                              new_name,
1086                              rh->priv_key,
1087                              GNUNET_TIME_UNIT_FOREVER_REL,
1088                              &background_lookup_result_processor,
1089                              NULL);
1090
1091   rh->proc(rh->proc_cls, rh, 0, NULL);
1092 }
1093
1094 /* Prototype */
1095 static void resolve_delegation_dht(struct ResolverHandle *rh);
1096
1097 /* Prototype */
1098 static void resolve_delegation_ns(struct ResolverHandle *rh);
1099
1100
1101 /**
1102  * Namestore resolution for delegation finished. Processing result.
1103  *
1104  * @param cls the closure
1105  * @param rh resolver handle
1106  * @param rd_count number of results (always 0)
1107  * @param rd record data (always NULL)
1108  */
1109 static void
1110 handle_delegation_ns(void* cls, struct ResolverHandle *rh,
1111                           unsigned int rd_count,
1112                           const struct GNUNET_NAMESTORE_RecordData *rd);
1113
1114
1115 /**
1116  * Function called when we get a result from the dht
1117  * for our query. Recursively tries to resolve authorities
1118  * for name in DHT.
1119  *
1120  * @param cls the request handle
1121  * @param exp lifetime
1122  * @param key the key the record was stored under
1123  * @param get_path get path
1124  * @param get_path_length get path length
1125  * @param put_path put path
1126  * @param put_path_length put path length
1127  * @param type the block type
1128  * @param size the size of the record
1129  * @param data the record data
1130  */
1131 static void
1132 process_delegation_result_dht(void* cls,
1133                  struct GNUNET_TIME_Absolute exp,
1134                  const GNUNET_HashCode * key,
1135                  const struct GNUNET_PeerIdentity *get_path,
1136                  unsigned int get_path_length,
1137                  const struct GNUNET_PeerIdentity *put_path,
1138                  unsigned int put_path_length,
1139                  enum GNUNET_BLOCK_Type type,
1140                  size_t size, const void *data)
1141 {
1142   struct ResolverHandle *rh;
1143   struct GNSNameRecordBlock *nrb;
1144   uint32_t num_records;
1145   char* name = NULL;
1146   char* rd_data = (char*) data;
1147   int i;
1148   int rd_size;
1149   struct GNUNET_CRYPTO_ShortHashCode zone, name_hash;
1150   GNUNET_HashCode zone_hash_double, name_hash_double;
1151
1152   rh = (struct ResolverHandle *)cls;
1153
1154   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1155              "GNS_PHASE_DELEGATE_DHT-%llu: Got DHT result\n", rh->id);
1156
1157   if (data == NULL)
1158     return;
1159
1160   nrb = (struct GNSNameRecordBlock*)data;
1161
1162   /* stop dht lookup and timeout task */
1163   GNUNET_DHT_get_stop (rh->get_handle);
1164
1165   rh->get_handle = NULL;
1166
1167   if (rh->dht_heap_node != NULL)
1168   {
1169     GNUNET_CONTAINER_heap_remove_node(rh->dht_heap_node);
1170     rh->dht_heap_node = NULL;
1171   }
1172
1173   num_records = ntohl(nrb->rd_count);
1174   name = (char*)&nrb[1];
1175   {
1176     struct GNUNET_NAMESTORE_RecordData rd[num_records];
1177
1178     rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock);
1179     rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock);
1180
1181     if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
1182                                                                rd_data,
1183                                                                num_records,
1184                                                                rd))
1185     {
1186       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
1187                  "GNS_PHASE_DELEGATE_DHT-%llu: Error deserializing data!\n",
1188                  rh->id);
1189       return;
1190     }
1191
1192     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1193                "GNS_PHASE_DELEGATE_DHT-%llu: Got name: %s (wanted %s)\n",
1194                rh->id, name, rh->authority_name);
1195     for (i=0; i<num_records; i++)
1196     {
1197
1198       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1199                 "GNS_PHASE_DELEGATE_DHT-%llu: Got name: %s (wanted %s)\n",
1200                 rh->id, name, rh->authority_name);
1201       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1202                  "GNS_PHASE_DELEGATE_DHT-%llu: Got type: %d (wanted %d)\n",
1203                  rh->id, rd[i].record_type, GNUNET_GNS_RECORD_PKEY);
1204       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1205                  "GNS_PHASE_DELEGATE_DHT-%llu: Got data length: %d\n",
1206                  rh->id, rd[i].data_size);
1207       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1208                  "GNS_PHASE_DELEGATE_DHT-%llu: Got flag %d\n",
1209                  rh->id, rd[i].flags);
1210
1211       if ((strcmp(name, rh->authority_name) == 0) &&
1212           (rd[i].record_type == GNUNET_GNS_RECORD_PKEY))
1213       {
1214         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1215                    "GNS_PHASE_DELEGATE_DHT-%llu: Authority found in DHT\n",
1216                    rh->id);
1217         rh->answered = 1;
1218         memcpy(&rh->authority, rd[i].data, sizeof(struct GNUNET_CRYPTO_ShortHashCode));
1219         struct AuthorityChain *auth =
1220           GNUNET_malloc(sizeof(struct AuthorityChain));
1221         auth->zone = rh->authority;
1222         memset(auth->name, 0, strlen(rh->authority_name)+1);
1223         strcpy(auth->name, rh->authority_name);
1224         GNUNET_CONTAINER_DLL_insert (rh->authority_chain_head,
1225                                      rh->authority_chain_tail,
1226                                      auth);
1227
1228         /** try to import pkey if private key available */
1229         if (rh->priv_key)
1230           process_discovered_authority(name, auth->zone,
1231                                        rh->authority_chain_tail->zone,
1232                                        rh->priv_key);
1233       }
1234
1235     }
1236
1237
1238     GNUNET_CRYPTO_short_hash(name, strlen(name), &name_hash);
1239     GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
1240     GNUNET_CRYPTO_hash_xor(key, &name_hash_double, &zone_hash_double);
1241     GNUNET_CRYPTO_short_hash_from_truncation (&zone_hash_double, &zone);
1242
1243     /* Save to namestore */
1244     if (0 != GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_tail->zone,
1245                                           &zone))
1246     {
1247       GNUNET_NAMESTORE_record_put (namestore_handle,
1248                                  &nrb->public_key,
1249                                  name,
1250                                  exp,
1251                                  num_records,
1252                                  rd,
1253                                  &nrb->signature,
1254                                  &on_namestore_record_put_result, //cont
1255                                  NULL); //cls
1256     }
1257   }
1258
1259   if (rh->answered)
1260   {
1261     rh->answered = 0;
1262     /**
1263      * delegate
1264      * FIXME in this case. should we ask namestore again?
1265      */
1266     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1267       "GNS_PHASE_DELEGATE_DHT-%llu: Answer from DHT for %s. Yet to resolve: %s\n",
1268       rh->id, rh->authority_name, rh->name);
1269     if (strcmp(rh->name, "") == 0)
1270     {
1271       rh->proc(rh->proc_cls, rh, 0, NULL);
1272     }
1273     else
1274     {
1275       rh->proc = &handle_delegation_ns;
1276       resolve_delegation_ns(rh);
1277     }
1278     return;
1279   }
1280
1281   /**
1282    * No pkey but name exists
1283    * promote back
1284    */
1285   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1286              "GNS_PHASE_DELEGATE_DHT-%llu: Adding %s back to %s\n",
1287              rh->id, rh->authority_name, rh->name);
1288   if (strcmp(rh->name, "") == 0)
1289     strcpy(rh->name, rh->authority_name);
1290   else
1291     GNUNET_snprintf(rh->name, MAX_DNS_NAME_LENGTH, "%s.%s",
1292                   rh->name, rh->authority_name); //FIXME ret
1293
1294   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1295              "GNS_PHASE_DELEGATE_DHT-%llu: %s restored\n", rh->id, rh->name);
1296   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1297            "GNS_PHASE_DELEGATE_DHT-%llu: DHT authority lookup found no match!\n",
1298            rh->id);
1299   rh->proc(rh->proc_cls, rh, 0, NULL);
1300 }
1301
1302 #define MAX_SOA_LENGTH sizeof(uint32_t)+sizeof(uint32_t)+sizeof(uint32_t)+sizeof(uint32_t)\
1303                         +(MAX_DNS_NAME_LENGTH*2)
1304 #define MAX_MX_LENGTH sizeof(uint16_t)+MAX_DNS_NAME_LENGTH
1305
1306
1307 static void
1308 expand_plus(char** dest, char* src, char* repl)
1309 {
1310   char* pos;
1311   unsigned int s_len = strlen(src)+1;
1312
1313   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1314              "GNS_POSTPROCESS: Got %s to expand with %s\n", src, repl);
1315
1316   if (s_len < 3)
1317   {
1318     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1319                "GNS_POSTPROCESS: %s to short\n", src);
1320
1321     /* no postprocessing */
1322     memcpy(*dest, src, s_len+1);
1323     return;
1324   }
1325
1326   if (0 == strcmp(src+s_len-3, ".+"))
1327   {
1328     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1329                "GNS_POSTPROCESS: Expanding .+ in %s\n", src);
1330     memset(*dest, 0, s_len+strlen(repl)+strlen(GNUNET_GNS_TLD));
1331     strcpy(*dest, src);
1332     pos = *dest+s_len-2;
1333     strcpy(pos, repl);
1334     pos += strlen(repl);
1335     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1336                "GNS_POSTPROCESS: Expanded to %s\n", *dest);
1337   }
1338   else
1339   {
1340     memcpy(*dest, src, s_len+1);
1341   }
1342 }
1343
1344 /**
1345  * finish lookup
1346  */
1347 static void
1348 finish_lookup(struct ResolverHandle *rh,
1349               struct RecordLookupHandle* rlh,
1350               unsigned int rd_count,
1351               const struct GNUNET_NAMESTORE_RecordData *rd)
1352 {
1353   int i;
1354   char new_rr_data[MAX_DNS_NAME_LENGTH];
1355   char new_mx_data[MAX_MX_LENGTH];
1356   char new_soa_data[MAX_SOA_LENGTH];
1357   struct GNUNET_NAMESTORE_RecordData p_rd[rd_count];
1358   char* repl_string;
1359   char* pos;
1360   unsigned int offset;
1361
1362   if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
1363   {
1364     GNUNET_SCHEDULER_cancel(rh->timeout_task);
1365     rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1366   }
1367
1368   if (rd_count > 0)
1369     memcpy(p_rd, rd, rd_count*sizeof(struct GNUNET_NAMESTORE_RecordData));
1370
1371   for (i = 0; i < rd_count; i++)
1372   {
1373
1374     if (rd[i].record_type != GNUNET_GNS_RECORD_TYPE_NS &&
1375         rd[i].record_type != GNUNET_GNS_RECORD_TYPE_CNAME &&
1376         rd[i].record_type != GNUNET_GNS_RECORD_MX &&
1377         rd[i].record_type != GNUNET_GNS_RECORD_TYPE_SOA)
1378     {
1379       p_rd[i].data = rd[i].data;
1380       continue;
1381     }
1382
1383     /**
1384      * for all those records we 'should'
1385      * also try to resolve the A/AAAA records (RFC1035)
1386      * This is a feature and not important
1387      */
1388
1389     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1390                "GNS_POSTPROCESS: Postprocessing\n");
1391
1392     if (strcmp(rh->name, "+") == 0)
1393       repl_string = rlh->name;
1394     else
1395       repl_string = rlh->name+strlen(rh->name)+1;
1396
1397     offset = 0;
1398     if (rd[i].record_type == GNUNET_GNS_RECORD_MX)
1399     {
1400       memcpy(new_mx_data, (char*)rd[i].data, sizeof(uint16_t));
1401       offset = sizeof(uint16_t);
1402       pos = new_mx_data+offset;
1403       expand_plus(&pos, (char*)rd[i].data+sizeof(uint16_t),
1404                   repl_string);
1405       offset += strlen(new_mx_data+sizeof(uint16_t))+1;
1406       p_rd[i].data = new_mx_data;
1407       p_rd[i].data_size = offset;
1408     }
1409     else if (rd[i].record_type == GNUNET_GNS_RECORD_TYPE_SOA)
1410     {
1411       /* expand mname and rname */
1412       pos = new_soa_data;
1413       expand_plus(&pos, (char*)rd[i].data, repl_string);
1414       offset = strlen(new_soa_data)+1;
1415       pos = new_soa_data+offset;
1416       expand_plus(&pos, (char*)rd[i].data+offset, repl_string);
1417       offset += strlen(new_soa_data+offset)+1;
1418       /* cpy the 4 numbers serial refresh retry and expire */
1419       memcpy(new_soa_data+offset, (char*)rd[i].data+offset, sizeof(uint32_t)*5);
1420       offset += sizeof(uint32_t)*5;
1421       p_rd[i].data_size = offset;
1422       p_rd[i].data = new_soa_data;
1423     }
1424     else
1425     {
1426       pos = new_rr_data;
1427       expand_plus(&pos, (char*)rd[i].data, repl_string);
1428       p_rd[i].data_size = strlen(new_rr_data)+1;
1429       p_rd[i].data = new_rr_data;
1430     }
1431
1432   }
1433
1434   rlh->proc(rlh->proc_cls, rd_count, p_rd);
1435   GNUNET_free(rlh);
1436
1437 }
1438
1439 /**
1440  * Process DHT lookup result for record.
1441  *
1442  * @param cls the closure
1443  * @param rh resolver handle
1444  * @param rd_count number of results
1445  * @param rd record data
1446  */
1447 static void
1448 handle_record_dht(void* cls, struct ResolverHandle *rh,
1449                        unsigned int rd_count,
1450                        const struct GNUNET_NAMESTORE_RecordData *rd)
1451 {
1452   struct RecordLookupHandle* rlh;
1453
1454   rlh = (struct RecordLookupHandle*)cls;
1455   if (rd_count == 0)
1456   {
1457     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1458                "GNS_PHASE_REC-%d: No records for %s found in DHT. Aborting\n",
1459                rh->id, rh->name);
1460     /* give up, cannot resolve */
1461     finish_lookup(rh, rlh, 0, NULL);
1462     free_resolver_handle(rh);
1463     return;
1464   }
1465
1466   /* results found yay */
1467   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1468              "GNS_PHASE_REC-%d: Record resolved from DHT!", rh->id);
1469
1470   finish_lookup(rh, rlh, rd_count, rd);
1471   free_resolver_handle(rh);
1472
1473 }
1474
1475
1476 /**
1477  * Process namestore lookup result for record.
1478  *
1479  * @param cls the closure
1480  * @param rh resolver handle
1481  * @param rd_count number of results
1482  * @param rd record data
1483  */
1484 static void
1485 handle_record_ns(void* cls, struct ResolverHandle *rh,
1486                        unsigned int rd_count,
1487                        const struct GNUNET_NAMESTORE_RecordData *rd)
1488 {
1489   struct RecordLookupHandle* rlh;
1490   rlh = (struct RecordLookupHandle*) cls;
1491   if (rd_count == 0)
1492   {
1493     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1494                "GNS_PHASE_REC-%d: NS returned no records. (status: %d)!\n",
1495                rh->id,
1496                rh->status);
1497
1498     /**
1499      * There are 4 conditions that have to met for us to consult the DHT:
1500      * 1. The entry in the DHT is RSL_RECORD_EXPIRED AND
1501      * 2. No entry in the NS existed AND
1502      * 3. The zone queried is not the local resolver's zone AND
1503      * 4. The name that was looked up is '+'
1504      *    because if it was any other canonical name we either already queried
1505      *    the DHT for the authority in the authority lookup phase (and thus
1506      *    would already have an entry in the NS for the record)
1507      */
1508     if (rh->status & (RSL_RECORD_EXPIRED | !RSL_RECORD_EXISTS) &&
1509         GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
1510                                      &local_zone) &&
1511         (strcmp(rh->name, "+") == 0))
1512     {
1513       rh->proc = &handle_record_dht;
1514       resolve_record_dht(rh);
1515       return;
1516     }
1517     /* give up, cannot resolve */
1518     finish_lookup(rh, rlh, 0, NULL);
1519     free_resolver_handle(rh);
1520     return;
1521   }
1522
1523   /* results found yay */
1524   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1525              "GNS_PHASE_REC-%d: Record resolved from namestore!", rh->id);
1526
1527   finish_lookup(rh, rlh, rd_count, rd);
1528
1529   free_resolver_handle(rh);
1530
1531 }
1532
1533
1534 /**
1535  * Determine if this name is canonical.
1536  * i.e.
1537  * a.b.gnunet  = not canonical
1538  * a           = canonical
1539  *
1540  * @param name the name to test
1541  * @return 1 if canonical
1542  */
1543 static int
1544 is_canonical(char* name)
1545 {
1546   uint32_t len = strlen(name);
1547   int i;
1548
1549   for (i=0; i<len; i++)
1550   {
1551     if (*(name+i) == '.')
1552       return 0;
1553   }
1554   return 1;
1555 }
1556
1557 /**
1558  * Move one level up in the domain hierarchy and return the
1559  * passed top level domain.
1560  *
1561  * @param name the domain
1562  * @param dest the destination where the tld will be put
1563  */
1564 void
1565 pop_tld(char* name, char* dest)
1566 {
1567   uint32_t len;
1568
1569   if (is_canonical(name))
1570   {
1571     strcpy(dest, name);
1572     strcpy(name, "");
1573     return;
1574   }
1575
1576   for (len = strlen(name); len > 0; len--)
1577   {
1578     if (*(name+len) == '.')
1579       break;
1580   }
1581
1582   //Was canonical?
1583   if (len == 0)
1584     return;
1585
1586   name[len] = '\0';
1587
1588   strcpy(dest, (name+len+1));
1589 }
1590
1591 /**
1592  * Checks if name is in tld
1593  *
1594  * @param name the name to check
1595  * @param tld the TLD to check for
1596  * @return GNUNET_YES or GNUNET_NO
1597  */
1598 int
1599 is_tld(const char* name, const char* tld)
1600 {
1601   int offset = 0;
1602
1603   if (strlen(name) <= strlen(tld))
1604   {
1605     return GNUNET_NO;
1606   }
1607
1608   offset = strlen(name)-strlen(tld);
1609   if (strcmp(name+offset, tld) != 0)
1610   {
1611     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1612                "%s is not in .%s TLD\n", name, tld);
1613     return GNUNET_NO;
1614   }
1615   return GNUNET_YES;
1616 }
1617
1618 /**
1619  * DHT resolution for delegation finished. Processing result.
1620  *
1621  * @param cls the closure
1622  * @param rh resolver handle
1623  * @param rd_count number of results (always 0)
1624  * @param rd record data (always NULL)
1625  */
1626 static void
1627 handle_delegation_dht(void* cls, struct ResolverHandle *rh,
1628                           unsigned int rd_count,
1629                           const struct GNUNET_NAMESTORE_RecordData *rd)
1630 {
1631   struct RecordLookupHandle* rlh;
1632   rlh = (struct RecordLookupHandle*) cls;
1633
1634
1635   if (strcmp(rh->name, "") == 0)
1636   {
1637     if ((rlh->record_type == GNUNET_GNS_RECORD_PKEY))
1638     {
1639       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1640                  "GNS_PHASE_DELEGATE_DHT-%llu: Resolved queried PKEY via DHT.\n",
1641                  rh->id);
1642       finish_lookup(rh, rlh, rd_count, rd);
1643       free_resolver_handle(rh);
1644       return;
1645     }
1646     /* We resolved full name for delegation. resolving record */
1647     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1648      "GNS_PHASE_DELEGATE_DHT-%llu: Resolved full name for delegation via DHT.\n",
1649      rh->id);
1650     strcpy(rh->name, "+\0");
1651     rh->proc = &handle_record_ns;
1652     resolve_record_ns(rh);
1653     return;
1654   }
1655
1656   /**
1657    * we still have some left
1658    **/
1659   if (is_canonical(rh->name))
1660   {
1661     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1662              "GNS_PHASE_DELEGATE_DHT-%llu: Resolving canonical record %s in ns\n",
1663              rh->id,
1664              rh->name);
1665     rh->proc = &handle_record_ns;
1666     resolve_record_ns(rh);
1667     return;
1668   }
1669   /* give up, cannot resolve */
1670   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1671  "GNS_PHASE_DELEGATE_DHT-%llu: Cannot fully resolve delegation for %s via DHT!\n",
1672  rh->id, rh->name);
1673   finish_lookup(rh, rlh, 0, NULL);
1674   free_resolver_handle(rh);
1675 }
1676
1677
1678 /**
1679  * Start DHT lookup for a name -> PKEY (compare NS) record in
1680  * rh->authority's zone
1681  *
1682  * @param rh the pending gns query
1683  */
1684 static void
1685 resolve_delegation_dht(struct ResolverHandle *rh)
1686 {
1687   uint32_t xquery;
1688   struct GNUNET_CRYPTO_ShortHashCode name_hash;
1689   GNUNET_HashCode name_hash_double;
1690   GNUNET_HashCode zone_hash_double;
1691   GNUNET_HashCode lookup_key;
1692   struct ResolverHandle *rh_heap_root;
1693
1694   pop_tld(rh->name, rh->authority_name);
1695   GNUNET_CRYPTO_short_hash(rh->authority_name,
1696                      strlen(rh->authority_name),
1697                      &name_hash);
1698   GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
1699   GNUNET_CRYPTO_short_hash_double(&rh->authority, &zone_hash_double);
1700   GNUNET_CRYPTO_hash_xor(&name_hash_double, &zone_hash_double, &lookup_key);
1701
1702   rh->dht_heap_node = NULL;
1703
1704   if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
1705   {
1706     //rh->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
1707     //                                          &dht_authority_lookup_timeout,
1708     //                                                   rh);
1709     rh->timeout_cont = &dht_authority_lookup_timeout;
1710     rh->timeout_cont_cls = rh;
1711   }
1712   else
1713   {
1714     if (max_allowed_background_queries <=
1715         GNUNET_CONTAINER_heap_get_size (dht_lookup_heap))
1716     {
1717       /* terminate oldest lookup */
1718       rh_heap_root = GNUNET_CONTAINER_heap_remove_root (dht_lookup_heap);
1719       GNUNET_DHT_get_stop(rh_heap_root->get_handle);
1720       rh_heap_root->dht_heap_node = NULL;
1721
1722       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1723         "GNS_PHASE_DELEGATE_DHT-%llu: Replacing oldest background query for %s\n",
1724         rh->id, rh_heap_root->authority_name);
1725
1726       rh_heap_root->proc(rh_heap_root->proc_cls,
1727                          rh_heap_root,
1728                          0,
1729                          NULL);
1730     }
1731     rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
1732                                          rh,
1733                                          GNUNET_TIME_absolute_get().abs_value);
1734   }
1735
1736   xquery = htonl(GNUNET_GNS_RECORD_PKEY);
1737
1738   GNUNET_assert(rh->get_handle == NULL);
1739   rh->get_handle = GNUNET_DHT_get_start(dht_handle,
1740                        GNUNET_TIME_UNIT_FOREVER_REL,
1741                        GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
1742                        &lookup_key,
1743                        DHT_GNS_REPLICATION_LEVEL,
1744                        GNUNET_DHT_RO_NONE,
1745                        &xquery,
1746                        sizeof(xquery),
1747                        &process_delegation_result_dht,
1748                        rh);
1749
1750 }
1751
1752
1753 /**
1754  * Namestore resolution for delegation finished. Processing result.
1755  *
1756  * @param cls the closure
1757  * @param rh resolver handle
1758  * @param rd_count number of results (always 0)
1759  * @param rd record data (always NULL)
1760  */
1761 static void
1762 handle_delegation_ns(void* cls, struct ResolverHandle *rh,
1763                           unsigned int rd_count,
1764                           const struct GNUNET_NAMESTORE_RecordData *rd)
1765 {
1766   struct RecordLookupHandle* rlh;
1767   rlh = (struct RecordLookupHandle*) cls;
1768
1769   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1770              "GNS_PHASE_DELEGATE_NS-%llu: Resolution status: %d.\n",
1771              rh->id, rh->status);
1772
1773   if (strcmp(rh->name, "") == 0)
1774   {
1775     if ((rlh->record_type == GNUNET_GNS_RECORD_PKEY))
1776     {
1777       GNUNET_assert(rd_count == 1);
1778       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1779                  "GNS_PHASE_DELEGATE_NS-%llu: Resolved queried PKEY in NS.\n",
1780                  rh->id);
1781       finish_lookup(rh, rlh, rd_count, rd);
1782       free_resolver_handle(rh);
1783       return;
1784     }
1785     /* We resolved full name for delegation. resolving record */
1786     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1787               "GNS_PHASE_DELEGATE_NS-%llu: Resolved full name for delegation.\n",
1788               rh->id);
1789     strcpy(rh->name, "+\0");
1790     rh->proc = &handle_record_ns;
1791     resolve_record_ns(rh);
1792     return;
1793   }
1794
1795   /**
1796    * we still have some left
1797    * check if authority in ns is fresh
1798    * and exists
1799    * or we are authority
1800    **/
1801   if (((rh->status & RSL_RECORD_EXISTS) && (!(rh->status & RSL_RECORD_EXPIRED)))
1802       || !GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
1803                                        &local_zone))
1804   {
1805     if (is_canonical(rh->name))
1806     {
1807       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1808                  "GNS_PHASE_DELEGATE_NS-%llu: Resolving canonical record %s\n",
1809                  rh->id,
1810                  rh->name);
1811       rh->proc = &handle_record_ns;
1812       resolve_record_ns(rh);
1813     }
1814     else
1815     {
1816       /* give up, cannot resolve */
1817       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1818           "GNS_PHASE_DELEGATE_NS-%llu: Cannot fully resolve delegation for %s!\n",
1819           rh->id,
1820           rh->name);
1821       finish_lookup(rh, rlh, rd_count, rd);
1822       //rlh->proc(rlh->proc_cls, 0, NULL);
1823     }
1824     return;
1825   }
1826
1827   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1828       "GNS_PHASE_DELEGATE_NS-%llu: Trying to resolve delegation for %s via DHT\n",
1829       rh->id, rh->name);
1830   rh->proc = &handle_delegation_dht;
1831   resolve_delegation_dht(rh);
1832 }
1833
1834
1835
1836 /**
1837  * This is a callback function that should give us only PKEY
1838  * records. Used to query the namestore for the authority (PKEY)
1839  * for 'name'. It will recursively try to resolve the
1840  * authority for a given name from the namestore.
1841  *
1842  * @param cls the pending query
1843  * @param key the key of the zone we did the lookup
1844  * @param expiration expiration date of the record data set in the namestore
1845  * @param name the name for which we need an authority
1846  * @param rd_count the number of records with 'name'
1847  * @param rd the record data
1848  * @param signature the signature of the authority for the record data
1849  */
1850 static void
1851 process_delegation_result_ns(void* cls,
1852                    const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
1853                    struct GNUNET_TIME_Absolute expiration,
1854                    const char *name,
1855                    unsigned int rd_count,
1856                    const struct GNUNET_NAMESTORE_RecordData *rd,
1857                    const struct GNUNET_CRYPTO_RsaSignature *signature)
1858 {
1859   struct ResolverHandle *rh;
1860   struct GNUNET_TIME_Relative remaining_time;
1861   struct GNUNET_CRYPTO_ShortHashCode zone;
1862   char new_name[MAX_DNS_NAME_LENGTH];
1863
1864   rh = (struct ResolverHandle *)cls;
1865   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1866              "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup\n",
1867              rh->id, rd_count);
1868
1869   GNUNET_CRYPTO_short_hash(key,
1870                      sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
1871                      &zone);
1872   remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
1873
1874   rh->status = 0;
1875
1876   if (name != NULL)
1877   {
1878     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1879                "GNS_PHASE_DELEGATE_NS-%llu: Records with name %s exist.\n",
1880                rh->id, name);
1881     rh->status |= RSL_RECORD_EXISTS;
1882   }
1883
1884   if (remaining_time.rel_value == 0)
1885   {
1886     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1887                "GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n",
1888                rh->id, name);
1889     rh->status |= RSL_RECORD_EXPIRED;
1890   }
1891
1892   /**
1893    * No authority found in namestore.
1894    */
1895   if (rd_count == 0)
1896   {
1897     /**
1898      * We did not find an authority in the namestore
1899      */
1900
1901     /**
1902      * No PKEY in zone.
1903      * Promote this authority back to a name maybe it is
1904      * our record.
1905      */
1906     if (strcmp(rh->name, "") == 0)
1907     {
1908       /* simply promote back */
1909       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1910                  "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n",
1911                  rh->id, rh->authority_name);
1912       strcpy(rh->name, rh->authority_name);
1913     }
1914     else
1915     {
1916       /* add back to existing name */
1917       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1918                  "GNS_PHASE_DELEGATE_NS-%llu: Adding %s back to %s\n",
1919                  rh->id, rh->authority_name, rh->name);
1920       //memset(new_name, 0, strlen(rh->name) + strlen(rh->authority_name) + 2);
1921       GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
1922                       rh->name, rh->authority_name);
1923       //strcpy(new_name, rh->name);
1924       //strcpy(new_name+strlen(new_name), ".");
1925       //strcpy(new_name+strlen(new_name), rh->authority_name);
1926       strcpy(rh->name, new_name);
1927       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1928                  "GNS_PHASE_DELEGATE_NS-%llu: %s restored\n", rh->id, rh->name);
1929     }
1930     rh->proc(rh->proc_cls, rh, 0, NULL);
1931     return;
1932   }
1933
1934   /**
1935    * We found an authority that may be able to help us
1936    * move on with query
1937    * Note only 1 pkey should have been returned.. anything else would be strange
1938    */
1939   int i;
1940   for (i=0; i<rd_count;i++)
1941   {
1942
1943     if (rd[i].record_type != GNUNET_GNS_RECORD_PKEY)
1944       continue;
1945
1946     if (ignore_pending_records &&
1947         (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
1948     {
1949       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1950       "GNS_PHASE_DELEGATE_NS-%llu: PKEY for %s is pending user confirmation.\n",
1951         name,
1952         rh->id);
1953       continue;
1954     }
1955
1956     if ((GNUNET_TIME_absolute_get_remaining (rd[i].expiration)).rel_value
1957          == 0)
1958     {
1959       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1960                  "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
1961                  rh->id);
1962       if (remaining_time.rel_value == 0)
1963       {
1964         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1965                    "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
1966                    rh->id);
1967         rh->authority_chain_head->fresh = 0;
1968         rh->proc(rh->proc_cls, rh, 0, NULL);
1969         return;
1970       }
1971
1972       continue;
1973     }
1974
1975     /**
1976      * Resolve rest of query with new authority
1977      */
1978     GNUNET_assert(rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
1979     memcpy(&rh->authority, rd[i].data,
1980            sizeof(struct GNUNET_CRYPTO_ShortHashCode));
1981     struct AuthorityChain *auth = GNUNET_malloc(sizeof(struct AuthorityChain));
1982     auth->zone = rh->authority;
1983     memset(auth->name, 0, strlen(rh->authority_name)+1);
1984     strcpy(auth->name, rh->authority_name);
1985     GNUNET_CONTAINER_DLL_insert (rh->authority_chain_head,
1986                                  rh->authority_chain_tail,
1987                                  auth);
1988
1989     /** try to import pkey if private key available
1990      * TODO: Only import last one?
1991      */
1992     if (rh->priv_key && (name != NULL))
1993       process_discovered_authority((char*)name, auth->zone,
1994                                    rh->authority_chain_tail->zone,
1995                                    rh->priv_key);
1996     /**
1997      * We are done with PKEY resolution if name is empty
1998      * else resolve again with new authority
1999      */
2000     if (strcmp(rh->name, "") == 0)
2001       rh->proc(rh->proc_cls, rh, rd_count, rd);
2002     else
2003       resolve_delegation_ns(rh);
2004     return;
2005   }
2006
2007   /**
2008    * no answers found
2009    */
2010   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2011     "GNS_PHASE_DELEGATE_NS-%llu: Authority lookup and no PKEY...\n", rh->id);
2012   /**
2013    * If we have found some records for the LAST label
2014    * we return the results. Else null.
2015    */
2016   if (strcmp(rh->name, "") == 0)
2017   {
2018     /* simply promote back */
2019     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2020                "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n",
2021                rh->id, rh->authority_name);
2022     strcpy(rh->name, rh->authority_name);
2023     rh->proc(rh->proc_cls, rh, rd_count, rd);
2024   }
2025   else
2026   {
2027     rh->proc(rh->proc_cls, rh, 0, NULL);
2028   }
2029 }
2030
2031
2032 /**
2033  * Resolve the delegation chain for the request in our namestore
2034  *
2035  * @param rh the resolver handle
2036  */
2037 static void
2038 resolve_delegation_ns(struct ResolverHandle *rh)
2039 {
2040   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2041              "GNS_PHASE_DELEGATE_NS-%llu: Resolving delegation for %s\n",
2042              rh->id, rh->name);
2043   pop_tld(rh->name, rh->authority_name);
2044   GNUNET_NAMESTORE_lookup_record(namestore_handle,
2045                                  &rh->authority,
2046                                  rh->authority_name,
2047                                  GNUNET_GNS_RECORD_ANY,
2048                                  &process_delegation_result_ns,
2049                                  rh);
2050
2051 }
2052
2053
2054 /**
2055  * Lookup of a record in a specific zone
2056  * calls lookup result processor on result
2057  *
2058  * @param zone the root zone
2059  * @param record_type the record type to look up
2060  * @param name the name to look up
2061  * @param key a private key for use with PSEU import (can be NULL)
2062  * @param timeout timeout for resolution
2063  * @param proc the processor to call on result
2064  * @param cls the closure to pass to proc
2065  */
2066 void
2067 gns_resolver_lookup_record(struct GNUNET_CRYPTO_ShortHashCode zone,
2068                            uint32_t record_type,
2069                            const char* name,
2070                            struct GNUNET_CRYPTO_RsaPrivateKey *key,
2071                            struct GNUNET_TIME_Relative timeout,
2072                            RecordLookupProcessor proc,
2073                            void* cls)
2074 {
2075   struct ResolverHandle *rh;
2076   struct RecordLookupHandle* rlh;
2077   char string_hash[MAX_DNS_LABEL_LENGTH];
2078   char nzkey[MAX_DNS_LABEL_LENGTH];
2079   char* nzkey_ptr = nzkey;
2080
2081   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2082               "Starting resolution for %s (type=%d)!\n",
2083               name, record_type);
2084
2085
2086   if (is_canonical((char*)name) && (strcmp(GNUNET_GNS_TLD, name) != 0))
2087   {
2088     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2089                 "%s is canonical and not gnunet -> cannot resolve!\n", name);
2090     proc(cls, 0, NULL);
2091     return;
2092   }
2093
2094   rlh = GNUNET_malloc(sizeof(struct RecordLookupHandle));
2095   rh = GNUNET_malloc(sizeof (struct ResolverHandle));
2096
2097   rh->authority = zone;
2098   rh->id = rid++;
2099   rh->proc_cls = rlh;
2100   rh->priv_key = key;
2101   rh->timeout = timeout;
2102   rh->get_handle = NULL;
2103   if (timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
2104   {
2105     /*
2106      * Set timeout for authority lookup phase to 1/2
2107      */
2108     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2109                 "Timeout for lookup set to %ds\n", rh->timeout.rel_value);
2110     rh->timeout_task = GNUNET_SCHEDULER_add_delayed(
2111                                 GNUNET_TIME_relative_divide(timeout, 2),
2112                                                 &handle_lookup_timeout,
2113                                                 rh);
2114     rh->timeout_cont = &dht_authority_lookup_timeout;
2115     rh->timeout_cont_cls = rh;
2116   }
2117   else
2118   {
2119     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "No timeout for query!\n");
2120     rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
2121   }
2122
2123   if (strcmp(GNUNET_GNS_TLD, name) == 0)
2124   {
2125     /**
2126      * Only 'gnunet' given
2127      */
2128     strcpy(rh->name, "\0");
2129   }
2130   else
2131   {
2132     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2133                 "Checking for TLD...\n");
2134     if (is_zkey_tld(name) == GNUNET_YES)
2135     {
2136       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2137                   "TLD is zkey\n");
2138       /**
2139        * This is a zkey tld
2140        * build hash and use as initial authority
2141        */
2142       memset(rh->name, 0,
2143              strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY));
2144       memcpy(rh->name, name,
2145              strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY) - 1);
2146       pop_tld(rh->name, string_hash);
2147
2148       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2149                   "ZKEY is %s!\n", string_hash);
2150
2151       GNUNET_STRINGS_utf8_toupper(string_hash, &nzkey_ptr);
2152
2153       if (GNUNET_OK != GNUNET_CRYPTO_short_hash_from_string(nzkey,
2154                                                       &rh->authority))
2155       {
2156         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2157                     "Cannot convert ZKEY %s to hash!\n", string_hash);
2158         GNUNET_free(rh);
2159         GNUNET_free(rlh);
2160         proc(cls, 0, NULL);
2161         return;
2162       }
2163
2164     }
2165     else
2166     {
2167       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2168                   "TLD is gnunet\n");
2169       /**
2170        * Presumably GNUNET tld
2171        */
2172       memset(rh->name, 0,
2173              strlen(name)-strlen(GNUNET_GNS_TLD));
2174       memcpy(rh->name, name,
2175              strlen(name)-strlen(GNUNET_GNS_TLD) - 1);
2176     }
2177   }
2178
2179   /**
2180    * Initialize authority chain
2181    */
2182   rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
2183   rh->authority_chain_head->prev = NULL;
2184   rh->authority_chain_head->next = NULL;
2185   rh->authority_chain_tail = rh->authority_chain_head;
2186   rh->authority_chain_head->zone = rh->authority;
2187
2188   /**
2189    * Copy original query into lookup handle
2190    */
2191   rlh->record_type = record_type;
2192   memset(rlh->name, 0, strlen(name) + 1);
2193   strcpy(rlh->name, name);
2194   rlh->proc = proc;
2195   rlh->proc_cls = cls;
2196
2197   rh->proc = &handle_delegation_ns;
2198   resolve_delegation_ns(rh);
2199 }
2200
2201 /******** END Record Resolver ***********/
2202
2203
2204 /**
2205  * Callback calles by namestore for a zone to name
2206  * result
2207  *
2208  * @param cls the closure
2209  * @param zone_key the zone we queried
2210  * @param expire the expiration time of the name
2211  * @param name the name found or NULL
2212  * @param rd_len number of records for the name
2213  * @param rd the record data (PKEY) for the name
2214  * @param signature the signature for the record data
2215  */
2216 static void
2217 process_zone_to_name_shorten(void *cls,
2218                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
2219                  struct GNUNET_TIME_Absolute expire,
2220                  const char *name,
2221                  unsigned int rd_len,
2222                  const struct GNUNET_NAMESTORE_RecordData *rd,
2223                  const struct GNUNET_CRYPTO_RsaSignature *signature)
2224 {
2225   struct ResolverHandle *rh = (struct ResolverHandle *)cls;
2226   struct NameShortenHandle* nsh = (struct NameShortenHandle*)rh->proc_cls;
2227   struct AuthorityChain *next_authority;
2228
2229   char result[MAX_DNS_NAME_LENGTH];
2230   char tmp_name[MAX_DNS_NAME_LENGTH];
2231   size_t answer_len;
2232
2233   /* we found a match in our own zone */
2234   if (rd_len != 0)
2235   {
2236     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2237                "result strlen %d\n", strlen(name));
2238     answer_len = strlen(rh->name) + strlen(name) + strlen(GNUNET_GNS_TLD) + 3;
2239     memset(result, 0, answer_len);
2240     if (strlen(rh->name) > 0)
2241     {
2242       strcpy(result, rh->name);
2243       strcpy(result+strlen(rh->name), ".");
2244     }
2245
2246     strcpy(result+strlen(result), name);
2247     strcpy(result+strlen(result), ".");
2248     strcpy(result+strlen(result), GNUNET_GNS_TLD);
2249
2250     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2251                "Sending shorten result %s\n", result);
2252
2253     nsh->proc(nsh->proc_cls, result);
2254     GNUNET_free(nsh);
2255     free_resolver_handle(rh);
2256   }
2257   else if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
2258                                         &local_zone) == 0)
2259   {
2260     /* our zone, just append .gnunet */
2261     answer_len = strlen(rh->name) + strlen(GNUNET_GNS_TLD) + 2;
2262     memset(result, 0, answer_len);
2263     strcpy(result, rh->name);
2264     strcpy(result+strlen(rh->name), ".");
2265     strcpy(result+strlen(rh->name)+1, GNUNET_GNS_TLD);
2266
2267     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2268                "Our zone: Sending name as shorten result %s\n", rh->name);
2269
2270     nsh->proc(nsh->proc_cls, result);
2271     GNUNET_free(nsh);
2272     free_resolver_handle(rh);
2273   }
2274   else
2275   {
2276     /**
2277      * No PSEU found.
2278      * continue with next authority
2279      */
2280     next_authority = rh->authority_chain_head;
2281
2282     GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
2283                     "%s.%s", rh->name, next_authority->name);
2284
2285     strcpy(rh->name, tmp_name);
2286     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2287                "No PSEU found for authority %s. Promoting back: %s\n",
2288                next_authority->name, rh->name);
2289
2290     GNUNET_CONTAINER_DLL_remove(rh->authority_chain_head,
2291                               rh->authority_chain_tail,
2292                               next_authority);
2293
2294     GNUNET_NAMESTORE_zone_to_name (namestore_handle,
2295                                    &rh->authority_chain_tail->zone,
2296                                    &rh->authority_chain_head->zone,
2297                                    &process_zone_to_name_shorten,
2298                                    rh);
2299   }
2300 }
2301
2302 /**
2303  * DHT resolution for delegation. Processing result.
2304  *
2305  * @param cls the closure
2306  * @param rh resolver handle
2307  * @param rd_count number of results
2308  * @param rd record data
2309  */
2310 static void
2311 handle_delegation_dht_bg_shorten(void* cls, struct ResolverHandle *rh,
2312                           unsigned int rd_count,
2313                           const struct GNUNET_NAMESTORE_RecordData *rd)
2314 {
2315
2316   /* We resolved full name for delegation. resolving record */
2317   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2318     "GNS_SHORTEN: Resolved up to %s for delegation via DHT in background.\n",
2319     rh->name);
2320   free_resolver_handle(rh);
2321 }
2322
2323 /**
2324  * Process result from namestore delegation lookup
2325  * for shorten operation
2326  *
2327  * @param cls the client shorten handle
2328  * @param rh the resolver handle
2329  * @param rd_count number of results (0)
2330  * @param rd data (NULL)
2331  */
2332 void
2333 handle_delegation_ns_shorten(void* cls,
2334                       struct ResolverHandle *rh,
2335                       uint32_t rd_count,
2336                       const struct GNUNET_NAMESTORE_RecordData *rd)
2337 {
2338   struct NameShortenHandle *nsh;
2339   char result[MAX_DNS_NAME_LENGTH];
2340   size_t answer_len;
2341   struct ResolverHandle *rh_bg;
2342
2343   nsh = (struct NameShortenHandle *)cls;
2344
2345   /**
2346    * At this point rh->name contains the part of the name
2347    * that we do not have a PKEY in our namestore to resolve.
2348    * The authority chain in the resolver handle is now
2349    * useful to backtrack if needed
2350    */
2351
2352   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2353              "PKEY resolved as far as possible in ns up to %s!\n", rh->name);
2354
2355   if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
2356                                    &local_zone) == 0)
2357   {
2358     /**
2359      * This is our zone append .gnunet unless name is empty
2360      * (it shouldn't be, usually FIXME what happens if we
2361      * shorten to our zone to a "" record??)
2362      */
2363
2364     answer_len = strlen(rh->name) + strlen(GNUNET_GNS_TLD) + 2;
2365     memset(result, 0, answer_len);
2366     strcpy(result, rh->name);
2367     strcpy(result+strlen(rh->name), ".");
2368     strcpy(result+strlen(rh->name)+1, GNUNET_GNS_TLD);
2369
2370     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2371                "Our zone: Sending name as shorten result %s\n", rh->name);
2372
2373     nsh->proc(nsh->proc_cls, result);
2374     GNUNET_free(nsh);
2375     free_resolver_handle(rh);
2376     return;
2377   }
2378
2379   /**
2380    * we have to this before zone to name for rh might
2381    * be freed by then
2382    */
2383   rh_bg = NULL;
2384   if (!is_canonical(rh->name))
2385   {
2386     rh_bg = GNUNET_malloc(sizeof(struct ResolverHandle));
2387     memcpy(rh_bg, rh, sizeof(struct ResolverHandle));
2388     rh_bg->id = rid++;
2389   }
2390
2391   /* backtrack authorities for names */
2392   GNUNET_NAMESTORE_zone_to_name (namestore_handle,
2393                                  &rh->authority_chain_tail->zone, //ours
2394                                  &rh->authority_chain_head->zone,
2395                                  &process_zone_to_name_shorten,
2396                                  rh);
2397
2398   if (rh_bg == NULL)
2399   {
2400     return;
2401   }
2402
2403   /**
2404    * If authority resolution is incomplete we can do a background lookup
2405    * of the full name so that next time we can (likely) fully or at least
2406    * further shorten the name
2407    */
2408   rh_bg->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
2409   rh_bg->authority_chain_tail = rh_bg->authority_chain_head;
2410   rh_bg->authority_chain_head->zone = rh_bg->authority;
2411
2412   rh_bg->proc = &handle_delegation_dht_bg_shorten;
2413   rh_bg->proc_cls = NULL;
2414
2415   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2416              "GNS_SHORTEN: Starting background lookup for %s\n",
2417              rh_bg->name);
2418
2419   resolve_delegation_dht(rh_bg);
2420
2421 }
2422
2423
2424 /**
2425  * Callback calles by namestore for a zone to name
2426  * result
2427  *
2428  * @param cls the closure
2429  * @param zone_key the zone we queried
2430  * @param expire the expiration time of the name
2431  * @param name the name found or NULL
2432  * @param rd_len number of records for the name
2433  * @param rd the record data (PKEY) for the name
2434  * @param signature the signature for the record data
2435  */
2436 static void
2437 process_zone_to_name_zkey(void *cls,
2438                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
2439                  struct GNUNET_TIME_Absolute expire,
2440                  const char *name,
2441                  unsigned int rd_len,
2442                  const struct GNUNET_NAMESTORE_RecordData *rd,
2443                  const struct GNUNET_CRYPTO_RsaSignature *signature)
2444 {
2445   struct ResolverHandle *rh = cls;
2446   struct NameShortenHandle *nsh = rh->proc_cls;
2447   struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc;
2448   char new_name[MAX_DNS_NAME_LENGTH];
2449
2450   /* zkey not in our zone */
2451   if (name == NULL)
2452   {
2453     /**
2454      * In this case we have not given this PKEY a name (yet)
2455      * It is either just not in our zone or not even cached
2456      * Since we do not know at this point we will not try to shorten
2457      * because PKEY import will happen if the user follows the zkey
2458      * link.
2459      */
2460     GNUNET_CRYPTO_short_hash_to_enc ((struct GNUNET_CRYPTO_ShortHashCode*)rd,
2461                                      &enc);
2462     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2463                "No name found for zkey %s returning verbatim!\n", enc);
2464     if (strcmp(rh->name, "") != 0)
2465       GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s.%s",
2466                       rh->name, enc, GNUNET_GNS_TLD_ZKEY);
2467     else
2468       GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
2469                       enc, GNUNET_GNS_TLD_ZKEY);
2470     nsh->proc(nsh->proc_cls, new_name);
2471     GNUNET_free(nsh);
2472     free_resolver_handle(rh);
2473     return;
2474   }
2475
2476   if (strcmp(rh->name, "") != 0)
2477     GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
2478                     rh->name, name);
2479   else
2480     strcpy(new_name, name);
2481
2482   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2483              "Continue shorten for %s!\n", new_name);
2484
2485   strcpy(rh->name, new_name);
2486
2487   rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
2488   rh->authority_chain_tail = rh->authority_chain_head;
2489   rh->authority_chain_head->zone = rh->authority;
2490
2491
2492   /* Start delegation resolution in our namestore */
2493   resolve_delegation_ns(rh);
2494 }
2495
2496
2497 /**
2498  * Shorten api from resolver
2499  *
2500  * @param zone the zone to use
2501  * @param name the name to shorten
2502  * @param key optional private key for background lookups and PSEU import
2503  * @param proc the processor to call with result
2504  * @param proc_cls closure to pass to proc
2505  */
2506 void
2507 gns_resolver_shorten_name(struct GNUNET_CRYPTO_ShortHashCode zone,
2508                           const char* name,
2509                           struct GNUNET_CRYPTO_RsaPrivateKey *key,
2510                           ShortenResultProcessor proc,
2511                           void* proc_cls)
2512 {
2513   struct ResolverHandle *rh;
2514   struct NameShortenHandle *nsh;
2515   char string_hash[MAX_DNS_LABEL_LENGTH];
2516   struct GNUNET_CRYPTO_ShortHashCode zkey;
2517   char nzkey[MAX_DNS_LABEL_LENGTH];
2518   char* nzkey_ptr = nzkey;
2519
2520
2521   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2522               "Starting shorten for %s!\n", name);
2523
2524   if (is_canonical((char*)name))
2525   {
2526     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2527                 "%s is canonical. Returning verbatim\n", name);
2528     proc(proc_cls, name);
2529     return;
2530   }
2531
2532   nsh = GNUNET_malloc(sizeof (struct NameShortenHandle));
2533
2534   nsh->proc = proc;
2535   nsh->proc_cls = proc_cls;
2536
2537   rh = GNUNET_malloc(sizeof (struct ResolverHandle));
2538   rh->authority = zone;
2539   rh->id = rid++;
2540   rh->priv_key = key;
2541   rh->proc = &handle_delegation_ns_shorten;
2542   rh->proc_cls = nsh;
2543   rh->id = rid++;
2544
2545   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2546                 "Checking for TLD...\n");
2547   if (is_zkey_tld(name) == GNUNET_YES)
2548   {
2549     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2550                 "TLD is zkey\n");
2551     /**
2552      * This is a zkey tld
2553      * build hash and use as initial authority
2554      * FIXME sscanf
2555      */
2556     memset(rh->name, 0,
2557            strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY));
2558     memcpy(rh->name, name,
2559            strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY) - 1);
2560     pop_tld(rh->name, string_hash);
2561
2562     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2563                 "ZKEY is %s!\n", string_hash);
2564
2565     GNUNET_STRINGS_utf8_toupper(string_hash, &nzkey_ptr);
2566
2567     if (GNUNET_OK != GNUNET_CRYPTO_short_hash_from_string(nzkey,
2568                                                           &zkey))
2569     {
2570       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2571                   "Cannot convert ZKEY %s to hash!\n", nzkey);
2572       GNUNET_free(rh);
2573       GNUNET_free(nsh);
2574       proc(proc_cls, name);
2575       return;
2576     }
2577
2578     GNUNET_NAMESTORE_zone_to_name (namestore_handle,
2579                                    &zone, //ours
2580                                    &zkey,
2581                                    &process_zone_to_name_zkey,
2582                                    rh);
2583     return;
2584
2585   }
2586   else
2587   {
2588     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2589                 "TLD is gnunet\n");
2590     /**
2591      * Presumably GNUNET tld
2592      */
2593     memset(rh->name, 0,
2594            strlen(name)-strlen(GNUNET_GNS_TLD));
2595     memcpy(rh->name, name,
2596            strlen(name)-strlen(GNUNET_GNS_TLD) - 1);
2597   }
2598
2599   rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
2600   rh->authority_chain_tail = rh->authority_chain_head;
2601   rh->authority_chain_head->zone = zone;
2602
2603
2604   /* Start delegation resolution in our namestore */
2605   resolve_delegation_ns(rh);
2606 }
2607
2608 /*********** END NAME SHORTEN ********************/
2609
2610
2611 /**
2612  * Process result from namestore delegation lookup
2613  * for get authority operation
2614  *
2615  * @param cls the client get auth handle
2616  * @param rh the resolver handle
2617  * @param rd_count number of results (0)
2618  * @param rd data (NULL)
2619  */
2620 void
2621 handle_delegation_result_ns_get_auth(void* cls,
2622                       struct ResolverHandle *rh,
2623                       uint32_t rd_count,
2624                       const struct GNUNET_NAMESTORE_RecordData *rd)
2625 {
2626   struct GetNameAuthorityHandle* nah;
2627   char result[MAX_DNS_NAME_LENGTH];
2628   size_t answer_len;
2629
2630   nah = (struct GetNameAuthorityHandle*) rh->proc_cls;
2631
2632   /**
2633    * At this point rh->name contains the part of the name
2634    * that we do not have a PKEY in our namestore to resolve.
2635    * The authority chain in the resolver handle is now
2636    * useful to backtrack if needed
2637    */
2638
2639   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2640              "PKEY resolved as far as possible in ns up to %s!\n", rh->name);
2641
2642   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2643              "Building response!\n");
2644   if (is_canonical(rh->name))
2645   {
2646     /**
2647      * We successfully resolved the authority in the ns
2648      * FIXME for our purposes this is fine
2649      * but maybe we want to have an api that also looks
2650      * into the dht (i.e. option in message)
2651      **/
2652     if (strlen(rh->name) > strlen(nah->name))
2653     {
2654       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2655                  "Record name longer than original lookup name... odd!\n");
2656       //FIXME to sth here
2657     }
2658
2659     answer_len = strlen(nah->name) - strlen(rh->name)
2660       + strlen(GNUNET_GNS_TLD) + 1;
2661     memset(result, 0, answer_len);
2662     strcpy(result, nah->name + strlen(rh->name) + 1);
2663
2664     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2665                "Got authority result %s\n", result);
2666
2667     nah->proc(nah->proc_cls, result);
2668     GNUNET_free(nah);
2669     free_resolver_handle(rh);
2670   }
2671   else
2672   {
2673     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2674                "Unable to resolve authority for remaining %s!\n", rh->name);
2675     nah->proc(nah->proc_cls, "");
2676     GNUNET_free(nah);
2677     free_resolver_handle(rh);
2678   }
2679
2680
2681 }
2682
2683
2684 /**
2685  * Tries to resolve the authority for name
2686  * in our namestore
2687  *
2688  * @param zone the root zone to look up for
2689  * @param name the name to lookup up
2690  * @param proc the processor to call when finished
2691  * @param proc_cls the closure to pass to the processor
2692  */
2693 void
2694 gns_resolver_get_authority(struct GNUNET_CRYPTO_ShortHashCode zone,
2695                            const char* name,
2696                            GetAuthorityResultProcessor proc,
2697                            void* proc_cls)
2698 {
2699   struct ResolverHandle *rh;
2700   struct GetNameAuthorityHandle *nah;
2701
2702   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2703               "Starting authority resolution for %s!\n", name);
2704
2705   nah = GNUNET_malloc(sizeof (struct GetNameAuthorityHandle));
2706   rh = GNUNET_malloc(sizeof (struct ResolverHandle));
2707   rh->authority = zone;
2708   rh->id = rid++;
2709
2710   if (strcmp(GNUNET_GNS_TLD, name) == 0)
2711   {
2712     strcpy(rh->name, "\0");
2713   }
2714   else
2715   {
2716     memset(rh->name, 0,
2717            strlen(name)-strlen(GNUNET_GNS_TLD));
2718     memcpy(rh->name, name,
2719            strlen(name)-strlen(GNUNET_GNS_TLD) - 1);
2720   }
2721
2722   memset(nah->name, 0,
2723          strlen(name)+1);
2724   strcpy(nah->name, name);
2725
2726   rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
2727   rh->authority_chain_tail = rh->authority_chain_head;
2728   rh->authority_chain_head->zone = zone;
2729   rh->proc = &handle_delegation_result_ns_get_auth;
2730   rh->proc_cls = (void*)nah;
2731
2732   nah->proc = proc;
2733   nah->proc_cls = proc_cls;
2734
2735   /* Start delegation resolution in our namestore */
2736   resolve_delegation_ns(rh);
2737
2738 }
2739
2740 /******** END GET AUTHORITY *************/
2741
2742 /* end of gnunet-service-gns_resolver.c */