Beispiel #1
0
/**
 * Destroy publish-structure.  Clients should never destroy publish
 * structures that were passed to #GNUNET_FS_publish_start already.
 *
 * @param fi structure to destroy
 * @param cleaner function to call on each entry in the structure
 *        (useful to clean up client_info); can be NULL; return
 *        values are ignored
 * @param cleaner_cls closure for @a cleaner
 */
void
GNUNET_FS_file_information_destroy (struct GNUNET_FS_FileInformation *fi,
                                    GNUNET_FS_FileInformationProcessor cleaner,
                                    void *cleaner_cls)
{
  struct GNUNET_FS_FileInformation *pos;
  int no;

  no = GNUNET_NO;
  if (GNUNET_YES == fi->is_directory)
  {
    /* clean up directory */
    while (NULL != (pos = fi->data.dir.entries))
    {
      fi->data.dir.entries = pos->next;
      GNUNET_FS_file_information_destroy (pos, cleaner, cleaner_cls);
    }
    /* clean up client-info */
    if (NULL != cleaner)
      cleaner (cleaner_cls, fi, fi->data.dir.dir_size, fi->meta, &fi->keywords,
               &fi->bo, &no, &fi->client_info);
    GNUNET_free_non_null (fi->data.dir.dir_data);
  }
  else
  {
    /* call clean-up function of the reader */
    if (NULL != fi->data.file.reader)
    {
      (void) fi->data.file.reader (fi->data.file.reader_cls, 0, 0, NULL, NULL);
      fi->data.file.reader = NULL;
    }
    /* clean up client-info */
    if (NULL != cleaner)
      cleaner (cleaner_cls, fi, fi->data.file.file_size, fi->meta,
               &fi->keywords, &fi->bo, &fi->data.file.do_index,
               &fi->client_info);
  }
  GNUNET_free_non_null (fi->filename);
  GNUNET_free_non_null (fi->emsg);
  if (NULL != fi->sks_uri)
      GNUNET_FS_uri_destroy (fi->sks_uri);
  if (NULL != fi->chk_uri)
      GNUNET_FS_uri_destroy (fi->chk_uri);
  /* clean up serialization */
  if ((NULL != fi->serialization) && (0 != UNLINK (fi->serialization)))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink",
                              fi->serialization);
  if (NULL != fi->keywords)
    GNUNET_FS_uri_destroy (fi->keywords);
  if (NULL != fi->meta)
    GNUNET_CONTAINER_meta_data_destroy (fi->meta);
  GNUNET_free_non_null (fi->serialization);
  if (NULL != fi->te)
  {
    GNUNET_FS_tree_encoder_finish (fi->te, NULL);
    fi->te = NULL;
  }
  GNUNET_free (fi);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  const char *keywords[] = {
    "down_foo",
    "down_bar",
  };
  char *fn1;
  char *fn2;
  char *buf;
  struct GNUNET_CONTAINER_MetaData *meta;
  struct GNUNET_FS_Uri *kuri;
  struct GNUNET_FS_FileInformation *fi1;
  struct GNUNET_FS_FileInformation *fi2;
  struct GNUNET_FS_FileInformation *fidir;
  struct GNUNET_FS_Handle *fs;
  size_t i;
  struct GNUNET_FS_BlockOptions bo;

  fs = GNUNET_FS_start (cfg, "test-fs-file-information", NULL, NULL,
                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
  fn1 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
  buf = GNUNET_malloc (FILESIZE);
  for (i = 0; i < FILESIZE; i++)
    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
  GNUNET_assert (FILESIZE ==
                 GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
                                       GNUNET_DISK_PERM_USER_READ |
                                       GNUNET_DISK_PERM_USER_WRITE));
  GNUNET_free (buf);

  fn2 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
  buf = GNUNET_malloc (FILESIZE);
  for (i = 0; i < FILESIZE; i++)
    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
  GNUNET_assert (FILESIZE ==
                 GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
                                       GNUNET_DISK_PERM_USER_READ |
                                       GNUNET_DISK_PERM_USER_WRITE));
  GNUNET_free (buf);

  meta = GNUNET_CONTAINER_meta_data_create ();
  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
  bo.content_priority = 42;
  bo.anonymity_level = 1;
  bo.replication_level = 0;
  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
  fi1 =
      GNUNET_FS_file_information_create_from_file (fs,
                                                   "file_information-context1",
                                                   fn1, kuri, meta, GNUNET_YES,
                                                   &bo);
  GNUNET_assert (fi1 != NULL);
  fi2 =
      GNUNET_FS_file_information_create_from_file (fs,
                                                   "file_information-context2",
                                                   fn2, kuri, meta, GNUNET_YES,
                                                   &bo);
  GNUNET_assert (fi2 != NULL);
  fidir =
      GNUNET_FS_file_information_create_empty_directory (fs,
                                                         "file_information-context-dir",
                                                         kuri, meta, &bo, NULL);
  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
  GNUNET_FS_uri_destroy (kuri);
  GNUNET_CONTAINER_meta_data_destroy (meta);
  GNUNET_assert (NULL != fidir);
  /* FIXME: test more of API! */
  GNUNET_FS_file_information_destroy (fidir, &mycleaner, NULL);
  GNUNET_DISK_directory_remove (fn1);
  GNUNET_DISK_directory_remove (fn2);
  GNUNET_free_non_null (fn1);
  GNUNET_free_non_null (fn2);
  GNUNET_FS_stop (fs);
}