/*
This file is part of GNUnet.
- (C) 2009, 2010, 2011, 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009, 2010, 2011, 2012 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
* 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
};
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;
}
+#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,
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);
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,
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,
GNUNET_free (handle);
}
+
+#if ENABLE_MALICIOUS
+/**
+ * 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
+ * @param cont continuation to call when done (transmitting request to service)
+ * @param cont_cls closure for @a cont
+ */
+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 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;
+ pending->handle = handle;
+ pending->free_on_send = GNUNET_YES;
+ 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
+
+
/* end of dht_api.c */
projects / oweals / gnunet.git / blobdiff