gnunet_fs_service.h

Go to the documentation of this file.

/*
     This file is part of GNUnet
     Copyright (C) 2004--2013 GNUnet e.V.

     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.

     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */
#ifndef GNUNET_FS_LIB_H
#define GNUNET_FS_LIB_H

#include "gnunet_util_lib.h"

#ifdef __cplusplus
extern "C"
{
#if 0                           /* keep Emacsens' auto-indent happy */
}
#endif
#endif

#define GNUNET_FS_VERSION 0x00090300


/* ******************** URI API *********************** */

#define GNUNET_FS_URI_PREFIX "gnunet://fs/"
#define GNUNET_FS_URI_KSK_INFIX "ksk/"
#define GNUNET_FS_URI_SKS_INFIX "sks/"
#define GNUNET_FS_URI_CHK_INFIX "chk/"
#define GNUNET_FS_URI_LOC_INFIX "loc/"


#define GNUNET_FS_PROBE_UPDATE_FREQUENCY GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_MILLISECONDS, 250)

struct GNUNET_FS_Uri;


typedef int
(*GNUNET_FS_KeywordIterator) (void *cls,
                              const char *keyword,
                              int is_mandatory);


int
GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri,
                      struct GNUNET_HashCode *key);


char *
GNUNET_FS_uri_to_string (const struct GNUNET_FS_Uri *uri);


char *
GNUNET_FS_uri_ksk_to_string_fancy (const struct GNUNET_FS_Uri *uri);


void
GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri,
                               const char *keyword,
                               int is_mandatory);


void
GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri *uri,
                                  const char *keyword);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_parse (const char *uri,
                     char **emsg);


void
GNUNET_FS_uri_destroy (struct GNUNET_FS_Uri *uri);


unsigned int
GNUNET_FS_uri_ksk_get_keyword_count (const struct GNUNET_FS_Uri *uri);


int
GNUNET_FS_uri_ksk_get_keywords (const struct GNUNET_FS_Uri *uri,
                                GNUNET_FS_KeywordIterator iterator,
                                void *iterator_cls);


int
GNUNET_FS_uri_loc_get_peer_identity (const struct GNUNET_FS_Uri *uri,
                                     struct GNUNET_PeerIdentity *peer);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_loc_get_uri (const struct GNUNET_FS_Uri *uri);


struct GNUNET_TIME_Absolute
GNUNET_FS_uri_loc_get_expiration (const struct GNUNET_FS_Uri *uri);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *base_uri,
                          const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key,
                          struct GNUNET_TIME_Absolute expiration_time);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri *u1,
                         const struct GNUNET_FS_Uri *u2);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_ksk_create (const char *keywords,
                          char **emsg);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_ksk_create_from_args (unsigned int argc,
                                    const char **argv);


int
GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
                          const struct GNUNET_FS_Uri *u2);


int
GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
                          const char *id);


int
GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri,
                                 struct GNUNET_CRYPTO_EcdsaPublicKey *pseudonym);


char *
GNUNET_FS_uri_sks_get_content_id (const struct GNUNET_FS_Uri *uri);


int
GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri);


int
GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri);


uint64_t
GNUNET_FS_uri_chk_get_file_size (const struct GNUNET_FS_Uri *uri);


int
GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri);


struct GNUNET_FS_Uri *
GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData
                                         *md);


/* ******************** command-line option parsing API *********************** */

struct GNUNET_GETOPT_CommandLineOption
GNUNET_FS_GETOPT_KEYWORDS (char shortName,
                           const char *name,
                           const char *argumentHelp,
                           const char *description,
                           struct GNUNET_FS_Uri **topKeywords);

struct GNUNET_GETOPT_CommandLineOption
GNUNET_FS_GETOPT_METADATA (char shortName,
                           const char *name,
                           const char *argumentHelp,
                           const char *description,
                           struct GNUNET_CONTAINER_MetaData **meta);

int
GNUNET_FS_getopt_set_metadata (struct
                               GNUNET_GETOPT_CommandLineProcessorContext *ctx,
                               void *scls,
                               const char *option,
                               const char *value);


/* ************************* sharing API ***************** */


enum GNUNET_FS_Status
{
  GNUNET_FS_STATUS_PUBLISH_START = 0,

  GNUNET_FS_STATUS_PUBLISH_RESUME = 1,

  GNUNET_FS_STATUS_PUBLISH_SUSPEND = 2,

  GNUNET_FS_STATUS_PUBLISH_PROGRESS = 3,

  GNUNET_FS_STATUS_PUBLISH_ERROR = 4,

  GNUNET_FS_STATUS_PUBLISH_COMPLETED = 5,

  GNUNET_FS_STATUS_PUBLISH_STOPPED = 6,

  GNUNET_FS_STATUS_DOWNLOAD_START = 7,

  GNUNET_FS_STATUS_DOWNLOAD_RESUME = 8,

  GNUNET_FS_STATUS_DOWNLOAD_SUSPEND = 9,

  GNUNET_FS_STATUS_DOWNLOAD_PROGRESS = 10,

  GNUNET_FS_STATUS_DOWNLOAD_ERROR = 11,

  GNUNET_FS_STATUS_DOWNLOAD_COMPLETED = 12,

  GNUNET_FS_STATUS_DOWNLOAD_STOPPED = 13,

  GNUNET_FS_STATUS_DOWNLOAD_ACTIVE = 14,

  GNUNET_FS_STATUS_DOWNLOAD_INACTIVE = 15,

  GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT = 16,

  GNUNET_FS_STATUS_SEARCH_START = 17,

  GNUNET_FS_STATUS_SEARCH_RESUME = 18,

  GNUNET_FS_STATUS_SEARCH_RESUME_RESULT = 19,

  GNUNET_FS_STATUS_SEARCH_SUSPEND = 20,

  GNUNET_FS_STATUS_SEARCH_RESULT = 21,

  GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE = 22,

  GNUNET_FS_STATUS_SEARCH_UPDATE = 23,

  GNUNET_FS_STATUS_SEARCH_ERROR = 24,

  GNUNET_FS_STATUS_SEARCH_PAUSED = 25,

  GNUNET_FS_STATUS_SEARCH_CONTINUED = 26,

  GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED = 27,

  GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND = 28,

  GNUNET_FS_STATUS_SEARCH_STOPPED = 29,

  GNUNET_FS_STATUS_UNINDEX_START = 30,

  GNUNET_FS_STATUS_UNINDEX_RESUME = 31,

  GNUNET_FS_STATUS_UNINDEX_SUSPEND = 32,

  GNUNET_FS_STATUS_UNINDEX_PROGRESS = 33,

  GNUNET_FS_STATUS_UNINDEX_ERROR = 34,

  GNUNET_FS_STATUS_UNINDEX_COMPLETED = 35,

  GNUNET_FS_STATUS_UNINDEX_STOPPED = 36,

  GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY = 37
};


struct GNUNET_FS_PublishContext;


struct GNUNET_FS_UnindexContext;


struct GNUNET_FS_SearchContext;


struct GNUNET_FS_SearchResult;


struct GNUNET_FS_DownloadContext;


struct GNUNET_FS_FileInformation;


struct GNUNET_FS_ProgressInfo
{
  union
  {
    struct GNUNET_FS_PublishStatusEvent
    {
      struct GNUNET_FS_PublishContext *pc;

      const struct GNUNET_FS_FileInformation *fi;

      void *cctx;

      void *pctx;

      const char *filename;

      uint64_t size;

      struct GNUNET_TIME_Relative eta;

      struct GNUNET_TIME_Relative duration;

      uint64_t completed;

      uint32_t anonymity;

      union
      {
        struct GNUNET_FS_PublishProgressEvent
        {
          const void *data;

          uint64_t offset;

          uint64_t data_len;

          unsigned int depth;
        } progress;

        struct GNUNET_FS_PublishProgressDirectoryEvent
        {
          uint64_t completed;

          uint64_t total;

          struct GNUNET_TIME_Relative eta;
        } progress_directory;

        struct GNUNET_FS_PublishResumeEvent
        {
          const char *message;

          const struct GNUNET_FS_Uri *chk_uri;

          const struct GNUNET_FS_Uri *sks_uri;
        } resume;

        struct GNUNET_FS_PublishCompletedEvent
        {
          const struct GNUNET_FS_Uri *chk_uri;

          const struct GNUNET_FS_Uri *sks_uri;
        } completed;

        struct GNUNET_FS_PublishErrorEvent
        {
          const char *message;
        } error;
      } specifics;
    } publish;


    struct GNUNET_FS_DownloadStatusEvent
    {
      struct GNUNET_FS_DownloadContext *dc;

      void *cctx;

      void *pctx;

      void *sctx;

      const struct GNUNET_FS_Uri *uri;

      const char *filename;

      uint64_t size;

      struct GNUNET_TIME_Relative eta;

      struct GNUNET_TIME_Relative duration;

      uint64_t completed;

      uint32_t anonymity;

      int is_active;

      union
      {
        struct GNUNET_FS_DownloadProgressEvent
        {
          const void *data;

          uint64_t offset;

          uint64_t data_len;

          struct GNUNET_TIME_Relative block_download_duration;

          unsigned int depth;

          uint32_t respect_offered;

          uint32_t num_transmissions;
        } progress;

        struct GNUNET_FS_DownloadStartEvent
        {
          const struct GNUNET_CONTAINER_MetaData *meta;
        } start;

        struct GNUNET_FS_DownloadResumeEvent
        {
          const struct GNUNET_CONTAINER_MetaData *meta;

          const char *message;
        } resume;

        struct GNUNET_FS_DownloadErrorEvent
        {
          const char *message;
        } error;
      } specifics;
    } download;

    struct GNUNET_FS_SearchStatusEvent
    {
      struct GNUNET_FS_SearchContext *sc;

      void *cctx;

      void *pctx;

      const struct GNUNET_FS_Uri *query;

      struct GNUNET_TIME_Relative duration;

      uint32_t anonymity;

      union
      {
        struct GNUNET_FS_SearchResultEvent
        {
          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;

          struct GNUNET_FS_SearchResult *result;

          uint32_t applicability_rank;
        } result;

        struct GNUNET_FS_SearchResumeResultEvent
        {
          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;

          struct GNUNET_FS_SearchResult *result;

          int32_t availability_rank;

          uint32_t availability_certainty;

          uint32_t applicability_rank;
        } resume_result;

        struct GNUNET_FS_SearchUpdateEvent
        {
          void *cctx;

          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;

          int32_t availability_rank;

          uint32_t availability_certainty;

          uint32_t applicability_rank;

          struct GNUNET_TIME_Relative current_probe_time;
        } update;

        struct GNUNET_FS_SearchSuspendResultEvent
        {
          void *cctx;

          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;
        } result_suspend;

        struct GNUNET_FS_SearchStoppedResultEvent
        {
          void *cctx;

          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;
        } result_stopped;

        struct GNUNET_GS_SearchResumeEvent
        {
          const char *message;

          int is_paused;
        } resume;

        struct GNUNET_FS_SearchErrorEvent
        {
          const char *message;
        } error;

        struct GNUNET_GS_SearchResultNamespaceEvent
        {
          const char *name;

          const char *root;

          const struct GNUNET_CONTAINER_MetaData *meta;

          struct GNUNET_CRYPTO_EcdsaPublicKey pseudonym;
        } ns;
      } specifics;
    } search;

    struct GNUNET_FS_UnindexEvent
    {
      struct GNUNET_FS_UnindexContext *uc;

      void *cctx;

      const char *filename;

      uint64_t size;

      struct GNUNET_TIME_Relative eta;

      struct GNUNET_TIME_Relative duration;

      uint64_t completed;

      union
      {
        struct GNUNET_FS_UnindexProgressEvent
        {
          const void *data;

          uint64_t offset;

          uint64_t data_len;

          unsigned int depth;
        } progress;

        struct GNUNET_FS_UnindexResumeEvent
        {
          const char *message;
        } resume;

        struct GNUNET_FS_UnindexErrorEvent
        {
          const char *message;
        } error;
      } specifics;
    } unindex;
  } value;

  enum GNUNET_FS_Status status;

  struct GNUNET_FS_Handle *fsh;
};


typedef void *
(*GNUNET_FS_ProgressCallback) (void *cls,
                               const struct GNUNET_FS_ProgressInfo *info);


enum GNUNET_FS_Flags
{
  GNUNET_FS_FLAGS_NONE = 0,

  GNUNET_FS_FLAGS_PERSISTENCE = 1,

  GNUNET_FS_FLAGS_DO_PROBES = 2
};


enum GNUNET_FS_OPTIONS
{
  GNUNET_FS_OPTIONS_END = 0,

  GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM = 1,

  GNUNET_FS_OPTIONS_REQUEST_PARALLELISM = 2
};


struct GNUNET_FS_BlockOptions
{
  struct GNUNET_TIME_Absolute expiration_time;

  uint32_t anonymity_level;

  uint32_t content_priority;

  uint32_t replication_level;
};


struct GNUNET_FS_Handle;


struct GNUNET_FS_Handle *
GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                 const char *client_name,
                 GNUNET_FS_ProgressCallback upcb,
                 void *upcb_cls,
                 enum GNUNET_FS_Flags flags,
                 ...);


void
GNUNET_FS_stop (struct GNUNET_FS_Handle *h);


typedef int
(*GNUNET_FS_FileInformationProcessor) (void *cls,
                                       struct GNUNET_FS_FileInformation *fi,
                                       uint64_t length,
                                       struct GNUNET_CONTAINER_MetaData *meta,
                                       struct GNUNET_FS_Uri **uri,
                                       struct GNUNET_FS_BlockOptions *bo,
                                       int *do_index,
                                       void **client_info);


const char *
GNUNET_FS_file_information_get_id (struct GNUNET_FS_FileInformation *s);


const char *
GNUNET_FS_file_information_get_filename (struct GNUNET_FS_FileInformation *s);


void
GNUNET_FS_file_information_set_filename (struct GNUNET_FS_FileInformation *s,
                                         const char *filename);


struct GNUNET_FS_FileInformation *
GNUNET_FS_file_information_create_from_file (struct GNUNET_FS_Handle *h,
                                             void *client_info,
                                             const char *filename,
                                             const struct
                                             GNUNET_FS_Uri *keywords,
                                             const struct
                                             GNUNET_CONTAINER_MetaData *meta,
                                             int do_index,
                                             const struct
                                             GNUNET_FS_BlockOptions *bo);


struct GNUNET_FS_FileInformation *
GNUNET_FS_file_information_create_from_data (struct GNUNET_FS_Handle *h,
                                             void *client_info,
                                             uint64_t length,
                                             void *data,
                                             const struct
                                             GNUNET_FS_Uri *keywords,
                                             const struct
                                             GNUNET_CONTAINER_MetaData *meta,
                                             int do_index,
                                             const struct
                                             GNUNET_FS_BlockOptions *bo);


typedef size_t
(*GNUNET_FS_DataReader) (void *cls,
                         uint64_t offset,
                         size_t max,
                         void *buf,
                         char **emsg);


struct GNUNET_FS_FileInformation *
GNUNET_FS_file_information_create_from_reader (struct GNUNET_FS_Handle *h,
                                               void *client_info,
                                               uint64_t length,
                                               GNUNET_FS_DataReader reader,
                                               void *reader_cls,
                                               const struct GNUNET_FS_Uri
                                               *keywords,
                                               const struct
                                               GNUNET_CONTAINER_MetaData *meta,
                                               int do_index,
                                               const struct
                                               GNUNET_FS_BlockOptions *bo);


struct GNUNET_FS_FileInformation *
GNUNET_FS_file_information_create_empty_directory (struct GNUNET_FS_Handle *h,
                                                   void *client_info,
                                                   const struct GNUNET_FS_Uri
                                                   *keywords,
                                                   const struct
                                                   GNUNET_CONTAINER_MetaData
                                                   *meta,
                                                   const struct
                                                   GNUNET_FS_BlockOptions *bo,
                                                   const char *filename);


int
GNUNET_FS_file_information_is_directory (const struct GNUNET_FS_FileInformation
                                         *ent);


int
GNUNET_FS_file_information_add (struct GNUNET_FS_FileInformation *dir,
                                struct GNUNET_FS_FileInformation *ent);


void
GNUNET_FS_file_information_inspect (struct GNUNET_FS_FileInformation *dir,
                                    GNUNET_FS_FileInformationProcessor proc,
                                    void *proc_cls);


void
GNUNET_FS_file_information_destroy (struct GNUNET_FS_FileInformation *fi,
                                    GNUNET_FS_FileInformationProcessor cleaner,
                                    void *cleaner_cls);


enum GNUNET_FS_PublishOptions
{
  GNUNET_FS_PUBLISH_OPTION_NONE = 0,

  GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY = 1
};


struct GNUNET_FS_PublishContext *
GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h,
                         struct GNUNET_FS_FileInformation *fi,
                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
                         const char *nid,
                         const char *nuid,
                         enum GNUNET_FS_PublishOptions options);


void
GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc);


typedef void
(*GNUNET_FS_PublishContinuation) (void *cls,
                                  const struct GNUNET_FS_Uri *uri,
                                  const char *emsg);


struct GNUNET_FS_PublishKskContext;


struct GNUNET_FS_PublishKskContext *
GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
                       const struct GNUNET_FS_Uri *ksk_uri,
                       const struct GNUNET_CONTAINER_MetaData *meta,
                       const struct GNUNET_FS_Uri *uri,
                       const struct GNUNET_FS_BlockOptions *bo,
                       enum GNUNET_FS_PublishOptions options,
                       GNUNET_FS_PublishContinuation cont, void *cont_cls);


void
GNUNET_FS_publish_ksk_cancel (struct GNUNET_FS_PublishKskContext *pkc);


struct GNUNET_FS_PublishSksContext;


struct GNUNET_FS_PublishSksContext *
GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
                       const char *identifier,
                       const char *update,
                       const struct GNUNET_CONTAINER_MetaData *meta,
                       const struct GNUNET_FS_Uri *uri,
                       const struct GNUNET_FS_BlockOptions *bo,
                       enum GNUNET_FS_PublishOptions options,
                       GNUNET_FS_PublishContinuation cont, void *cont_cls);


void
GNUNET_FS_publish_sks_cancel (struct GNUNET_FS_PublishSksContext *psc);


typedef int
(*GNUNET_FS_IndexedFileProcessor) (void *cls,
                                   const char *filename,
                                   const struct GNUNET_HashCode *file_id);


struct GNUNET_FS_GetIndexedContext;


struct GNUNET_FS_GetIndexedContext *
GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h,
                             GNUNET_FS_IndexedFileProcessor iterator,
                             void *iterator_cls);


void
GNUNET_FS_get_indexed_files_cancel (struct GNUNET_FS_GetIndexedContext *gic);


struct GNUNET_FS_UnindexContext *
GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h,
                         const char *filename,
                         void *cctx);


void
GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc);


typedef void (*GNUNET_FS_IdentifierProcessor) (void *cls,
                                               const char *last_id,
                                               const struct
                                               GNUNET_FS_Uri *last_uri,
                                               const struct
                                               GNUNET_CONTAINER_MetaData *
                                               last_meta,
                                               const char *next_id);


void
GNUNET_FS_namespace_list_updateable (struct GNUNET_FS_Handle *h,
                                     const struct
                                     GNUNET_CRYPTO_EcdsaPrivateKey *ns,
                                     const char *next_id,
                                     GNUNET_FS_IdentifierProcessor ip,
                                     void *ip_cls);


enum GNUNET_FS_SearchOptions
{
  GNUNET_FS_SEARCH_OPTION_NONE = 0,

  GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY = 1
};


struct GNUNET_FS_SearchContext *
GNUNET_FS_search_start (struct GNUNET_FS_Handle *h,
                        const struct GNUNET_FS_Uri *uri, uint32_t anonymity,
                        enum GNUNET_FS_SearchOptions options, void *cctx);


void
GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc);


void
GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc);


void
GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc);


struct GNUNET_FS_SearchResult *
GNUNET_FS_probe (struct GNUNET_FS_Handle *h,
                 const struct GNUNET_FS_Uri *uri,
                 const struct GNUNET_CONTAINER_MetaData *meta,
                 void *client_info,
                 uint32_t anonymity);


void *
GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr);


enum GNUNET_FS_DownloadOptions
{
  GNUNET_FS_DOWNLOAD_OPTION_NONE = 0,

  GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY = 1,

  GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE = 2,

  GNUNET_FS_DOWNLOAD_NO_TEMPORARIES = 4,

  GNUNET_FS_DOWNLOAD_IS_PROBE = (1 << 31)
};


struct GNUNET_FS_DownloadContext *
GNUNET_FS_download_start (struct GNUNET_FS_Handle *h,
                          const struct GNUNET_FS_Uri *uri,
                          const struct GNUNET_CONTAINER_MetaData *meta,
                          const char *filename, const char *tempname,
                          uint64_t offset, uint64_t length, uint32_t anonymity,
                          enum GNUNET_FS_DownloadOptions options, void *cctx,
                          struct GNUNET_FS_DownloadContext *parent);


struct GNUNET_FS_DownloadContext *
GNUNET_FS_download_start_from_search (struct GNUNET_FS_Handle *h,
                                      struct GNUNET_FS_SearchResult *sr,
                                      const char *filename,
                                      const char *tempname, uint64_t offset,
                                      uint64_t length, uint32_t anonymity,
                                      enum GNUNET_FS_DownloadOptions options,
                                      void *cctx);


void
GNUNET_FS_download_stop (struct GNUNET_FS_DownloadContext *dc, int do_delete);


void
GNUNET_FS_download_suspend (struct GNUNET_FS_DownloadContext *dc);


void
GNUNET_FS_download_resume (struct GNUNET_FS_DownloadContext *dc);


/* ******************** Directory API *********************** */


#define GNUNET_FS_DIRECTORY_MIME  "application/gnunet-directory"
#define GNUNET_FS_DIRECTORY_MAGIC "\211GND\r\n\032\n"
#define GNUNET_FS_DIRECTORY_EXT   ".gnd"

int
GNUNET_FS_meta_data_test_for_directory (const struct GNUNET_CONTAINER_MetaData
                                        *md);


void
GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md);


char *
GNUNET_FS_meta_data_suggest_filename (const struct
                                      GNUNET_CONTAINER_MetaData *md);


typedef void (*GNUNET_FS_DirectoryEntryProcessor) (void *cls,
                                                   const char *filename,
                                                   const struct GNUNET_FS_Uri *
                                                   uri,
                                                   const struct
                                                   GNUNET_CONTAINER_MetaData *
                                                   meta, size_t length,
                                                   const void *data);


int
GNUNET_FS_directory_list_contents (size_t size, const void *data,
                                   uint64_t offset,
                                   GNUNET_FS_DirectoryEntryProcessor dep,
                                   void *dep_cls);


struct GNUNET_FS_DirectoryBuilder;


struct GNUNET_FS_DirectoryBuilder *
GNUNET_FS_directory_builder_create (const struct GNUNET_CONTAINER_MetaData
                                    *mdir);


void
GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
                                 const struct GNUNET_FS_Uri *uri,
                                 const struct GNUNET_CONTAINER_MetaData *md,
                                 const void *data);


int
GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
                                    size_t *rsize, void **rdata);


/* ******************** DirScanner API *********************** */

enum GNUNET_FS_DirScannerProgressUpdateReason
{
  GNUNET_FS_DIRSCANNER_FILE_START = 0,

  GNUNET_FS_DIRSCANNER_FILE_IGNORED,

  GNUNET_FS_DIRSCANNER_ALL_COUNTED,

  GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED,

  GNUNET_FS_DIRSCANNER_FINISHED,

  GNUNET_FS_DIRSCANNER_INTERNAL_ERROR
};


typedef void (*GNUNET_FS_DirScannerProgressCallback) (void *cls,
                                                      const char *filename,
                                                      int is_directory,
                                                      enum
                                                      GNUNET_FS_DirScannerProgressUpdateReason
                                                      reason);


struct GNUNET_FS_ShareTreeItem
{
  struct GNUNET_FS_ShareTreeItem *prev;

  struct GNUNET_FS_ShareTreeItem *next;

  struct GNUNET_FS_ShareTreeItem *parent;

  struct GNUNET_FS_ShareTreeItem *children_head;

  struct GNUNET_FS_ShareTreeItem *children_tail;

  struct GNUNET_CONTAINER_MetaData *meta;

  struct GNUNET_FS_Uri *ksk_uri;

  char *filename;

  char *short_filename;

  int is_directory;
};


struct GNUNET_FS_DirScanner;


struct GNUNET_FS_DirScanner *
GNUNET_FS_directory_scan_start (const char *filename,
                                int disable_extractor,
                                const char *ex,
                                GNUNET_FS_DirScannerProgressCallback cb,
                                void *cb_cls);


void
GNUNET_FS_directory_scan_abort (struct GNUNET_FS_DirScanner *ds);


struct GNUNET_FS_ShareTreeItem *
GNUNET_FS_directory_scan_get_result (struct GNUNET_FS_DirScanner *ds);


void
GNUNET_FS_share_tree_trim (struct GNUNET_FS_ShareTreeItem *toplevel);


void
GNUNET_FS_share_tree_free (struct GNUNET_FS_ShareTreeItem *toplevel);


#if 0                           /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif

#endif
  /* end of group */