src/fs/fs_namespace.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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  * @file fs/fs_namespace.c
  23  * @brief create and destroy namespaces
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_constants.h"
  28 #include "gnunet_signatures.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_fs_service.h"
  31 #include "fs_api.h"
  32
  33
  34 /**
  35  * Maximum legal size for an sblock.
  36  */
  37 #define MAX_SBLOCK_SIZE (60 * 1024)
  38
  39
  40 /**
  41  * Context for creating a namespace asynchronously.
  42  */
  43 struct GNUNET_FS_NamespaceCreationContext
  44 {
  45   /**
  46    * Context for asynchronous key creation.
  47    */
  48   struct GNUNET_CRYPTO_RsaKeyGenerationContext *keycreator;
  49
  50   /**
  51    * Name of the file to store key in / read key from.
  52    */
  53   char *filename;
  54
  55   /**
  56    * Name of the namespace.
  57    */
  58   char *name;
  59
  60   /**
  61    * Global fs handle
  62    */
  63   struct GNUNET_FS_Handle *h;
  64
  65   /**
  66    * Function to call when generation ends (successfully or not)
  67    */
  68   GNUNET_FS_NamespaceCreationCallback cont;
  69
  70   /**
  71    * Client value to pass to continuation function.
  72    */
  73   void *cont_cls;
  74 };
  75
  76
  77 /**
  78  * Return the name of the directory in which we store
  79  * our local namespaces (or rather, their public keys).
  80  *
  81  * @param h global fs handle
  82  * @return NULL on error, otherwise the name of the directory
  83  */
  84 static char *
  85 get_namespace_directory (struct GNUNET_FS_Handle *h)
  86 {
  87   char *dn;
  88
  89   if (GNUNET_OK !=
  90       GNUNET_CONFIGURATION_get_value_filename (h->cfg, "FS", "IDENTITY_DIR",
  91                                                &dn))
  92   {
  93     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
  94                                "fs", "IDENTITY_DIR");
  95     return NULL;
  96   }
  97   return dn;
  98 }
  99
 100
 101 /**
 102  * Return the name of the directory in which we store
 103  * the update information graph for the given local namespace.
 104  *
 105  * @param ns namespace handle
 106  * @return NULL on error, otherwise the name of the directory
 107  */
 108 static char *
 109 get_update_information_directory (struct GNUNET_FS_Namespace *ns)
 110 {
 111   char *dn;
 112   char *ret;
 113
 114   if (GNUNET_OK !=
 115       GNUNET_CONFIGURATION_get_value_filename (ns->h->cfg, "FS", "UPDATE_DIR",
 116                                                &dn))
 117   {
 118     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
 119                                "fs", "UPDATE_DIR");
 120     return NULL;
 121   }
 122   GNUNET_asprintf (&ret, "%s%s%s", dn, DIR_SEPARATOR_STR, ns->name);
 123   GNUNET_free (dn);
 124   return ret;
 125 }
 126
 127
 128 /**
 129  * Write the namespace update node graph to a file.
 130  *
 131  * @param ns namespace to dump
 132  */
 133 static void
 134 write_update_information_graph (struct GNUNET_FS_Namespace *ns)
 135 {
 136   char *fn;
 137   struct GNUNET_BIO_WriteHandle *wh;
 138   unsigned int i;
 139   struct NamespaceUpdateNode *n;
 140   char *uris;
 141
 142   fn = get_update_information_directory (ns);
 143   wh = GNUNET_BIO_write_open (fn);
 144   if (NULL == wh)
 145   {
 146     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 147                 _("Failed to open `%s' for writing: %s\n"), STRERROR (errno));
 148     GNUNET_free (fn);
 149     return;
 150   }
 151   if (GNUNET_OK != GNUNET_BIO_write_int32 (wh, ns->update_node_count))
 152     goto END;
 153   for (i = 0; i < ns->update_node_count; i++)
 154   {
 155     n = ns->update_nodes[i];
 156     uris = GNUNET_FS_uri_to_string (n->uri);
 157     if ((GNUNET_OK != GNUNET_BIO_write_string (wh, n->id)) ||
 158         (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, n->md)) ||
 159         (GNUNET_OK != GNUNET_BIO_write_string (wh, n->update)) ||
 160         (GNUNET_OK != GNUNET_BIO_write_string (wh, uris)))
 161     {
 162       GNUNET_free (uris);
 163       break;
 164     }
 165     GNUNET_free (uris);
 166   }
 167 END:
 168   if (GNUNET_OK != GNUNET_BIO_write_close (wh))
 169     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to write `%s': %s\n"),
 170                 STRERROR (errno));
 171   GNUNET_free (fn);
 172 }
 173
 174
 175 /**
 176  * Read the namespace update node graph from a file.
 177  *
 178  * @param ns namespace to read
 179  */
 180 static void
 181 read_update_information_graph (struct GNUNET_FS_Namespace *ns)
 182 {
 183   char *fn;
 184   struct GNUNET_BIO_ReadHandle *rh;
 185   unsigned int i;
 186   struct NamespaceUpdateNode *n;
 187   char *uris;
 188   uint32_t count;
 189   char *emsg;
 190
 191   fn = get_update_information_directory (ns);
 192   if (GNUNET_YES != GNUNET_DISK_file_test (fn))
 193   {
 194     GNUNET_free (fn);
 195     return;
 196   }
 197   rh = GNUNET_BIO_read_open (fn);
 198   if (NULL == rh)
 199   {
 200     GNUNET_free (fn);
 201     return;
 202   }
 203   if (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &count))
 204   {
 205     GNUNET_break (0);
 206     goto END;
 207   }
 208   if (count > 1024 * 1024)
 209   {
 210     GNUNET_break (0);
 211     goto END;
 212   }
 213   if (0 == count)
 214   {
 215     GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
 216     GNUNET_free (fn);
 217     return;
 218   }
 219   ns->update_nodes =
 220       GNUNET_malloc (count * sizeof (struct NamespaceUpdateNode *));
 221
 222   for (i = 0; i < count; i++)
 223   {
 224     n = GNUNET_malloc (sizeof (struct NamespaceUpdateNode));
 225     if ((GNUNET_OK != GNUNET_BIO_read_string (rh, "identifier", &n->id, 1024))
 226         || (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "meta", &n->md)) ||
 227         (GNUNET_OK !=
 228          GNUNET_BIO_read_string (rh, "update-id", &n->update, 1024)) ||
 229         (GNUNET_OK != GNUNET_BIO_read_string (rh, "uri", &uris, 1024 * 2)))
 230     {
 231       GNUNET_break (0);
 232       GNUNET_free_non_null (n->id);
 233       GNUNET_free_non_null (n->update);
 234       if (n->md != NULL)
 235         GNUNET_CONTAINER_meta_data_destroy (n->md);
 236       GNUNET_free (n);
 237       break;
 238     }
 239     n->uri = GNUNET_FS_uri_parse (uris, &emsg);
 240     GNUNET_free (uris);
 241     if (n->uri == NULL)
 242     {
 243       GNUNET_break (0);
 244       GNUNET_free (emsg);
 245       GNUNET_free (n->id);
 246       GNUNET_free_non_null (n->update);
 247       GNUNET_CONTAINER_meta_data_destroy (n->md);
 248       GNUNET_free (n);
 249       break;
 250     }
 251     ns->update_nodes[i] = n;
 252   }
 253   ns->update_node_count = i;
 254 END:
 255   if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
 256   {
 257     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to write `%s': %s\n"), emsg);
 258     GNUNET_free (emsg);
 259   }
 260   GNUNET_free (fn);
 261 }
 262
 263
 264 /**
 265  * Create a namespace with the given name; if one already
 266  * exists, return a handle to the existing namespace.
 267  *
 268  * @param h handle to the file sharing subsystem
 269  * @param name name to use for the namespace
 270  * @return handle to the namespace, NULL on error (i.e. invalid filename)
 271  */
 272 struct GNUNET_FS_Namespace *
 273 GNUNET_FS_namespace_create (struct GNUNET_FS_Handle *h, const char *name)
 274 {
 275   char *dn;
 276   char *fn;
 277   struct GNUNET_FS_Namespace *ret;
 278
 279   dn = get_namespace_directory (h);
 280   if (NULL == dn)
 281   {
 282     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 283                 _("Can't determine where namespace directory is\n"));
 284     return NULL;
 285   }
 286   GNUNET_asprintf (&fn, "%s%s%s", dn, DIR_SEPARATOR_STR, name);
 287   GNUNET_free (dn);
 288   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Namespace));
 289   ret->h = h;
 290   ret->rc = 1;
 291   ret->key = GNUNET_CRYPTO_rsa_key_create_from_file (fn);
 292   if (NULL == ret->key)
 293   {
 294     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 295                 _("Failed to create or read private key for namespace `%s'\n"),
 296                 name);
 297     GNUNET_free (ret);
 298     GNUNET_free (fn);
 299     return NULL;
 300   }
 301   ret->name = GNUNET_strdup (name);
 302   ret->filename = fn;
 303   return ret;
 304 }
 305
 306
 307 /**
 308  * Open the namespace with the given name; if it does not exist,
 309  * or the key file is corrupted, the function fails.
 310  *
 311  * @param h handle to the file sharing subsystem
 312  * @param name name of the namespace
 313  * @return handle to the namespace,
 314  *         NULL on error (i.e. invalid filename, non-existent filename)
 315  */
 316 struct GNUNET_FS_Namespace *
 317 GNUNET_FS_namespace_open_existing (struct GNUNET_FS_Handle *h, const char *name)
 318 {
 319   char *dn;
 320   char *fn;
 321   struct GNUNET_FS_Namespace *ret;
 322
 323   dn = get_namespace_directory (h);
 324   if (NULL == dn)
 325   {
 326     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 327                 _("Can't determine where namespace directory is\n"));
 328     return NULL;
 329   }
 330   GNUNET_asprintf (&fn, "%s%s%s", dn, DIR_SEPARATOR_STR, name);
 331   GNUNET_free (dn);
 332   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Namespace));
 333   ret->h = h;
 334   ret->rc = 1;
 335   ret->key = GNUNET_CRYPTO_rsa_key_create_from_existing_file (fn);
 336   if (NULL == ret->key)
 337   {
 338     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 339                 _("Failed to read private key for namespace `%s'\n"), name);
 340     GNUNET_free (ret);
 341     GNUNET_free (fn);
 342     return NULL;
 343   }
 344   ret->name = GNUNET_strdup (name);
 345   ret->filename = fn;
 346   return ret;
 347 }
 348
 349
 350 /**
 351  * Function called upon completion of 'GNUNET_CRYPTO_rsa_key_create_start'.
 352  *
 353  * @param cls closure
 354  * @param pk NULL on error, otherwise the private key (which must be free'd by the callee)
 355  * @param emsg NULL on success, otherwise an error message
 356  */
 357 static void
 358 ns_key_created (void *cls, struct GNUNET_CRYPTO_RsaPrivateKey *pk,
 359     const char *emsg)
 360 {
 361   struct GNUNET_FS_NamespaceCreationContext *ncc = cls;
 362
 363   ncc->keycreator = NULL;
 364
 365   if (pk)
 366   {
 367     struct GNUNET_FS_Namespace *ret;
 368     ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Namespace));
 369     ret->rc = 1;
 370     ret->key = pk;
 371     ret->h = ncc->h;
 372     ret->name = ncc->name;
 373     ret->filename = ncc->filename;
 374     ncc->cont (ncc->cont_cls, ret, NULL);
 375   }
 376   else
 377   {
 378     GNUNET_free (ncc->filename);
 379     GNUNET_free (ncc->name);
 380     ncc->cont (ncc->cont_cls, NULL, emsg);
 381   }
 382   GNUNET_free (ncc);
 383 }
 384
 385
 386 /**
 387  * Create a namespace with the given name.
 388  * If one already exists, the continuation will be called with a handle to
 389  * the existing namespace.
 390  * Otherwise creates a new namespace.
 391  *
 392  * @param h handle to the file sharing subsystem
 393  * @param name name to use for the namespace
 394  * @return namespace creation context, NULL on error (i.e. invalid filename)
 395  */
 396 struct GNUNET_FS_NamespaceCreationContext *
 397 GNUNET_FS_namespace_create_start (struct GNUNET_FS_Handle *h, const char *name,
 398     GNUNET_FS_NamespaceCreationCallback cont, void *cont_cls)
 399 {
 400   char *dn;
 401   char *fn;
 402   struct GNUNET_FS_NamespaceCreationContext *ret;
 403
 404   dn = get_namespace_directory (h);
 405   if (NULL == dn)
 406   {
 407     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 408                 _("Can't determine where namespace directory is\n"));
 409     return NULL;
 410   }
 411   GNUNET_asprintf (&fn, "%s%s%s", dn, DIR_SEPARATOR_STR, name);
 412   GNUNET_free (dn);
 413
 414   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_NamespaceCreationContext));
 415   ret->filename = fn;
 416   ret->h = h;
 417   ret->name = GNUNET_strdup (name);
 418   ret->cont = cont;
 419   ret->cont_cls = cont_cls;
 420
 421   ret->keycreator = GNUNET_CRYPTO_rsa_key_create_start (fn,
 422       ns_key_created, ret);
 423
 424   if (NULL == ret->keycreator)
 425   {
 426     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 427         _("Failed to start creating or reading private key for namespace `%s'\n"),
 428         name);
 429     GNUNET_free (fn);
 430     GNUNET_free (ret->name);
 431     GNUNET_free (ret);
 432     return NULL;
 433   }
 434   return ret;
 435 }
 436
 437
 438 /**
 439  * Abort namespace creation.
 440  *
 441  * @param ncc namespace creation context to abort
 442  */
 443 void
 444 GNUNET_FS_namespace_create_stop (struct GNUNET_FS_NamespaceCreationContext *ncc)
 445 {
 446   if (NULL != ncc->keycreator)
 447   {
 448     GNUNET_CRYPTO_rsa_key_create_stop (ncc->keycreator);
 449     ncc->keycreator = NULL;
 450   }
 451   if (NULL != ncc->filename)
 452   {
 453     if (0 != UNLINK (ncc->filename))
 454       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", ncc->filename);
 455     GNUNET_free (ncc->filename);
 456   }
 457   GNUNET_free_non_null (ncc->name);
 458   GNUNET_free (ncc);
 459 }
 460
 461
 462 /**
 463  * Duplicate a namespace handle.
 464  *
 465  * @param ns namespace handle
 466  * @return duplicated handle to the namespace
 467  */
 468 struct GNUNET_FS_Namespace *
 469 GNUNET_FS_namespace_dup (struct GNUNET_FS_Namespace *ns)
 470 {
 471   ns->rc++;
 472   return ns;
 473 }
 474
 475
 476 /**
 477  * Delete a namespace handle.  Can be used for a clean shutdown (free
 478  * memory) or also to freeze the namespace to prevent further
 479  * insertions by anyone.
 480  *
 481  * @param ns handle to the namespace that should be deleted / freed
 482  * @param freeze prevents future insertions; creating a namespace
 483  *        with the same name again will create a fresh namespace instead
 484  *
 485  * @return GNUNET_OK on success, GNUNET_SYSERR on error
 486  */
 487 int
 488 GNUNET_FS_namespace_delete (struct GNUNET_FS_Namespace *ns, int freeze)
 489 {
 490   unsigned int i;
 491   struct NamespaceUpdateNode *nsn;
 492
 493   ns->rc--;
 494   if (freeze)
 495   {
 496     if (0 != UNLINK (ns->filename))
 497       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "unlink",
 498                                 ns->filename);
 499   }
 500   if (0 != ns->rc)
 501     return GNUNET_OK;
 502   GNUNET_CRYPTO_rsa_key_free (ns->key);
 503   GNUNET_free (ns->filename);
 504   GNUNET_free (ns->name);
 505   for (i = 0; i < ns->update_node_count; i++)
 506   {
 507     nsn = ns->update_nodes[i];
 508     GNUNET_CONTAINER_meta_data_destroy (nsn->md);
 509     GNUNET_FS_uri_destroy (nsn->uri);
 510     GNUNET_free (nsn->id);
 511     GNUNET_free (nsn->update);
 512     GNUNET_free (nsn);
 513   }
 514   GNUNET_array_grow (ns->update_nodes, ns->update_node_count,
 515                      0);
 516   if (ns->update_map != NULL)
 517     GNUNET_CONTAINER_multihashmap_destroy (ns->update_map);
 518   GNUNET_free (ns);
 519   return GNUNET_OK;
 520 }
 521
 522
 523 /**
 524  * Context for the 'process_namespace' callback.
 525  * Specifies a function to call on each namespace.
 526  */
 527 struct ProcessNamespaceContext
 528 {
 529   /**
 530    * Function to call.
 531    */
 532   GNUNET_FS_NamespaceInfoProcessor cb;
 533
 534   /**
 535    * Closure for 'cb'.
 536    */
 537   void *cb_cls;
 538 };
 539
 540
 541 /**
 542  * Get hash of the public key of a namespace.
 543  *
 544  * @param ns namespace
 545  * @param id buffer to store the key in
 546  * @return GNUNET_OK on success
 547  *         GNUNET_SYSERR on failure (contents of id remain intact)
 548  */
 549 int
 550 GNUNET_FS_namespace_get_public_key_hash (struct GNUNET_FS_Namespace *ns,
 551     struct GNUNET_HashCode *id)
 552 {
 553   if ((NULL == ns) || (NULL == id))
 554     return GNUNET_SYSERR;
 555   GNUNET_CRYPTO_rsa_get_public_key_hash (ns->key, id);
 556   return GNUNET_OK;
 557 }
 558
 559
 560 /**
 561  * Function called with a filename of a namespace. Reads the key and
 562  * calls the callback.
 563  *
 564  * @param cls closure (struct ProcessNamespaceContext)
 565  * @param filename complete filename (absolute path)
 566  * @return GNUNET_OK to continue to iterate,
 567  *  GNUNET_SYSERR to abort iteration with error!
 568  */
 569 static int
 570 process_namespace (void *cls, const char *filename)
 571 {
 572   struct ProcessNamespaceContext *pnc = cls;
 573   struct GNUNET_CRYPTO_RsaPrivateKey *key;
 574   struct GNUNET_HashCode id;
 575   const char *name;
 576   const char *t;
 577
 578   key = GNUNET_CRYPTO_rsa_key_create_from_file (filename);
 579   if (NULL == key)
 580   {
 581     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 582                 _
 583                 ("Failed to read namespace private key file `%s', deleting it!\n"),
 584                 filename);
 585     if (0 != UNLINK (filename))
 586       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
 587     return GNUNET_OK;
 588   }
 589   GNUNET_CRYPTO_rsa_get_public_key_hash (key, &id);
 590   GNUNET_CRYPTO_rsa_key_free (key);
 591   name = filename;
 592   while (NULL != (t = strstr (name, DIR_SEPARATOR_STR)))
 593     name = t + 1;
 594   pnc->cb (pnc->cb_cls, name, &id);
 595   return GNUNET_OK;
 596 }
 597
 598
 599 /**
 600  * Build a list of all available local (!) namespaces The returned
 601  * names are only the nicknames since we only iterate over the local
 602  * namespaces.
 603  *
 604  * @param h handle to the file sharing subsystem
 605  * @param cb function to call on each known namespace
 606  * @param cb_cls closure for cb
 607  */
 608 void
 609 GNUNET_FS_namespace_list (struct GNUNET_FS_Handle *h,
 610                           GNUNET_FS_NamespaceInfoProcessor cb, void *cb_cls)
 611 {
 612   char *dn;
 613   struct ProcessNamespaceContext ctx;
 614
 615   dn = get_namespace_directory (h);
 616   if (NULL == dn)
 617     return;
 618   ctx.cb = cb;
 619   ctx.cb_cls = cb_cls;
 620   GNUNET_DISK_directory_scan (dn, &process_namespace, &ctx);
 621   GNUNET_free (dn);
 622 }
 623
 624
 625 /**
 626  * Context for the SKS publication.
 627  */
 628 struct GNUNET_FS_PublishSksContext
 629 {
 630
 631   /**
 632    * URI of the new entry in the namespace.
 633    */
 634   struct GNUNET_FS_Uri *uri;
 635
 636   /**
 637    * Namespace update node to add to namespace on success (or to be
 638    * deleted if publishing failed).
 639    */
 640   struct NamespaceUpdateNode *nsn;
 641
 642   /**
 643    * Namespace we're publishing to.
 644    */
 645   struct GNUNET_FS_Namespace *ns;
 646
 647   /**
 648    * Handle to the datastore.
 649    */
 650   struct GNUNET_DATASTORE_Handle *dsh;
 651
 652   /**
 653    * Function to call once we're done.
 654    */
 655   GNUNET_FS_PublishContinuation cont;
 656
 657   /**
 658    * Closure for cont.
 659    */
 660   void *cont_cls;
 661
 662   /**
 663    * Handle for our datastore request.
 664    */
 665   struct GNUNET_DATASTORE_QueueEntry *dqe;
 666 };
 667
 668
 669 /**
 670  * Function called by the datastore API with
 671  * the result from the PUT (SBlock) request.
 672  *
 673  * @param cls closure of type "struct GNUNET_FS_PublishSksContext*"
 674  * @param success GNUNET_OK on success
 675  * @param min_expiration minimum expiration time required for content to be stored
 676  * @param msg error message (or NULL)
 677  */
 678 static void
 679 sb_put_cont (void *cls, int success,
 680              struct GNUNET_TIME_Absolute min_expiration,
 681              const char *msg)
 682 {
 683   struct GNUNET_FS_PublishSksContext *psc = cls;
 684   struct GNUNET_HashCode hc;
 685
 686   psc->dqe = NULL;
 687   if (GNUNET_OK != success)
 688   {
 689     if (NULL != psc->cont)
 690       psc->cont (psc->cont_cls, NULL, msg);
 691     GNUNET_FS_publish_sks_cancel (psc);
 692     return;
 693   }
 694   if (NULL != psc->nsn)
 695   {
 696     /* FIXME: this can be done much more
 697      * efficiently by simply appending to the
 698      * file and overwriting the 4-byte header */
 699     if (psc->ns->update_nodes == NULL)
 700       read_update_information_graph (psc->ns);
 701     GNUNET_array_append (psc->ns->update_nodes,
 702                          psc->ns->update_node_count, psc->nsn);
 703     if (psc->ns->update_map != NULL)
 704     {
 705       GNUNET_CRYPTO_hash (psc->nsn->id, strlen (psc->nsn->id), &hc);
 706       GNUNET_CONTAINER_multihashmap_put (psc->ns->update_map, &hc,
 707                                          psc->nsn,
 708                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 709     }
 710     psc->nsn = NULL;
 711     write_update_information_graph (psc->ns);
 712   }
 713   if (NULL != psc->cont)
 714     psc->cont (psc->cont_cls, psc->uri, NULL);
 715   GNUNET_FS_publish_sks_cancel (psc);
 716 }
 717
 718
 719 /**
 720  * Publish an SBlock on GNUnet.
 721  *
 722  * @param h handle to the file sharing subsystem
 723  * @param ns namespace to publish in
 724  * @param identifier identifier to use
 725  * @param update update identifier to use
 726  * @param meta metadata to use
 727  * @param uri URI to refer to in the SBlock
 728  * @param bo block options
 729  * @param options publication options
 730  * @param cont continuation
 731  * @param cont_cls closure for cont
 732  * @return NULL on error ('cont' will still be called)
 733  */
 734 struct GNUNET_FS_PublishSksContext *
 735 GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
 736                        struct GNUNET_FS_Namespace *ns,
 737                        const char *identifier, const char *update,
 738                        const struct GNUNET_CONTAINER_MetaData *meta,
 739                        const struct GNUNET_FS_Uri *uri,
 740                        const struct GNUNET_FS_BlockOptions *bo,
 741                        enum GNUNET_FS_PublishOptions options,
 742                        GNUNET_FS_PublishContinuation cont, void *cont_cls)
 743 {
 744   struct GNUNET_FS_PublishSksContext *psc;
 745   struct GNUNET_CRYPTO_AesSessionKey sk;
 746   struct GNUNET_CRYPTO_AesInitializationVector iv;
 747   struct GNUNET_FS_Uri *sks_uri;
 748   char *uris;
 749   size_t size;
 750   size_t slen;
 751   size_t nidlen;
 752   size_t idlen;
 753   ssize_t mdsize;
 754   struct SBlock *sb;
 755   struct SBlock *sb_enc;
 756   char *dest;
 757   struct GNUNET_CONTAINER_MetaData *mmeta;
 758   struct GNUNET_HashCode key;          /* hash of thisId = key */
 759   struct GNUNET_HashCode id;           /* hash of hc = identifier */
 760   struct GNUNET_HashCode query;        /* id ^ nsid = DB query */
 761
 762   idlen = strlen (identifier);
 763   if (NULL != update)
 764     nidlen = strlen (update) + 1;
 765   else
 766     nidlen = 1;
 767   uris = GNUNET_FS_uri_to_string (uri);
 768   slen = strlen (uris) + 1;
 769   if ( (slen >= MAX_SBLOCK_SIZE - sizeof (struct SBlock)) ||
 770        (nidlen >= MAX_SBLOCK_SIZE - sizeof (struct SBlock) - slen) )
 771   {
 772     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 773                 _("Identifiers or URI too long to create SBlock"));
 774     GNUNET_free (uris);
 775     return NULL;
 776   }
 777   if (NULL == meta)
 778     mmeta = GNUNET_CONTAINER_meta_data_create ();
 779   else
 780     mmeta = GNUNET_CONTAINER_meta_data_duplicate (meta);
 781   mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (mmeta);
 782   size = sizeof (struct SBlock) + slen + nidlen + mdsize;
 783   if ( (size > MAX_SBLOCK_SIZE) ||
 784        (size < sizeof (struct SBlock) + slen + nidlen) )
 785   {
 786     size = MAX_SBLOCK_SIZE;
 787     mdsize = MAX_SBLOCK_SIZE - (sizeof (struct SBlock) + slen + nidlen);
 788   }
 789   sb = GNUNET_malloc (sizeof (struct SBlock) + size);
 790   dest = (char *) &sb[1];
 791   if (NULL != update)
 792     memcpy (dest, update, nidlen);
 793   else
 794     memset (dest, 0, 1);
 795   dest += nidlen;
 796   memcpy (dest, uris, slen);
 797   GNUNET_free (uris);
 798   dest += slen;
 799   mdsize =
 800       GNUNET_CONTAINER_meta_data_serialize (mmeta, &dest, mdsize,
 801                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
 802   GNUNET_CONTAINER_meta_data_destroy (mmeta);
 803   if (-1 == mdsize)
 804   {
 805     GNUNET_break (0);
 806     GNUNET_free (sb);
 807     if (NULL != cont)
 808       cont (cont_cls, NULL, _("Internal error."));
 809     return NULL;
 810   }
 811   size = sizeof (struct SBlock) + mdsize + slen + nidlen;
 812   sb_enc = GNUNET_malloc (size);
 813   GNUNET_CRYPTO_hash (identifier, idlen, &key);
 814   GNUNET_CRYPTO_hash (&key, sizeof (struct GNUNET_HashCode), &id);
 815   sks_uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
 816   sks_uri->type = GNUNET_FS_URI_SKS;
 817   GNUNET_CRYPTO_rsa_key_get_public (ns->key, &sb_enc->subspace);
 818   GNUNET_CRYPTO_hash (&sb_enc->subspace,
 819                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 820                       &sks_uri->data.sks.ns);
 821   sks_uri->data.sks.identifier = GNUNET_strdup (identifier);
 822   GNUNET_CRYPTO_hash_xor (&id, &sks_uri->data.sks.ns,
 823                           &sb_enc->identifier);
 824   GNUNET_CRYPTO_hash_to_aes_key (&key, &sk, &iv);
 825   GNUNET_CRYPTO_aes_encrypt (&sb[1], size - sizeof (struct SBlock), &sk, &iv,
 826                              &sb_enc[1]);
 827   sb_enc->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_SBLOCK);
 828   sb_enc->purpose.size =
 829       htonl (slen + mdsize + nidlen + sizeof (struct SBlock) -
 830              sizeof (struct GNUNET_CRYPTO_RsaSignature));
 831   GNUNET_assert (GNUNET_OK ==
 832                  GNUNET_CRYPTO_rsa_sign (ns->key, &sb_enc->purpose,
 833                                          &sb_enc->signature));
 834   psc = GNUNET_malloc (sizeof (struct GNUNET_FS_PublishSksContext));
 835   psc->uri = sks_uri;
 836   psc->cont = cont;
 837   psc->ns = GNUNET_FS_namespace_dup (ns);
 838   psc->cont_cls = cont_cls;
 839   if (0 != (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
 840   {
 841     GNUNET_free (sb_enc);
 842     GNUNET_free (sb);
 843     sb_put_cont (psc, GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, NULL);
 844     return NULL;
 845   }
 846   psc->dsh = GNUNET_DATASTORE_connect (h->cfg);
 847   if (NULL == psc->dsh)
 848   {
 849     GNUNET_free (sb_enc);
 850     GNUNET_free (sb);
 851     sb_put_cont (psc, GNUNET_NO, GNUNET_TIME_UNIT_ZERO_ABS, _("Failed to connect to datastore."));
 852     return NULL;
 853   }
 854   GNUNET_CRYPTO_hash_xor (&sks_uri->data.sks.ns, &id, &query);
 855   if (NULL != update)
 856   {
 857     psc->nsn = GNUNET_malloc (sizeof (struct NamespaceUpdateNode));
 858     psc->nsn->id = GNUNET_strdup (identifier);
 859     psc->nsn->update = GNUNET_strdup (update);
 860     psc->nsn->md = GNUNET_CONTAINER_meta_data_duplicate (meta);
 861     psc->nsn->uri = GNUNET_FS_uri_dup (uri);
 862   }
 863   psc->dqe = GNUNET_DATASTORE_put (psc->dsh, 0, &sb_enc->identifier, size, sb_enc,
 864                                    GNUNET_BLOCK_TYPE_FS_SBLOCK, bo->content_priority,
 865                                    bo->anonymity_level, bo->replication_level,
 866                                    bo->expiration_time, -2, 1,
 867                                    GNUNET_CONSTANTS_SERVICE_TIMEOUT, &sb_put_cont, psc);
 868   GNUNET_free (sb);
 869   GNUNET_free (sb_enc);
 870   return psc;
 871 }
 872
 873
 874 /**
 875  * Abort the SKS publishing operation.
 876  *
 877  * @param psc context of the operation to abort.
 878  */
 879 void
 880 GNUNET_FS_publish_sks_cancel (struct GNUNET_FS_PublishSksContext *psc)
 881 {
 882   if (NULL != psc->dqe)
 883   {
 884     GNUNET_DATASTORE_cancel (psc->dqe);
 885     psc->dqe = NULL;
 886   }
 887   if (NULL != psc->dsh)
 888   {
 889     GNUNET_DATASTORE_disconnect (psc->dsh, GNUNET_NO);
 890     psc->dsh = NULL;
 891   }
 892   GNUNET_FS_namespace_delete (psc->ns, GNUNET_NO);
 893   GNUNET_FS_uri_destroy (psc->uri);
 894   if (NULL != psc->nsn)
 895   {
 896     GNUNET_CONTAINER_meta_data_destroy (psc->nsn->md);
 897     GNUNET_FS_uri_destroy (psc->nsn->uri);
 898     GNUNET_free (psc->nsn->id);
 899     GNUNET_free (psc->nsn->update);
 900     GNUNET_free (psc->nsn);
 901   }
 902   GNUNET_free (psc);
 903 }
 904
 905
 906 /**
 907  * Closure for 'process_update_node'.
 908  */
 909 struct ProcessUpdateClosure
 910 {
 911   /**
 912    * Function to call for each node.
 913    */
 914   GNUNET_FS_IdentifierProcessor ip;
 915
 916   /**
 917    * Closure for 'ip'.
 918    */
 919   void *ip_cls;
 920 };
 921
 922
 923 /**
 924  * Call the iterator in the closure for each node.
 925  *
 926  * @param cls closure (of type 'struct ProcessUpdateClosure *')
 927  * @param key current key code
 928  * @param value value in the hash map (of type 'struct NamespaceUpdateNode *')
 929  * @return GNUNET_YES if we should continue to
 930  *         iterate,
 931  *         GNUNET_NO if not.
 932  */
 933 static int
 934 process_update_node (void *cls, const struct GNUNET_HashCode * key, void *value)
 935 {
 936   struct ProcessUpdateClosure *pc = cls;
 937   struct NamespaceUpdateNode *nsn = value;
 938
 939   pc->ip (pc->ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
 940   return GNUNET_YES;
 941 }
 942
 943
 944 /**
 945  * Closure for 'find_trees'.
 946  */
 947 struct FindTreeClosure
 948 {
 949   /**
 950    * Namespace we are operating on.
 951    */
 952   struct GNUNET_FS_Namespace *ns;
 953
 954   /**
 955    * Array with 'head's of TREEs.
 956    */
 957   struct NamespaceUpdateNode **tree_array;
 958
 959   /**
 960    * Size of 'tree_array'
 961    */
 962   unsigned int tree_array_size;
 963
 964   /**
 965    * Current generational ID used.
 966    */
 967   unsigned int nug;
 968
 969   /**
 970    * Identifier for the current TREE, or UINT_MAX for none yet.
 971    */
 972   unsigned int id;
 973 };
 974
 975
 976 /**
 977  * Find all nodes reachable from the current node (including the
 978  * current node itself).  If they are in no tree, add them to the
 979  * current one.   If they are the head of another tree, merge the
 980  * trees.  If they are in the middle of another tree, let them be.
 981  * We can tell that a node is already in an tree by checking if
 982  * its 'nug' field is set to the current 'nug' value.  It is the
 983  * head of an tree if it is in the 'tree_array' under its respective
 984  * 'tree_id'.
 985  *
 986  * In short, we're trying to find the smallest number of tree to
 987  * cover a directed graph.
 988  *
 989  * @param cls closure (of type 'struct FindTreeClosure')
 990  * @param key current key code
 991  * @param value value in the hash map
 992  * @return GNUNET_YES if we should continue to
 993  *         iterate,
 994  *         GNUNET_NO if not.
 995  */
 996 static int
 997 find_trees (void *cls, const struct GNUNET_HashCode * key, void *value)
 998 {
 999   struct FindTreeClosure *fc = cls;
1000   struct NamespaceUpdateNode *nsn = value;
1001   struct GNUNET_HashCode hc;
1002
1003   if (nsn->nug == fc->nug)
1004   {
1005     if (UINT_MAX == nsn->tree_id)
1006       return GNUNET_YES;        /* circular */
1007     GNUNET_assert (nsn->tree_id < fc->tree_array_size);
1008     if (fc->tree_array[nsn->tree_id] != nsn)
1009       return GNUNET_YES;        /* part of "another" (directed) TREE,
1010                                  * and not root of it, end trace */
1011     if (nsn->tree_id == fc->id)
1012       return GNUNET_YES;        /* that's our own root (can this be?) */
1013     /* merge existing TREE, we have a root for both */
1014     fc->tree_array[nsn->tree_id] = NULL;
1015     if (UINT_MAX == fc->id)
1016       fc->id = nsn->tree_id;    /* take over ID */
1017   }
1018   else
1019   {
1020     nsn->nug = fc->nug;
1021     nsn->tree_id = UINT_MAX;    /* mark as undef */
1022     /* trace */
1023     GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
1024     GNUNET_CONTAINER_multihashmap_get_multiple (fc->ns->update_map, &hc,
1025                                                 &find_trees, fc);
1026   }
1027   return GNUNET_YES;
1028 }
1029
1030
1031 /**
1032  * List all of the identifiers in the namespace for which we could
1033  * produce an update.  Namespace updates form a graph where each node
1034  * has a name.  Each node can have any number of URI/meta-data entries
1035  * which can each be linked to other nodes.  Cycles are possible.
1036  *
1037  * Calling this function with "next_id" NULL will cause the library to
1038  * call "ip" with a root for each strongly connected component of the
1039  * graph (a root being a node from which all other nodes in the Tree
1040  * are reachable).
1041  *
1042  * Calling this function with "next_id" being the name of a node will
1043  * cause the library to call "ip" with all children of the node.  Note
1044  * that cycles within the final tree are possible (including self-loops).
1045  * I know, odd definition of a tree, but the GUI will display an actual
1046  * tree (GtkTreeView), so that's what counts for the term here.
1047  *
1048  * @param ns namespace to inspect for updateable content
1049  * @param next_id ID to look for; use NULL to look for tree roots
1050  * @param ip function to call on each updateable identifier
1051  * @param ip_cls closure for ip
1052  */
1053 void
1054 GNUNET_FS_namespace_list_updateable (struct GNUNET_FS_Namespace *ns,
1055                                      const char *next_id,
1056                                      GNUNET_FS_IdentifierProcessor ip,
1057                                      void *ip_cls)
1058 {
1059   unsigned int i;
1060   unsigned int nug;
1061   struct GNUNET_HashCode hc;
1062   struct NamespaceUpdateNode *nsn;
1063   struct ProcessUpdateClosure pc;
1064   struct FindTreeClosure fc;
1065
1066   if (NULL == ns->update_nodes)
1067     read_update_information_graph (ns);
1068   if (NULL == ns->update_nodes)
1069   {
1070     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1071                 "No updateable nodes found for ID `%s'\n", next_id);
1072     return;                     /* no nodes */
1073   }
1074   if (NULL == ns->update_map)
1075   {
1076     /* need to construct */
1077     ns->update_map =
1078         GNUNET_CONTAINER_multihashmap_create (2 +
1079                                               3 * ns->update_node_count /
1080                                               4,
1081                                               GNUNET_NO);
1082     for (i = 0; i < ns->update_node_count; i++)
1083     {
1084       nsn = ns->update_nodes[i];
1085       GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
1086       GNUNET_CONTAINER_multihashmap_put (ns->update_map, &hc, nsn,
1087                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
1088     }
1089   }
1090   if (NULL != next_id)
1091   {
1092     GNUNET_CRYPTO_hash (next_id, strlen (next_id), &hc);
1093     pc.ip = ip;
1094     pc.ip_cls = ip_cls;
1095     GNUNET_CONTAINER_multihashmap_get_multiple (ns->update_map, &hc,
1096                                                 &process_update_node, &pc);
1097     return;
1098   }
1099   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1100               "Calculating TREEs to find roots of update trees\n");
1101   /* Find heads of TREEs in update graph */
1102   nug = ++ns->nug_gen;
1103   fc.tree_array = NULL;
1104   fc.tree_array_size = 0;
1105
1106   for (i = 0; i < ns->update_node_count; i++)
1107   {
1108     nsn = ns->update_nodes[i];
1109     if (nsn->nug == nug)
1110     {
1111       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TREE of node `%s' is %u\n", nsn->id,
1112                   nsn->nug);
1113       continue;                 /* already placed in TREE */
1114     }
1115     GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
1116     nsn->nug = nug;
1117     nsn->tree_id = UINT_MAX;
1118     fc.id = UINT_MAX;
1119     fc.nug = nug;
1120     fc.ns = ns;
1121     GNUNET_CONTAINER_multihashmap_get_multiple (ns->update_map, &hc,
1122                                                 &find_trees, &fc);
1123     if (UINT_MAX == fc.id)
1124     {
1125       /* start new TREE */
1126       for (fc.id = 0; fc.id < fc.tree_array_size; fc.id++)
1127       {
1128         if (fc.tree_array[fc.id] == NULL)
1129         {
1130           fc.tree_array[fc.id] = nsn;
1131           nsn->tree_id = fc.id;
1132           break;
1133         }
1134       }
1135       if (fc.id == fc.tree_array_size)
1136       {
1137         GNUNET_array_append (fc.tree_array, fc.tree_array_size, nsn);
1138         nsn->tree_id = fc.id;
1139       }
1140       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1141                   "Starting new TREE %u with node `%s'\n", nsn->tree_id,
1142                   nsn->id);
1143       /* put all nodes with same identifier into this TREE */
1144       GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
1145       fc.id = nsn->tree_id;
1146       fc.nug = nug;
1147       fc.ns = ns;
1148       GNUNET_CONTAINER_multihashmap_get_multiple (ns->update_map, &hc,
1149                                                   &find_trees, &fc);
1150     }
1151     else
1152     {
1153       /* make head of TREE "id" */
1154       fc.tree_array[fc.id] = nsn;
1155       nsn->tree_id = fc.id;
1156     }
1157     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TREE of node `%s' is %u\n", nsn->id,
1158                 fc.id);
1159   }
1160   for (i = 0; i < fc.tree_array_size; i++)
1161   {
1162     nsn = fc.tree_array[i];
1163     if (NULL != nsn)
1164     {
1165       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Root of TREE %u is node `%s'\n", i,
1166                   nsn->id);
1167       ip (ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
1168     }
1169   }
1170   GNUNET_array_grow (fc.tree_array, fc.tree_array_size, 0);
1171   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done processing TREEs\n");
1172 }
1173
1174
1175 /* end of fs_namespace.c */