upload.c

GNUnet是一个安全的点对点网络框架

  filename = GNUNET_malloc (strlen (dirName) + strlen (name) + 2);
  strcpy (filename, dirName);
  if (dirName[strlen (dirName) - 1] != DIR_SEPARATOR)
    strcat (filename, DIR_SEPARATOR_STR);
  strcat (filename, name);
  md_tmp = GNUNET_meta_data_create ();
  child = addUploads (parent->shared, filename, NULL, md_tmp, parent);
  GNUNET_free (filename);
  GNUNET_meta_data_destroy (md_tmp);
  if (child == NULL)
    return GNUNET_SYSERR;
  parent->total += child->total;
  return GNUNET_OK;
}

static struct GNUNET_FSUI_UploadList *
addUploads (struct GNUNET_FSUI_UploadShared *shared,
            const char *filename,
            const struct GNUNET_ECRS_URI *keywords,
            const struct GNUNET_MetaData *md,
            struct GNUNET_FSUI_UploadList *parent)
{
  GNUNET_FSUI_UploadList *utc;

  utc = GNUNET_malloc (sizeof (GNUNET_FSUI_UploadList));
  utc->completed = 0;
  utc->total = 0;               /* to be set later */
  utc->start_time = GNUNET_get_time ();
  utc->shared = shared;
  utc->next = NULL;
  utc->child = NULL;
  utc->parent = parent;
  utc->uri = NULL;
  utc->cctx = NULL;             /* to be set later */
  utc->state = GNUNET_FSUI_ACTIVE;
  if (GNUNET_YES == GNUNET_disk_file_test (shared->ctx->ectx, filename))
    {
      utc->is_directory = GNUNET_NO;
      /* add this file */
      if (GNUNET_OK != GNUNET_disk_file_size (shared->ctx->ectx,
                                              filename, &utc->total,
                                              GNUNET_YES))
        {
          GNUNET_free (utc);
          return NULL;
        }
      utc->meta =
        (md ==
         NULL) ? GNUNET_meta_data_create () : GNUNET_meta_data_duplicate (md);
    }
  else
    {
      utc->is_directory = GNUNET_YES;
      if (GNUNET_SYSERR == shared->dsc (shared->dscClosure,
                                        filename, &addChildUpload, utc))
        {
          /* error scanning upload directory */
          while (utc->child != NULL)
            freeUploadList (utc->child);
          GNUNET_free (utc);
          return NULL;
        }
      utc->meta = GNUNET_meta_data_duplicate (md);
      GNUNET_meta_data_insert (utc->meta,
                               EXTRACTOR_MIMETYPE, GNUNET_DIRECTORY_MIME);
    }
  if (keywords != NULL)
    utc->keywords = GNUNET_ECRS_uri_duplicate (keywords);
  else
    utc->keywords = NULL;
  utc->filename = GNUNET_strdup (filename);

  /* finally, link with parent */
  GNUNET_mutex_lock (shared->ctx->lock);
  utc->next = parent->child;
  parent->child = utc;
  GNUNET_mutex_unlock (shared->ctx->lock);
  return utc;
}

static void
signalUploadStopped (struct GNUNET_FSUI_UploadList *ul, int first_only)
{
  GNUNET_FSUI_Event event;

  while (ul != NULL)
    {
      signalUploadStopped (ul->child, 0);
      event.type = GNUNET_FSUI_upload_stopped;
      event.data.UploadStopped.uc.pos = ul;
      event.data.UploadStopped.uc.cctx = ul->cctx;
      event.data.UploadStopped.uc.ppos = ul->parent;
      event.data.UploadStopped.uc.pcctx = ul->parent->cctx;
      ul->shared->ctx->ecb (ul->shared->ctx->ecbClosure, &event);
      if (first_only)
        break;
      ul = ul->next;
    }
}

static void
freeShared (struct GNUNET_FSUI_UploadShared *shared)
{
  if (shared->global_keywords != NULL)
    GNUNET_ECRS_uri_destroy (shared->global_keywords);
  EXTRACTOR_removeAll (shared->extractors);
  GNUNET_free_non_null (shared->extractor_config);
  GNUNET_free (shared->top_filename);
  GNUNET_free (shared);
}

/**
 * Start uploading a file.  Note that an upload cannot be stopped once
 * started (not necessary anyway), but it can fail.  The function also
 * automatically the uploaded file in the global keyword space under
 * the given keywords.
 *
 * @return GNUNET_OK on success (at least we started with it),
 *  GNUNET_SYSERR if the file does not exist or gnunetd is not
 *  running
 */
struct GNUNET_FSUI_UploadList *
GNUNET_FSUI_upload_start (struct GNUNET_FSUI_Context *ctx,
                          const char *filename,
                          GNUNET_FSUI_DirectoryScanCallback dsc,
                          void *dscClosure,
                          unsigned int anonymityLevel,
                          unsigned int priority,
                          int doIndex,
                          int doExtract,
                          int individualKeywords,
                          GNUNET_CronTime expiration,
                          const struct GNUNET_MetaData *md,
                          const struct GNUNET_ECRS_URI *globalURI,
                          const struct GNUNET_ECRS_URI *keyUri)
{
  char *config;
  EXTRACTOR_ExtractorList *extractors;
  struct GNUNET_FSUI_UploadShared *shared;
  struct GNUNET_FSUI_UploadList *ul;

  config = NULL;
  extractors = NULL;
  if (doExtract)
    {
      extractors = EXTRACTOR_loadDefaultLibraries ();
      if (GNUNET_GC_have_configuration_value (ctx->cfg, "FS", "EXTRACTORS"))
        {
          GNUNET_GC_get_configuration_value_string (ctx->cfg,
                                                    "FS",
                                                    "EXTRACTORS", NULL,
                                                    &config);
          if (config != NULL)
            {
              extractors = EXTRACTOR_loadConfigLibraries (extractors, config);
            }
        }
    }
  shared = GNUNET_malloc (sizeof (GNUNET_FSUI_UploadShared));
  shared->dsc = dsc;
  shared->dscClosure = dscClosure;
  shared->extractors = extractors;
  shared->expiration = expiration;
  shared->ctx = ctx;
  shared->handle = NULL;
  shared->global_keywords =
    globalURI != NULL ? GNUNET_ECRS_uri_duplicate (globalURI) : NULL;
  shared->extractor_config = config;
  shared->doIndex = doIndex;
  shared->anonymityLevel = anonymityLevel;
  shared->priority = priority;
  shared->individualKeywords = individualKeywords;
  shared->top_filename = GNUNET_strdup (filename);
  ul = addUploads (shared, filename, keyUri, md, &ctx->activeUploads);
  if (ul == NULL)
    {
      freeShared (shared);
      return NULL;
    }
  shared->handle =
    GNUNET_thread_create (&GNUNET_FSUI_uploadThreadEvent, ul, 128 * 1024);
  if (shared->handle == NULL)
    {
      GNUNET_GE_LOG_STRERROR (ctx->ectx,
                              GNUNET_GE_ERROR | GNUNET_GE_USER |
                              GNUNET_GE_BULK, "PTHREAD_CREATE");
      freeUploadList (ul);
      freeShared (shared);
      return NULL;
    }
  GNUNET_GE_ASSERT (ctx->ectx, ul->shared == shared);
  return ul;
}

/**
 * Abort an upload.  If the context is for a recursive
 * upload, all sub-uploads will also be aborted.
 * Note that if this is not the top-level upload,
 * the top-level upload will continue without the
 * subtree selected using this abort command.
 *
 * @return GNUNET_SYSERR on error
 */
int
GNUNET_FSUI_upload_abort (struct GNUNET_FSUI_UploadList *ul)
{
  GNUNET_FSUI_UploadList *c;
  GNUNET_FSUI_UploadList *p;
  struct GNUNET_FSUI_Context *ctx;
  GNUNET_FSUI_Event event;

  if (ul == NULL)
    return GNUNET_SYSERR;
  ctx = ul->shared->ctx;
  if ((ul->state != GNUNET_FSUI_ACTIVE) && (ul->state != GNUNET_FSUI_PENDING))
    return GNUNET_NO;
  if (ul->state == GNUNET_FSUI_ACTIVE)
    {
      ul->state = GNUNET_FSUI_ABORTED;
      c = ul->child;
      while (c != NULL)
        {
          GNUNET_FSUI_upload_abort (c);
          c = c->next;
        }
      GNUNET_thread_stop_sleep (ul->shared->handle);
      event.type = GNUNET_FSUI_upload_aborted;
      event.data.UploadAborted.uc.pos = ul;
      event.data.UploadAborted.uc.cctx = ul->cctx;
      event.data.UploadAborted.uc.ppos = ul->parent;
      event.data.UploadAborted.uc.pcctx = ul->parent->cctx;
      ctx->ecb (ctx->ecbClosure, &event);
    }
  else
    {
      ul->state = GNUNET_FSUI_ABORTED_JOINED;
      c = ul->child;
      while (c != NULL)
        {
          GNUNET_FSUI_upload_abort (c);
          c = c->next;
        }
      event.type = GNUNET_FSUI_upload_aborted;
      event.data.UploadAborted.uc.pos = ul;
      event.data.UploadAborted.uc.cctx = ul->cctx;
      event.data.UploadAborted.uc.ppos = ul->parent;
      event.data.UploadAborted.uc.pcctx = ul->parent->cctx;
      ctx->ecb (ctx->ecbClosure, &event);
    }
  if (!ul->is_directory)
    {
      /* reduce total size of all parents accordingly
         and generate progress events */
      p = ul->parent;
      while (p != &ctx->activeUploads)
        {
          p->total -= ul->total;
          event.type = GNUNET_FSUI_upload_progress;
          event.data.UploadProgress.uc.pos = p;
          event.data.UploadProgress.uc.cctx = p->cctx;
          event.data.UploadProgress.uc.ppos = p->parent;
          event.data.UploadProgress.uc.pcctx = p->parent->cctx;
          event.data.UploadProgress.completed = p->completed;
          event.data.UploadProgress.total = p->total;
          /* use "now" for ETA, given that the user is aborting stuff */
          event.data.UploadProgress.eta = GNUNET_get_time ();
          event.data.UploadProgress.filename = p->filename;
          ctx->ecb (ctx->ecbClosure, &event);
          p = p->parent;
        }
    }
  return GNUNET_OK;
}

/**
 * Stop an upload.  Only to be called for the top-level
 * upload.
 *
 * @return GNUNET_SYSERR on error
 */
int
GNUNET_FSUI_upload_stop (struct GNUNET_FSUI_UploadList *ul)
{
  void *unused;
  struct GNUNET_FSUI_UploadShared *shared;
  struct GNUNET_FSUI_Context *ctx;

  if (ul == NULL)
    return GNUNET_SYSERR;
  ctx = ul->shared->ctx;
  GNUNET_GE_ASSERT (ctx->ectx, ul->parent == &ctx->activeUploads);
  if ((ul->state == GNUNET_FSUI_ACTIVE) ||
      (ul->state == GNUNET_FSUI_COMPLETED) ||
      (ul->state == GNUNET_FSUI_ABORTED) || (ul->state == GNUNET_FSUI_ERROR))
    {
      GNUNET_GE_ASSERT (ctx->ectx, ul->shared->handle != NULL);
      GNUNET_thread_join (ul->shared->handle, &unused);
      ul->shared->handle = NULL;
      if (ul->state == GNUNET_FSUI_ACTIVE)
        ul->state = GNUNET_FSUI_PENDING;
      else
        ul->state++;            /* add _JOINED */
    }
  else
    {
      GNUNET_GE_ASSERT (ctx->ectx, ul->shared->handle == NULL);
    }
  signalUploadStopped (ul, 1);
  shared = ul->shared;
  freeUploadList (ul);
  freeShared (shared);
  return GNUNET_OK;
}

/* end of upload.c */