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 {
      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 {
          const void *data;

          uint64_t offset;

          uint64_t data_len;

          unsigned int depth;
        } progress;

        struct {
          uint64_t completed;

          uint64_t total;

          struct GNUNET_TIME_Relative eta;
        } progress_directory;

        struct {
          const char *message;

          const struct GNUNET_FS_Uri *chk_uri;

          const struct GNUNET_FS_Uri *sks_uri;
        } resume;

        struct {
          const struct GNUNET_FS_Uri *chk_uri;

          const struct GNUNET_FS_Uri *sks_uri;
        } completed;

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


    struct {
      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 {
          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 {
          const struct GNUNET_CONTAINER_MetaData *meta;
        } start;

        struct {
          const struct GNUNET_CONTAINER_MetaData *meta;

          const char *message;
        } resume;

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

    struct {
      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 {
          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;

          struct GNUNET_FS_SearchResult *result;

          uint32_t applicability_rank;
        } result;

        struct {
          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 {
          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 {
          void *cctx;

          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;
        } result_suspend;

        struct {
          void *cctx;

          const struct GNUNET_CONTAINER_MetaData *meta;

          const struct GNUNET_FS_Uri *uri;
        } result_stopped;

        struct {
          const char *message;

          int is_paused;
        } resume;

        struct {
          const char *message;
        } error;

        struct {
          const char *name;

          const char *root;

          const struct GNUNET_CONTAINER_MetaData *meta;

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

    struct {
      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 {
          const void *data;

          uint64_t offset;

          uint64_t data_len;

          unsigned int depth;
        } progress;

        struct {
          const char *message;
        } resume;

        struct {
          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 */