};
-/**
- * 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.
*/
}
+/**
+ * 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);
}
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;
client->service_name);
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;
(GNUNET_SYSERR == client->in_receive) )
{
GNUNET_assert (NULL == client->receive_task);
- client->receive_task = GNUNET_SCHEDULER_add_now (&receive_task, client);
+ client->receive_task = GNUNET_SCHEDULER_add_now (&receive_task,
+ client);
return;
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
/**
* 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;
* 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,
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)
{
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)))
+ (delay.rel_value_us < 1) )
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Transmission failed %u times, giving up.\n",
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);
}
-/**
- * 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