src/fs/fs_pseudonym.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2003-2013 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  * @file fs/fs_pseudonym.c
  22  * @brief pseudonym functions
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_fs_service.h"
  28
  29
  30 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
  31
  32 #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
  33
  34 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
  35
  36
  37 /**
  38  * Name of the directory which stores meta data for pseudonym
  39  */
  40 #define PS_METADATA_DIR DIR_SEPARATOR_STR "data" DIR_SEPARATOR_STR "pseudonym" DIR_SEPARATOR_STR "metadata" DIR_SEPARATOR_STR
  41
  42 /**
  43  * Name of the directory which stores names for pseudonyms
  44  */
  45 #define PS_NAMES_DIR    DIR_SEPARATOR_STR "data" DIR_SEPARATOR_STR "pseudonym" DIR_SEPARATOR_STR "names"    DIR_SEPARATOR_STR
  46
  47
  48 /**
  49  * Configuration section we use.
  50  */
  51 #define GNUNET_CLIENT_SERVICE_NAME "fs"
  52
  53
  54 /* ************************* Disk operations (pseudonym data mgmt) **************** */
  55
  56 /**
  57  * Registered callbacks for discovery of pseudonyms.
  58  */
  59 struct GNUNET_FS_Pseudonym_DiscoveryHandle
  60 {
  61   /**
  62    * This is a doubly linked list.
  63    */
  64   struct GNUNET_FS_Pseudonym_DiscoveryHandle *next;
  65
  66   /**
  67    * This is a doubly linked list.
  68    */
  69   struct GNUNET_FS_Pseudonym_DiscoveryHandle *prev;
  70
  71   /**
  72    * Function to call each time a pseudonym is discovered.
  73    */
  74   GNUNET_FS_PseudonymIterator callback;
  75
  76   /**
  77    * Closure for callback.
  78    */
  79   void *callback_cls;
  80 };
  81
  82
  83 /**
  84  * Head of the linked list of functions to call when
  85  * new pseudonyms are added.
  86  */
  87 static struct GNUNET_FS_Pseudonym_DiscoveryHandle *disco_head;
  88
  89 /**
  90  * Tail of the linked list of functions to call when
  91  * new pseudonyms are added.
  92  */
  93 static struct GNUNET_FS_Pseudonym_DiscoveryHandle *disco_tail;
  94
  95
  96 /**
  97  * Internal notification about new tracked URI.
  98  *
  99  * @param pseudonym public key of the pseudonym
 100  * @param md meta data to be written
 101  * @param rating rating of pseudonym
 102  */
 103 static void
 104 internal_notify (const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
 105                  const struct GNUNET_CONTAINER_MetaData *md, int rating)
 106 {
 107   struct GNUNET_FS_Pseudonym_DiscoveryHandle *pos;
 108
 109   for (pos = disco_head; NULL != pos; pos = pos->next)
 110     pos->callback (pos->callback_cls, pseudonym, NULL, NULL, md, rating);
 111 }
 112
 113
 114 /**
 115  * Register callback to be invoked whenever we discover
 116  * a new pseudonym.
 117  * Will immediately call provided iterator callback for all
 118  * already discovered pseudonyms.
 119  *
 120  * @param cfg configuration to use
 121  * @param iterator iterator over pseudonym
 122  * @param iterator_cls point to a closure
 123  * @return registration handle
 124  */
 125 struct GNUNET_FS_Pseudonym_DiscoveryHandle *
 126 GNUNET_FS_pseudonym_discovery_callback_register (const struct
 127                                               GNUNET_CONFIGURATION_Handle *cfg,
 128                                               GNUNET_FS_PseudonymIterator iterator,
 129                                               void *iterator_cls)
 130 {
 131   struct GNUNET_FS_Pseudonym_DiscoveryHandle *dh;
 132
 133   dh = GNUNET_new (struct GNUNET_FS_Pseudonym_DiscoveryHandle);
 134   dh->callback = iterator;
 135   dh->callback_cls = iterator_cls;
 136   GNUNET_CONTAINER_DLL_insert (disco_head, disco_tail, dh);
 137   GNUNET_FS_pseudonym_list_all (cfg, iterator, iterator_cls);
 138   return dh;
 139 }
 140
 141
 142 /**
 143  * Unregister pseudonym discovery callback.
 144  *
 145  * @param dh registration to unregister
 146  */
 147 void
 148 GNUNET_FS_pseudonym_discovery_callback_unregister (struct GNUNET_FS_Pseudonym_DiscoveryHandle *dh)
 149 {
 150   GNUNET_CONTAINER_DLL_remove (disco_head, disco_tail, dh);
 151   GNUNET_free (dh);
 152 }
 153
 154
 155 /**
 156  * Get the filename (or directory name) for the given
 157  * pseudonym identifier and directory prefix.
 158  *
 159  * @param cfg configuration to use
 160  * @param prefix path components to append to the private directory name
 161  * @param pseudonym the pseudonym, can be NULL
 162  * @return filename of the pseudonym (if pseudonym != NULL) or directory with the data (if pseudonym == NULL)
 163  */
 164 static char *
 165 get_data_filename (const struct GNUNET_CONFIGURATION_Handle *cfg,
 166                    const char *prefix,
 167                    const struct GNUNET_CRYPTO_EccPublicKey *pseudonym)
 168 {
 169   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 170   struct GNUNET_HashCode psid;
 171
 172   if (NULL != pseudonym)
 173   {
 174     GNUNET_CRYPTO_hash (pseudonym,
 175                         sizeof (struct GNUNET_CRYPTO_EccPublicKey),
 176                         &psid);
 177     GNUNET_CRYPTO_hash_to_enc (&psid, &enc);
 178   }
 179   return GNUNET_DISK_get_home_filename (cfg,
 180                                         GNUNET_CLIENT_SERVICE_NAME, prefix,
 181                                         (NULL == pseudonym)
 182                                         ? NULL
 183                                         : (const char *) &enc,
 184                                         NULL);
 185 }
 186
 187
 188 /**
 189  * Get the filename (or directory name) for the given
 190  * hash code and directory prefix.
 191  *
 192  * @param cfg configuration to use
 193  * @param prefix path components to append to the private directory name
 194  * @param hc some hash code
 195  * @return filename of the pseudonym (if hc != NULL) or directory with the data (if hc == NULL)
 196  */
 197 static char *
 198 get_data_filename_hash (const struct GNUNET_CONFIGURATION_Handle *cfg,
 199                         const char *prefix,
 200                         const struct GNUNET_HashCode *hc)
 201 {
 202   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 203
 204   if (NULL != hc)
 205     GNUNET_CRYPTO_hash_to_enc (hc, &enc);
 206   return GNUNET_DISK_get_home_filename (cfg,
 207                                         GNUNET_CLIENT_SERVICE_NAME, prefix,
 208                                         (NULL == hc)
 209                                         ? NULL
 210                                         : (const char *) &enc,
 211                                         NULL);
 212 }
 213
 214
 215 /**
 216  * Set the pseudonym metadata, rank and name.
 217  * Writes the pseudonym infomation into a file
 218  *
 219  * @param cfg overall configuration
 220  * @param pseudonym id of the pseudonym
 221  * @param name name to set. Must be the non-unique version of it.
 222  *        May be NULL, in which case it erases pseudonym's name!
 223  * @param md metadata to set
 224  *        May be NULL, in which case it erases pseudonym's metadata!
 225  * @param rank rank to assign
 226  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 227  */
 228 int
 229 GNUNET_FS_pseudonym_set_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
 230                            const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
 231                            const char *name,
 232                            const struct GNUNET_CONTAINER_MetaData *md,
 233                            int32_t rank)
 234 {
 235   char *fn;
 236   struct GNUNET_BIO_WriteHandle *fileW;
 237
 238   fn = get_data_filename (cfg, PS_METADATA_DIR, pseudonym);
 239   if (NULL == (fileW = GNUNET_BIO_write_open (fn)))
 240   {
 241     GNUNET_free (fn);
 242     return GNUNET_SYSERR;
 243   }
 244   if ((GNUNET_OK != GNUNET_BIO_write (fileW, pseudonym,
 245                                       sizeof (struct GNUNET_CRYPTO_EccPublicKey))) ||
 246       (GNUNET_OK != GNUNET_BIO_write_int32 (fileW, rank)) ||
 247       (GNUNET_OK != GNUNET_BIO_write_string (fileW, name)) ||
 248       (GNUNET_OK != GNUNET_BIO_write_meta_data (fileW, md)))
 249   {
 250     (void) GNUNET_BIO_write_close (fileW);
 251     GNUNET_break (GNUNET_OK == GNUNET_DISK_directory_remove (fn));
 252     GNUNET_free (fn);
 253     return GNUNET_SYSERR;
 254   }
 255   if (GNUNET_OK != GNUNET_BIO_write_close (fileW))
 256   {
 257     GNUNET_break (GNUNET_OK == GNUNET_DISK_directory_remove (fn));
 258     GNUNET_free (fn);
 259     return GNUNET_SYSERR;
 260   }
 261   GNUNET_free (fn);
 262   /* create entry for pseudonym name in names */
 263   if (NULL != name)
 264     GNUNET_free_non_null (GNUNET_FS_pseudonym_name_uniquify (cfg, pseudonym,
 265                                                           name, NULL));
 266   return GNUNET_OK;
 267 }
 268
 269
 270 /**
 271  * Read pseudonym infomation from a file
 272  *
 273  * @param cfg configuration to use
 274  * @param pseudonym hash code of a pseudonym
 275  * @param meta meta data to be read from a file
 276  * @param rank rank of a pseudonym
 277  * @param ns_name name of a pseudonym
 278  * @return GNUNET_OK on success, GNUNET_SYSERR on error
 279  */
 280 static int
 281 read_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
 282            const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
 283            struct GNUNET_CONTAINER_MetaData **meta,
 284            int32_t *rank,
 285            char **ns_name)
 286 {
 287   struct GNUNET_CRYPTO_EccPublicKey pd;
 288   char *fn;
 289   char *emsg;
 290   struct GNUNET_BIO_ReadHandle *fileR;
 291
 292   fn = get_data_filename (cfg, PS_METADATA_DIR, pseudonym);
 293   if (GNUNET_YES !=
 294       GNUNET_DISK_file_test (fn))
 295   {
 296     GNUNET_free (fn);
 297     return GNUNET_SYSERR;
 298   }
 299   if (NULL == (fileR = GNUNET_BIO_read_open (fn)))
 300   {
 301     GNUNET_free (fn);
 302     return GNUNET_SYSERR;
 303   }
 304   emsg = NULL;
 305   *ns_name = NULL;
 306   if ( (GNUNET_OK != GNUNET_BIO_read (fileR, "pseudonym", &pd, sizeof (pd))) ||
 307        (0 != memcmp (&pd, pseudonym, sizeof (pd))) ||
 308        (GNUNET_OK != GNUNET_BIO_read_int32 (fileR, rank)) ||
 309        (GNUNET_OK !=
 310         GNUNET_BIO_read_string (fileR, "Read string error!", ns_name, 200)) ||
 311        (GNUNET_OK !=
 312        GNUNET_BIO_read_meta_data (fileR, "Read meta data error!", meta)) )
 313   {
 314     (void) GNUNET_BIO_read_close (fileR, &emsg);
 315     GNUNET_free_non_null (emsg);
 316     GNUNET_free_non_null (*ns_name);
 317     *ns_name = NULL;
 318     GNUNET_break (GNUNET_OK == GNUNET_DISK_directory_remove (fn));
 319     GNUNET_free (fn);
 320     return GNUNET_SYSERR;
 321   }
 322   if (GNUNET_OK != GNUNET_BIO_read_close (fileR, &emsg))
 323   {
 324     LOG (GNUNET_ERROR_TYPE_WARNING,
 325          _("Failed to parse metadata about pseudonym from file `%s': %s\n"), fn,
 326          emsg);
 327     GNUNET_break (GNUNET_OK == GNUNET_DISK_directory_remove (fn));
 328     GNUNET_CONTAINER_meta_data_destroy (*meta);
 329     *meta = NULL;
 330     GNUNET_free_non_null (*ns_name);
 331     *ns_name = NULL;
 332     GNUNET_free_non_null (emsg);
 333     GNUNET_free (fn);
 334     return GNUNET_SYSERR;
 335   }
 336   GNUNET_free (fn);
 337   return GNUNET_OK;
 338 }
 339
 340
 341 /**
 342  * Return unique variant of the namespace name.  Use it after
 343  * GNUNET_FS_pseudonym_get_info() to make sure that name is unique.
 344  *
 345  * @param cfg configuration
 346  * @param pseudonym public key of the pseudonym
 347  * @param name name to uniquify
 348  * @param suffix if not NULL, filled with the suffix value
 349  * @return NULL on failure (should never happen), name on success.
 350  *         Free the name with GNUNET_free().
 351  */
 352 char *
 353 GNUNET_FS_pseudonym_name_uniquify (const struct GNUNET_CONFIGURATION_Handle *cfg,
 354                                 const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
 355                                 const char *name,
 356                                 unsigned int *suffix)
 357 {
 358   struct GNUNET_HashCode nh;
 359   struct GNUNET_CRYPTO_EccPublicKey pi;
 360   uint64_t len;
 361   char *fn;
 362   struct GNUNET_DISK_FileHandle *fh;
 363   unsigned int i;
 364   unsigned int idx;
 365   char *ret;
 366   struct stat sbuf;
 367
 368   GNUNET_CRYPTO_hash (name, strlen (name), &nh);
 369   fn = get_data_filename_hash (cfg, PS_NAMES_DIR, &nh);
 370   len = 0;
 371   if (0 == STAT (fn, &sbuf))
 372     GNUNET_break (GNUNET_OK == GNUNET_DISK_file_size (fn, &len, GNUNET_YES, GNUNET_YES));
 373   fh = GNUNET_DISK_file_open (fn,
 374                               GNUNET_DISK_OPEN_CREATE |
 375                               GNUNET_DISK_OPEN_READWRITE,
 376                               GNUNET_DISK_PERM_USER_READ |
 377                               GNUNET_DISK_PERM_USER_WRITE);
 378   i = 0;
 379   idx = -1;
 380   while ((len >= sizeof (struct GNUNET_CRYPTO_EccPublicKey)) &&
 381          (sizeof (struct GNUNET_CRYPTO_EccPublicKey) ==
 382           GNUNET_DISK_file_read (fh, &pi, sizeof (struct GNUNET_CRYPTO_EccPublicKey))))
 383   {
 384     if (0 == memcmp (&pi, pseudonym, sizeof (struct GNUNET_CRYPTO_EccPublicKey)))
 385     {
 386       idx = i;
 387       break;
 388     }
 389     i++;
 390     len -= sizeof (struct GNUNET_HashCode);
 391   }
 392   if (-1 == idx)
 393   {
 394     idx = i;
 395     if (sizeof (struct GNUNET_CRYPTO_EccPublicKey) !=
 396         GNUNET_DISK_file_write (fh, pseudonym, sizeof (struct GNUNET_CRYPTO_EccPublicKey)))
 397       LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "write", fn);
 398   }
 399   GNUNET_DISK_file_close (fh);
 400   ret = GNUNET_malloc (strlen (name) + 32);
 401   GNUNET_snprintf (ret, strlen (name) + 32, "%s-%u", name, idx);
 402   if (suffix != NULL)
 403     *suffix = idx;
 404   GNUNET_free (fn);
 405   return ret;
 406 }
 407
 408
 409 /**
 410  * Get namespace name, metadata and rank
 411  * This is a wrapper around internal read_info() call, and ensures that
 412  * returned data is not invalid (not NULL).
 413  *
 414  * @param cfg configuration
 415  * @param pseudonym public key of the pseudonym
 416  * @param ret_meta a location to store metadata pointer. NULL, if metadata
 417  *        is not needed. Destroy with GNUNET_CONTAINER_meta_data_destroy().
 418  * @param ret_rank a location to store rank. NULL, if rank not needed.
 419  * @param ret_name a location to store human-readable name. Name is not unique.
 420  *        NULL, if name is not needed. Free with GNUNET_free().
 421  * @param name_is_a_dup is set to GNUNET_YES, if ret_name was filled with
 422  *        a duplicate of a "no-name" placeholder
 423  * @return GNUNET_OK on success. GNUENT_SYSERR if the data was
 424  *         unobtainable (in that case ret_* are filled with placeholders -
 425  *         empty metadata container, rank -1 and a "no-name" name).
 426  */
 427 int
 428 GNUNET_FS_pseudonym_get_info (const struct GNUNET_CONFIGURATION_Handle *cfg,
 429                               const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
 430                               struct GNUNET_CONTAINER_MetaData **ret_meta,
 431                               int32_t *ret_rank,
 432                               char **ret_name,
 433                               int *name_is_a_dup)
 434 {
 435   struct GNUNET_CONTAINER_MetaData *meta;
 436   char *name;
 437   int32_t rank = -1;
 438
 439   meta = NULL;
 440   name = NULL;
 441   if (GNUNET_OK == read_info (cfg, pseudonym, &meta, &rank, &name))
 442   {
 443     if ((meta != NULL) && (name == NULL))
 444       name =
 445           GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
 446                                                          EXTRACTOR_METATYPE_TITLE,
 447                                                          EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
 448                                                          EXTRACTOR_METATYPE_FILENAME,
 449                                                          EXTRACTOR_METATYPE_DESCRIPTION,
 450                                                          EXTRACTOR_METATYPE_SUBJECT,
 451                                                          EXTRACTOR_METATYPE_PUBLISHER,
 452                                                          EXTRACTOR_METATYPE_AUTHOR_NAME,
 453                                                          EXTRACTOR_METATYPE_COMMENT,
 454                                                          EXTRACTOR_METATYPE_SUMMARY,
 455                                                          -1);
 456     if (ret_name != NULL)
 457     {
 458       if (name == NULL)
 459       {
 460         name = GNUNET_strdup (_("no-name"));
 461         if (name_is_a_dup != NULL)
 462           *name_is_a_dup = GNUNET_YES;
 463       }
 464       else if (name_is_a_dup != NULL)
 465         *name_is_a_dup = GNUNET_NO;
 466       *ret_name = name;
 467     }
 468     else if (name != NULL)
 469       GNUNET_free (name);
 470
 471     if (ret_meta != NULL)
 472     {
 473       if (meta == NULL)
 474         meta = GNUNET_CONTAINER_meta_data_create ();
 475       *ret_meta = meta;
 476     }
 477     else if (meta != NULL)
 478       GNUNET_CONTAINER_meta_data_destroy (meta);
 479
 480     if (ret_rank != NULL)
 481       *ret_rank = rank;
 482
 483     return GNUNET_OK;
 484   }
 485   if (ret_name != NULL)
 486     *ret_name = GNUNET_strdup (_("no-name"));
 487   if (ret_meta != NULL)
 488     *ret_meta = GNUNET_CONTAINER_meta_data_create ();
 489   if (ret_rank != NULL)
 490     *ret_rank = -1;
 491   if (name_is_a_dup != NULL)
 492     *name_is_a_dup = GNUNET_YES;
 493   return GNUNET_SYSERR;
 494 }
 495
 496
 497 /**
 498  * Get the namespace ID belonging to the given namespace name.
 499  *
 500  * @param cfg configuration to use
 501  * @param ns_uname unique (!) human-readable name for the namespace
 502  * @param pseudonym set to public key of pseudonym based on 'ns_uname'
 503  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 504  */
 505 int
 506 GNUNET_FS_pseudonym_name_to_id (const struct GNUNET_CONFIGURATION_Handle *cfg,
 507                              const char *ns_uname,
 508                              struct GNUNET_CRYPTO_EccPublicKey *pseudonym)
 509 {
 510   size_t slen;
 511   uint64_t len;
 512   unsigned int idx;
 513   char *name;
 514   struct GNUNET_HashCode nh;
 515   char *fn;
 516   struct GNUNET_DISK_FileHandle *fh;
 517
 518   idx = -1;
 519   slen = strlen (ns_uname);
 520   while ((slen > 0) && (1 != SSCANF (&ns_uname[slen - 1], "-%u", &idx)))
 521     slen--;
 522   if (0 == slen)
 523     return GNUNET_SYSERR;
 524   name = GNUNET_strdup (ns_uname);
 525   name[slen - 1] = '\0';
 526
 527   GNUNET_CRYPTO_hash (name, strlen (name), &nh);
 528   GNUNET_free (name);
 529   fn = get_data_filename_hash (cfg, PS_NAMES_DIR, &nh);
 530
 531   if ((GNUNET_OK != GNUNET_DISK_file_test (fn) ||
 532        (GNUNET_OK != GNUNET_DISK_file_size (fn, &len, GNUNET_YES, GNUNET_YES))) ||
 533       ((idx + 1) * sizeof (struct GNUNET_CRYPTO_EccPublicKey) > len))
 534   {
 535     GNUNET_free (fn);
 536     return GNUNET_SYSERR;
 537   }
 538   fh = GNUNET_DISK_file_open (fn,
 539                               GNUNET_DISK_OPEN_CREATE |
 540                               GNUNET_DISK_OPEN_READWRITE,
 541                               GNUNET_DISK_PERM_USER_READ |
 542                               GNUNET_DISK_PERM_USER_WRITE);
 543   GNUNET_free (fn);
 544   if (GNUNET_SYSERR ==
 545       GNUNET_DISK_file_seek (fh, idx * sizeof (struct GNUNET_CRYPTO_EccPublicKey),
 546                              GNUNET_DISK_SEEK_SET))
 547   {
 548     GNUNET_DISK_file_close (fh);
 549     return GNUNET_SYSERR;
 550   }
 551   if (sizeof (struct GNUNET_CRYPTO_EccPublicKey) !=
 552       GNUNET_DISK_file_read (fh, pseudonym, sizeof (struct GNUNET_CRYPTO_EccPublicKey)))
 553   {
 554     GNUNET_DISK_file_close (fh);
 555     return GNUNET_SYSERR;
 556   }
 557   GNUNET_DISK_file_close (fh);
 558   return GNUNET_OK;
 559 }
 560
 561
 562
 563 /**
 564  * struct used to list the pseudonym
 565  */
 566 struct ListPseudonymClosure
 567 {
 568
 569   /**
 570    * iterator over pseudonym
 571    */
 572   GNUNET_FS_PseudonymIterator iterator;
 573
 574   /**
 575    * Closure for iterator.
 576    */
 577   void *iterator_cls;
 578
 579   /**
 580    * Configuration to use.
 581    */
 582   const struct GNUNET_CONFIGURATION_Handle *cfg;
 583 };
 584
 585
 586
 587 /**
 588  * Helper function to list all available pseudonyms
 589  *
 590  * @param cls point to a struct ListPseudonymClosure
 591  * @param fullname name of pseudonym
 592  */
 593 static int
 594 list_pseudonym_helper (void *cls, const char *fullname)
 595 {
 596   struct ListPseudonymClosure *lpc = cls;
 597   struct GNUNET_CRYPTO_EccPublicKey pd;
 598   char *emsg;
 599   struct GNUNET_BIO_ReadHandle *fileR;
 600   int32_t rank;
 601   char *ns_name;
 602   struct GNUNET_CONTAINER_MetaData *meta;
 603   int ret;
 604   char *name_unique;
 605
 606   if (NULL == (fileR = GNUNET_BIO_read_open (fullname)))
 607     return GNUNET_SYSERR;
 608   emsg = NULL;
 609   ns_name = NULL;
 610   if ( (GNUNET_OK != GNUNET_BIO_read (fileR, "pseudonym", &pd, sizeof (pd))) ||
 611        (GNUNET_OK != GNUNET_BIO_read_int32 (fileR, &rank)) ||
 612        (GNUNET_OK !=
 613         GNUNET_BIO_read_string (fileR, "Read string error!", &ns_name, 200)) ||
 614        (GNUNET_OK !=
 615        GNUNET_BIO_read_meta_data (fileR, "Read meta data error!", &meta)) )
 616   {
 617     (void) GNUNET_BIO_read_close (fileR, &emsg);
 618     GNUNET_free_non_null (emsg);
 619     GNUNET_free_non_null (ns_name);
 620     GNUNET_break (GNUNET_OK == GNUNET_DISK_directory_remove (fullname));
 621     return GNUNET_SYSERR;
 622   }
 623   if (NULL == ns_name)
 624     ns_name = GNUNET_strdup (_("no-name"));
 625   if (GNUNET_OK != GNUNET_BIO_read_close (fileR, &emsg))
 626   {
 627     LOG (GNUNET_ERROR_TYPE_WARNING,
 628          _("Failed to parse metadata about pseudonym from file `%s': %s\n"), fullname,
 629          emsg);
 630     GNUNET_break (GNUNET_OK == GNUNET_DISK_directory_remove (fullname));
 631     GNUNET_CONTAINER_meta_data_destroy (meta);
 632     GNUNET_free (ns_name);
 633     GNUNET_free_non_null (emsg);
 634     return GNUNET_SYSERR;
 635   }
 636   ret = GNUNET_OK;
 637   name_unique = GNUNET_FS_pseudonym_name_uniquify (lpc->cfg, &pd, ns_name, NULL);
 638   if (NULL != lpc->iterator)
 639     ret = lpc->iterator (lpc->iterator_cls, &pd, ns_name, name_unique, meta, rank);
 640   GNUNET_free (ns_name);
 641   GNUNET_free_non_null (name_unique);
 642   GNUNET_CONTAINER_meta_data_destroy (meta);
 643   return ret;
 644 }
 645
 646
 647 /**
 648  * List all available pseudonyms.
 649  *
 650  * @param cfg overall configuration
 651  * @param iterator function to call for each pseudonym
 652  * @param iterator_cls closure for iterator
 653  * @return number of pseudonyms found
 654  */
 655 int
 656 GNUNET_FS_pseudonym_list_all (const struct GNUNET_CONFIGURATION_Handle *cfg,
 657                            GNUNET_FS_PseudonymIterator iterator,
 658                            void *iterator_cls)
 659 {
 660   struct ListPseudonymClosure cls;
 661   char *fn;
 662   int ret;
 663
 664   cls.iterator = iterator;
 665   cls.iterator_cls = iterator_cls;
 666   cls.cfg = cfg;
 667   fn = get_data_filename (cfg, PS_METADATA_DIR, NULL);
 668   GNUNET_assert (fn != NULL);
 669   GNUNET_DISK_directory_create (fn);
 670   ret = GNUNET_DISK_directory_scan (fn, &list_pseudonym_helper, &cls);
 671   GNUNET_free (fn);
 672   return ret;
 673 }
 674
 675
 676 /**
 677  * Change the rank of a pseudonym.
 678  *
 679  * @param cfg overall configuration
 680  * @param pseudonym the pseudonym
 681  * @param delta by how much should the rating be changed?
 682  * @return new rating of the pseudonym
 683  */
 684 int
 685 GNUNET_FS_pseudonym_rank (const struct GNUNET_CONFIGURATION_Handle *cfg,
 686                        const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
 687                        int32_t delta)
 688 {
 689   struct GNUNET_CONTAINER_MetaData *meta;
 690   int ret;
 691   int32_t rank;
 692   char *name;
 693
 694   name = NULL;
 695   ret = read_info (cfg, pseudonym, &meta, &rank, &name);
 696   if (ret == GNUNET_SYSERR)
 697   {
 698     rank = 0;
 699     meta = GNUNET_CONTAINER_meta_data_create ();
 700   }
 701   rank += delta;
 702   GNUNET_FS_pseudonym_set_info (cfg, pseudonym, name, meta, rank);
 703   GNUNET_CONTAINER_meta_data_destroy (meta);
 704   GNUNET_free_non_null (name);
 705   return rank;
 706 }
 707
 708
 709 /**
 710  * Add a pseudonym to the set of known pseudonyms.
 711  * For all pseudonym advertisements that we discover
 712  * FS should automatically call this function.
 713  *
 714  * @param cfg overall configuration
 715  * @param pseudonym the pseudonym to add
 716  * @param meta metadata for the pseudonym
 717  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 718  */
 719 int
 720 GNUNET_FS_pseudonym_add (const struct GNUNET_CONFIGURATION_Handle *cfg,
 721                          const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
 722                          const struct GNUNET_CONTAINER_MetaData *meta)
 723 {
 724   char *name;
 725   int32_t rank;
 726   struct GNUNET_CONTAINER_MetaData *old;
 727   char *fn;
 728   struct stat sbuf;
 729   int ret;
 730
 731   rank = 0;
 732   fn = get_data_filename (cfg, PS_METADATA_DIR, pseudonym);
 733   GNUNET_assert (fn != NULL);
 734
 735   if ((0 == STAT (fn, &sbuf)) &&
 736       (GNUNET_OK == read_info (cfg, pseudonym, &old, &rank, &name)))
 737   {
 738     GNUNET_CONTAINER_meta_data_merge (old, meta);
 739     ret = GNUNET_FS_pseudonym_set_info (cfg, pseudonym, name, old, rank);
 740     GNUNET_CONTAINER_meta_data_destroy (old);
 741     GNUNET_free_non_null (name);
 742   }
 743   else
 744   {
 745     ret = GNUNET_FS_pseudonym_set_info (cfg, pseudonym, NULL, meta, rank);
 746   }
 747   GNUNET_free (fn);
 748   internal_notify (pseudonym, meta, rank);
 749   return ret;
 750 }
 751
 752
 753
 754 /* end of pseudonym.c */