src/fs/fs.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file fs/fs.h
  23  * @brief definitions for the entire fs module
  24  * @author Igor Wronsky, Christian Grothoff
  25  */
  26 #ifndef FS_H
  27 #define FS_H
  28
  29 #include "gnunet_datastore_service.h"
  30 #include "gnunet_fs_service.h"
  31
  32 /**
  33  * Size of the individual blocks used for file-sharing.
  34  */
  35 #define GNUNET_FS_DBLOCK_SIZE (32*1024)
  36
  37
  38 /**
  39  * Pick a multiple of 2 here to achive 8-byte alignment!
  40  * We also probably want DBlocks to have (roughly) the
  41  * same size as IBlocks.  With SHA-512, the optimal
  42  * value is 32768 byte / 128 byte = 256
  43  * (128 byte = 2 * 512 bits).  DO NOT CHANGE!
  44  */
  45 #define GNUNET_FS_CHK_PER_INODE 256
  46
  47
  48 /**
  49  * Maximum size for a file to be considered for
  50  * inlining in a directory.
  51  */
  52 #define GNUNET_FS_MAX_INLINE_SIZE 65536
  53
  54
  55
  56 /**
  57  * @brief content hash key
  58  */
  59 struct ContentHashKey
  60 {
  61   GNUNET_HashCode key;
  62   GNUNET_HashCode query;
  63 };
  64
  65
  66 /**
  67  * @brief complete information needed
  68  * to download a file.
  69  */
  70 struct FileIdentifier
  71 {
  72
  73   /**
  74    * Total size of the file in bytes. (network byte order (!))
  75    */
  76   uint64_t file_length;
  77
  78   /**
  79    * Query and key of the top GNUNET_EC_IBlock.
  80    */
  81   struct ContentHashKey chk;
  82
  83 };
  84
  85
  86 /**
  87  * Information about a file and its location
  88  * (peer claiming to share the file).
  89  */
  90 struct Location
  91 {
  92   /**
  93    * Information about the shared file.
  94    */
  95   struct FileIdentifier fi;
  96
  97   /**
  98    * Identity of the peer sharing the file.
  99    */
 100   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded peer;
 101
 102   /**
 103    * Time when this location URI expires.
 104    */
 105   struct GNUNET_TIME_Absolute expirationTime;
 106
 107   /**
 108    * RSA signature over the GNUNET_EC_FileIdentifier,
 109    * GNUNET_hash of the peer and expiration time.
 110    */
 111   struct GNUNET_CRYPTO_RsaSignature contentSignature;
 112
 113 };
 114
 115 enum uri_types
 116 { chk, sks, ksk, loc };
 117
 118 /**
 119  * A Universal Resource Identifier (URI), opaque.
 120  */
 121 struct GNUNET_FS_Uri
 122 {
 123   enum uri_types type;
 124   union
 125   {
 126     struct
 127     {
 128       /**
 129        * Keywords start with a '+' if they are
 130        * mandatory (in which case the '+' is NOT
 131        * part of the keyword) and with a
 132        * simple space if they are optional
 133        * (in which case the space is ALSO not
 134        * part of the actual keyword).
 135        *
 136        * Double-quotes to protect spaces and
 137        * %-encoding are NOT used internally
 138        * (only in URI-strings).
 139        */
 140       char **keywords;
 141
 142       /**
 143        * Size of the keywords array.
 144        */
 145       unsigned int keywordCount;
 146     } ksk;
 147
 148     struct
 149     {
 150       /**
 151        * Hash of the public key for the namespace.
 152        */
 153       GNUNET_HashCode namespace;
 154
 155       /**
 156        * Human-readable identifier chosen for this
 157        * entry in the namespace.
 158        */
 159       char *identifier;
 160     } sks;
 161
 162     /**
 163      * Information needed to retrieve a file (content-hash-key
 164      * plus file size).
 165      */
 166     struct FileIdentifier chk;
 167
 168     /**
 169      * Information needed to retrieve a file including signed
 170      * location (identity of a peer) of the content.
 171      */
 172     struct Location loc;
 173   } data;
 174
 175 };
 176
 177
 178 /**
 179  * Information for a file or directory that is
 180  * about to be published.
 181  */
 182 struct GNUNET_FS_FileInformation
 183 {
 184
 185   /**
 186    * Files in a directory are kept as a linked list.
 187    */
 188   struct GNUNET_FS_FileInformation *next;
 189
 190   /**
 191    * If this is a file in a directory, "dir" refers to
 192    * the directory; otherwise NULL.
 193    */
 194   struct GNUNET_FS_FileInformation *dir;
 195
 196   /**
 197    * Pointer kept for the client.
 198    */
 199   void *client_info;
 200
 201   /**
 202    * Metadata to use for the file.
 203    */
 204   struct GNUNET_CONTAINER_MetaData *meta;
 205
 206   /**
 207    * Keywords to use for KBlocks.
 208    */
 209   struct GNUNET_FS_Uri *keywords;
 210
 211   /**
 212    * CHK for this file or directory. NULL if
 213    * we have not yet computed it.
 214    */
 215   struct GNUNET_FS_Uri *chk_uri;
 216
 217   /**
 218    * At what time should the content expire?
 219    */
 220   struct GNUNET_TIME_Absolute expirationTime;
 221
 222   /**
 223    * Under what filename is this struct serialized
 224    * (for operational persistence).
 225    */
 226   char *serialization;
 227
 228   /**
 229    * In-memory cache of the current CHK tree.
 230    * This struct will contain the CHK values
 231    * from the root to the currently processed
 232    * node in the tree as identified by
 233    * "current_depth" and "publish_offset".
 234    * The "chktree" will be initially NULL,
 235    * then allocated to a sufficient number of
 236    * entries for the size of the file and
 237    * finally freed once the upload is complete.
 238    */
 239   struct ContentHashKey *chk_tree;
 240
 241   /**
 242    * Number of entries in "chk_tree".
 243    */
 244   unsigned int chk_tree_depth;
 245
 246   /**
 247    * Depth in the CHK-tree at which we are
 248    * currently publishing.  0 is the root
 249    * of the tree.
 250    */
 251   unsigned int current_depth;
 252
 253   /**
 254    * How many bytes of this file or directory have been
 255    * published so far?
 256    */
 257   uint64_t publish_offset;
 258
 259   /**
 260    * Data describing either the file or the directory.
 261    */
 262   union
 263   {
 264
 265     /**
 266      * Data for a file.
 267      */
 268     struct {
 269
 270       /**
 271        * Function that can be used to read the data for the file.
 272        */
 273       GNUNET_FS_DataReader reader;
 274
 275       /**
 276        * Closure for reader.
 277        */
 278       void *reader_cls;
 279
 280       /**
 281        * Size of the file (in bytes).
 282        */
 283       uint64_t file_size;
 284
 285       /**
 286        * Should the file be indexed or inserted?
 287        */
 288       int do_index;
 289
 290     } file;
 291
 292     /**
 293      * Data for a directory.
 294      */
 295     struct {
 296
 297       /**
 298        * Name of the directory.
 299        */
 300       char *dirname;
 301
 302       /**
 303        * Linked list of entries in the directory.
 304        */
 305       struct GNUNET_FS_FileInformation *entries;
 306
 307       /**
 308        * Size of the directory itself (in bytes); 0 if the
 309        * size has not yet been calculated.
 310        */
 311       uint64_t dir_size;
 312
 313       /**
 314        * Pointer to the data for the directory (or NULL if not
 315        * available).
 316        */
 317       char *dir_data;
 318
 319     } dir;
 320
 321   } data;
 322
 323   /**
 324    * Is this struct for a file or directory?
 325    */
 326   int is_directory;
 327
 328   /**
 329    * Desired anonymity level.
 330    */
 331   unsigned int anonymity;
 332
 333   /**
 334    * Desired priority (for keeping the content in the DB).
 335    */
 336   unsigned int priority;
 337
 338 };
 339
 340
 341 /**
 342  * Master context for most FS operations.
 343  */
 344 struct GNUNET_FS_Handle
 345 {
 346   /**
 347    * Scheduler.
 348    */
 349   struct GNUNET_SCHEDULER_Handle *sched;
 350
 351   /**
 352    * Configuration to use.
 353    */
 354   const struct GNUNET_CONFIGURATION_Handle *cfg;
 355
 356   /**
 357    * Name of our client.
 358    */
 359   char *client_name;
 360
 361   /**
 362    * Function to call with updates on our progress.
 363    */
 364   GNUNET_FS_ProgressCallback upcb;
 365
 366   /**
 367    * Closure for upcb.
 368    */
 369   void *upcb_cls;
 370
 371   /**
 372    * Connection to the FS service.
 373    */
 374   struct GNUNET_CLIENT_Connection *client;
 375
 376
 377 };
 378
 379
 380 /**
 381  * Handle for controlling an upload.
 382  */
 383 struct GNUNET_FS_PublishContext
 384 {
 385   /**
 386    * Handle to the global fs context.
 387    */
 388   struct GNUNET_FS_Handle *h;
 389
 390   /**
 391    * Argument to pass to the client in callbacks.
 392    */
 393   void *client_ctx;
 394
 395   /**
 396    * File-structure that is being shared.
 397    */
 398   struct GNUNET_FS_FileInformation *fi;
 399
 400   /**
 401    * Namespace that we are publishing in, NULL if we have no namespace.
 402    */
 403   struct GNUNET_FS_Namespace *namespace;
 404
 405   /**
 406    * ID of the content in the namespace, NULL if we have no namespace.
 407    */
 408   char *nid;
 409
 410   /**
 411    * ID for future updates, NULL if we have no namespace or no updates.
 412    */
 413   char *nuid;
 414
 415   /**
 416    * ID of the task performing the upload. NO_TASK
 417    * if the upload has completed.
 418    */
 419   GNUNET_SCHEDULER_TaskIdentifier upload_task;
 420
 421   /**
 422    * Current position in the file-tree for the
 423    * upload.
 424    */
 425   struct GNUNET_FS_FileInformation *fi_pos;
 426
 427   /**
 428    * Connection to the datastore service.
 429    */
 430   struct GNUNET_DATASTORE_Handle *dsh;
 431
 432   /**
 433    * Space reservation ID with datastore service
 434    * for this upload.
 435    */
 436   int rid;
 437 };
 438
 439
 440 /**
 441  * Handle for controlling an unindexing operation.
 442  */
 443 struct GNUNET_FS_UnindexContext
 444 {
 445 };
 446
 447
 448 /**
 449  * Handle for controlling a search.
 450  */
 451 struct GNUNET_FS_SearchContext
 452 {
 453 };
 454
 455
 456 /**
 457  * Context for controlling a download.
 458  */
 459 struct GNUNET_FS_DownloadContext
 460 {
 461 };
 462
 463 struct GNUNET_FS_Namespace
 464 {
 465   /**
 466    * Reference counter.
 467    */
 468   unsigned int rc;
 469 };
 470
 471
 472 #endif