fs_api.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 FS_API_H
#define FS_API_H
 
#include "gnunet_constants.h"
#include "gnunet_datastore_service.h"
#include "gnunet_dht_service.h"
 
#include "gnunet_fs_service.h"
#include "gnunet_block_lib.h"
#include "block_fs.h"
#include "fs.h"
 
#define CHK_PER_INODE 256
 
#define MAX_INLINE_SIZE 65536
 
#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH "search"
 
#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH "search-child"
 
#define GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD "download"
 
#define GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD "download-child"
 
#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH "publish"
 
#define GNUNET_FS_SYNC_PATH_FILE_INFO "publish-file"
 
#define GNUNET_FS_SYNC_PATH_MASTER_UNINDEX "unindex"
 
 
struct FileIdentifier
{
  uint64_t file_length;
 
  struct ContentHashKey chk;
};
 
 
struct Location
{
  struct FileIdentifier fi;
 
  struct GNUNET_PeerIdentity peer;
 
  struct GNUNET_TIME_Absolute expirationTime;
 
  struct GNUNET_CRYPTO_EddsaSignature contentSignature;
};
 
enum GNUNET_FS_UriType
{
  GNUNET_FS_URI_CHK,
 
  GNUNET_FS_URI_SKS,
 
  GNUNET_FS_URI_KSK,
 
  GNUNET_FS_URI_LOC
};
 
 
struct GNUNET_FS_Uri
{
  enum GNUNET_FS_UriType type;
 
  union
  {
    struct
    {
      char **keywords;
 
      unsigned int keywordCount;
    } ksk;
 
    struct
    {
      struct GNUNET_CRYPTO_EcdsaPublicKey ns;
 
      char *identifier;
    } sks;
 
    struct FileIdentifier chk;
 
    struct Location loc;
  } data;
};
 
 
struct GNUNET_FS_FileInformation
{
  struct GNUNET_FS_FileInformation *next;
 
  struct GNUNET_FS_FileInformation *dir;
 
  struct GNUNET_FS_Handle *h;
 
  void *client_info;
 
  struct GNUNET_FS_MetaData *meta;
 
  struct GNUNET_FS_Uri *keywords;
 
  struct GNUNET_FS_Uri *chk_uri;
 
  struct GNUNET_FS_Uri *sks_uri;
 
  struct GNUNET_FS_BlockOptions bo;
 
  struct GNUNET_TIME_Absolute start_time;
 
  char *serialization;
 
  struct GNUNET_FS_TreeEncoder *te;
 
  char *emsg;
 
  char *filename;
 
  union
  {
    struct
    {
      GNUNET_FS_DataReader reader;
 
      void *reader_cls;
 
      struct GNUNET_HashCode file_id;
 
      uint64_t file_size;
 
      int do_index;
 
      int have_hash;
 
      int index_start_confirmed;
    } file;
 
    struct
    {
      struct GNUNET_FS_FileInformation *entries;
 
      size_t dir_size;
 
      void *dir_data;
 
      uint64_t contents_completed;
 
      uint64_t contents_size;
    } dir;
  } data;
 
  int is_directory;
 
  int is_published;
};
 
 
enum GNUNET_FS_QueuePriority
{
  GNUNET_FS_QUEUE_PRIORITY_PROBE,
 
  GNUNET_FS_QUEUE_PRIORITY_NORMAL
};
 
 
struct GNUNET_FS_QueueEntry
{
  struct GNUNET_FS_QueueEntry *next;
 
  struct GNUNET_FS_QueueEntry *prev;
 
  GNUNET_SCHEDULER_TaskCallback start;
 
  GNUNET_SCHEDULER_TaskCallback stop;
 
  void *cls;
 
  struct GNUNET_FS_Handle *h;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_TIME_Absolute queue_time;
 
  struct GNUNET_TIME_Absolute start_time;
 
  struct GNUNET_TIME_Relative run_time;
 
  unsigned int blocks;
 
  enum GNUNET_FS_QueuePriority priority;
 
  unsigned int start_times;
 
  int active;
};
 
 
struct GNUNET_FS_SearchResult
{
  struct GNUNET_FS_Handle *h;
 
  struct GNUNET_FS_SearchResult *next;
 
  struct GNUNET_FS_SearchResult *prev;
 
  struct GNUNET_FS_SearchContext *sc;
 
  struct GNUNET_FS_Uri *uri;
 
  struct GNUNET_FS_MetaData *meta;
 
  void *client_info;
 
  struct GNUNET_FS_DownloadContext *probe_ctx;
 
  struct GNUNET_FS_DownloadContext *download;
 
  struct GNUNET_FS_SearchContext *update_search;
 
  char *serialization;
 
  uint8_t *keyword_bitmap;
 
  struct GNUNET_HashCode key;
 
  struct GNUNET_SCHEDULER_Task *probe_cancel_task;
 
  struct GNUNET_TIME_Absolute probe_active_time;
 
  struct GNUNET_TIME_Relative remaining_probe_time;
 
  uint32_t anonymity;
 
  uint32_t mandatory_missing;
 
  uint32_t optional_support;
 
  uint32_t availability_success;
 
  uint32_t availability_trials;
};
 
 
struct GNUNET_FS_QueueEntry *
GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
                  GNUNET_SCHEDULER_TaskCallback start,
                  GNUNET_SCHEDULER_TaskCallback stop,
                  void *cls,
                  unsigned int blocks,
                  enum GNUNET_FS_QueuePriority priority);
 
 
void
GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qe);
 
 
size_t
GNUNET_FS_data_reader_file_ (void *cls,
                             uint64_t offset,
                             size_t max,
                             void *buf,
                             char **emsg);
 
 
void *
GNUNET_FS_make_file_reader_context_ (const char *filename);
 
 
size_t
GNUNET_FS_data_reader_copy_ (void *cls,
                             uint64_t offset,
                             size_t max,
                             void *buf,
                             char **emsg);
 
 
void *
GNUNET_FS_search_probe_progress_ (void *cls,
                                  const struct GNUNET_FS_ProgressInfo *info);
 
 
void
GNUNET_FS_publish_main_ (void *cls);
 
 
void
GNUNET_FS_unindex_process_hash_ (void *cls,
                                 const struct GNUNET_HashCode *file_id);
 
 
void
GNUNET_FS_unindex_do_extract_keywords_ (struct GNUNET_FS_UnindexContext *uc);
 
 
void
GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc);
 
 
void *
GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
                                struct GNUNET_FS_PublishContext *pc,
                                const struct GNUNET_FS_FileInformation *p,
                                uint64_t offset);
 
 
void
GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
                                 struct GNUNET_FS_DownloadContext *dc);
 
 
void
GNUNET_FS_download_start_task_ (void *cls);
 
 
void
GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
                                struct GNUNET_FS_UnindexContext *uc,
                                uint64_t offset);
 
void *
GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
                               struct GNUNET_FS_Handle *h,
                               struct GNUNET_FS_SearchContext *sc);
 
 
void
GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc);
 
int
GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc);
 
void
GNUNET_FS_download_start_downloading_ (struct GNUNET_FS_DownloadContext *dc);
 
 
void
GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr);
 
 
void
GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
                             const char *ext,
                             const char *ent);
 
 
void
GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
                            const char *ext,
                            const char *uni);
 
 
void
GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *f);
 
 
void
GNUNET_FS_publish_sync_ (struct GNUNET_FS_PublishContext *pc);
 
 
void
GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc);
 
 
void
GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc);
 
 
void
GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr);
 
 
void
GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc);
 
 
void
GNUNET_FS_publish_signal_suspend_ (void *cls);
 
 
void
GNUNET_FS_search_signal_suspend_ (void *cls);
 
 
void
GNUNET_FS_download_signal_suspend_ (void *cls);
 
 
void
GNUNET_FS_unindex_signal_suspend_ (void *cls);
 
 
typedef void (*SuspendSignalFunction) (void *cls);
 
struct TopLevelActivity
{
  struct TopLevelActivity *next;
 
  struct TopLevelActivity *prev;
 
  SuspendSignalFunction ssf;
 
  void *ssf_cls;
};
 
 
struct TopLevelActivity *
GNUNET_FS_make_top (struct GNUNET_FS_Handle *h,
                    SuspendSignalFunction ssf,
                    void *ssf_cls);
 
 
void
GNUNET_FS_end_top (struct GNUNET_FS_Handle *h,
                   struct TopLevelActivity *top);
 
 
struct GNUNET_FS_Handle
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  char *client_name;
 
  GNUNET_FS_ProgressCallback upcb;
 
  void *upcb_cls;
 
  struct TopLevelActivity *top_head;
 
  struct TopLevelActivity *top_tail;
 
  struct GNUNET_FS_QueueEntry *running_head;
 
  struct GNUNET_FS_QueueEntry *running_tail;
 
  struct GNUNET_FS_QueueEntry *pending_head;
 
  struct GNUNET_FS_QueueEntry *pending_tail;
 
  struct GNUNET_FS_SearchResult *probes_head;
 
  struct GNUNET_FS_SearchResult *probes_tail;
 
  struct GNUNET_SCHEDULER_Task *queue_job;
 
  struct GNUNET_SCHEDULER_Task *probe_ping_task;
 
  struct GNUNET_TIME_Relative avg_block_latency;
 
  unsigned int active_downloads;
 
  unsigned int active_blocks;
 
  enum GNUNET_FS_Flags flags;
 
  unsigned int max_parallel_downloads;
 
  unsigned int max_parallel_requests;
};
 
 
struct GNUNET_FS_PublishContext
{
  struct GNUNET_FS_Handle *h;
 
  struct TopLevelActivity *top;
 
  struct GNUNET_FS_FileInformation *fi;
 
  struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
 
  char *nid;
 
  char *nuid;
 
  char *serialization;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_FS_FileInformation *fi_pos;
 
  struct GNUNET_CRYPTO_FileHashContext *fhc;
 
  struct GNUNET_DATASTORE_Handle *dsh;
 
  struct GNUNET_DATASTORE_QueueEntry *qre;
 
  struct GNUNET_FS_PublishSksContext *sks_pc;
 
  struct GNUNET_FS_PublishKskContext *ksk_pc;
 
  struct GNUNET_SCHEDULER_Task *upload_task;
 
  uint64_t reserve_space;
 
  uint32_t reserve_entries;
 
  enum GNUNET_FS_PublishOptions options;
 
  int rid;
 
  int any_done;
 
  int all_done;
 
  int skip_next_fi_callback;
};
 
 
enum UnindexState
{
  UNINDEX_STATE_HASHING = 0,
 
  UNINDEX_STATE_DS_REMOVE = 1,
 
  UNINDEX_STATE_EXTRACT_KEYWORDS = 2,
 
  UNINDEX_STATE_DS_REMOVE_KBLOCKS = 3,
 
  UNINDEX_STATE_FS_NOTIFY = 4,
 
  UNINDEX_STATE_COMPLETE = 5,
 
  UNINDEX_STATE_ERROR = 6
};
 
 
struct GNUNET_FS_UnindexContext
{
  struct ContentHashKey chk;
 
  struct GNUNET_FS_Handle *h;
 
  struct TopLevelActivity *top;
 
  struct GNUNET_FS_DirScanner *dscan;
 
  struct GNUNET_FS_Uri *ksk_uri;
 
  uint32_t ksk_offset;
 
  char *filename;
 
  char *serialization;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_DATASTORE_Handle *dsh;
 
  void *client_info;
 
  struct GNUNET_FS_TreeEncoder *tc;
 
  struct GNUNET_DISK_FileHandle *fh;
 
  struct GNUNET_DATASTORE_QueueEntry *dqe;
 
  struct GNUNET_HashCode ukey;
 
  struct GNUNET_HashCode uquery;
 
  char *emsg;
 
  struct GNUNET_CRYPTO_FileHashContext *fhc;
 
  uint64_t file_size;
 
  struct GNUNET_TIME_Absolute start_time;
 
  struct GNUNET_HashCode file_id;
 
  enum UnindexState state;
};
 
 
struct SearchRequestEntry
{
  struct GNUNET_HashCode uquery;
 
  struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
 
  char *keyword;
 
  struct GNUNET_CONTAINER_MultiHashMap *results;
 
  int mandatory;
};
 
 
struct GNUNET_FS_SearchContext
{
  struct GNUNET_FS_Handle *h;
 
  struct TopLevelActivity *top;
 
  struct GNUNET_FS_Uri *uri;
 
  struct GNUNET_FS_SearchResult *psearch_result;
 
  struct GNUNET_MQ_Handle *mq;
 
  void *client_info;
 
  char *serialization;
 
  char *emsg;
 
  struct GNUNET_CONTAINER_MultiHashMap *master_result_map;
 
  struct SearchRequestEntry *requests;
 
  struct GNUNET_TIME_Absolute start_time;
 
  struct GNUNET_TIME_Relative reconnect_backoff;
 
  struct GNUNET_SCHEDULER_Task *task;
 
  uint32_t anonymity;
 
  uint32_t mandatory_count;
 
  enum GNUNET_FS_SearchOptions options;
};
 
 
enum BlockRequestState
{
  BRS_INIT = 0,
 
  BRS_RECONSTRUCT_DOWN = 1,
 
  BRS_RECONSTRUCT_META_UP = 2,
 
  BRS_RECONSTRUCT_UP = 3,
 
  BRS_CHK_SET = 4,
 
  BRS_DOWNLOAD_DOWN = 5,
 
  BRS_DOWNLOAD_UP = 6,
 
  BRS_ERROR = 7
};
 
 
struct DownloadRequest
{
  struct DownloadRequest *parent;
 
  struct DownloadRequest **children;
 
  struct ContentHashKey chk;
 
  uint64_t offset;
 
  unsigned int num_children;
 
  unsigned int depth;
 
  unsigned int chk_idx;
 
  enum BlockRequestState state;
};
 
 
void
GNUNET_FS_free_download_request_ (struct DownloadRequest *dr);
 
 
void
GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr);
 
 
struct GNUNET_FS_DownloadContext
{
  struct GNUNET_FS_Handle *h;
 
  struct TopLevelActivity *top;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_FS_DownloadContext *parent;
 
  struct GNUNET_FS_SearchResult *search;
 
  struct GNUNET_FS_DownloadContext *child_head;
 
  struct GNUNET_FS_DownloadContext *child_tail;
 
  struct GNUNET_FS_DownloadContext *prev;
 
  struct GNUNET_FS_DownloadContext *next;
 
  void *client_info;
 
  struct GNUNET_FS_Uri *uri;
 
  struct GNUNET_FS_MetaData *meta;
 
  char *emsg;
 
  char *serialization;
 
  char *filename;
 
  char *temp_filename;
 
  struct GNUNET_FS_QueueEntry *job_queue;
 
  struct GNUNET_FS_TreeEncoder *te;
 
  struct GNUNET_DISK_FileHandle *rfh;
 
  struct GNUNET_CONTAINER_MultiHashMap *active;
 
  struct DownloadRequest *top_request;
 
  struct GNUNET_PeerIdentity target;
 
  struct GNUNET_SCHEDULER_Task *task;
 
  uint64_t offset;
 
  uint64_t length;
 
  uint64_t completed;
 
  uint64_t old_file_size;
 
  struct GNUNET_TIME_Absolute start_time;
 
  struct GNUNET_TIME_Relative reconnect_backoff;
 
  uint32_t anonymity;
 
  unsigned int treedepth;
 
  enum GNUNET_FS_DownloadOptions options;
 
  int has_finished;
 
  int issue_requests;
};
 
 
#endif
 
/* end of fs_api.h */