/*
This file is part of GNUnet.
- (C) 2001-2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2001-2013 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.
*/
/**
#include "platform.h"
#include "gnunet_protocols.h"
#include "gnunet_util_lib.h"
+#include "gnunet_socks.h"
/**
* If we are re-trying and are delaying to do so,
* handle to the scheduled task managing the delay.
*/
- struct GNUNET_SCHEDULER_Task * reconnect_task;
+ struct GNUNET_SCHEDULER_Task *reconnect_task;
/**
* Timeout for the operation overall.
};
-/**
- * Context for processing
- * "GNUNET_CLIENT_transmit_and_get_response" requests.
- */
-struct TransmitGetResponseContext
-{
- /**
- * Client handle.
- */
- struct GNUNET_CLIENT_Connection *client;
-
- /**
- * Message to transmit; do not free, allocated
- * right after this struct.
- */
- const struct GNUNET_MessageHeader *hdr;
-
- /**
- * Timeout to use.
- */
- struct GNUNET_TIME_Absolute timeout;
-
- /**
- * Function to call when done.
- */
- GNUNET_CLIENT_MessageHandler rn;
-
- /**
- * Closure for @e rn.
- */
- void *rn_cls;
-};
-
/**
* Struct to refer to a GNUnet TCP connection.
* This is more than just a socket because if the server
*/
char *service_name;
- /**
- * Context of a transmit_and_get_response operation, NULL
- * if no such operation is pending.
- */
- struct TransmitGetResponseContext *tag;
-
/**
* Handler for current receiver task.
*/
/**
* Are we currently busy doing receive-processing?
- * #GNUNET_YES if so, #GNUNET_NO if not.
+ * #GNUNET_YES if so, #GNUNET_NO if not. #GNUNET_SYSERR
+ * if the connection has failed (but we may not have
+ * closed the handle itself yet).
*/
int in_receive;
char *hostname;
unsigned long long port;
+ /* Never use a local source if a proxy is configured */
+ if (GNUNET_YES == GNUNET_SOCKS_check_service (service_name,cfg))
+ return GNUNET_SOCKS_do_connect (service_name,cfg);
+
connection = NULL;
if (0 == (attempt % 2))
{
}
+/**
+ * Create a message queue to connect to a GNUnet service.
+ * If handlers are specfied, receive messages from the connection.
+ *
+ * @param connection the client connection
+ * @param handlers handlers for receiving messages, can be NULL
+ * @param error_handler error handler
+ * @param error_handler_cls closure for the @a error_handler
+ * @return the message queue, NULL on error
+ */
+struct GNUNET_MQ_Handle *
+GNUNET_CLIENT_connecT (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ const char *service_name,
+ const struct GNUNET_MQ_MessageHandler *handlers,
+ GNUNET_MQ_ErrorHandler error_handler,
+ void *error_handler_cls)
+{
+ struct GNUNET_CLIENT_Connection *c;
+
+ c = GNUNET_CLIENT_connect (service_name,
+ cfg);
+ if (NULL == c)
+ return NULL;
+ return GNUNET_MQ_queue_for_connection_client (c,
+ handlers,
+ error_handler,
+ error_handler_cls);
+}
+
+
/**
* Get a connection with a service.
*
GNUNET_SCHEDULER_cancel (client->receive_task);
client->receive_task = NULL;
}
- if (NULL != client->tag)
- {
- GNUNET_free (client->tag);
- client->tag = NULL;
- }
client->receiver_handler = NULL;
- GNUNET_array_grow (client->received_buf, client->received_size, 0);
+ GNUNET_array_grow (client->received_buf,
+ client->received_size,
+ 0);
GNUNET_free (client->service_name);
GNUNET_free (client);
}
* @param errCode value of errno (on errors receiving)
*/
static void
-receive_helper (void *cls, const void *buf, size_t available,
- const struct sockaddr *addr, socklen_t addrlen, int errCode)
+receive_helper (void *cls,
+ const void *buf,
+ size_t available,
+ const struct sockaddr *addr,
+ socklen_t addrlen,
+ int errCode)
{
struct GNUNET_CLIENT_Connection *client = cls;
struct GNUNET_TIME_Relative remaining;
GNUNET_assert (GNUNET_NO == client->msg_complete);
GNUNET_assert (GNUNET_YES == client->in_receive);
client->in_receive = GNUNET_NO;
- if ((0 == available) || (NULL == client->connection) || (0 != errCode))
+ if ( (0 == available) ||
+ (NULL == client->connection) ||
+ (0 != errCode) )
{
/* signal timeout! */
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Timeout in receive_helper, available %u, client->connection %s, errCode `%s'\n",
- (unsigned int) available, NULL == client->connection ? "NULL" : "non-NULL",
+ (unsigned int) available,
+ NULL == client->connection ? "NULL" : "non-NULL",
STRERROR (errCode));
+ /* remember failure */
+ client->in_receive = GNUNET_SYSERR;
if (NULL != (receive_handler = client->receiver_handler))
{
receive_handler_cls = client->receiver_handler_cls;
client->receiver_handler = NULL;
- receive_handler (receive_handler_cls, NULL);
+ receive_handler (receive_handler_cls,
+ NULL);
}
return;
}
if (client->received_size < client->received_pos + available)
GNUNET_array_grow (client->received_buf, client->received_size,
client->received_pos + available);
- memcpy (&client->received_buf[client->received_pos], buf, available);
+ GNUNET_memcpy (&client->received_buf[client->received_pos], buf, available);
client->received_pos += available;
check_complete (client);
/* check for timeout */
/**
* Continuation to call the receive callback.
*
- * @param cls our handle to the client connection
- * @param tc scheduler context
+ * @param cls our handle to the client connection
*/
static void
-receive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+receive_task (void *cls)
{
struct GNUNET_CLIENT_Connection *client = cls;
GNUNET_CLIENT_MessageHandler handler = client->receiver_handler;
char mbuf[msize] GNUNET_ALIGN;
struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) mbuf;
+ client->receive_task = NULL;
+ if ( (GNUNET_SYSERR == client->in_receive) &&
+ (GNUNET_YES != client->msg_complete) )
+ {
+ /* Connection failure, signal to caller! */
+ client->receiver_handler = NULL;
+ if (NULL != handler)
+ handler (handler_cls,
+ NULL);
+ return;
+ }
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received message of type %u and size %u from %s service.\n",
ntohs (cmsg->type),
msize,
client->service_name);
- client->receive_task = NULL;
GNUNET_assert (GNUNET_YES == client->msg_complete);
GNUNET_assert (client->received_pos >= msize);
- memcpy (msg, cmsg, msize);
- memmove (client->received_buf, &client->received_buf[msize],
+ GNUNET_memcpy (msg, cmsg, msize);
+ memmove (client->received_buf,
+ &client->received_buf[msize],
client->received_pos - msize);
client->received_pos -= msize;
client->msg_complete = GNUNET_NO;
if (NULL == client->connection)
{
/* already disconnected, fail instantly! */
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Client API violation for service `%s'\n",
+ client->service_name);
GNUNET_break (0); /* this should not happen in well-written code! */
if (NULL != handler)
- handler (handler_cls, NULL);
+ handler (handler_cls,
+ NULL);
return;
}
client->receiver_handler = handler;
client->receiver_handler_cls = handler_cls;
client->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
- if (GNUNET_YES == client->msg_complete)
+ if ( (GNUNET_YES == client->msg_complete) ||
+ (GNUNET_SYSERR == client->in_receive) )
{
GNUNET_assert (NULL == client->receive_task);
- client->receive_task = GNUNET_SCHEDULER_add_now (&receive_task, client);
- }
- else
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG, "calling GNUNET_CONNECTION_receive\n");
- GNUNET_assert (GNUNET_NO == client->in_receive);
- client->in_receive = GNUNET_YES;
- GNUNET_CONNECTION_receive (client->connection, GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
- timeout, &receive_helper, client);
+ client->receive_task = GNUNET_SCHEDULER_add_now (&receive_task,
+ client);
+ return;
}
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "calling GNUNET_CONNECTION_receive\n");
+ GNUNET_assert (GNUNET_NO == client->in_receive);
+ client->in_receive = GNUNET_YES;
+ GNUNET_CONNECTION_receive (client->connection,
+ GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+ timeout,
+ &receive_helper,
+ client);
}
/**
* ID of task used for asynchronous operations.
*/
- struct GNUNET_SCHEDULER_Task * task;
+ struct GNUNET_SCHEDULER_Task *task;
/**
* Final result to report back (once known).
* and then cleans up.
*
* @param cls the `struct GNUNET_CLIENT_TestHandle`
- * @param tc scheduler context
*/
static void
-report_result (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+report_result (void *cls)
{
struct GNUNET_CLIENT_TestHandle *th = cls;
* @param msg message received, NULL on timeout or fatal error
*/
static void
-confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+confirm_handler (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_CLIENT_TestHandle *th = cls;
* @param cls our `struct GNUNET_CLIENT_TransmissionHandle`
* @param size number of bytes available for transmission
* @param buf where to write them
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
*/
static size_t
client_notify (void *cls, size_t size, void *buf);
* service after a while.
*
* @param cls our `struct GNUNET_CLIENT_TransmitHandle` of the request
- * @param tc unused
*/
static void
-client_delayed_retry (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+client_delayed_retry (void *cls)
{
struct GNUNET_CLIENT_TransmitHandle *th = cls;
struct GNUNET_TIME_Relative delay;
th->reconnect_task = NULL;
- if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
- {
- /* give up, was shutdown */
- th->client->th = NULL;
- th->notify (th->notify_cls, 0, NULL);
- GNUNET_free (th);
- return;
- }
th->client->connection =
do_connect (th->client->service_name,
th->client->cfg,
"Transmission failed %u times, trying again in %s.\n",
MAX_ATTEMPTS - th->attempts_left,
GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
+ GNUNET_assert (NULL == th->th);
GNUNET_assert (NULL == th->reconnect_task);
th->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th);
+ GNUNET_SCHEDULER_add_delayed (delay,
+ &client_delayed_retry,
+ th);
return;
}
th->th =
GNUNET_CONNECTION_notify_transmit_ready (th->client->connection, th->size,
GNUNET_TIME_absolute_get_remaining
- (th->timeout), &client_notify,
+ (th->timeout),
+ &client_notify,
th);
if (NULL == th->th)
{
* @return number of bytes written to @a buf
*/
static size_t
-client_notify (void *cls, size_t size, void *buf)
+client_notify (void *cls,
+ size_t size,
+ void *buf)
{
struct GNUNET_CLIENT_TransmitHandle *th = cls;
struct GNUNET_CLIENT_Connection *client = th->client;
{
delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
delay.rel_value_us /= 2;
- if ((GNUNET_YES != th->auto_retry) || (0 == --th->attempts_left) ||
- (delay.rel_value_us < 1)||
- (0 != (GNUNET_SCHEDULER_get_reason() & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
+ if ( (GNUNET_YES != th->auto_retry) ||
+ (0 == --th->attempts_left) ||
+ (delay.rel_value_us < 1) )
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Transmission failed %u times, giving up.\n",
MAX_ATTEMPTS - th->attempts_left);
- GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
+ GNUNET_break (0 ==
+ th->notify (th->notify_cls, 0, NULL));
GNUNET_free (th);
return 0;
}
GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
client->th = th;
GNUNET_assert (NULL == th->reconnect_task);
+ GNUNET_assert (NULL == th->th);
th->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th);
+ GNUNET_SCHEDULER_add_delayed (delay,
+ &client_delayed_retry,
+ th);
return 0;
}
GNUNET_assert (size >= th->size);
client->th = th;
if (NULL == client->connection)
{
+ GNUNET_assert (NULL == th->th);
GNUNET_assert (NULL == th->reconnect_task);
th->reconnect_task =
GNUNET_SCHEDULER_add_delayed (client->back_off,
&client_delayed_retry,
th);
-
}
else
{
- th->th =
- GNUNET_CONNECTION_notify_transmit_ready (client->connection, size, timeout,
- &client_notify, th);
+ th->th = GNUNET_CONNECTION_notify_transmit_ready (client->connection,
+ size,
+ timeout,
+ &client_notify,
+ th);
if (NULL == th->th)
{
GNUNET_break (0);
}
-/**
- * Function called to notify a client about the socket
- * begin ready to queue the message. @a buf will be
- * NULL and @a size zero if the socket was closed for
- * writing in the meantime.
- *
- * @param cls closure of type "struct TransmitGetResponseContext*"
- * @param size number of bytes available in @a buf
- * @param buf where the callee should write the message
- * @return number of bytes written to @a buf
- */
-static size_t
-transmit_for_response (void *cls,
- size_t size,
- void *buf)
-{
- struct TransmitGetResponseContext *tc = cls;
- uint16_t msize;
-
- tc->client->tag = NULL;
- msize = ntohs (tc->hdr->size);
- if (NULL == buf)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- _("Could not submit request, not expecting to receive a response.\n"));
- if (NULL != tc->rn)
- tc->rn (tc->rn_cls, NULL);
- GNUNET_free (tc);
- return 0;
- }
- GNUNET_assert (size >= msize);
- memcpy (buf, tc->hdr, msize);
- GNUNET_CLIENT_receive (tc->client, tc->rn, tc->rn_cls,
- GNUNET_TIME_absolute_get_remaining (tc->timeout));
- GNUNET_free (tc);
- return msize;
-}
-
-
-/**
- * Convenience API that combines sending a request
- * to the service and waiting for a response.
- * If either operation times out, the callback
- * will be called with a "NULL" response (in which
- * case the connection should probably be destroyed).
- *
- * @param client connection to use
- * @param hdr message to transmit
- * @param timeout when to give up (for both transmission
- * and for waiting for a response)
- * @param auto_retry if the connection to the service dies, should we
- * automatically re-connect and retry (within the timeout period)
- * or should we immediately fail in this case? Pass GNUNET_YES
- * if the caller does not care about temporary connection errors,
- * for example because the protocol is stateless
- * @param rn function to call with the response
- * @param rn_cls closure for @a rn
- * @return #GNUNET_OK on success, #GNUNET_SYSERR if a request
- * is already pending
- */
-int
-GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *client,
- const struct GNUNET_MessageHeader *hdr,
- struct GNUNET_TIME_Relative timeout,
- int auto_retry,
- GNUNET_CLIENT_MessageHandler rn,
- void *rn_cls)
-{
- struct TransmitGetResponseContext *tc;
- uint16_t msize;
-
- if (NULL != client->th)
- return GNUNET_SYSERR;
- GNUNET_assert (NULL == client->tag);
- msize = ntohs (hdr->size);
- tc = GNUNET_malloc (sizeof (struct TransmitGetResponseContext) + msize);
- tc->client = client;
- tc->hdr = (const struct GNUNET_MessageHeader *) &tc[1];
- memcpy (&tc[1], hdr, msize);
- tc->timeout = GNUNET_TIME_relative_to_absolute (timeout);
- tc->rn = rn;
- tc->rn_cls = rn_cls;
- if (NULL ==
- GNUNET_CLIENT_notify_transmit_ready (client, msize, timeout, auto_retry,
- &transmit_for_response, tc))
- {
- GNUNET_break (0);
- GNUNET_free (tc);
- return GNUNET_SYSERR;
- }
- client->tag = tc;
- return GNUNET_OK;
-}
-
-
/* end of client.c */
projects / oweals / gnunet.git / blobdiff