src/fs/gnunet-service-fs.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 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/gnunet-service-fs.h
  23  * @brief shared data structures of gnunet-service-fs.c
  24  * @author Christian Grothoff
  25  */
  26 #ifndef GNUNET_SERVICE_FS_H
  27 #define GNUNET_SERVICE_FS_H
  28
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_statistics_service.h"
  31 #include "gnunet_transport_service.h"
  32 #include "gnunet_core_service.h"
  33 #include "gnunet_block_lib.h"
  34 #include "fs.h"
  35
  36 #define DEBUG_FS GNUNET_YES
  37
  38 #define DEBUG_FS_CLIENT GNUNET_EXTRA_LOGGING
  39
  40 /**
  41  * By which amount do we decrement the TTL for simple forwarding /
  42  * indirection of the query; in milli-seconds.  Set somewhat in
  43  * accordance to your network latency (above the time it'll take you
  44  * to send a packet and get a reply).
  45  */
  46 #define TTL_DECREMENT 5000
  47
  48 /**
  49  * At what frequency should our datastore load decrease
  50  * automatically (since if we don't use it, clearly the
  51  * load must be going down).
  52  */
  53 #define DATASTORE_LOAD_AUTODECLINE GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
  54
  55 /**
  56  * Only the (mandatory) query is included.
  57  */
  58 #define GET_MESSAGE_BIT_QUERY_ONLY 0
  59
  60 /**
  61  * The peer identity of a peer waiting for the
  62  * reply is included (used if the response
  63  * should be transmitted to someone other than
  64  * the sender of the GET).
  65  */
  66 #define GET_MESSAGE_BIT_RETURN_TO 1
  67
  68 /**
  69  * The hash of the public key of the target
  70  * namespace is included (for SKS queries).
  71  */
  72 #define GET_MESSAGE_BIT_SKS_NAMESPACE 2
  73
  74 /**
  75  * The peer identity of a peer that had claimed to have the content
  76  * previously is included (can be used if responder-anonymity is not
  77  * desired; note that the precursor presumably lacked a direct
  78  * connection to the specified peer; still, the receiver is in no way
  79  * required to limit forwarding only to the specified peer, it should
  80  * only prefer it somewhat if possible).
  81  */
  82 #define GET_MESSAGE_BIT_TRANSMIT_TO 4
  83
  84
  85 /**
  86  * Message sent between peers asking for FS-content.
  87  */
  88 struct GetMessage
  89 {
  90
  91   /**
  92    * Message type will be GNUNET_MESSAGE_TYPE_FS_GET.
  93    */
  94   struct GNUNET_MessageHeader header;
  95
  96   /**
  97    * Type of the query (block type).
  98    */
  99   uint32_t type GNUNET_PACKED;
 100
 101   /**
 102    * How important is this request (network byte order)
 103    */
 104   uint32_t priority GNUNET_PACKED;
 105
 106   /**
 107    * Relative time to live in MILLISECONDS (network byte order)
 108    */
 109   int32_t ttl GNUNET_PACKED;
 110
 111   /**
 112    * The content hash should be mutated using this value
 113    * before checking against the bloomfilter (used to
 114    * get many different filters for the same hash codes).
 115    * The number should be in big-endian format when used
 116    * for mingling.
 117    */
 118   uint32_t filter_mutator GNUNET_PACKED;
 119
 120   /**
 121    * Which of the optional hash codes are present at the end of the
 122    * message?  See GET_MESSAGE_BIT_xx constants.  For each bit that is
 123    * set, an additional GNUNET_HashCode with the respective content
 124    * (in order of the bits) will be appended to the end of the GET
 125    * message.
 126    */
 127   uint32_t hash_bitmap GNUNET_PACKED;
 128
 129   /**
 130    * Hashcodes of the file(s) we're looking for.
 131    * Details depend on the query type.
 132    */
 133   GNUNET_HashCode query GNUNET_PACKED;
 134
 135   /* this is followed by hash codes as specified in the "hash_bitmap";
 136    * after that, an optional bloomfilter (with bits set for replies
 137    * that should be suppressed) can be present */
 138 };
 139
 140
 141 /**
 142  * Message send by a peer that wants to be excluded
 143  * from migration for a while.
 144  */
 145 struct MigrationStopMessage
 146 {
 147   /**
 148    * Message type will be
 149    * GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP.
 150    */
 151   struct GNUNET_MessageHeader header;
 152
 153   /**
 154    * Always zero.
 155    */
 156   uint32_t reserved GNUNET_PACKED;
 157
 158   /**
 159    * How long should the block last?
 160    */
 161   struct GNUNET_TIME_RelativeNBO duration;
 162
 163 };
 164
 165
 166 /**
 167  * A connected peer.
 168  */
 169 struct GSF_ConnectedPeer;
 170
 171 /**
 172  * An active request.
 173  */
 174 struct GSF_PendingRequest;
 175
 176 /**
 177  * A local client.
 178  */
 179 struct GSF_LocalClient;
 180
 181 /**
 182  * Information kept per plan per request ('pe' module).
 183  */
 184 struct GSF_RequestPlan;
 185
 186 /**
 187  * DLL of request plans a particular pending request is
 188  * involved with.
 189  */
 190 struct GSF_RequestPlanReference;
 191
 192 /**
 193  * Our connection to the datastore.
 194  */
 195 extern struct GNUNET_DATASTORE_Handle *GSF_dsh;
 196
 197 /**
 198  * Our configuration.
 199  */
 200 extern const struct GNUNET_CONFIGURATION_Handle *GSF_cfg;
 201
 202 /**
 203  * Handle for reporting statistics.
 204  */
 205 extern struct GNUNET_STATISTICS_Handle *GSF_stats;
 206
 207 /**
 208  * Pointer to handle to the core service (points to NULL until we've
 209  * connected to it).
 210  */
 211 extern struct GNUNET_CORE_Handle *GSF_core;
 212
 213 /**
 214  * Handle for DHT operations.
 215  */
 216 extern struct GNUNET_DHT_Handle *GSF_dht;
 217
 218 /**
 219  * How long do requests typically stay in the routing table?
 220  */
 221 extern struct GNUNET_LOAD_Value *GSF_rt_entry_lifetime;
 222
 223 /**
 224  * Running average of the observed latency to other peers (round trip).
 225  */
 226 extern struct GNUNET_TIME_Relative GSF_avg_latency;
 227
 228 /**
 229  * Typical priorities we're seeing from other peers right now.  Since
 230  * most priorities will be zero, this value is the weighted average of
 231  * non-zero priorities seen "recently".  In order to ensure that new
 232  * values do not dramatically change the ratio, values are first
 233  * "capped" to a reasonable range (+N of the current value) and then
 234  * averaged into the existing value by a ratio of 1:N.  Hence
 235  * receiving the largest possible priority can still only raise our
 236  * "current_priorities" by at most 1.
 237  */
 238 extern double GSF_current_priorities;
 239
 240 /**
 241  * How many query messages have we received 'recently' that
 242  * have not yet been claimed as cover traffic?
 243  */
 244 extern unsigned int GSF_cover_query_count;
 245
 246 /**
 247  * How many content messages have we received 'recently' that
 248  * have not yet been claimed as cover traffic?
 249  */
 250 extern unsigned int GSF_cover_content_count;
 251
 252 /**
 253  * Our block context.
 254  */
 255 extern struct GNUNET_BLOCK_Context *GSF_block_ctx;
 256
 257 /**
 258  * Are we introducing randomized delays for better anonymity?
 259  */
 260 extern int GSF_enable_randomized_delays;
 261
 262 /**
 263  * Test if the DATABASE (GET) load on this peer is too high
 264  * to even consider processing the query at
 265  * all.
 266  *
 267  * @return GNUNET_YES if the load is too high to do anything (load high)
 268  *         GNUNET_NO to process normally (load normal)
 269  *         GNUNET_SYSERR to process for free (load low)
 270  */
 271 int
 272 GSF_test_get_load_too_high_ (uint32_t priority);
 273
 274
 275 /**
 276  * We've just now completed a datastore request.  Update our
 277  * datastore load calculations.
 278  *
 279  * @param start time when the datastore request was issued
 280  */
 281 void
 282 GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start);
 283
 284
 285
 286 #endif
 287 /* end of gnunet-service-fs.h */