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_common.h"
#include "gnunet_util_lib.h"
 
#ifdef __cplusplus
extern "C"
{
#if 0                           /* keep Emacsens' auto-indent happy */
}
#endif
#endif
 
#define GNUNET_FS_VERSION 0x00090300
 
#if GNUNET_FS_EXTRACTOR_ENABLED
 
#include <extractor.h>
 
#else
 
/* definitions from extractor.h we need for the build */
 
enum EXTRACTOR_MetaType
{
  EXTRACTOR_METATYPE_RESERVED = 0,
  EXTRACTOR_METATYPE_MIMETYPE = 1,
  EXTRACTOR_METATYPE_FILENAME = 2,
  EXTRACTOR_METATYPE_COMMENT = 3,
  EXTRACTOR_METATYPE_TITLE = 4,
  EXTRACTOR_METATYPE_BOOK_TITLE = 5,
  EXTRACTOR_METATYPE_JOURNAL_NAME = 8,
  EXTRACTOR_METATYPE_AUTHOR_NAME = 13,
  EXTRACTOR_METATYPE_PUBLICATION_DATE = 24,
  EXTRACTOR_METATYPE_URL = 29,
  EXTRACTOR_METATYPE_URI = 30,
  EXTRACTOR_METATYPE_ISRC = 31,
  EXTRACTOR_METATYPE_UNKNOWN = 45,
  EXTRACTOR_METATYPE_DESCRIPTION = 46,
  EXTRACTOR_METATYPE_KEYWORDS = 49,
  EXTRACTOR_METATYPE_SUBJECT = 52,
  EXTRACTOR_METATYPE_PACKAGE_NAME = 69,
  EXTRACTOR_METATYPE_THUMBNAIL = 114,
  EXTRACTOR_METATYPE_ALBUM = 129,
  EXTRACTOR_METATYPE_ARTIST = 130,
  EXTRACTOR_METATYPE_ORIGINAL_TITLE = 162,
  EXTRACTOR_METATYPE_GNUNET_FULL_DATA = 174,
  EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME = 180,
};
 
enum EXTRACTOR_MetaFormat
{
  EXTRACTOR_METAFORMAT_UNKNOWN = 0,
 
  EXTRACTOR_METAFORMAT_UTF8 = 1,
 
  EXTRACTOR_METAFORMAT_BINARY = 2,
 
  EXTRACTOR_METAFORMAT_C_STRING = 3
};
 
 
typedef int (*EXTRACTOR_MetaDataProcessor) (void *cls,
                                            const char *plugin_name,
                                            enum EXTRACTOR_MetaType type,
                                            enum EXTRACTOR_MetaFormat format,
                                            const char *data_mime_type,
                                            const char *data,
                                            size_t data_len);
 
#endif
 
#ifndef EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME
/* hack for LE < 0.6.3 */
#define EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME 180
#endif
 
 
/* ******************** 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;
 
struct GNUNET_FS_MetaData;
 
 
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);
 
 
const struct GNUNET_HashCode*
GNUNET_FS_uri_chk_get_file_hash (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_FS_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_FS_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_FS_MetaData *meta;
        } start;
 
        struct GNUNET_FS_DownloadResumeEvent
        {
          const struct GNUNET_FS_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_FS_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_FS_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_FS_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_FS_MetaData *meta;
 
          const struct GNUNET_FS_Uri *uri;
        } result_suspend;
 
        struct GNUNET_FS_SearchStoppedResultEvent
        {
          void *cctx;
 
          const struct GNUNET_FS_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_FS_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_FS_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 (const 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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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 = (UINT32_C(1) << 31)
};
 
 
struct GNUNET_FS_DownloadContext *
GNUNET_FS_download_start (struct GNUNET_FS_Handle *h,
                          const struct GNUNET_FS_Uri *uri,
                          const struct GNUNET_FS_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_FS_MetaData
                                        *md);
 
 
void
GNUNET_FS_meta_data_make_directory (struct GNUNET_FS_MetaData *md);
 
 
char *
GNUNET_FS_meta_data_suggest_filename (const struct
                                      GNUNET_FS_MetaData *md);
 
 
typedef void (*GNUNET_FS_DirectoryEntryProcessor) (void *cls,
                                                   const char *filename,
                                                   const struct GNUNET_FS_Uri *
                                                   uri,
                                                   const struct
                                                   GNUNET_FS_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_FS_MetaData
                                    *mdir);
 
 
void
GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
                                 const struct GNUNET_FS_Uri *uri,
                                 const struct GNUNET_FS_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_FS_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);
 
/* ****************** metadata ******************* */
 
 
struct GNUNET_FS_MetaData *
GNUNET_FS_meta_data_create (void);
 
 
struct GNUNET_FS_MetaData *
GNUNET_FS_meta_data_duplicate (
  const struct GNUNET_FS_MetaData *md);
 
 
void
GNUNET_FS_meta_data_destroy (struct GNUNET_FS_MetaData *md);
 
 
int
GNUNET_FS_meta_data_test_equal (
  const struct GNUNET_FS_MetaData *md1,
  const struct GNUNET_FS_MetaData *md2);
 
 
int
GNUNET_FS_meta_data_insert (struct GNUNET_FS_MetaData *md,
                                   const char *plugin_name,
                                   enum EXTRACTOR_MetaType type,
                                   enum EXTRACTOR_MetaFormat format,
                                   const char *data_mime_type,
                                   const char *data,
                                   size_t data_size);
 
 
void
GNUNET_FS_meta_data_merge (struct GNUNET_FS_MetaData *md,
                                  const struct GNUNET_FS_MetaData *in);
 
 
int
GNUNET_FS_meta_data_delete (struct GNUNET_FS_MetaData *md,
                                   enum EXTRACTOR_MetaType type,
                                   const char *data,
                                   size_t data_size);
 
 
void
GNUNET_FS_meta_data_clear (struct GNUNET_FS_MetaData *md);
 
 
void
GNUNET_FS_meta_data_add_publication_date (
  struct GNUNET_FS_MetaData *md);
 
 
int
GNUNET_FS_meta_data_iterate (const struct GNUNET_FS_MetaData *md,
                                    EXTRACTOR_MetaDataProcessor iter,
                                    void *iter_cls);
 
 
char *
GNUNET_FS_meta_data_get_by_type (
  const struct GNUNET_FS_MetaData *md,
  enum EXTRACTOR_MetaType type);
 
 
char *
GNUNET_FS_meta_data_get_first_by_types (
  const struct GNUNET_FS_MetaData *md,
  ...);
 
size_t
GNUNET_FS_meta_data_get_thumbnail (
  const struct GNUNET_FS_MetaData *md,
  unsigned char **thumb);
 
 
enum GNUNET_FS_MetaDataSerializationOptions
{
  GNUNET_FS_META_DATA_SERIALIZE_FULL = 0,
 
  GNUNET_FS_META_DATA_SERIALIZE_PART = 1,
 
  GNUNET_FS_META_DATA_SERIALIZE_NO_COMPRESS = 2
};
 
 
ssize_t
GNUNET_FS_meta_data_serialize (
  const struct GNUNET_FS_MetaData *md,
  char **target,
  size_t max,
  enum GNUNET_FS_MetaDataSerializationOptions opt);
 
 
ssize_t
GNUNET_FS_meta_data_get_serialized_size (
  const struct GNUNET_FS_MetaData *md);
 
 
struct GNUNET_FS_MetaData *
GNUNET_FS_meta_data_deserialize (const char *input, size_t size);
 
enum GNUNET_GenericReturnValue
GNUNET_FS_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
                            const char *what,
                            const struct GNUNET_FS_MetaData *m);
 
struct GNUNET_BIO_ReadSpec
GNUNET_FS_read_spec_meta_data (const char *what,
                                struct GNUNET_FS_MetaData **result);
 
 
 
struct GNUNET_BIO_WriteSpec
GNUNET_FS_write_spec_meta_data (const char *what,
                                 const struct GNUNET_FS_MetaData *m);
 
enum GNUNET_GenericReturnValue
GNUNET_FS_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
                           const char *what,
                           struct GNUNET_FS_MetaData **result);
 
 
#if 0                           /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
#endif
  /* end of group */
 /* end of group addition */