/*
This file is part of GNUnet.
- (C) 2009, 2010, 2011, 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009, 2010, 2011, 2012 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
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
* Continuation to call when the request has been
* transmitted (for the first time) to the service; can be NULL.
*/
- GNUNET_SCHEDULER_Task cont;
+ GNUNET_SCHEDULER_TaskCallback cont;
/**
* Closure for 'cont'.
};
+#if ENABLE_MALICIOUS
+/**
+ * Handle to act malicious message
+ */
+struct GNUNET_DHT_ActMaliciousHandle
+{
+ /**
+ * Continuation to call when done.
+ */
+ GNUNET_DHT_ActMaliciousContinuation cont;
+
+ /**
+ * Main handle to this DHT api
+ */
+ struct GNUNET_DHT_Handle *dht_handle;
+
+ /**
+ * Closure for 'cont'.
+ */
+ void *cont_cls;
+};
+#endif
/**
* Handle to a PUT request.
/**
* Timeout task for this operation.
*/
- GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ struct GNUNET_SCHEDULER_Task * timeout_task;
/**
* Unique ID for the PUT operation.
};
-
-
/**
* Handle to a GET request
*/
/**
* Task for trying to reconnect.
*/
- GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+ struct GNUNET_SCHEDULER_Task * reconnect_task;
/**
* How quickly should we retry? Used for exponential back-off on
* Did we start our receive loop yet?
*/
int in_receive;
+
+#if ENABLE_MALICIOUS
+ /**
+ * Handle of act malicious request.
+ */
+ struct GNUNET_DHT_ActMaliciousHandle *mh;
+#endif
};
* Try reconnecting to the dht service.
*
* @param cls a `struct GNUNET_DHT_Handle`
- * @param tc scheduler context
*/
static void
-try_reconnect (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+try_reconnect (void *cls)
{
struct GNUNET_DHT_Handle *handle = cls;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting with DHT %p\n", handle);
handle->retry_time = GNUNET_TIME_STD_BACKOFF (handle->retry_time);
- handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ handle->reconnect_task = NULL;
if (GNUNET_YES != try_connect (handle))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n");
if (NULL == handle->client)
return;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == handle->reconnect_task);
+ GNUNET_assert (NULL == handle->reconnect_task);
if (NULL != handle->th)
GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th);
handle->th = NULL;
head->in_pending_queue = GNUNET_NO;
if (NULL != head->cont)
{
- head->cont (head->cont_cls, NULL);
+ head->cont (head->cont_cls);
head->cont = NULL;
head->cont_cls = NULL;
}
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting to process replies from DHT\n");
handle->in_receive = GNUNET_YES;
-
+
GNUNET_CLIENT_receive (handle->client, &service_message_handler, handle,
GNUNET_TIME_UNIT_FOREVER_REL);
}
}
+#if ENABLE_MALICIOUS
+/**
+ * Process a act malicious confirmation from service.
+ * @param handle The DHT handle.
+ * @param msg confirmation message from the service.
+ * @return #GNUNET_OK if everything went fine,
+ * #GNUNET_SYSERR if the message is malformed.
+ */
+static int
+process_act_malicious_confirmation_message (struct GNUNET_DHT_Handle *handle,
+ const struct GNUNET_DHT_ClientActMaliciousConfirmationMessage *msg)
+{
+ struct GNUNET_DHT_ActMaliciousHandle *mh;
+ GNUNET_DHT_PutContinuation cont;
+ void *cont_cls;
+
+ mh = handle->mh;
+ if (NULL == mh)
+ return GNUNET_OK;
+ cont = mh->cont;
+ cont_cls = mh->cont_cls;
+ if (NULL != cont)
+ cont (cont_cls, GNUNET_OK);
+
+ return GNUNET_OK;
+}
+#endif
+
+
/**
* Process a put confirmation message from the service.
*
ret = process_put_confirmation_message (handle,
(const struct GNUNET_DHT_ClientPutConfirmationMessage*) msg);
break;
+#if ENABLE_MALICIOUS
+ case GNUNET_MESSAGE_TYPE_DHT_CLIENT_ACT_MALICIOUS_OK:
+ if(msize != sizeof (struct GNUNET_DHT_ClientActMaliciousConfirmationMessage))
+ {
+ GNUNET_break (0);
+ break;
+ }
+ ret = process_act_malicious_confirmation_message (handle,
+ (const struct GNUNET_DHT_ClientActMaliciousConfirmationMessage*) msg);
+ break;
+#endif
default:
GNUNET_break(0);
LOG (GNUNET_ERROR_TYPE_WARNING,
pm->in_pending_queue = GNUNET_NO;
GNUNET_assert (GNUNET_YES == pm->free_on_send);
if (NULL != pm->cont)
- pm->cont (pm->cont_cls, NULL);
+ pm->cont (pm->cont_cls);
GNUNET_free (pm);
}
while (NULL != (ph = handle->put_head))
GNUNET_CLIENT_disconnect (handle->client);
handle->client = NULL;
}
- if (GNUNET_SCHEDULER_NO_TASK != handle->reconnect_task)
+ if (NULL != handle->reconnect_task)
GNUNET_SCHEDULER_cancel (handle->reconnect_task);
GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests);
GNUNET_free (handle);
* Timeout for the transmission of a fire&forget-request. Clean it up.
*
* @param cls the `struct GNUNET_DHT_PutHandle *`
- * @param tc scheduler context
*/
static void
-timeout_put_request (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_put_request (void *cls)
{
struct GNUNET_DHT_PutHandle *ph = cls;
struct GNUNET_DHT_Handle *handle = ph->dht_handle;
- ph->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ ph->timeout_task = NULL;
if (NULL != ph->pending)
{
GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail,
* the message pointer in the put handle to NULL.
*
* @param cls the `struct GNUNET_DHT_PutHandle`
- * @param tc unused
*/
static void
-mark_put_message_gone (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+mark_put_message_gone (void *cls)
{
struct GNUNET_DHT_PutHandle *ph = cls;
struct PendingMessage *pending;
struct GNUNET_DHT_PutHandle *ph;
-
msize = sizeof (struct GNUNET_DHT_ClientPutMessage) + size;
if ((msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
(size >= GNUNET_SERVER_MAX_MESSAGE_SIZE))
GNUNET_free (ph->pending);
ph->pending = NULL;
}
- if (ph->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+ if (ph->timeout_task != NULL)
{
GNUNET_SCHEDULER_cancel (ph->timeout_task);
- ph->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ ph->timeout_task = NULL;
}
GNUNET_CONTAINER_DLL_remove (handle->put_head,
handle->put_tail,
#if ENABLE_MALICIOUS
/**
- * Turn the DHT service to act malicious depending on @a flag
+ * Turn the DHT service to act malicious.
*
* @param handle the DHT handle
* @param action 1 to make the service malicious; 0 to make it benign
- FIXME: perhaps make this an enum of known malicious behaviors?
+ * @param cont continuation to call when done (transmitting request to service)
+ * @param cont_cls closure for @a cont
*/
-void
-GNUNET_DHT_malicious (struct GNUNET_DHT_Handle *handle, unsigned int action)
+struct GNUNET_DHT_ActMaliciousHandle *
+GNUNET_DHT_act_malicious (struct GNUNET_DHT_Handle *handle,
+ unsigned int action,
+ GNUNET_DHT_PutContinuation cont,
+ void *cont_cls)
{
struct GNUNET_DHT_ActMaliciousMessage *amm;
+ struct GNUNET_DHT_ActMaliciousHandle *mh;
struct PendingMessage *pending;
size_t msize;
-
+
msize = sizeof(struct GNUNET_DHT_ActMaliciousMessage);
if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
{
GNUNET_break(0);
- return;
+ return NULL;
}
-
+ mh = GNUNET_new (struct GNUNET_DHT_ActMaliciousHandle);
+ mh->dht_handle = handle;
+ mh->cont = cont;
+ mh->cont_cls = cont_cls;
pending = GNUNET_malloc (sizeof (struct PendingMessage) + msize);
amm = (struct GNUNET_DHT_ActMaliciousMessage *)&pending[1];
pending->msg = &amm->header;
amm->header.size = htons (msize);
amm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_ACT_MALICIOUS);
amm->action = action;
-
+ handle->mh = mh;
GNUNET_CONTAINER_DLL_insert (handle->pending_head, handle->pending_tail,
pending);
pending->in_pending_queue = GNUNET_YES;
process_pending_messages (handle);
+ return mh;
}
#endif
projects / oweals / gnunet.git / blobdiff