From 710e8923105dfcc38d8aefed19e6da670db9c440 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 18 Jun 2016 18:49:13 +0000 Subject: partial refactoring, will cause FTBFS, to be completed ASAP --- src/set/set_api.c | 195 +++++++++++++++++++++++++++++++----------------------- 1 file changed, 114 insertions(+), 81 deletions(-) (limited to 'src/set') diff --git a/src/set/set_api.c b/src/set/set_api.c index 794ae57b7..343b5f881 100644 --- a/src/set/set_api.c +++ b/src/set/set_api.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - Copyright (C) 2012-2014 GNUnet e.V. + Copyright (C) 2012-2016 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -243,7 +243,7 @@ struct GNUNET_SET_ListenHandle static struct GNUNET_SET_Handle * create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op, - uint32_t *cookie); + const uint32_t *cookie); /** @@ -251,21 +251,17 @@ create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg, * iterator and sends an acknowledgement to the service. * * @param cls the `struct GNUNET_SET_Handle *` - * @param mh the message + * @param msg the message */ static void handle_copy_lazy (void *cls, - const struct GNUNET_MessageHeader *mh) + const struct GNUNET_SET_CopyLazyResponseMessage *msg) { - struct GNUNET_SET_CopyLazyResponseMessage *msg; struct GNUNET_SET_Handle *set = cls; struct SetCopyRequest *req; struct GNUNET_SET_Handle *new_set; - msg = (struct GNUNET_SET_CopyLazyResponseMessage *) mh; - req = set->copy_req_head; - if (NULL == req) { /* Service sent us unsolicited lazy copy response */ @@ -275,22 +271,35 @@ handle_copy_lazy (void *cls, LOG (GNUNET_ERROR_TYPE_DEBUG, "Handling response to lazy copy\n"); - GNUNET_CONTAINER_DLL_remove (set->copy_req_head, set->copy_req_tail, req); - - // We pass none as operation here, since it doesn't matter when // cloning. - new_set = create_internal (set->cfg, GNUNET_SET_OPERATION_NONE, &msg->cookie); - + new_set = create_internal (set->cfg, + GNUNET_SET_OPERATION_NONE, + &msg->cookie); req->cb (req->cls, new_set); - GNUNET_free (req); } +/** + * Check that the given @a msg is well-formed. + * + * @param cls closure + * @param msg message to check + * @return #GNUNET_OK if message is well-formed + */ +static int +check_iter_element (void *cls, + const struct GNUNET_SET_IterResponseMessage *msg) +{ + /* minimum size was already checked, everything else is OK! */ + return GNUNET_OK; +} + + /** * Handle element for iteration over the set. Notifies the * iterator and sends an acknowledgement to the service. @@ -298,30 +307,18 @@ handle_copy_lazy (void *cls, * @param cls the `struct GNUNET_SET_Handle *` * @param mh the message */ -static void -handle_iter_element (void *cls, - const struct GNUNET_MessageHeader *mh) + static void + handle_iter_element (void *cls, + const struct GNUNET_SET_IterResponseMessage *msg) { struct GNUNET_SET_Handle *set = cls; GNUNET_SET_ElementIterator iter = set->iterator; - struct GNUNET_SET_Element element; - const struct GNUNET_SET_IterResponseMessage *msg; + struct GNUNET_SET_Element element; struct GNUNET_SET_IterAckMessage *ack_msg; struct GNUNET_MQ_Envelope *ev; uint16_t msize; - msize = ntohs (mh->size); - if (msize < sizeof (sizeof (struct GNUNET_SET_IterResponseMessage))) - { - /* message malformed */ - GNUNET_break (0); - set->iterator = NULL; - set->iteration_id++; - iter (set->iterator_cls, - NULL); - iter = NULL; - } - msg = (const struct GNUNET_SET_IterResponseMessage *) mh; + msize = ntohs (msg->header.size); if (set->iteration_id != ntohs (msg->iteration_id)) { /* element from a previous iteration, skip! */ @@ -365,6 +362,22 @@ handle_iter_done (void *cls, } +/** + * Check that the given @a msg is well-formed. + * + * @param cls closure + * @param msg message to check + * @return #GNUNET_OK if message is well-formed + */ +static int +check_result (void *cls, + const struct GNUNET_SET_ResultMessage *msg) +{ + /* minimum size was already checked, everything else is OK! */ + return GNUNET_OK; +} + + /** * Handle result message for a set operation. * @@ -373,15 +386,13 @@ handle_iter_done (void *cls, */ static void handle_result (void *cls, - const struct GNUNET_MessageHeader *mh) + const struct GNUNET_SET_ResultMessage *msg) { struct GNUNET_SET_Handle *set = cls; - const struct GNUNET_SET_ResultMessage *msg; struct GNUNET_SET_OperationHandle *oh; struct GNUNET_SET_Element e; enum GNUNET_SET_Status result_status; - msg = (const struct GNUNET_SET_ResultMessage *) mh; GNUNET_assert (NULL != set->mq); result_status = ntohs (msg->result_status); LOG (GNUNET_ERROR_TYPE_DEBUG, @@ -442,7 +453,7 @@ do_element: LOG (GNUNET_ERROR_TYPE_DEBUG, "Treating result as element\n"); e.data = &msg[1]; - e.size = ntohs (mh->size) - sizeof (struct GNUNET_SET_ResultMessage); + e.size = ntohs (msg->header.size) - sizeof (struct GNUNET_SET_ResultMessage); e.element_type = ntohs (msg->element_type); if (NULL != oh->result_cb) oh->result_cb (oh->result_cls, @@ -522,7 +533,8 @@ handle_client_set_error (void *cls, enum GNUNET_MQ_Error error) { struct GNUNET_SET_Handle *set = cls; - + GNUNET_SET_ElementIterator iter = set->iterator; + LOG (GNUNET_ERROR_TYPE_DEBUG, "Handling client set error %d\n", error); @@ -534,6 +546,11 @@ handle_client_set_error (void *cls, GNUNET_SET_STATUS_FAILURE); set_operation_destroy (set->ops_head); } + set->iterator = NULL; + set->iteration_id++; + if (NULL != iter) + iter (set->iterator_cls, + NULL); set->invalid = GNUNET_YES; if (GNUNET_YES == set->destroy_requested) { @@ -547,31 +564,34 @@ handle_client_set_error (void *cls, static struct GNUNET_SET_Handle * create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op, - uint32_t *cookie) + const uint32_t *cookie) { - static const struct GNUNET_MQ_MessageHandler mq_handlers[] = { - { &handle_result, - GNUNET_MESSAGE_TYPE_SET_RESULT, - 0 }, - { &handle_iter_element, - GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT, - 0 }, - { &handle_iter_done, - GNUNET_MESSAGE_TYPE_SET_ITER_DONE, - sizeof (struct GNUNET_MessageHeader) }, - { &handle_copy_lazy, - GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE, - sizeof (struct GNUNET_SET_CopyLazyResponseMessage) }, - GNUNET_MQ_HANDLERS_END + GNUNET_MQ_hd_var_size (result, + GNUNET_MESSAGE_TYPE_SET_RESULT, + struct GNUNET_SET_ResultMessage); + GNUNET_MQ_hd_var_size (iter_element, + GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT, + struct GNUNET_SET_IterResponseMessage); + GNUNET_MQ_hd_fixed_size (iter_done, + GNUNET_MESSAGE_TYPE_SET_ITER_DONE, + struct GNUNET_MessageHeader); + GNUNET_MQ_hd_fixed_size (copy_lazy, + GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE, + struct GNUNET_SET_CopyLazyResponseMessage); + struct GNUNET_SET_Handle *set = GNUNET_new (struct GNUNET_SET_Handle); + struct GNUNET_MQ_MessageHandler mq_handlers[] = { + make_result_handler (set), + make_iter_element_handler (set), + make_iter_done_handler (set), + make_copy_lazy_handler (set), + GNUNET_MQ_handler_end () }; - struct GNUNET_SET_Handle *set; struct GNUNET_MQ_Envelope *mqm; struct GNUNET_SET_CreateMessage *create_msg; struct GNUNET_SET_CopyLazyConnectMessage *copy_msg; - set = GNUNET_new (struct GNUNET_SET_Handle); - set->client = GNUNET_CLIENT_connect ("set", cfg); set->cfg = cfg; + set->client = GNUNET_CLIENT_connect ("set", cfg); if (NULL == set->client) { GNUNET_free (set); @@ -795,42 +815,49 @@ static void listen_connect (void *cls); +/** + * Check validity of request message for a listen operation + * + * @param cls the listen handle + * @param msg the message + * @return #GNUNET_OK if the message is well-formed + */ +static int +check_request (void *cls, + const struct GNUNET_SET_RequestMessage *msg) +{ + const struct GNUNET_MessageHeader *context_msg; + + context_msg = GNUNET_MQ_extract_nested_mh (msg); + if (NULL == context_msg) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + return GNUNET_OK; +} + + /** * Handle request message for a listen operation * * @param cls the listen handle - * @param mh the message + * @param msg the message */ static void handle_request (void *cls, - const struct GNUNET_MessageHeader *mh) + const struct GNUNET_SET_RequestMessage *msg) { struct GNUNET_SET_ListenHandle *lh = cls; - const struct GNUNET_SET_RequestMessage *msg; struct GNUNET_SET_Request req; const struct GNUNET_MessageHeader *context_msg; - uint16_t msize; struct GNUNET_MQ_Envelope *mqm; struct GNUNET_SET_RejectMessage *rmsg; LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing incoming operation request\n"); - msize = ntohs (mh->size); - if (msize < sizeof (struct GNUNET_SET_RequestMessage)) - { - GNUNET_break (0); - GNUNET_CLIENT_disconnect (lh->client); - lh->client = NULL; - GNUNET_MQ_destroy (lh->mq); - lh->mq = NULL; - lh->reconnect_task = GNUNET_SCHEDULER_add_delayed (lh->reconnect_backoff, - &listen_connect, lh); - lh->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (lh->reconnect_backoff); - return; - } /* we got another valid request => reset the backoff */ lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS; - msg = (const struct GNUNET_SET_RequestMessage *) mh; req.accept_id = ntohl (msg->accept_id); req.accepted = GNUNET_NO; context_msg = GNUNET_MQ_extract_nested_mh (msg); @@ -871,7 +898,8 @@ handle_client_listener_error (void *cls, GNUNET_MQ_destroy (lh->mq); lh->mq = NULL; lh->reconnect_task = GNUNET_SCHEDULER_add_delayed (lh->reconnect_backoff, - &listen_connect, lh); + &listen_connect, + lh); lh->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (lh->reconnect_backoff); } @@ -883,12 +911,15 @@ handle_client_listener_error (void *cls, */ static void listen_connect (void *cls) -{ - static const struct GNUNET_MQ_MessageHandler mq_handlers[] = { - { &handle_request, GNUNET_MESSAGE_TYPE_SET_REQUEST }, - GNUNET_MQ_HANDLERS_END - }; +{ + GNUNET_MQ_hd_var_size (request, + GNUNET_MESSAGE_TYPE_SET_REQUEST, + struct GNUNET_SET_RequestMessage); struct GNUNET_SET_ListenHandle *lh = cls; + struct GNUNET_MQ_MessageHandler mq_handlers[] = { + make_request_handler (lh), + GNUNET_MQ_handler_end () + }; struct GNUNET_MQ_Envelope *mqm; struct GNUNET_SET_ListenMessage *msg; @@ -900,7 +931,8 @@ listen_connect (void *cls) GNUNET_assert (NULL == lh->mq); lh->mq = GNUNET_MQ_queue_for_connection_client (lh->client, mq_handlers, - &handle_client_listener_error, lh); + &handle_client_listener_error, + lh); mqm = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_LISTEN); msg->operation = htonl (lh->operation); msg->app_id = lh->app_id; @@ -1133,11 +1165,12 @@ GNUNET_SET_element_dup (const struct GNUNET_SET_Element *element) * Hash a set element. * * @param element the element that should be hashed - * @param ret_hash a pointer to where the hash of @a element + * @param[out] ret_hash a pointer to where the hash of @a element * should be stored */ void -GNUNET_SET_element_hash (const struct GNUNET_SET_Element *element, struct GNUNET_HashCode *ret_hash) +GNUNET_SET_element_hash (const struct GNUNET_SET_Element *element, + struct GNUNET_HashCode *ret_hash) { struct GNUNET_HashContext *ctx = GNUNET_CRYPTO_hash_context_start (); -- cgit v1.2.3