src/namestore/gnunet-service-namestore.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012, 2013, 2014 GNUnet e.V.
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @file namestore/gnunet-service-namestore.c
  23  * @brief namestore for the GNUnet naming system
  24  * @author Matthias Wachs
  25  * @author Christian Grothoff
  26  */
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_dnsparser_lib.h"
  30 #include "gnunet_gns_service.h"
  31 #include "gnunet_namecache_service.h"
  32 #include "gnunet_namestore_service.h"
  33 #include "gnunet_namestore_plugin.h"
  34 #include "gnunet_signatures.h"
  35 #include "namestore.h"
  36
  37 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
  38
  39
  40 /**
  41  * A namestore client
  42  */
  43 struct NamestoreClient;
  44
  45
  46 /**
  47  * A namestore iteration operation.
  48  */
  49 struct ZoneIteration
  50 {
  51   /**
  52    * Next element in the DLL
  53    */
  54   struct ZoneIteration *next;
  55
  56   /**
  57    * Previous element in the DLL
  58    */
  59   struct ZoneIteration *prev;
  60
  61   /**
  62    * Namestore client which intiated this zone iteration
  63    */
  64   struct NamestoreClient *nc;
  65
  66   /**
  67    * The nick to add to the records
  68    */
  69   struct GNUNET_GNSRECORD_Data *nick;
  70
  71   /**
  72    * Key of the zone we are iterating over.
  73    */
  74   struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
  75
  76   /**
  77    * The operation id fot the zone iteration in the response for the client
  78    */
  79   uint32_t request_id;
  80
  81   /**
  82    * Offset of the zone iteration used to address next result of the zone
  83    * iteration in the store
  84    *
  85    * Initialy set to 0 in handle_iteration_start
  86    * Incremented with by every call to handle_iteration_next
  87    */
  88   uint32_t offset;
  89
  90 };
  91
  92
  93 /**
  94  * A namestore client
  95  */
  96 struct NamestoreClient
  97 {
  98
  99   /**
 100    * The client
 101    */
 102   struct GNUNET_SERVICE_Client *client;
 103
 104   /**
 105    * Message queue for transmission to @e client
 106    */
 107   struct GNUNET_MQ_Handle *mq;
 108
 109   /**
 110    * Head of the DLL of
 111    * Zone iteration operations in progress initiated by this client
 112    */
 113   struct ZoneIteration *op_head;
 114
 115   /**
 116    * Tail of the DLL of
 117    * Zone iteration operations in progress initiated by this client
 118    */
 119   struct ZoneIteration *op_tail;
 120 };
 121
 122
 123 /**
 124  * A namestore monitor.
 125  */
 126 struct ZoneMonitor
 127 {
 128   /**
 129    * Next element in the DLL
 130    */
 131   struct ZoneMonitor *next;
 132
 133   /**
 134    * Previous element in the DLL
 135    */
 136   struct ZoneMonitor *prev;
 137
 138   /**
 139    * Namestore client which intiated this zone monitor
 140    */
 141   struct NamestoreClient *nc;
 142
 143   /**
 144    * Private key of the zone.
 145    */
 146   struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
 147
 148   /**
 149    * Task active during initial iteration.
 150    */
 151   struct GNUNET_SCHEDULER_Task *task;
 152
 153   /**
 154    * Offset of the zone iteration used to address next result of the zone
 155    * iteration in the store
 156    *
 157    * Initialy set to 0.
 158    * Incremented with by every call to #handle_iteration_next
 159    */
 160   uint32_t offset;
 161
 162 };
 163
 164
 165 /**
 166  * Pending operation on the namecache.
 167  */
 168 struct CacheOperation
 169 {
 170
 171   /**
 172    * Kept in a DLL.
 173    */
 174   struct CacheOperation *prev;
 175
 176   /**
 177    * Kept in a DLL.
 178    */
 179   struct CacheOperation *next;
 180
 181   /**
 182    * Handle to namecache queue.
 183    */
 184   struct GNUNET_NAMECACHE_QueueEntry *qe;
 185
 186   /**
 187    * Client to notify about the result.
 188    */
 189   struct NamestoreClient *nc;
 190
 191   /**
 192    * Client's request ID.
 193    */
 194   uint32_t rid;
 195 };
 196
 197
 198 /**
 199  * Public key of all zeros.
 200  */
 201 static const struct GNUNET_CRYPTO_EcdsaPrivateKey zero;
 202
 203 /**
 204  * Configuration handle.
 205  */
 206 static const struct GNUNET_CONFIGURATION_Handle *GSN_cfg;
 207
 208 /**
 209  * Namecache handle.
 210  */
 211 static struct GNUNET_NAMECACHE_Handle *namecache;
 212
 213 /**
 214  * Database handle
 215  */
 216 static struct GNUNET_NAMESTORE_PluginFunctions *GSN_database;
 217
 218 /**
 219  * Name of the database plugin
 220  */
 221 static char *db_lib_name;
 222
 223 /**
 224  * Head of cop DLL.
 225  */
 226 static struct CacheOperation *cop_head;
 227
 228 /**
 229  * Tail of cop DLL.
 230  */
 231 static struct CacheOperation *cop_tail;
 232
 233 /**
 234  * First active zone monitor.
 235  */
 236 static struct ZoneMonitor *monitor_head;
 237
 238 /**
 239  * Last active zone monitor.
 240  */
 241 static struct ZoneMonitor *monitor_tail;
 242
 243 /**
 244  * Notification context shared by all monitors.
 245  */
 246 static struct GNUNET_NotificationContext *monitor_nc;
 247
 248
 249 /**
 250  * Task run during shutdown.
 251  *
 252  * @param cls unused
 253  */
 254 static void
 255 cleanup_task (void *cls)
 256 {
 257   struct CacheOperation *cop;
 258
 259   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 260               "Stopping namestore service\n");
 261   while (NULL != (cop = cop_head))
 262   {
 263     GNUNET_NAMECACHE_cancel (cop->qe);
 264     GNUNET_CONTAINER_DLL_remove (cop_head,
 265                                  cop_tail,
 266                                  cop);
 267     GNUNET_free (cop);
 268   }
 269   GNUNET_NAMECACHE_disconnect (namecache);
 270   namecache = NULL;
 271   GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name,
 272                                               GSN_database));
 273   GNUNET_free (db_lib_name);
 274   db_lib_name = NULL;
 275   if (NULL != monitor_nc)
 276   {
 277     GNUNET_notification_context_destroy (monitor_nc);
 278     monitor_nc = NULL;
 279   }
 280 }
 281
 282
 283 /**
 284  * Called whenever a client is disconnected.
 285  * Frees our resources associated with that client.
 286  *
 287  * @param cls closure
 288  * @param client identification of the client
 289  * @param app_ctx the `struct NamestoreClient` of @a client
 290  */
 291 static void
 292 client_disconnect_cb (void *cls,
 293                       struct GNUNET_SERVICE_Client *client,
 294                       void *app_ctx)
 295 {
 296   struct NamestoreClient *nc = app_ctx;
 297   struct ZoneIteration *no;
 298   struct ZoneMonitor *zm;
 299   struct CacheOperation *cop;
 300
 301   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 302               "Client %p disconnected\n",
 303               client);
 304   for (zm = monitor_head; NULL != zm; zm = zm->next)
 305   {
 306     if (nc == zm->nc)
 307     {
 308       GNUNET_CONTAINER_DLL_remove (monitor_head,
 309                                    monitor_tail,
 310                                    zm);
 311       if (NULL != zm->task)
 312       {
 313         GNUNET_SCHEDULER_cancel (zm->task);
 314         zm->task = NULL;
 315       }
 316       GNUNET_free (zm);
 317       break;
 318     }
 319   }
 320   while (NULL != (no = nc->op_head))
 321   {
 322     GNUNET_CONTAINER_DLL_remove (nc->op_head,
 323                                  nc->op_tail,
 324                                  no);
 325     GNUNET_free (no);
 326   }
 327   for (cop = cop_head; NULL != cop; cop = cop->next)
 328     if (nc == cop->nc)
 329       cop->nc = NULL;
 330   GNUNET_free (nc);
 331 }
 332
 333
 334 /**
 335  * Add a client to our list of active clients.
 336  *
 337  * @param cls NULL
 338  * @param client client to add
 339  * @param mq message queue for @a client
 340  * @return internal namestore client structure for this client
 341  */
 342 static void *
 343 client_connect_cb (void *cls,
 344                    struct GNUNET_SERVICE_Client *client,
 345                    struct GNUNET_MQ_Handle *mq)
 346 {
 347   struct NamestoreClient *nc;
 348
 349   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 350               "Client %p connected\n",
 351               client);
 352   nc = GNUNET_new (struct NamestoreClient);
 353   nc->client = client;
 354   nc->mq = mq;
 355   return nc;
 356 }
 357
 358
 359 /**
 360  * Function called with the records for the #GNUNET_GNS_MASTERZONE_STR
 361  * label in the zone.  Used to locate the #GNUNET_GNSRECORD_TYPE_NICK
 362  * record, which (if found) is then copied to @a cls for future use.
 363  *
 364  * @param cls a `struct GNUNET_GNSRECORD_Data **` for storing the nick (if found)
 365  * @param private_key the private key of the zone (unused)
 366  * @param label should be #GNUNET_GNS_MASTERZONE_STR
 367  * @param rd_count number of records in @a rd
 368  * @param rd records stored under @a label in the zone
 369  */
 370 static void
 371 lookup_nick_it (void *cls,
 372                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
 373                 const char *label,
 374                 unsigned int rd_count,
 375                 const struct GNUNET_GNSRECORD_Data *rd)
 376 {
 377   struct GNUNET_GNSRECORD_Data **res = cls;
 378
 379   if (0 != strcmp (label, GNUNET_GNS_MASTERZONE_STR))
 380   {
 381     GNUNET_break (0);
 382     return;
 383   }
 384   for (unsigned int c = 0; c < rd_count; c++)
 385   {
 386     if (GNUNET_GNSRECORD_TYPE_NICK == rd[c].record_type)
 387     {
 388       (*res) = GNUNET_malloc (rd[c].data_size + sizeof (struct GNUNET_GNSRECORD_Data));
 389       (*res)->data = &(*res)[1];
 390       GNUNET_memcpy ((void *) (*res)->data,
 391                      rd[c].data,
 392                      rd[c].data_size);
 393       (*res)->data_size = rd[c].data_size;
 394       (*res)->expiration_time = rd[c].expiration_time;
 395       (*res)->flags = rd[c].flags;
 396       (*res)->record_type = GNUNET_GNSRECORD_TYPE_NICK;
 397       return;
 398     }
 399   }
 400   (*res) = NULL;
 401 }
 402
 403
 404 /**
 405  * Return the NICK record for the zone (if it exists).
 406  *
 407  * @param zone private key for the zone to look for nick
 408  * @return NULL if no NICK record was found
 409  */
 410 static struct GNUNET_GNSRECORD_Data *
 411 get_nick_record (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone)
 412 {
 413   struct GNUNET_CRYPTO_EcdsaPublicKey pub;
 414   struct GNUNET_GNSRECORD_Data *nick;
 415   int res;
 416
 417   res = GSN_database->lookup_records (GSN_database->cls, zone,
 418                                       GNUNET_GNS_MASTERZONE_STR,
 419                                       &lookup_nick_it, &nick);
 420   if ( (GNUNET_OK != res) ||
 421        (NULL == nick) )
 422   {
 423     GNUNET_CRYPTO_ecdsa_key_get_public (zone, &pub);
 424     GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
 425                 "No nick name set for zone `%s'\n",
 426                 GNUNET_GNSRECORD_z2s (&pub));
 427     return NULL;
 428   }
 429   return nick;
 430 }
 431
 432
 433 static void
 434 merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd,
 435                          unsigned int rdc2,
 436                          const struct GNUNET_GNSRECORD_Data *rd2,
 437                          unsigned int *rdc_res,
 438                          struct GNUNET_GNSRECORD_Data **rd_res)
 439 {
 440   uint64_t latest_expiration;
 441   size_t req;
 442   char *data;
 443   int record_offset;
 444   size_t data_offset;
 445
 446   (*rdc_res) = 1 + rdc2;
 447   if (0 == 1 + rdc2)
 448   {
 449     (*rd_res) = NULL;
 450     return;
 451   }
 452
 453   req = 0;
 454   for (unsigned int c=0; c< 1; c++)
 455     req += sizeof (struct GNUNET_GNSRECORD_Data) + nick_rd[c].data_size;
 456   for (unsigned int c=0; c< rdc2; c++)
 457     req += sizeof (struct GNUNET_GNSRECORD_Data) + rd2[c].data_size;
 458   (*rd_res) = GNUNET_malloc (req);
 459   data = (char *) &(*rd_res)[1 + rdc2];
 460   data_offset = 0;
 461   latest_expiration = 0;
 462
 463   for (unsigned int c=0; c< rdc2; c++)
 464   {
 465     if (0 != (rd2[c].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
 466     {
 467       if ((GNUNET_TIME_absolute_get().abs_value_us + rd2[c].expiration_time) >
 468         latest_expiration)
 469           latest_expiration = rd2[c].expiration_time;
 470     }
 471     else if (rd2[c].expiration_time > latest_expiration)
 472       latest_expiration = rd2[c].expiration_time;
 473     (*rd_res)[c] = rd2[c];
 474     (*rd_res)[c].data = (void *) &data[data_offset];
 475     GNUNET_memcpy ((void *) (*rd_res)[c].data,
 476                    rd2[c].data,
 477                    rd2[c].data_size);
 478     data_offset += (*rd_res)[c].data_size;
 479   }
 480   record_offset = rdc2;
 481   for (unsigned int c=0; c< 1; c++)
 482   {
 483     (*rd_res)[c+record_offset] = nick_rd[c];
 484     (*rd_res)[c+record_offset].expiration_time = latest_expiration;
 485     (*rd_res)[c+record_offset].data = (void *) &data[data_offset];
 486     GNUNET_memcpy ((void *) (*rd_res)[c+record_offset].data,
 487                    nick_rd[c].data,
 488                    nick_rd[c].data_size);
 489     data_offset += (*rd_res)[c+record_offset].data_size;
 490   }
 491   GNUNET_assert (req == (sizeof (struct GNUNET_GNSRECORD_Data)) * (*rdc_res) + data_offset);
 492 }
 493
 494
 495 /**
 496  * Generate a `struct LookupNameResponseMessage` and send it to the
 497  * given client using the given notification context.
 498  *
 499  * @param nc client to unicast to
 500  * @param request_id request ID to use
 501  * @param zone_key zone key of the zone
 502  * @param name name
 503  * @param rd_count number of records in @a rd
 504  * @param rd array of records
 505  */
 506 static void
 507 send_lookup_response (struct NamestoreClient *nc,
 508                       uint32_t request_id,
 509                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 510                       const char *name,
 511                       unsigned int rd_count,
 512                       const struct GNUNET_GNSRECORD_Data *rd)
 513 {
 514   struct GNUNET_MQ_Envelope *env;
 515   struct RecordResultMessage *zir_msg;
 516   struct GNUNET_GNSRECORD_Data *nick;
 517   struct GNUNET_GNSRECORD_Data *res;
 518   unsigned int res_count;
 519   size_t name_len;
 520   size_t rd_ser_len;
 521   char *name_tmp;
 522   char *rd_ser;
 523
 524   nick = get_nick_record (zone_key);
 525   if ((NULL != nick) && (0 != strcmp(name, GNUNET_GNS_MASTERZONE_STR)))
 526   {
 527     nick->flags = (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
 528     merge_with_nick_records (nick,
 529                              rd_count,
 530                              rd,
 531                              &res_count,
 532                              &res);
 533     GNUNET_free (nick);
 534   }
 535   else
 536   {
 537     res_count = rd_count;
 538     res = (struct GNUNET_GNSRECORD_Data *) rd;
 539   }
 540
 541   name_len = strlen (name) + 1;
 542   rd_ser_len = GNUNET_GNSRECORD_records_get_size (res_count, res);
 543   env = GNUNET_MQ_msg_extra (zir_msg,
 544                              name_len + rd_ser_len,
 545                              GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT);
 546   zir_msg->gns_header.r_id = htonl (request_id);
 547   zir_msg->name_len = htons (name_len);
 548   zir_msg->rd_count = htons (res_count);
 549   zir_msg->rd_len = htons (rd_ser_len);
 550   zir_msg->private_key = *zone_key;
 551   name_tmp = (char *) &zir_msg[1];
 552   GNUNET_memcpy (name_tmp,
 553                  name,
 554                  name_len);
 555   rd_ser = &name_tmp[name_len];
 556   GNUNET_GNSRECORD_records_serialize (res_count,
 557                                       res,
 558                                       rd_ser_len,
 559                                       rd_ser);
 560   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 561               "Sending RECORD_RESULT message with %u records\n",
 562               res_count);
 563   GNUNET_MQ_send (nc->mq,
 564                   env);
 565   if (rd != res)
 566     GNUNET_free (res);
 567 }
 568
 569
 570 /**
 571  * Send response to the store request to the client.
 572  *
 573  * @param client client to talk to
 574  * @param res status of the operation
 575  * @param rid client's request ID
 576  */
 577 static void
 578 send_store_response (struct NamestoreClient *nc,
 579                      int res,
 580                      uint32_t rid)
 581 {
 582   struct GNUNET_MQ_Envelope *env;
 583   struct RecordStoreResponseMessage *rcr_msg;
 584
 585   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 586               "Sending RECORD_STORE_RESPONSE message\n");
 587   env = GNUNET_MQ_msg (rcr_msg,
 588                        GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE);
 589   rcr_msg->gns_header.r_id = htonl (rid);
 590   rcr_msg->op_result = htonl (res);
 591   GNUNET_MQ_send (nc->mq,
 592                   env);
 593 }
 594
 595
 596 /**
 597  * Cache operation complete, clean up.
 598  *
 599  * @param cls the `struct CacheOperation`
 600  * @param success success
 601  * @param emsg error messages
 602  */
 603 static void
 604 finish_cache_operation (void *cls,
 605                         int32_t success,
 606                         const char *emsg)
 607 {
 608   struct CacheOperation *cop = cls;
 609
 610   if (NULL != emsg)
 611     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 612                 _("Failed to replicate block in namecache: %s\n"),
 613                 emsg);
 614   else
 615     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 616                 "CACHE operation completed\n");
 617   GNUNET_CONTAINER_DLL_remove (cop_head,
 618                                cop_tail,
 619                                cop);
 620   if (NULL != cop->nc)
 621     send_store_response (cop->nc,
 622                          success,
 623                          cop->rid);
 624   GNUNET_free (cop);
 625 }
 626
 627
 628 /**
 629  * We just touched the plaintext information about a name in our zone;
 630  * refresh the corresponding (encrypted) block in the namecache.
 631  *
 632  * @param nc client responsible for the request, can be NULL
 633  * @param rid request ID of the client
 634  * @param zone_key private key of the zone
 635  * @param name label for the records
 636  * @param rd_count number of records
 637  * @param rd records stored under the given @a name
 638  */
 639 static void
 640 refresh_block (struct NamestoreClient *nc,
 641                uint32_t rid,
 642                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
 643                const char *name,
 644                unsigned int rd_count,
 645                const struct GNUNET_GNSRECORD_Data *rd)
 646 {
 647   struct GNUNET_GNSRECORD_Block *block;
 648   struct CacheOperation *cop;
 649   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
 650   struct GNUNET_GNSRECORD_Data *nick;
 651   struct GNUNET_GNSRECORD_Data *res;
 652   unsigned int res_count;
 653
 654   nick = get_nick_record (zone_key);
 655   res_count = rd_count;
 656   res = (struct GNUNET_GNSRECORD_Data *) rd; /* fixme: a bit unclean... */
 657   if (NULL != nick)
 658   {
 659     nick->flags = (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
 660     merge_with_nick_records (nick,
 661                              rd_count,rd,
 662                              &res_count,
 663                              &res);
 664     GNUNET_free (nick);
 665   }
 666
 667   if (0 == res_count)
 668     block = GNUNET_GNSRECORD_block_create (zone_key,
 669                                            GNUNET_TIME_UNIT_ZERO_ABS,
 670                                            name,
 671                                            res, rd_count);
 672   else
 673     block = GNUNET_GNSRECORD_block_create (zone_key,
 674                                            GNUNET_GNSRECORD_record_get_expiration_time (res_count,
 675                                                res),
 676                                            name,
 677                                            res, res_count);
 678   GNUNET_assert (NULL != block);
 679   GNUNET_CRYPTO_ecdsa_key_get_public (zone_key,
 680                                       &pkey);
 681   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 682               "Caching block for label `%s' with %u records in zone `%s' in namecache\n",
 683               name,
 684               res_count,
 685               GNUNET_GNSRECORD_z2s (&pkey));
 686   cop = GNUNET_new (struct CacheOperation);
 687   cop->nc = nc;
 688   cop->rid = rid;
 689   GNUNET_CONTAINER_DLL_insert (cop_head,
 690                                cop_tail,
 691                                cop);
 692   cop->qe = GNUNET_NAMECACHE_block_cache (namecache,
 693                                           block,
 694                                           &finish_cache_operation,
 695                                           cop);
 696   GNUNET_free (block);
 697 }
 698
 699
 700 /**
 701  * Closure for #lookup_it().
 702  */
 703 struct RecordLookupContext
 704 {
 705   const char *label;
 706
 707   int found;
 708
 709   unsigned int res_rd_count;
 710
 711   size_t rd_ser_len;
 712
 713   char *res_rd;
 714
 715   struct GNUNET_GNSRECORD_Data *nick;
 716 };
 717
 718
 719 static void
 720 lookup_it (void *cls,
 721            const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key,
 722            const char *label,
 723            unsigned int rd_count,
 724            const struct GNUNET_GNSRECORD_Data *rd)
 725 {
 726   struct RecordLookupContext *rlc = cls;
 727   struct GNUNET_GNSRECORD_Data *rd_res;
 728   unsigned int rdc_res;
 729
 730   if (0 == strcmp (label, rlc->label))
 731   {
 732     rlc->found = GNUNET_YES;
 733     if (0 != rd_count)
 734     {
 735       if ( (NULL != rlc->nick) &&
 736            (0 != strcmp (label,
 737                          GNUNET_GNS_MASTERZONE_STR)) )
 738       {
 739         /* Merge */
 740         rd_res = NULL;
 741         rdc_res = 0;
 742         rlc->nick->flags = (rlc->nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
 743         merge_with_nick_records (rlc->nick,
 744                                  rd_count, rd,
 745                                  &rdc_res, &rd_res);
 746
 747         rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rdc_res,
 748                                                              rd_res);
 749         rlc->res_rd_count = rdc_res;
 750         rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
 751         GNUNET_GNSRECORD_records_serialize (rdc_res,
 752                                             rd_res,
 753                                             rlc->rd_ser_len,
 754                                             rlc->res_rd);
 755
 756         GNUNET_free  (rd_res);
 757         GNUNET_free  (rlc->nick);
 758         rlc->nick = NULL;
 759       }
 760       else
 761       {
 762         rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count,
 763                                                              rd);
 764         rlc->res_rd_count = rd_count;
 765         rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
 766         GNUNET_GNSRECORD_records_serialize (rd_count,
 767                                             rd,
 768                                             rlc->rd_ser_len,
 769                                             rlc->res_rd);
 770       }
 771     }
 772     else
 773     {
 774       rlc->rd_ser_len = 0;
 775       rlc->res_rd_count = 0;
 776       rlc->res_rd = NULL;
 777     }
 778   }
 779 }
 780
 781
 782 /**
 783  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message
 784  *
 785  * @param cls client sending the message
 786  * @param ll_msg message of type `struct LabelLookupMessage`
 787  * @return #GNUNET_OK if @a ll_msg is well-formed
 788  */
 789 static int
 790 check_record_lookup (void *cls,
 791                      const struct LabelLookupMessage *ll_msg)
 792 {
 793   uint32_t name_len;
 794   size_t src_size;
 795   const char *name_tmp;
 796
 797   name_len = ntohl (ll_msg->label_len);
 798   src_size = ntohs (ll_msg->gns_header.header.size);
 799   if (name_len != src_size - sizeof (struct LabelLookupMessage))
 800   {
 801     GNUNET_break (0);
 802     return GNUNET_SYSERR;
 803   }
 804
 805   name_tmp = (const char *) &ll_msg[1];
 806   if ('\0' != name_tmp[name_len -1])
 807   {
 808     GNUNET_break (0);
 809     return GNUNET_SYSERR;
 810   }
 811   return GNUNET_OK;
 812 }
 813
 814
 815 /**
 816  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message
 817  *
 818  * @param cls client sending the message
 819  * @param ll_msg message of type `struct LabelLookupMessage`
 820  */
 821 static void
 822 handle_record_lookup (void *cls,
 823                       const struct LabelLookupMessage *ll_msg)
 824 {
 825   struct NamestoreClient *nc = cls;
 826   struct GNUNET_MQ_Envelope *env;
 827   struct LabelLookupResponseMessage *llr_msg;
 828   struct RecordLookupContext rlc;
 829   const char *name_tmp;
 830   char *res_name;
 831   char *conv_name;
 832   uint32_t name_len;
 833   int res;
 834
 835   name_len = ntohl (ll_msg->label_len);
 836   name_tmp = (const char *) &ll_msg[1];
 837   GNUNET_SERVICE_client_continue (nc->client);
 838   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 839               "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n",
 840               name_tmp);
 841
 842   conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
 843   if (NULL == conv_name)
 844   {
 845     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 846                 "Error converting name `%s'\n",
 847                 name_tmp);
 848     GNUNET_SERVICE_client_drop (nc->client);
 849     return;
 850   }
 851   rlc.label = conv_name;
 852   rlc.found = GNUNET_NO;
 853   rlc.res_rd_count = 0;
 854   rlc.res_rd = NULL;
 855   rlc.rd_ser_len = 0;
 856   rlc.nick = get_nick_record (&ll_msg->zone);
 857   res = GSN_database->lookup_records (GSN_database->cls,
 858                                       &ll_msg->zone,
 859                                       conv_name,
 860                                       &lookup_it,
 861                                       &rlc);
 862   GNUNET_free (conv_name);
 863   env = GNUNET_MQ_msg_extra (llr_msg,
 864                              name_len + rlc.rd_ser_len,
 865                              GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE);
 866   llr_msg->gns_header.r_id = ll_msg->gns_header.r_id;
 867   llr_msg->private_key = ll_msg->zone;
 868   llr_msg->name_len = htons (name_len);
 869   llr_msg->rd_count = htons (rlc.res_rd_count);
 870   llr_msg->rd_len = htons (rlc.rd_ser_len);
 871   res_name = (char *) &llr_msg[1];
 872   if  ((GNUNET_YES == rlc.found) && (GNUNET_OK == res))
 873     llr_msg->found = ntohs (GNUNET_YES);
 874   else
 875     llr_msg->found = ntohs (GNUNET_NO);
 876   GNUNET_memcpy (&llr_msg[1],
 877                  name_tmp,
 878                  name_len);
 879   GNUNET_memcpy (&res_name[name_len],
 880                  rlc.res_rd,
 881                  rlc.rd_ser_len);
 882   GNUNET_MQ_send (nc->mq,
 883                   env);
 884   GNUNET_free_non_null (rlc.res_rd);
 885 }
 886
 887
 888 /**
 889  * Checks a #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE message
 890  *
 891  * @param cls client sending the message
 892  * @param rp_msg message of type `struct RecordStoreMessage`
 893  * @return #GNUNET_OK if @a rp_msg is well-formed
 894  */
 895 static int
 896 check_record_store (void *cls,
 897                     const struct RecordStoreMessage *rp_msg)
 898 {
 899   size_t name_len;
 900   size_t msg_size;
 901   size_t msg_size_exp;
 902   size_t rd_ser_len;
 903   const char *name_tmp;
 904
 905   name_len = ntohs (rp_msg->name_len);
 906   msg_size = ntohs (rp_msg->gns_header.header.size);
 907   rd_ser_len = ntohs (rp_msg->rd_len);
 908   msg_size_exp = sizeof (struct RecordStoreMessage) + name_len + rd_ser_len;
 909   if (msg_size != msg_size_exp)
 910   {
 911     GNUNET_break (0);
 912     return GNUNET_SYSERR;
 913   }
 914   if ((0 == name_len) || (name_len > MAX_NAME_LEN))
 915   {
 916     GNUNET_break (0);
 917     return GNUNET_SYSERR;
 918   }
 919   name_tmp = (const char *) &rp_msg[1];
 920   if ('\0' != name_tmp[name_len -1])
 921   {
 922     GNUNET_break (0);
 923     return GNUNET_SYSERR;
 924   }
 925   return GNUNET_OK;
 926 }
 927
 928
 929 /**
 930  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE message
 931  *
 932  * @param cls client sending the message
 933  * @param rp_msg message of type `struct RecordStoreMessage`
 934  */
 935 static void
 936 handle_record_store (void *cls,
 937                      const struct RecordStoreMessage *rp_msg)
 938 {
 939   struct NamestoreClient *nc = cls;
 940   size_t name_len;
 941   size_t rd_ser_len;
 942   uint32_t rid;
 943   const char *name_tmp;
 944   char *conv_name;
 945   const char *rd_ser;
 946   unsigned int rd_count;
 947   int res;
 948   struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
 949   struct ZoneMonitor *zm;
 950
 951   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 952               "Received NAMESTORE_RECORD_STORE message\n");
 953   rid = ntohl (rp_msg->gns_header.r_id);
 954   name_len = ntohs (rp_msg->name_len);
 955   rd_count = ntohs (rp_msg->rd_count);
 956   rd_ser_len = ntohs (rp_msg->rd_len);
 957   GNUNET_break (0 == ntohs (rp_msg->reserved));
 958   name_tmp = (const char *) &rp_msg[1];
 959   rd_ser = &name_tmp[name_len];
 960   {
 961     struct GNUNET_GNSRECORD_Data rd[rd_count];
 962
 963     if (GNUNET_OK !=
 964         GNUNET_GNSRECORD_records_deserialize (rd_ser_len,
 965                                               rd_ser,
 966                                               rd_count,
 967                                               rd))
 968     {
 969       GNUNET_break (0);
 970       GNUNET_SERVICE_client_drop (nc->client);
 971       return;
 972     }
 973
 974     /* Extracting and converting private key */
 975     GNUNET_CRYPTO_ecdsa_key_get_public (&rp_msg->private_key,
 976                                         &pubkey);
 977     conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
 978     if (NULL == conv_name)
 979     {
 980       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 981                   "Error converting name `%s'\n",
 982                   name_tmp);
 983       GNUNET_SERVICE_client_drop (nc->client);
 984       return;
 985     }
 986     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 987                 "Creating %u records for name `%s' in zone `%s'\n",
 988                 (unsigned int) rd_count,
 989                 conv_name,
 990                 GNUNET_GNSRECORD_z2s (&pubkey));
 991
 992     if ( (0 == rd_count) &&
 993          (GNUNET_NO ==
 994           GSN_database->iterate_records (GSN_database->cls,
 995                                          &rp_msg->private_key,
 996                                          0,
 997                                          NULL,
 998                                          0)) )
 999     {
1000       /* This name does not exist, so cannot be removed */
1001       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1002                   "Name `%s' does not exist, no deletion required\n",
1003                   conv_name);
1004       res = GNUNET_NO;
1005     }
1006     else
1007     {
1008       struct GNUNET_GNSRECORD_Data rd_clean[rd_count];
1009       unsigned int rd_clean_off;
1010
1011       /* remove "NICK" records, unless this is for the "+" label */
1012       rd_clean_off = 0;
1013       for (unsigned int i=0;i<rd_count;i++)
1014       {
1015         rd_clean[rd_clean_off] = rd[i];
1016         if ( (0 == strcmp (GNUNET_GNS_MASTERZONE_STR,
1017                            conv_name)) ||
1018              (GNUNET_GNSRECORD_TYPE_NICK != rd[i].record_type) )
1019           rd_clean_off++;
1020       }
1021       res = GSN_database->store_records (GSN_database->cls,
1022                                          &rp_msg->private_key,
1023                                          conv_name,
1024                                          rd_clean_off,
1025                                          rd_clean);
1026       if (GNUNET_OK == res)
1027       {
1028         for (zm = monitor_head; NULL != zm; zm = zm->next)
1029         {
1030           if ( (0 == memcmp (&rp_msg->private_key, &zm->zone,
1031                              sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))) ||
1032                (0 == memcmp (&zm->zone,
1033                              &zero,
1034                              sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))) )
1035           {
1036             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1037                         "Notifying monitor about changes under label `%s'\n",
1038                         conv_name);
1039             send_lookup_response (zm->nc,
1040                                   0,
1041                                   &rp_msg->private_key,
1042                                   conv_name,
1043                                   rd_count, rd);
1044           }
1045           else
1046             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1047                         "Monitor is for another zone\n");
1048         }
1049         if (NULL == monitor_head)
1050           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1051                       "No monitors active\n");
1052       }
1053       else
1054       {
1055         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1056                     "Error storing record: %d\n",
1057                     res);
1058       }
1059     }
1060     if (GNUNET_OK == res)
1061     {
1062       refresh_block (nc,
1063                      rid,
1064                      &rp_msg->private_key,
1065                      conv_name,
1066                      rd_count,
1067                      rd);
1068       GNUNET_SERVICE_client_continue (nc->client);
1069       GNUNET_free (conv_name);
1070       return;
1071     }
1072     GNUNET_free (conv_name);
1073   }
1074   send_store_response (nc,
1075                        res,
1076                        rid);
1077   GNUNET_SERVICE_client_continue (nc->client);
1078 }
1079
1080
1081 /**
1082  * Context for record remove operations passed from #handle_zone_to_name to
1083  * #handle_zone_to_name_it as closure
1084  */
1085 struct ZoneToNameCtx
1086 {
1087   /**
1088    * Namestore client
1089    */
1090   struct NamestoreClient *nc;
1091
1092   /**
1093    * Request id (to be used in the response to the client).
1094    */
1095   uint32_t rid;
1096
1097   /**
1098    * Set to #GNUNET_OK on success, #GNUNET_SYSERR on error.  Note that
1099    * not finding a name for the zone still counts as a 'success' here,
1100    * as this field is about the success of executing the IPC protocol.
1101    */
1102   int success;
1103 };
1104
1105
1106 /**
1107  * Zone to name iterator
1108  *
1109  * @param cls struct ZoneToNameCtx *
1110  * @param zone_key the zone key
1111  * @param name name
1112  * @param rd_count number of records in @a rd
1113  * @param rd record data
1114  */
1115 static void
1116 handle_zone_to_name_it (void *cls,
1117                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
1118                         const char *name,
1119                         unsigned int rd_count,
1120                         const struct GNUNET_GNSRECORD_Data *rd)
1121 {
1122   struct ZoneToNameCtx *ztn_ctx = cls;
1123   struct GNUNET_MQ_Envelope *env;
1124   struct ZoneToNameResponseMessage *ztnr_msg;
1125   int16_t res;
1126   size_t name_len;
1127   size_t rd_ser_len;
1128   size_t msg_size;
1129   char *name_tmp;
1130   char *rd_tmp;
1131
1132   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1133               "Found result for zone-to-name lookup: `%s'\n",
1134               name);
1135   res = GNUNET_YES;
1136   name_len = (NULL == name) ? 0 : strlen (name) + 1;
1137   rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
1138   msg_size = sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len;
1139   if (msg_size >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
1140   {
1141     GNUNET_break (0);
1142     ztn_ctx->success = GNUNET_SYSERR;
1143     return;
1144   }
1145   env = GNUNET_MQ_msg_extra (ztnr_msg,
1146                              name_len + rd_ser_len,
1147                              GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
1148   ztnr_msg->gns_header.header.size = htons (msg_size);
1149   ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid);
1150   ztnr_msg->res = htons (res);
1151   ztnr_msg->rd_len = htons (rd_ser_len);
1152   ztnr_msg->rd_count = htons (rd_count);
1153   ztnr_msg->name_len = htons (name_len);
1154   ztnr_msg->zone = *zone_key;
1155   name_tmp = (char *) &ztnr_msg[1];
1156   GNUNET_memcpy (name_tmp,
1157                  name,
1158                  name_len);
1159   rd_tmp = &name_tmp[name_len];
1160   GNUNET_GNSRECORD_records_serialize (rd_count,
1161                                       rd,
1162                                       rd_ser_len,
1163                                       rd_tmp);
1164   ztn_ctx->success = GNUNET_OK;
1165   GNUNET_MQ_send (ztn_ctx->nc->mq,
1166                   env);
1167 }
1168
1169
1170 /**
1171  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME message
1172  *
1173  * @param cls client client sending the message
1174  * @param ztn_msg message of type 'struct ZoneToNameMessage'
1175  */
1176 static void
1177 handle_zone_to_name (void *cls,
1178                      const struct ZoneToNameMessage *ztn_msg)
1179 {
1180   struct NamestoreClient *nc = cls;
1181   struct ZoneToNameCtx ztn_ctx;
1182   struct GNUNET_MQ_Envelope *env;
1183   struct ZoneToNameResponseMessage *ztnr_msg;
1184
1185   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1186               "Received `%s' message\n",
1187               "ZONE_TO_NAME");
1188   ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id);
1189   ztn_ctx.nc = nc;
1190   ztn_ctx.success = GNUNET_NO;
1191   if (GNUNET_SYSERR ==
1192       GSN_database->zone_to_name (GSN_database->cls,
1193                                   &ztn_msg->zone,
1194                                   &ztn_msg->value_zone,
1195                                   &handle_zone_to_name_it, &ztn_ctx))
1196   {
1197     /* internal error, hang up instead of signalling something
1198        that might be wrong */
1199     GNUNET_break (0);
1200     GNUNET_SERVICE_client_drop (nc->client);
1201     return;
1202   }
1203   if (GNUNET_NO == ztn_ctx.success)
1204   {
1205     /* no result found, send empty response */
1206     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1207                 "Found no result for zone-to-name lookup.\n");
1208     env = GNUNET_MQ_msg (ztnr_msg,
1209                          GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
1210     ztnr_msg->gns_header.r_id = ztn_msg->gns_header.r_id;
1211     ztnr_msg->res = htons (GNUNET_NO);
1212     GNUNET_MQ_send (nc->mq,
1213                     env);
1214   }
1215   GNUNET_SERVICE_client_continue (nc->client);
1216 }
1217
1218
1219 /**
1220  * Zone iteration processor result
1221  */
1222 enum ZoneIterationResult
1223 {
1224   /**
1225    * Iteration start.
1226    */
1227   IT_START = 0,
1228
1229   /**
1230    * Found records,
1231    * Continue to iterate with next iteration_next call
1232    */
1233   IT_SUCCESS_MORE_AVAILABLE = 1,
1234
1235   /**
1236    * Iteration complete
1237    */
1238   IT_SUCCESS_NOT_MORE_RESULTS_AVAILABLE = 2
1239 };
1240
1241
1242 /**
1243  * Context for record remove operations passed from
1244  * #run_zone_iteration_round to #zone_iterate_proc as closure
1245  */
1246 struct ZoneIterationProcResult
1247 {
1248   /**
1249    * The zone iteration handle
1250    */
1251   struct ZoneIteration *zi;
1252
1253   /**
1254    * Iteration result: iteration done?
1255    * #IT_SUCCESS_MORE_AVAILABLE:  if there may be more results overall but
1256    * we got one for now and have sent it to the client
1257    * #IT_SUCCESS_NOT_MORE_RESULTS_AVAILABLE: if there are no further results,
1258    * #IT_START: if we are still trying to find a result.
1259    */
1260   int res_iteration_finished;
1261
1262 };
1263
1264
1265 /**
1266  * Process results for zone iteration from database
1267  *
1268  * @param cls struct ZoneIterationProcResult *proc
1269  * @param zone_key the zone key
1270  * @param name name
1271  * @param rd_count number of records for this name
1272  * @param rd record data
1273  */
1274 static void
1275 zone_iterate_proc (void *cls,
1276                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
1277                    const char *name,
1278                    unsigned int rd_count,
1279                    const struct GNUNET_GNSRECORD_Data *rd)
1280 {
1281   struct ZoneIterationProcResult *proc = cls;
1282   int do_refresh_block;
1283
1284   if ((NULL == zone_key) && (NULL == name))
1285   {
1286     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1287                 "Iteration done\n");
1288     proc->res_iteration_finished = IT_SUCCESS_NOT_MORE_RESULTS_AVAILABLE;
1289     return;
1290   }
1291   if ((NULL == zone_key) || (NULL == name))
1292   {
1293     /* what is this!? should never happen */
1294     proc->res_iteration_finished = IT_START;
1295     GNUNET_break (0);
1296     return;
1297   }
1298   proc->res_iteration_finished = IT_SUCCESS_MORE_AVAILABLE;
1299   send_lookup_response (proc->zi->nc,
1300                         proc->zi->request_id,
1301                         zone_key,
1302                         name,
1303                         rd_count,
1304                         rd);
1305   do_refresh_block = GNUNET_NO;
1306   for (unsigned int i=0;i<rd_count;i++)
1307     if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
1308     {
1309       do_refresh_block = GNUNET_YES;
1310       break;
1311     }
1312   if (GNUNET_YES == do_refresh_block)
1313     refresh_block (NULL,
1314                    0,
1315                    zone_key,
1316                    name,
1317                    rd_count,
1318                    rd);
1319
1320 }
1321
1322
1323 /**
1324  * Perform the next round of the zone iteration.
1325  *
1326  * @param zi zone iterator to process
1327  */
1328 static void
1329 run_zone_iteration_round (struct ZoneIteration *zi)
1330 {
1331   struct ZoneIterationProcResult proc;
1332   struct GNUNET_MQ_Envelope *env;
1333   struct RecordResultMessage *rrm;
1334   int ret;
1335
1336   memset (&proc, 0, sizeof (proc));
1337   proc.zi = zi;
1338   proc.res_iteration_finished = IT_START;
1339   while (IT_START == proc.res_iteration_finished)
1340   {
1341     if (GNUNET_SYSERR ==
1342         (ret = GSN_database->iterate_records (GSN_database->cls,
1343                                               (0 == memcmp (&zi->zone, &zero, sizeof (zero)))
1344                                               ? NULL
1345                                               : &zi->zone,
1346                                               zi->offset,
1347                                               &zone_iterate_proc, &proc)))
1348     {
1349       GNUNET_break (0);
1350       break;
1351     }
1352     if (GNUNET_NO == ret)
1353       proc.res_iteration_finished = IT_SUCCESS_NOT_MORE_RESULTS_AVAILABLE;
1354     zi->offset++;
1355   }
1356   if (IT_SUCCESS_MORE_AVAILABLE == proc.res_iteration_finished)
1357   {
1358     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1359                 "More results available\n");
1360     return; /* more results later */
1361   }
1362   /* send empty response to indicate end of list */
1363   env = GNUNET_MQ_msg (rrm,
1364                        GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT);
1365   rrm->gns_header.r_id = htonl (zi->request_id);
1366   GNUNET_MQ_send (zi->nc->mq,
1367                   env);
1368   GNUNET_CONTAINER_DLL_remove (zi->nc->op_head,
1369                                zi->nc->op_tail,
1370                                zi);
1371   GNUNET_free (zi);
1372 }
1373
1374
1375 /**
1376  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START message
1377  *
1378  * @param cls the client sending the message
1379  * @param zis_msg message from the client
1380  */
1381 static void
1382 handle_iteration_start (void *cls,
1383                         const struct ZoneIterationStartMessage *zis_msg)
1384 {
1385   struct NamestoreClient *nc = cls;
1386   struct ZoneIteration *zi;
1387
1388   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1389               "Received ZONE_ITERATION_START message\n");
1390   zi = GNUNET_new (struct ZoneIteration);
1391   zi->request_id = ntohl (zis_msg->gns_header.r_id);
1392   zi->offset = 0;
1393   zi->nc = nc;
1394   zi->zone = zis_msg->zone;
1395
1396   GNUNET_CONTAINER_DLL_insert (nc->op_head,
1397                                nc->op_tail,
1398                                zi);
1399   run_zone_iteration_round (zi);
1400   GNUNET_SERVICE_client_continue (nc->client);
1401 }
1402
1403
1404 /**
1405  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP message
1406  *
1407  * @param cls the client sending the message
1408  * @param zis_msg message from the client
1409  */
1410 static void
1411 handle_iteration_stop (void *cls,
1412                        const struct ZoneIterationStopMessage *zis_msg)
1413 {
1414   struct NamestoreClient *nc = cls;
1415   struct ZoneIteration *zi;
1416   uint32_t rid;
1417
1418   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1419               "Received `%s' message\n",
1420               "ZONE_ITERATION_STOP");
1421   rid = ntohl (zis_msg->gns_header.r_id);
1422   for (zi = nc->op_head; NULL != zi; zi = zi->next)
1423     if (zi->request_id == rid)
1424       break;
1425   if (NULL == zi)
1426   {
1427     GNUNET_break (0);
1428     GNUNET_SERVICE_client_drop (nc->client);
1429     return;
1430   }
1431   GNUNET_CONTAINER_DLL_remove (nc->op_head,
1432                                nc->op_tail,
1433                                zi);
1434   GNUNET_free (zi);
1435   GNUNET_SERVICE_client_continue (nc->client);
1436 }
1437
1438
1439 /**
1440  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT message
1441  *
1442  * @param cls the client sending the message
1443  * @param message message from the client
1444  */
1445 static void
1446 handle_iteration_next (void *cls,
1447                        const struct ZoneIterationNextMessage *zis_msg)
1448 {
1449   struct NamestoreClient *nc = cls;
1450   struct ZoneIteration *zi;
1451   uint32_t rid;
1452
1453   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1454               "Received ZONE_ITERATION_NEXT message\n");
1455   rid = ntohl (zis_msg->gns_header.r_id);
1456   for (zi = nc->op_head; NULL != zi; zi = zi->next)
1457     if (zi->request_id == rid)
1458       break;
1459   if (NULL == zi)
1460   {
1461     GNUNET_break (0);
1462     GNUNET_SERVICE_client_drop (nc->client);
1463     return;
1464   }
1465   run_zone_iteration_round (zi);
1466   GNUNET_SERVICE_client_continue (nc->client);
1467 }
1468
1469
1470 /**
1471  * Send 'sync' message to zone monitor, we're now in sync.
1472  *
1473  * @param zm monitor that is now in sync
1474  */
1475 static void
1476 monitor_sync (struct ZoneMonitor *zm)
1477 {
1478   struct GNUNET_MQ_Envelope *env;
1479   struct GNUNET_MessageHeader *sync;
1480
1481   env = GNUNET_MQ_msg (sync,
1482                        GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC);
1483   GNUNET_MQ_send (zm->nc->mq,
1484                   env);
1485 }
1486
1487
1488 /**
1489  * Obtain the next datum during the zone monitor's zone intiial iteration.
1490  *
1491  * @param cls zone monitor that does its initial iteration
1492  */
1493 static void
1494 monitor_next (void *cls);
1495
1496
1497 /**
1498  * A #GNUNET_NAMESTORE_RecordIterator for monitors.
1499  *
1500  * @param cls a 'struct ZoneMonitor *' with information about the monitor
1501  * @param zone_key zone key of the zone
1502  * @param name name
1503  * @param rd_count number of records in @a rd
1504  * @param rd array of records
1505  */
1506 static void
1507 monitor_iterate_cb (void *cls,
1508                     const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
1509                     const char *name,
1510                     unsigned int rd_count,
1511                     const struct GNUNET_GNSRECORD_Data *rd)
1512 {
1513   struct ZoneMonitor *zm = cls;
1514
1515   if (NULL == name)
1516   {
1517     /* finished with iteration */
1518     monitor_sync (zm);
1519     return;
1520   }
1521   send_lookup_response (zm->nc,
1522                         0,
1523                         zone_key,
1524                         name,
1525                         rd_count,
1526                         rd);
1527   zm->task = GNUNET_SCHEDULER_add_now (&monitor_next,
1528                                        zm);
1529 }
1530
1531
1532 /**
1533  * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START message
1534  *
1535  * @param cls the client sending the message
1536  * @param message message from the client
1537  */
1538 static void
1539 handle_monitor_start (void *cls,
1540                       const struct ZoneMonitorStartMessage *zis_msg)
1541 {
1542   struct NamestoreClient *nc = cls;
1543   struct ZoneMonitor *zm;
1544
1545   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1546               "Received ZONE_MONITOR_START message\n");
1547   zm = GNUNET_new (struct ZoneMonitor);
1548   zm->nc = nc;
1549   zm->zone = zis_msg->zone;
1550   GNUNET_CONTAINER_DLL_insert (monitor_head,
1551                                monitor_tail,
1552                                zm);
1553   GNUNET_SERVICE_client_mark_monitor (nc->client);
1554   GNUNET_SERVICE_client_disable_continue_warning (nc->client);
1555   GNUNET_notification_context_add (monitor_nc,
1556                                    nc->mq);
1557   if (GNUNET_YES == ntohl (zis_msg->iterate_first))
1558     zm->task = GNUNET_SCHEDULER_add_now (&monitor_next,
1559                                          zm);
1560   else
1561     monitor_sync (zm);
1562 }
1563
1564
1565 /**
1566  * Obtain the next datum during the zone monitor's zone intiial iteration.
1567  *
1568  * @param cls zone monitor that does its initial iteration
1569  */
1570 static void
1571 monitor_next (void *cls)
1572 {
1573   struct ZoneMonitor *zm = cls;
1574   int ret;
1575
1576   zm->task = NULL;
1577   ret = GSN_database->iterate_records (GSN_database->cls,
1578                                        (0 == memcmp (&zm->zone,
1579                                                      &zero,
1580                                                      sizeof (zero)))
1581                                        ? NULL
1582                                        : &zm->zone,
1583                                        zm->offset++,
1584                                        &monitor_iterate_cb,
1585                                        zm);
1586   if (GNUNET_SYSERR == ret)
1587   {
1588     GNUNET_SERVICE_client_drop (zm->nc->client);
1589     return;
1590   }
1591   if (GNUNET_NO == ret)
1592   {
1593     /* empty zone */
1594     monitor_sync (zm);
1595     return;
1596   }
1597 }
1598
1599
1600 /**
1601  * Process namestore requests.
1602  *
1603  * @param cls closure
1604  * @param cfg configuration to use
1605  * @param service the initialized service
1606  */
1607 static void
1608 run (void *cls,
1609      const struct GNUNET_CONFIGURATION_Handle *cfg,
1610      struct GNUNET_SERVICE_Handle *service)
1611 {
1612   char *database;
1613
1614   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1615               "Starting namestore service\n");
1616   GSN_cfg = cfg;
1617   monitor_nc = GNUNET_notification_context_create (1);
1618   namecache = GNUNET_NAMECACHE_connect (cfg);
1619   /* Loading database plugin */
1620   if (GNUNET_OK !=
1621       GNUNET_CONFIGURATION_get_value_string (cfg,
1622                                              "namestore",
1623                                              "database",
1624                                              &database))
1625     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1626                 "No database backend configured\n");
1627
1628   GNUNET_asprintf (&db_lib_name,
1629                    "libgnunet_plugin_namestore_%s",
1630                    database);
1631   GSN_database = GNUNET_PLUGIN_load (db_lib_name,
1632                                      (void *) GSN_cfg);
1633   GNUNET_free (database);
1634   GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
1635                                  NULL);
1636   if (NULL == GSN_database)
1637   {
1638     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1639                 "Could not load database backend `%s'\n",
1640                 db_lib_name);
1641     GNUNET_SCHEDULER_shutdown ();
1642     return;
1643   }
1644 }
1645
1646
1647 /**
1648  * Define "main" method using service macro.
1649  */
1650 GNUNET_SERVICE_MAIN
1651 ("namestore",
1652  GNUNET_SERVICE_OPTION_NONE,
1653  &run,
1654  &client_connect_cb,
1655  &client_disconnect_cb,
1656  NULL,
1657  GNUNET_MQ_hd_var_size (record_store,
1658                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE,
1659                         struct RecordStoreMessage,
1660                         NULL),
1661  GNUNET_MQ_hd_var_size (record_lookup,
1662                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP,
1663                         struct LabelLookupMessage,
1664                         NULL),
1665  GNUNET_MQ_hd_fixed_size (zone_to_name,
1666                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME,
1667                           struct ZoneToNameMessage,
1668                           NULL),
1669  GNUNET_MQ_hd_fixed_size (iteration_start,
1670                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START,
1671                           struct ZoneIterationStartMessage,
1672                           NULL),
1673  GNUNET_MQ_hd_fixed_size (iteration_next,
1674                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT,
1675                           struct ZoneIterationNextMessage,
1676                           NULL),
1677  GNUNET_MQ_hd_fixed_size (iteration_stop,
1678                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP,
1679                           struct ZoneIterationStopMessage,
1680                           NULL),
1681  GNUNET_MQ_hd_fixed_size (monitor_start,
1682                           GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START,
1683                           struct ZoneMonitorStartMessage,
1684                           NULL),
1685  GNUNET_MQ_handler_end ());
1686
1687
1688 /* end of gnunet-service-namestore.c */