X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ffs%2Fgnunet-service-fs.h;h=8830058e99a4ca9712c34871e027267590c1f0f7;hb=a900b29ddaa9ea46c731b054b5e3ef3e725b95a8;hp=de83e1b10696d893681fea7572e6b9054131be80;hpb=3ef84f3677066f95a67a3df8b9943cf7892a7894;p=oweals%2Fgnunet.git diff --git a/src/fs/gnunet-service-fs.h b/src/fs/gnunet-service-fs.h index de83e1b10..8830058e9 100644 --- a/src/fs/gnunet-service-fs.h +++ b/src/fs/gnunet-service-fs.h @@ -31,8 +31,132 @@ #include "gnunet_transport_service.h" #include "gnunet_core_service.h" #include "gnunet_block_lib.h" +#include "gnunet_ats_service.h" #include "fs.h" + +/** + * By which amount do we decrement the TTL for simple forwarding / + * indirection of the query; in milli-seconds. Set somewhat in + * accordance to your network latency (above the time it'll take you + * to send a packet and get a reply). + */ +#define TTL_DECREMENT 5000 + +/** + * At what frequency should our datastore load decrease + * automatically (since if we don't use it, clearly the + * load must be going down). + */ +#define DATASTORE_LOAD_AUTODECLINE GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250) + +/** + * Only the (mandatory) query is included. + */ +#define GET_MESSAGE_BIT_QUERY_ONLY 0 + +/** + * The peer identity of a peer waiting for the + * reply is included (used if the response + * should be transmitted to someone other than + * the sender of the GET). + */ +#define GET_MESSAGE_BIT_RETURN_TO 1 + +/** + * The peer identity of a peer that had claimed to have the content + * previously is included (can be used if responder-anonymity is not + * desired; note that the precursor presumably lacked a direct + * connection to the specified peer; still, the receiver is in no way + * required to limit forwarding only to the specified peer, it should + * only prefer it somewhat if possible). + */ +#define GET_MESSAGE_BIT_TRANSMIT_TO 4 + + +GNUNET_NETWORK_STRUCT_BEGIN + +/** + * Message sent between peers asking for FS-content. + */ +struct GetMessage +{ + + /** + * Message type will be GNUNET_MESSAGE_TYPE_FS_GET. + */ + struct GNUNET_MessageHeader header; + + /** + * Type of the query (block type). + */ + uint32_t type GNUNET_PACKED; + + /** + * How important is this request (network byte order) + */ + uint32_t priority GNUNET_PACKED; + + /** + * Relative time to live in MILLISECONDS (network byte order) + */ + int32_t ttl GNUNET_PACKED; + + /** + * The content hash should be mutated using this value + * before checking against the bloomfilter (used to + * get many different filters for the same hash codes). + * The number should be in big-endian format when used + * for mingling. + */ + uint32_t filter_mutator GNUNET_PACKED; + + /** + * Which of the optional hash codes are present at the end of the + * message? See GET_MESSAGE_BIT_xx constants. For each bit that is + * set, an additional struct GNUNET_HashCode with the respective content + * (in order of the bits) will be appended to the end of the GET + * message. + */ + uint32_t hash_bitmap GNUNET_PACKED; + + /** + * Hashcodes of the file(s) we're looking for. + * Details depend on the query type. + */ + struct GNUNET_HashCode query; + + /* this is followed by hash codes as specified in the "hash_bitmap"; + * after that, an optional bloomfilter (with bits set for replies + * that should be suppressed) can be present */ +}; + + +/** + * Message send by a peer that wants to be excluded + * from migration for a while. + */ +struct MigrationStopMessage +{ + /** + * Message type will be + * GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP. + */ + struct GNUNET_MessageHeader header; + + /** + * Always zero. + */ + uint32_t reserved GNUNET_PACKED; + + /** + * How long should the block last? + */ + struct GNUNET_TIME_RelativeNBO duration; + +}; +GNUNET_NETWORK_STRUCT_END + /** * A connected peer. */ @@ -48,6 +172,15 @@ struct GSF_PendingRequest; */ struct GSF_LocalClient; +/** + * Information kept per plan per request ('pe' module). + */ +struct GSF_RequestPlan; + +/** + * Bijection between request plans and pending requests. + */ +struct GSF_PendingRequestPlanBijection; /** * Our connection to the datastore. @@ -80,6 +213,17 @@ extern struct GNUNET_DHT_Handle *GSF_dht; */ extern struct GNUNET_LOAD_Value *GSF_rt_entry_lifetime; +/** + * Running average of the observed latency to other peers (round trip). + */ +extern struct GNUNET_TIME_Relative GSF_avg_latency; + +/** + * Handle to ATS service. + */ +extern struct GNUNET_ATS_PerformanceHandle *GSF_ats; + + /** * Typical priorities we're seeing from other peers right now. Since * most priorities will be zero, this value is the weighted average of @@ -93,11 +237,55 @@ extern struct GNUNET_LOAD_Value *GSF_rt_entry_lifetime; extern double GSF_current_priorities; /** - * How many query messages have we received 'recently' that + * How many query messages have we received 'recently' that * have not yet been claimed as cover traffic? */ extern unsigned int GSF_cover_query_count; +/** + * How many content messages have we received 'recently' that + * have not yet been claimed as cover traffic? + */ +extern unsigned int GSF_cover_content_count; + +/** + * Our block context. + */ +extern struct GNUNET_BLOCK_Context *GSF_block_ctx; + +/** + * Are we introducing randomized delays for better anonymity? + */ +extern int GSF_enable_randomized_delays; + +/** + * Size of the datastore queue we assume for common requests. + */ +extern unsigned int GSF_datastore_queue_size; + + +/** + * Test if the DATABASE (GET) load on this peer is too high + * to even consider processing the query at + * all. + * + * @return GNUNET_YES if the load is too high to do anything (load high) + * GNUNET_NO to process normally (load normal) + * GNUNET_SYSERR to process for free (load low) + */ +int +GSF_test_get_load_too_high_ (uint32_t priority); + + +/** + * We've just now completed a datastore request. Update our + * datastore load calculations. + * + * @param start time when the datastore request was issued + */ +void +GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start); + #endif