GNUNET_CONNECTION_TransmitReadyNotify notify;
/**
- * Closure for notify.
+ * Closure for @e notify.
*/
void *notify_cls;
GNUNET_CLIENT_MessageHandler rn;
/**
- * Closure for "rn".
+ * Closure for @e rn.
*/
void *rn_cls;
};
GNUNET_CLIENT_MessageHandler receiver_handler;
/**
- * Closure for receiver_handler.
+ * Closure for @e receiver_handler.
*/
void *receiver_handler_cls;
struct sockaddr_un s_un;
unixpath = NULL;
- if ((GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_filename (cfg, service_name,
- "UNIXPATH", &unixpath)) &&
- (0 < strlen (unixpath)))
+ if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH", &unixpath)) &&
+ (0 < strlen (unixpath)))
{
/* We have a non-NULL unixpath, need to validate it */
if (strlen (unixpath) >= sizeof (s_un.sun_path))
*
* @param service_name name of service to connect to
* @param cfg configuration to use
- * @return GNUNET_OK if the configuration is valid, GNUNET_SYSERR if not
+ * @return #GNUNET_OK if the configuration is valid, #GNUNET_SYSERR if not
*/
static int
test_service_configuration (const char *service_name,
#if AF_UNIX
char *unixpath = NULL;
- if ((GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH", &unixpath)) &&
- (0 < strlen (unixpath)))
+ if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH", &unixpath)) &&
+ (0 < strlen (unixpath)))
ret = GNUNET_OK;
GNUNET_free_non_null (unixpath);
#endif
if ( (GNUNET_YES ==
GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) &&
(GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "PORT", &port)) &&
+ GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "PORT", &port)) &&
(port <= 65535) && (0 != port) &&
(GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "HOSTNAME",
*/
static struct GNUNET_CONNECTION_Handle *
do_connect (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int attempt)
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ unsigned int attempt)
{
struct GNUNET_CONNECTION_Handle *connection;
char *hostname;
/* if port is 0, try UNIX */
connection = try_unixpath (service_name, cfg);
if (NULL != connection)
+ {
+ GNUNET_free_non_null (hostname);
return connection;
+ }
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Port is 0 for service `%s', UNIXPATH did not work, returning NULL!\n",
service_name);
struct GNUNET_CLIENT_Connection *client;
struct GNUNET_CONNECTION_Handle *connection;
- if (GNUNET_OK !=
+ if (GNUNET_OK !=
test_service_configuration (service_name,
cfg))
return NULL;
/**
* Callback function for data received from the network. Note that
- * both "available" and "errCode" would be 0 if the read simply timed out.
+ * both @a available and @a errCode would be 0 if the read simply timed out.
*
* @param cls closure
* @param buf pointer to received data
- * @param available number of bytes availabe in "buf",
+ * @param available number of bytes availabe in @a buf,
* possibly 0 (on errors)
* @param addr address of the sender
- * @param addrlen size of addr
+ * @param addrlen size of @a addr
* @param errCode value of errno (on errors receiving)
*/
static void
if (0 == remaining.rel_value_us)
{
/* signal timeout! */
- if (NULL != client->receiver_handler)
- client->receiver_handler (client->receiver_handler_cls, NULL);
+ if (NULL != (receive_handler = client->receiver_handler))
+ {
+ client->receiver_handler = NULL;
+ receive_handler (client->receiver_handler_cls, NULL);
+ }
return;
}
/* back to receive -- either for more data or to call callback! */
(const struct GNUNET_MessageHeader *) client->received_buf;
void *handler_cls = client->receiver_handler_cls;
uint16_t msize = ntohs (cmsg->size);
- char mbuf[msize];
+ char mbuf[msize] GNUNET_ALIGN;
struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader *) mbuf;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Received message of type %u and size %u\n",
- ntohs (cmsg->type), msize);
+ 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 = GNUNET_SCHEDULER_NO_TASK;
GNUNET_assert (GNUNET_YES == client->msg_complete);
GNUNET_assert (client->received_pos >= msize);
*
* @param client the service
* @param handler function to call with the message
- * @param handler_cls closure for handler
+ * @param handler_cls closure for @a handler
* @param timeout how long to wait until timing out
*/
void
GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *client,
- GNUNET_CLIENT_MessageHandler handler, void *handler_cls,
+ GNUNET_CLIENT_MessageHandler handler,
+ void *handler_cls,
struct GNUNET_TIME_Relative timeout)
{
if (NULL == client->connection)
/**
* Handle for a test to check if a service is running.
*/
-struct GNUNET_CLIENT_TestHandle
+struct GNUNET_CLIENT_TestHandle
{
/**
* Function to call with the result of the test.
GNUNET_CLIENT_TestResultCallback cb;
/**
- * Closure for 'cb'.
+ * Closure for @e cb.
*/
void *cb_cls;
/**
* Client connection we are using for the test, if any.
- */
+ */
struct GNUNET_CLIENT_Connection *client;
/**
struct GNUNET_CLIENT_TransmitHandle *th;
/**
- * Deadline for calling 'cb'.
+ * Deadline for calling @e cb.
*/
struct GNUNET_TIME_Absolute test_deadline;
* Task that reports back the result by calling the callback
* and then cleans up.
*
- * @param cls the 'struct GNUNET_CLIENT_TestHandle'
+ * @param cls the `struct GNUNET_CLIENT_TestHandle`
* @param tc scheduler context
*/
static void
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_CLIENT_TestHandle *th = cls;
-
+
th->task = GNUNET_SCHEDULER_NO_TASK;
th->cb (th->cb_cls, th->result);
GNUNET_CLIENT_service_test_cancel (th);
{
th->result = result;
th->task = GNUNET_SCHEDULER_add_now (&report_result,
- th);
+ th);
}
/**
* Receive confirmation from test, service is up.
*
- * @param cls closure with the 'struct GNUNET_CLIENT_TestHandle'
+ * @param cls closure with the `struct GNUNET_CLIENT_TestHandle`
* @param msg message received, NULL on timeout or fatal error
*/
static void
* Send the 'TEST' message to the service. If successful, prepare to
* receive the reply.
*
- * @param cls the 'struct GNUNET_CLIENT_TestHandle' of the test
- * @param size number of bytes available in buf
+ * @param cls the `struct GNUNET_CLIENT_TestHandle` of the test
+ * @param size number of bytes available in @a buf
* @param buf where to write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
*/
static size_t
write_test (void *cls, size_t size, void *buf)
th->th = NULL;
if (size < sizeof (struct GNUNET_MessageHeader))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"Failed to transmit TEST request.\n");
service_test_report (th, GNUNET_NO);
return 0; /* client disconnected */
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting `%s' request.\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmitting `%s' request.\n",
"TEST");
msg = (struct GNUNET_MessageHeader *) buf;
msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
msg->size = htons (sizeof (struct GNUNET_MessageHeader));
- GNUNET_CLIENT_receive (th->client,
+ GNUNET_CLIENT_receive (th->client,
&confirm_handler, th,
GNUNET_TIME_absolute_get_remaining
(th->test_deadline));
* @param cfg configuration to use
* @param timeout how long to wait at most
* @param cb function to call with the result
- * @param cb_cls closure for 'cb'
+ * @param cb_cls closure for @a cb
* @return handle to cancel the test
*/
struct GNUNET_CLIENT_TestHandle *
GNUNET_CLIENT_service_test (const char *service,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
- GNUNET_CLIENT_TestResultCallback cb, void *cb_cls)
+ GNUNET_CLIENT_TestResultCallback cb,
+ void *cb_cls)
{
struct GNUNET_CLIENT_TestHandle *th;
char *hostname;
th->cb = cb;
th->cb_cls = cb_cls;
th->test_deadline = GNUNET_TIME_relative_to_absolute (timeout);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"Testing if service `%s' is running.\n",
service);
#ifdef AF_UNIX
/* probe UNIX support */
struct sockaddr_un s_un;
char *unixpath;
+ int abstract;
unixpath = NULL;
- if ((GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_filename (cfg, service, "UNIXPATH", &unixpath)) &&
+ if ((GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_filename (cfg,
+ service,
+ "UNIXPATH",
+ &unixpath)) &&
(0 < strlen (unixpath))) /* We have a non-NULL unixpath, does that mean it's valid? */
{
if (strlen (unixpath) >= sizeof (s_un.sun_path))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
- _("UNIXPATH `%s' too long, maximum length is %llu\n"), unixpath,
+ _("UNIXPATH `%s' too long, maximum length is %llu\n"),
+ unixpath,
(unsigned long long) sizeof (s_un.sun_path));
unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
LOG (GNUNET_ERROR_TYPE_INFO,
_("Using `%s' instead\n"), unixpath);
}
}
+#ifdef LINUX
+ abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
+ "TESTING",
+ "USE_ABSTRACT_SOCKETS");
+#else
+ abstract = GNUNET_NO;
+#endif
+ if ((NULL != unixpath) && (GNUNET_YES != abstract))
+ {
+ if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (unixpath))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+ "mkdir", unixpath);
+ }
if (NULL != unixpath)
{
sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0);
memset (&s_un, 0, sizeof (s_un));
s_un.sun_family = AF_UNIX;
strncpy (s_un.sun_path, unixpath, sizeof (s_un.sun_path) - 1);
+ if (GNUNET_YES == abstract)
+ s_un.sun_path[0] = '\0';
#if HAVE_SOCKADDR_IN_SIN_LEN
s_un.sun_len = (u_char) sizeof (struct sockaddr_un);
#endif
service_test_report (th, GNUNET_YES);
return th;
}
- (void) GNUNET_NETWORK_socket_close (sock);
+ (void) GNUNET_NETWORK_socket_close (sock);
/* let's try IP */
}
}
* a transmission request. Either pass it on to our
* user or, if possible, retry.
*
- * @param cls our "struct GNUNET_CLIENT_TransmissionHandle"
+ * @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
* This task is run if we should re-try connection to the
* service after a while.
*
- * @param cls our "struct GNUNET_CLIENT_TransmitHandle" of the request
+ * @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,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_CLIENT_TransmitHandle *th = cls;
struct GNUNET_TIME_Relative delay;
-
+
th->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
{
return;
}
th->client->connection =
- do_connect (th->client->service_name, th->client->cfg, th->client->attempts++);
+ do_connect (th->client->service_name,
+ th->client->cfg,
+ th->client->attempts++);
th->client->first_message = GNUNET_YES;
if (NULL == th->client->connection)
{
"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 (GNUNET_SCHEDULER_NO_TASK == th->reconnect_task);
th->reconnect_task =
GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th);
return;
* Connection notifies us about failure or success of a transmission
* request. Either pass it on to our user or, if possible, retry.
*
- * @param cls our "struct GNUNET_CLIENT_TransmissionHandle"
+ * @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)
size_t ret;
struct GNUNET_TIME_Relative delay;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "client_notify is running\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "client_notify is running\n");
th->th = NULL;
client->th = NULL;
if (NULL == buf)
{
GNUNET_CONNECTION_receive_cancel (client->connection);
client->in_receive = GNUNET_NO;
- }
+ }
GNUNET_CONNECTION_destroy (client->connection);
client->connection = NULL;
delay = GNUNET_TIME_relative_min (delay, client->back_off);
MAX_ATTEMPTS - th->attempts_left,
GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
client->th = th;
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == th->reconnect_task);
th->reconnect_task =
GNUNET_SCHEDULER_add_delayed (delay, &client_delayed_retry, th);
return 0;
GNUNET_assert (size >= th->size);
ret = th->notify (th->notify_cls, size, buf);
GNUNET_free (th);
+ if (sizeof (struct GNUNET_MessageHeader) <= ret)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmitting message of type %u and size %u to %s service.\n",
+ ntohs (((struct GNUNET_MessageHeader *) buf)->type),
+ ntohs (((struct GNUNET_MessageHeader *) buf)->size),
+ client->service_name);
+ }
return ret;
}
* if the caller does not care about temporary connection errors,
* for example because the protocol is stateless
* @param notify function to call
- * @param notify_cls closure for notify
+ * @param notify_cls closure for @a notify
* @return NULL if our buffer will never hold size bytes,
* a handle if the notify callback was queued (can be used to cancel)
*/
size_t size,
struct GNUNET_TIME_Relative timeout,
int auto_retry,
- GNUNET_CONNECTION_TransmitReadyNotify
- notify, void *notify_cls)
+ GNUNET_CONNECTION_TransmitReadyNotify notify,
+ void *notify_cls)
{
struct GNUNET_CLIENT_TransmitHandle *th;
GNUNET_break (0);
return NULL;
}
- th = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_TransmitHandle));
+ th = GNUNET_new (struct GNUNET_CLIENT_TransmitHandle);
th->client = client;
th->size = size;
th->timeout = GNUNET_TIME_relative_to_absolute (timeout);
client->th = th;
if (NULL == client->connection)
{
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == th->reconnect_task);
th->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (client->back_off, &client_delayed_retry,
+ GNUNET_SCHEDULER_add_delayed (client->back_off,
+ &client_delayed_retry,
th);
}
* @param th handle from the original request.
*/
void
-GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle
- *th)
+GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle *th)
{
if (GNUNET_SCHEDULER_NO_TASK != th->reconnect_task)
{
/**
* Function called to notify a client about the socket
- * begin ready to queue the message. "buf" will be
- * NULL and "size" zero if the socket was closed for
+ * 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 buf
+ * @param size number of bytes available in @a buf
* @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
*/
static size_t
-transmit_for_response (void *cls, size_t size, void *buf)
+transmit_for_response (void *cls,
+ size_t size,
+ void *buf)
{
struct TransmitGetResponseContext *tc = cls;
uint16_t msize;
* 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 rn
- * @return GNUNET_OK on success, GNUNET_SYSERR if a request
+ * @param rn_cls closure for @a rn
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if a request
* is already pending
*/
int