Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
-
/**
* @file fs/gnunet-service-fs_lc.c
* @brief API to handle 'local clients'
* @author Christian Grothoff
*/
-
#include "platform.h"
#include "gnunet-service-fs.h"
#include "gnunet-service-fs_lc.h"
*/
static struct GSF_LocalClient *client_head;
-
/**
* Head of linked list of our local clients.
*/
struct GSF_LocalClient *pos;
pos = client_head;
- while ((pos != NULL) && (pos->client != client))
+ while ((NULL != pos) && (pos->client != client))
pos = pos->next;
- if (pos != NULL)
+ if (NULL != pos)
return pos;
- pos = GNUNET_malloc (sizeof (struct GSF_LocalClient));
+ pos = GNUNET_new (struct GSF_LocalClient);
pos->client = client;
- GNUNET_CONTAINER_DLL_insert (client_head, client_tail, pos);
+ GNUNET_CONTAINER_DLL_insert (client_head,
+ client_tail,
+ pos);
return pos;
}
* 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 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 expiration when does @a data expire?
* @param last_transmission when was the last time we've tried to download 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
+ * @param data_len number of bytes in @a data
*/
static void
-client_response_handler (void *cls, enum GNUNET_BLOCK_EvaluationResult eval,
+client_response_handler (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,
+ enum GNUNET_BLOCK_Type type,
+ const void *data,
size_t data_len)
{
struct ClientRequest *cr = cls;
if (NULL == data)
{
- /* ugh, request 'timed out' -- how can this be? */
- GNUNET_break (0);
+ /* local-only request, with no result, clean up. */
+ if (GNUNET_SCHEDULER_NO_TASK == cr->kill_task)
+ cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
+ cr);
return;
}
prd = GSF_pending_request_get_data_ (pr);
* @param client identification of the client
* @param message the actual message
* @param prptr where to store the pending request handle for the request
- * @return GNUNET_YES to start local processing,
- * GNUNET_NO to not (yet) start local processing,
- * GNUNET_SYSERR on error
+ * @return #GNUNET_YES to start local processing,
+ * #GNUNET_NO to not (yet) start local processing,
+ * #GNUNET_SYSERR on error
*/
int
GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader
- *message,
+ const struct GNUNET_MessageHeader *message,
struct GSF_PendingRequest **prptr)
{
- static struct GNUNET_HashCode all_zeros;
+ static struct GNUNET_PeerIdentity all_zeros;
const struct SearchMessage *sm;
struct GSF_LocalClient *lc;
struct ClientRequest *cr;
(type == GNUNET_BLOCK_TYPE_ANY))
{
cr = lc->cr_head;
- while (cr != NULL)
+ while (NULL != cr)
{
prd = GSF_pending_request_get_data_ (cr->pr);
/* only unify with queries that hae not yet started local processing
GNUNET_STATISTICS_update (GSF_stats,
gettext_noop ("# client searches active"), 1,
GNUNET_NO);
- cr = GNUNET_malloc (sizeof (struct ClientRequest));
+ cr = GNUNET_new (struct ClientRequest);
cr->lc = lc;
GNUNET_CONTAINER_DLL_insert (lc->cr_head, lc->cr_tail, cr);
options = GSF_PRO_LOCAL_REQUEST;
if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
options |= GSF_PRO_LOCAL_ONLY;
cr->pr = GSF_pending_request_create_ (options, type,
- &sm->query,
+ &sm->query,
(0 !=
memcmp (&sm->target, &all_zeros,
- sizeof (struct GNUNET_HashCode)))
- ? (const struct GNUNET_PeerIdentity *)
- &sm->target : NULL, NULL, 0,
+ sizeof (struct GNUNET_PeerIdentity)))
+ ? &sm->target : NULL, NULL, 0,
0 /* bf */ ,
ntohl (sm->anonymity_level),
0 /* priority */ ,
* If we were able to transmit messages and there are still more
* pending, ask core again for further calls to this function.
*
- * @param cls closure, pointer to the 'struct GSF_LocalClient'
- * @param size number of bytes available in buf
+ * @param cls closure, pointer to the `struct GSF_LocalClient`
+ * @param size number of bytes available in @a buf
* @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
*/
static size_t
-transmit_to_client (void *cls, size_t size, void *buf)
+transmit_to_client (void *cls,
+ size_t size,
+ void *buf)
{
struct GSF_LocalClient *lc = cls;
char *cbuf = buf;
res = GNUNET_malloc (sizeof (struct ClientResponse) + msize);
res->lc = lc;
res->msize = msize;
- memcpy (&res[1], msg, msize);
- GNUNET_CONTAINER_DLL_insert_tail (lc->res_head, lc->res_tail, res);
+ memcpy (&res[1],
+ msg,
+ msize);
+ GNUNET_CONTAINER_DLL_insert_tail (lc->res_head,
+ lc->res_tail,
+ res);
if (NULL == lc->th)
lc->th =
GNUNET_SERVER_notify_transmit_ready (lc->client, msize,
* @param client handle of the client
*/
void
-GSF_client_disconnect_handler_ (void *cls, struct GNUNET_SERVER_Client *client)
+GSF_client_disconnect_handler_ (void *cls,
+ struct GNUNET_SERVER_Client *client)
{
struct GSF_LocalClient *pos;
struct ClientRequest *cr;
GNUNET_CONTAINER_DLL_remove (pos->res_head, pos->res_tail, res);
GNUNET_free (res);
}
- if (pos->th != NULL)
+ if (NULL != pos->th)
{
GNUNET_SERVER_notify_transmit_ready_cancel (pos->th);
pos->th = NULL;
projects / oweals / gnunet.git / blobdiff