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 3, 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_constants.h"
  30 #include "gnunet_datastore_service.h"
  31 #include "gnunet_dht_service.h"
  32 #include "gnunet_fs_service.h"
  33 #include "gnunet_block_lib.h"
  34 #include "block_fs.h"
  35
  36
  37 /**
  38  * Size of the individual blocks used for file-sharing.
  39  */
  40 #define DBLOCK_SIZE (32*1024)
  41
  42 /**
  43  * Blocksize to use when hashing files for indexing (blocksize for IO,
  44  * not for the DBlocks).  Larger blocksizes can be more efficient but
  45  * will be more disruptive as far as the scheduler is concerned.
  46  */
  47 #define HASHING_BLOCKSIZE (1024 * 128)
  48
  49
  50 /**
  51  * @brief content hash key
  52  */
  53 struct ContentHashKey
  54 {
  55   /**
  56    * Hash of the original content, used for encryption.
  57    */
  58   GNUNET_HashCode key;
  59
  60   /**
  61    * Hash of the encrypted content, used for querying.
  62    */
  63   GNUNET_HashCode query;
  64 };
  65
  66
  67 /**
  68  * Message sent from a GNUnet (fs) publishing activity to the
  69  * gnunet-fs-service to initiate indexing of a file.  The service is
  70  * supposed to check if the specified file is available and has the
  71  * same cryptographic hash.  It should then respond with either a
  72  * confirmation or a denial.
  73  *
  74  * On OSes where this works, it is considered acceptable if the
  75  * service only checks that the path, device and inode match (it can
  76  * then be assumed that the hash will also match without actually
  77  * computing it; this is an optimization that should be safe given
  78  * that the client is not our adversary).
  79  */
  80 struct IndexStartMessage
  81 {
  82
  83   /**
  84    * Message type will be GNUNET_MESSAGE_TYPE_FS_INDEX_START.
  85    */
  86   struct GNUNET_MessageHeader header;
  87
  88   /**
  89    * For alignment.
  90    */
  91   uint32_t reserved GNUNET_PACKED;
  92
  93   /**
  94    * ID of device containing the file, as seen by the client.  This
  95    * device ID is obtained using a call like "statvfs" (and converting
  96    * the "f_fsid" field to a 32-bit big-endian number).  Use 0 if the
  97    * OS does not support this, in which case the service must do a
  98    * full hash recomputation.
  99    */
 100   uint64_t device GNUNET_PACKED;
 101
 102   /**
 103    * Inode of the file on the given device, as seen by the client
 104    * ("st_ino" field from "struct stat").  Use 0 if the OS does not
 105    * support this, in which case the service must do a full hash
 106    * recomputation.
 107    */
 108   uint64_t inode GNUNET_PACKED;
 109
 110   /**
 111    * Hash of the file that we would like to index.
 112    */
 113   GNUNET_HashCode file_id;
 114
 115   /* this is followed by a 0-terminated
 116    * filename of a file with the hash
 117    * "file_id" as seen by the client */
 118
 119 };
 120
 121
 122 /**
 123  * Message send by FS service in response to a request
 124  * asking for a list of all indexed files.
 125  */
 126 struct IndexInfoMessage
 127 {
 128   /**
 129    * Message type will be
 130    * GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY.
 131    */
 132   struct GNUNET_MessageHeader header;
 133
 134   /**
 135    * Always zero.
 136    */
 137   uint32_t reserved GNUNET_PACKED;
 138
 139   /**
 140    * Hash of the indexed file.
 141    */
 142   GNUNET_HashCode file_id;
 143
 144   /* this is followed by a 0-terminated
 145    * filename of a file with the hash
 146    * "file_id" as seen by the client */
 147
 148 };
 149
 150
 151 /**
 152  * Message sent from a GNUnet (fs) unindexing activity to the
 153  * gnunet-service-fs to indicate that a file will be unindexed.  The
 154  * service is supposed to remove the file from the list of indexed
 155  * files and response with a confirmation message (even if the file
 156  * was already not on the list).
 157  */
 158 struct UnindexMessage
 159 {
 160
 161   /**
 162    * Message type will be
 163    * GNUNET_MESSAGE_TYPE_FS_UNINDEX.
 164    */
 165   struct GNUNET_MessageHeader header;
 166
 167   /**
 168    * Always zero.
 169    */
 170   uint32_t reserved GNUNET_PACKED;
 171
 172   /**
 173    * Hash of the file that we will unindex.
 174    */
 175   GNUNET_HashCode file_id;
 176
 177 };
 178
 179
 180 /**
 181  * Message sent from a GNUnet (fs) search activity to the
 182  * gnunet-service-fs to start a search.
 183  */
 184 struct SearchMessage
 185 {
 186
 187   /**
 188    * Message type will be
 189    * GNUNET_MESSAGE_TYPE_FS_START_SEARCH.
 190    */
 191   struct GNUNET_MessageHeader header;
 192
 193   /**
 194    * Bitmask with options.  Zero for no options, one for loopback-only.
 195    * Other bits are currently not defined.
 196    */
 197   int32_t options GNUNET_PACKED;
 198
 199   /**
 200    * Type of the content that we're looking for.
 201    */
 202   uint32_t type GNUNET_PACKED;
 203
 204   /**
 205    * Desired anonymity level, big-endian.
 206    */
 207   uint32_t anonymity_level GNUNET_PACKED;
 208
 209   /**
 210    * If the request is for a DBLOCK or IBLOCK, this is the identity of
 211    * the peer that is known to have a response.  Set to all-zeros if
 212    * such a target is not known (note that even if OUR anonymity
 213    * level is >0 we may happen to know the responder's identity;
 214    * nevertheless, we should probably not use it for a DHT-lookup
 215    * or similar blunt actions in order to avoid exposing ourselves).
 216    * <p>
 217    * If the request is for an SBLOCK, this is the identity of the
 218    * pseudonym to which the SBLOCK belongs.
 219    * <p>
 220    * If the request is for a KBLOCK, "target" must be all zeros.
 221    */
 222   GNUNET_HashCode target;
 223
 224   /**
 225    * Hash of the keyword (aka query) for KBLOCKs; Hash of
 226    * the CHK-encoded block for DBLOCKS and IBLOCKS (aka query)
 227    * and hash of the identifier XORed with the target for
 228    * SBLOCKS (aka query).
 229    */
 230   GNUNET_HashCode query;
 231
 232   /* this is followed by the hash codes of already-known
 233    * results (which should hence be excluded from what
 234    * the service returns); naturally, this only applies
 235    * to queries that can have multiple results, such as
 236    * those for KBLOCKS (KSK) and SBLOCKS (SKS) */
 237 };
 238
 239
 240 /**
 241  * Response from FS service with a result for a previous FS search.
 242  * Note that queries for DBLOCKS and IBLOCKS that have received a
 243  * single response are considered done.  This message is transmitted
 244  * between peers as well as between the service and a client.
 245  */
 246 struct PutMessage
 247 {
 248
 249   /**
 250    * Message type will be GNUNET_MESSAGE_TYPE_FS_PUT.
 251    */
 252   struct GNUNET_MessageHeader header;
 253
 254   /**
 255    * Type of the block (in big endian).  Should never be zero.
 256    */
 257   uint32_t type GNUNET_PACKED;
 258
 259   /**
 260    * When does this result expire?
 261    */
 262   struct GNUNET_TIME_AbsoluteNBO expiration;
 263
 264   /* this is followed by the actual encrypted content */
 265
 266 };
 267
 268
 269
 270 #endif
 271
 272 /* end of fs.h */