X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ffs%2Fgnunet-service-fs_pr.h;h=8a95c20f4523736f2eb19fb1e29b5fd904c6af6f;hb=26d1b687ca01be01505b69ff48ae5d3e0cd4186e;hp=ea464e57811cb298a0c1c4cef36cf9fd5599aad5;hpb=390a68296dd89f61461bdca02060d36e2e02af2b;p=oweals%2Fgnunet.git diff --git a/src/fs/gnunet-service-fs_pr.h b/src/fs/gnunet-service-fs_pr.h index ea464e578..8a95c20f4 100644 --- a/src/fs/gnunet-service-fs_pr.h +++ b/src/fs/gnunet-service-fs_pr.h @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors) + Copyright (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -33,38 +33,44 @@ * Options for pending requests (bits to be ORed). */ enum GSF_PendingRequestOptions - { +{ + + /** + * No special options (P2P-default). + */ + GSF_PRO_DEFAULTS = 0, + /** * Request must only be processed locally. */ - GSF_PRO_LOCAL_ONLY = 1, - + GSF_PRO_LOCAL_ONLY = 1, + /** * Request must only be forwarded (no routing) */ - GSF_PRO_FORWARD_ONLY = 2, + GSF_PRO_FORWARD_ONLY = 2, /** * Request persists indefinitely (no expiration). */ - GSF_PRO_REQUEST_EXPIRES = 4, + GSF_PRO_REQUEST_NEVER_EXPIRES = 4, /** * Request is allowed to refresh bloomfilter and change mingle value. */ - GSF_PRO_BLOOMFILTER_FULL_REFRESH = 8, + GSF_PRO_BLOOMFILTER_FULL_REFRESH = 8, /** * Request priority is allowed to be exceeded. */ - GSF_PRO_PRIORITY_UNLIMITED = 16, + GSF_PRO_PRIORITY_UNLIMITED = 16, /** * Option mask for typical local requests. */ - GSF_PRO_LOCAL_REQUEST = (GSF_PRO_BLOOMFILTER_FULL_REFRESH | GSF_PRO_PRIORITY_UNLIMITED) - - }; + GSF_PRO_LOCAL_REQUEST = + (GSF_PRO_BLOOMFILTER_FULL_REFRESH | GSF_PRO_PRIORITY_UNLIMITED | GSF_PRO_REQUEST_NEVER_EXPIRES) +}; /** @@ -78,28 +84,23 @@ struct GSF_PendingRequestData /** * Primary query hash for this request. */ - GNUNET_HashCode query; + struct GNUNET_HashCode query; /** - * Namespace to query, only set if the type is SBLOCK. - */ - GNUNET_HashCode namespace; - - /** - * Identity of a peer hosting the content, only set if - * 'has_target' is GNUNET_YES. + * Identity of a peer hosting the content, otherwise NULl. + * Allocated after struct only if needed. Do not free! */ - struct GNUNET_PeerIdentity target; + const struct GNUNET_PeerIdentity *target; /** * Fields for the plan module to track a DLL with the request. */ - struct GSF_RequestPlan *rp_head; + struct GSF_PendingRequestPlanBijection *pr_head; /** * Fields for the plan module to track a DLL with the request. */ - struct GSF_RequestPlan *rp_tail; + struct GSF_PendingRequestPlanBijection *pr_tail; /** * Current TTL for the request. @@ -126,11 +127,27 @@ struct GSF_PendingRequestData */ uint32_t original_priority; + /** + * Counter for how often this request has been transmitted (estimate, + * because we might have the same request pending for multiple clients, + * and of course because a transmission may have failed at a lower + * layer). + */ + uint32_t num_transmissions; + + /** + * How much respect did we (in total) offer for this request so far (estimate, + * because we might have the same request pending for multiple clients, + * and of course because a transmission may have failed at a lower + * layer). + */ + uint32_t respect_offered; + /** * Options for the request. */ enum GSF_PendingRequestOptions options; - + /** * Type of the requested block. */ @@ -142,9 +159,10 @@ struct GSF_PendingRequestData unsigned int results_found; /** - * Is the 'target' value set to a valid peer identity? + * Has this request been started yet (local/p2p operations)? Or are + * we still constructing it? */ - int has_target; + int has_started; }; @@ -153,30 +171,41 @@ struct GSF_PendingRequestData * Handle a reply to a pending request. Also called if a request * expires (then with data == NULL). The handler may be called * many times (depending on the request type), but will not be - * called during or after a call to GSF_pending_request_cancel + * called during or after a call to GSF_pending_request_cancel * and will also not be called anymore after a call signalling * expiration. * * @param cls user-specified closure + * @param eval evaluation of the result * @param pr handle to the original pending request + * @param reply_anonymity_level anonymity level for the reply, UINT32_MAX for "unknown" * @param expiration when does 'data' expire? + * @param last_transmission the last time we've tried to get this block (FOREVER if unknown) + * @param type type of the block * @param data response data, NULL on request expiration * @param data_len number of bytes in data */ -typedef void (*GSF_PendingRequestReplyHandler)(void *cls, - struct GSF_PendingRequest *pr, - struct GNUNET_TIME_Absolute expiration, - const void *data, - size_t data_len); +typedef void (*GSF_PendingRequestReplyHandler) (void *cls, + enum + GNUNET_BLOCK_EvaluationResult + eval, + struct GSF_PendingRequest * pr, + uint32_t reply_anonymity_level, + struct GNUNET_TIME_Absolute + expiration, + struct GNUNET_TIME_Absolute + last_transmission, + enum GNUNET_BLOCK_Type type, + const void *data, + size_t data_len); /** - * Create a new pending request. + * Create a new pending request. * * @param options request options * @param type type of the block that is being requested * @param query key for the lookup - * @param namespace namespace to lookup, NULL for no namespace * @param target preferred target for the request, NULL for none * @param bf_data raw data for bloom filter for known replies, can be NULL * @param bf_size number of bytes in bf_data @@ -186,6 +215,7 @@ typedef void (*GSF_PendingRequestReplyHandler)(void *cls, * @param ttl current time-to-live for the request * @param sender_pid peer ID to use for the sender when forwarding, 0 for none; * reference counter is taken over by this function + * @param origin_pid peer ID of origin of query (do not loop back) * @param replies_seen hash codes of known local replies * @param replies_seen_count size of the 'replies_seen' array * @param rh handle to call when we get a reply @@ -194,21 +224,17 @@ typedef void (*GSF_PendingRequestReplyHandler)(void *cls, */ struct GSF_PendingRequest * GSF_pending_request_create_ (enum GSF_PendingRequestOptions options, - enum GNUNET_BLOCK_Type type, - const GNUNET_HashCode *query, - const GNUNET_HashCode *namespace, - const struct GNUNET_PeerIdentity *target, - const char *bf_data, - size_t bf_size, - uint32_t mingle, - uint32_t anonymity_level, - uint32_t priority, - int32_t ttl, - GNUNET_PEER_Id sender_pid, - const GNUNET_HashCode *replies_seen, - unsigned int replies_seen_count, - GSF_PendingRequestReplyHandler rh, - void *rh_cls); + enum GNUNET_BLOCK_Type type, + const struct GNUNET_HashCode * query, + const struct GNUNET_PeerIdentity *target, + const char *bf_data, size_t bf_size, + uint32_t mingle, uint32_t anonymity_level, + uint32_t priority, int32_t ttl, + GNUNET_PEER_Id sender_pid, + GNUNET_PEER_Id origin_pid, + const struct GNUNET_HashCode * replies_seen, + unsigned int replies_seen_count, + GSF_PendingRequestReplyHandler rh, void *rh_cls); /** @@ -221,13 +247,13 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options, */ void GSF_pending_request_update_ (struct GSF_PendingRequest *pr, - const GNUNET_HashCode *replies_seen, - unsigned int replies_seen_count); + const struct GNUNET_HashCode * replies_seen, + unsigned int replies_seen_count); /** * Obtain the public data associated with a pending request - * + * * @param pr pending request * @return associated public data */ @@ -235,6 +261,20 @@ struct GSF_PendingRequestData * GSF_pending_request_get_data_ (struct GSF_PendingRequest *pr); +/** + * Test if two pending requests are compatible (would generate + * the same query modulo filters and should thus be processed + * jointly). + * + * @param pra a pending request + * @param prb another pending request + * @return GNUNET_OK if the requests are compatible + */ +int +GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra, + struct GSF_PendingRequest *prb); + + /** * Generate the message corresponding to the given pending request for * transmission to other peers (or at least determine its size). @@ -246,17 +286,17 @@ GSF_pending_request_get_data_ (struct GSF_PendingRequest *pr); */ size_t GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr, - size_t buf_size, - void *buf); + size_t buf_size, void *buf); /** * Explicitly cancel a pending request. * * @param pr request to cancel + * @param full_cleanup fully purge the request */ void -GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr); +GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup); /** @@ -268,9 +308,9 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr); * @param pr handle to the pending request * @return GNUNET_YES to continue to iterate */ -typedef int (*GSF_PendingRequestIterator)(void *cls, - const GNUNET_HashCode *key, - struct GSF_PendingRequest *pr); +typedef int (*GSF_PendingRequestIterator) (void *cls, + const struct GNUNET_HashCode * key, + struct GSF_PendingRequest * pr); /** @@ -280,8 +320,7 @@ typedef int (*GSF_PendingRequestIterator)(void *cls, * @param cls closure for it */ void -GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, - void *cls); +GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls); /** @@ -299,7 +338,7 @@ GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, */ int GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp, - const struct GNUNET_MessageHeader *message); + const struct GNUNET_MessageHeader *message); /** @@ -311,6 +350,15 @@ void GSF_dht_lookup_ (struct GSF_PendingRequest *pr); +/** + * Consider downloading via cadet (if possible) + * + * @param pr the pending request to process + */ +void +GSF_cadet_lookup_ (struct GSF_PendingRequest *pr); + + /** * Function to be called after we're done processing * replies from the local lookup. @@ -319,9 +367,10 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr); * @param pr the pending request we were processing * @param result final datastore lookup result */ -typedef void (*GSF_LocalLookupContinuation)(void *cls, - struct GSF_PendingRequest *pr, - enum GNUNET_BLOCK_EvaluationResult result); +typedef void (*GSF_LocalLookupContinuation) (void *cls, + struct GSF_PendingRequest * pr, + enum GNUNET_BLOCK_EvaluationResult + result); /** @@ -333,8 +382,20 @@ typedef void (*GSF_LocalLookupContinuation)(void *cls, */ void GSF_local_lookup_ (struct GSF_PendingRequest *pr, - GSF_LocalLookupContinuation cont, - void *cont_cls); + GSF_LocalLookupContinuation cont, void *cont_cls); + + +/** + * Is the given target a legitimate peer for forwarding the given request? + * + * @param pr request + * @param target + * @return GNUNET_YES if this request could be forwarded to the given peer + */ +int +GSF_pending_request_test_target_ (struct GSF_PendingRequest *pr, + const struct GNUNET_PeerIdentity *target); + /**