GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);
if (sock->receive_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sock->sched,
- sock->receive_task);
+ GNUNET_SCHEDULER_cancel (sock->sched, sock->receive_task);
sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
{
if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) &&
(conn->received_pos >=
- ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)->
- size)))
+ ntohs (((const struct GNUNET_MessageHeader *) conn->
+ received_buf)->size)))
conn->msg_complete = GNUNET_YES;
}
/* signal timeout! */
if (NULL != (receive_handler = conn->receiver_handler))
{
- receive_handler_cls = conn->receiver_handler_cls;
+ receive_handler_cls = conn->receiver_handler_cls;
conn->receiver_handler = NULL;
receive_handler (receive_handler_cls, NULL);
}
if (GNUNET_YES == sock->msg_complete)
{
sock->receive_task = GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_SCHEDULER_NO_TASK,
- &receive_task, sock);
+ GNUNET_SCHEDULER_NO_TASK,
+ &receive_task, sock);
}
else
{
sock->in_receive = GNUNET_YES;
GNUNET_CONNECTION_receive (sock->sock,
- GNUNET_SERVER_MAX_MESSAGE_SIZE,
- timeout, &receive_helper, sock);
+ GNUNET_SERVER_MAX_MESSAGE_SIZE,
+ timeout, &receive_helper, sock);
}
}
}
#if DEBUG_CLIENT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting `%s' request.\n",
- "TEST");
+ "Transmitting `%s' request.\n", "TEST");
#endif
msg = (struct GNUNET_MessageHeader *) buf;
msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
{
#if DEBUG_CLIENT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmission failed due to shutdown.\n");
+ "Transmission failed due to shutdown.\n");
#endif
th->sock->th = NULL;
th->notify (th->notify_cls, 0, NULL);
- GNUNET_free (th);
+ GNUNET_free (th);
return;
}
th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock,
(0 == --th->attempts_left) || (delay.value < 1))
{
#if DEBUG_CLIENT
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmission failed %u times, giving up.\n",
- MAX_ATTEMPTS - th->attempts_left);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmission failed %u times, giving up.\n",
+ MAX_ATTEMPTS - th->attempts_left);
#endif
GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
GNUNET_free (th);
delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS);
#if DEBUG_CLIENT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmission failed %u times, trying again in %llums.\n",
- MAX_ATTEMPTS - th->attempts_left,
- (unsigned long long) delay.value);
+ "Transmission failed %u times, trying again in %llums.\n",
+ MAX_ATTEMPTS - th->attempts_left,
+ (unsigned long long) delay.value);
#endif
th->reconnect_task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
- delay,
- &client_delayed_retry, th);
+ delay,
+ &client_delayed_retry,
+ th);
th->sock->th = th;
return 0;
}
delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT;
if (h->nth.notify_ready != NULL)
delay = GNUNET_TIME_relative_min (delay,
- GNUNET_TIME_absolute_get_remaining (h->
- nth.
- transmit_timeout));
+ GNUNET_TIME_absolute_get_remaining
+ (h->nth.transmit_timeout));
if (h->receiver != NULL)
delay = GNUNET_TIME_relative_min (delay,
- GNUNET_TIME_absolute_get_remaining (h->
- receive_timeout));
+ GNUNET_TIME_absolute_get_remaining
+ (h->receive_timeout));
ap->task =
- GNUNET_SCHEDULER_add_write_net (h->sched,
- delay, ap->sock,
+ GNUNET_SCHEDULER_add_write_net (h->sched, delay, ap->sock,
&connect_probe_continuation, ap);
}
GNUNET_assert (sock->dns_active == NULL);
sock->dns_active = GNUNET_RESOLVER_ip_get (sock->sched,
- sock->cfg,
- sock->hostname,
- AF_UNSPEC,
- GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
- &try_connect_using_address, sock);
+ sock->cfg,
+ sock->hostname,
+ AF_UNSPEC,
+ GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
+ &try_connect_using_address,
+ sock);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Receive from `%s' encounters error: time out by %llums... (%p)\n",
GNUNET_a2s (sh->addr, sh->addrlen),
- GNUNET_TIME_absolute_get_duration (sh->receive_timeout).
- value, sh);
+ GNUNET_TIME_absolute_get_duration (sh->
+ receive_timeout).value,
+ sh);
#endif
signal_timeout (sh);
return;
GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size);
RETRY:
ret = GNUNET_NETWORK_socket_send (sock->sock,
- &sock->write_buffer[sock->
- write_buffer_pos],
+ &sock->
+ write_buffer[sock->write_buffer_pos],
have);
if (ret == -1)
{
#endif
sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched,
GNUNET_TIME_absolute_get_remaining
- (sock->nth.
- transmit_timeout),
+ (sock->
+ nth.transmit_timeout),
sock->sock,
&transmit_ready,
sock);
struct GNUNET_CONTAINER_heap_node *root_node;
struct GNUNET_CONTAINER_heap_node *last;
- if ( (root == NULL) ||
- (root->size == 0) ||
- (root->root == NULL) )
+ if ((root == NULL) || (root->size == 0) || (root->root == NULL))
{
GNUNET_break (0);
return NULL;
ret = root_node->element;
last = getPos (root, root->size);
- if ( (root_node == last) && (root->size == 1))
+ if ((root_node == last) && (root->size == 1))
{
/* We are removing the last node in the heap! */
GNUNET_free (last);
root_node->cost = last->cost;
if (root->traversal_pos == last)
- root->traversal_pos = root->root;
+ root->traversal_pos = root->root;
GNUNET_free (last);
root->size--;
percolateDownHeap (root->root, root);
return GNUNET_NO;
}
GNUNET_SCHEDULER_add_with_priority (iter->sched,
- iter->priority,
- &directory_iterator_task, iter);
+ iter->priority,
+ &directory_iterator_task, iter);
return GNUNET_YES;
}
*/ \r
HANDLE h;
\r
-#else /* \r */
+#else /* \r */
/**\r
* File handle on other OSes.\r
*/ \r
int fd;
\r
-#endif /* \r */
+#endif /* \r */
};
\r\r\r\r
/**\r
GNUNET_SERVICE_run (argc,
argv,
"resolver", GNUNET_SERVICE_OPTION_NONE,
- &run, NULL)) ? 0 : 1;
+ &run, NULL)) ? 0 : 1;
while (head != NULL)
{
start = GNUNET_TIME_absolute_get ();
perfHash ();
printf ("Hash perf took %llu ms\n",
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value);
return 0;
}
if (pos->write_set != NULL)
GNUNET_NETWORK_fdset_add (ws, pos->write_set);
if (pos->reason != 0)
- *timeout = GNUNET_TIME_UNIT_ZERO;
+ *timeout = GNUNET_TIME_UNIT_ZERO;
pos = pos->next;
}
}
const struct GNUNET_NETWORK_FDSet *rs,
const struct GNUNET_NETWORK_FDSet *ws)
{
- if (now.value >= task->timeout.value)
+ if (now.value >= task->timeout.value)
task->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
(rs != NULL) && (set_overlaps (rs, task->read_set)))
{
pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
/* we don't move the task into the ready queue yet; check_ready
- will do that later, possibly adding additional
- readyness-factors */
+ will do that later, possibly adding additional
+ readyness-factors */
pos = pos->next;
}
}
GNUNET_assert (sigpipe != NULL);
pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
GNUNET_assert (pr != NULL);
- shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown);
+ shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown);
shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown);
shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown);
- shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown);
+ shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown);
#endif
memset (&sched, 0, sizeof (sched));
sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
GNUNET_SCHEDULER_add_continuation (&sched,
task,
- task_cls,
- GNUNET_SCHEDULER_REASON_STARTUP);
+ task_cls,
+ GNUNET_SCHEDULER_REASON_STARTUP);
last_tr = 0;
busy_wait_warning = 0;
- while ( (sched.pending != NULL) || (sched.ready_count > 0) )
+ while ((sched.pending != NULL) || (sched.ready_count > 0))
{
GNUNET_NETWORK_fdset_zero (rs);
GNUNET_NETWORK_fdset_zero (ws);
}
#ifndef MINGW
if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
- {
- /* consume the signal */
- GNUNET_DISK_file_read (pr, &c, sizeof(c));
- /* mark all active tasks as ready due to shutdown */
- GNUNET_SCHEDULER_shutdown (&sched);
- }
+ {
+ /* consume the signal */
+ GNUNET_DISK_file_read (pr, &c, sizeof (c));
+ /* mark all active tasks as ready due to shutdown */
+ GNUNET_SCHEDULER_shutdown (&sched);
+ }
#endif
if (last_tr == sched.tasks_run)
{
GNUNET_SCHEDULER_TaskIdentifier
GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+ GNUNET_SCHEDULER_Task task, void *task_cls)
{
- return GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
+ return GNUNET_SCHEDULER_add_select (sched,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
prerequisite_task,
GNUNET_TIME_UNIT_ZERO,
NULL, NULL, task, task_cls);
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority prio,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle * sched,
+ enum GNUNET_SCHEDULER_Priority prio,
+ GNUNET_SCHEDULER_Task task,
+ void *task_cls)
{
- return GNUNET_SCHEDULER_add_select (sched,
- prio,
+ return GNUNET_SCHEDULER_add_select (sched,
+ prio,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_ZERO,
NULL, NULL, task, task_cls);
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
struct GNUNET_TIME_Relative delay,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+ GNUNET_SCHEDULER_Task task, void *task_cls)
{
return GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
GNUNET_SCHEDULER_NO_TASK, delay,
NULL, NULL, task, task_cls);
}
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
- struct GNUNET_NETWORK_Handle *rfd,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched,
+ struct GNUNET_TIME_Relative delay,
+ struct GNUNET_NETWORK_Handle * rfd,
+ GNUNET_SCHEDULER_Task task, void *task_cls)
{
struct GNUNET_NETWORK_FDSet *rs;
GNUNET_SCHEDULER_TaskIdentifier ret;
GNUNET_assert (rfd != NULL);
rs = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (rs, rfd);
- ret = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- delay,
- rs, NULL, task, task_cls);
+ ret = GNUNET_SCHEDULER_add_select (sched,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ delay, rs, NULL, task, task_cls);
GNUNET_NETWORK_fdset_destroy (rs);
return ret;
}
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
- struct GNUNET_NETWORK_Handle *wfd,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched,
+ struct GNUNET_TIME_Relative delay,
+ struct GNUNET_NETWORK_Handle * wfd,
+ GNUNET_SCHEDULER_Task task, void *task_cls)
{
struct GNUNET_NETWORK_FDSet *ws;
GNUNET_SCHEDULER_TaskIdentifier ret;
GNUNET_assert (wfd != NULL);
ws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (ws, wfd);
- ret = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
+ ret = GNUNET_SCHEDULER_add_select (sched,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
GNUNET_SCHEDULER_NO_TASK, delay,
NULL, ws, task, task_cls);
GNUNET_NETWORK_fdset_destroy (ws);
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
- const struct GNUNET_DISK_FileHandle *rfd,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched,
+ struct GNUNET_TIME_Relative delay,
+ const struct GNUNET_DISK_FileHandle * rfd,
+ GNUNET_SCHEDULER_Task task, void *task_cls)
{
struct GNUNET_NETWORK_FDSet *rs;
GNUNET_SCHEDULER_TaskIdentifier ret;
rs = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_handle_set (rs, rfd);
ret = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK, delay,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK, delay,
rs, NULL, task, task_cls);
GNUNET_NETWORK_fdset_destroy (rs);
return ret;
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
- const struct GNUNET_DISK_FileHandle *wfd,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched,
+ struct GNUNET_TIME_Relative delay,
+ const struct GNUNET_DISK_FileHandle * wfd,
+ GNUNET_SCHEDULER_Task task, void *task_cls)
{
struct GNUNET_NETWORK_FDSet *ws;
GNUNET_SCHEDULER_TaskIdentifier ret;
GNUNET_assert (wfd != NULL);
ws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_handle_set (ws, wfd);
- ret = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- delay,
- NULL, ws, task, task_cls);
+ ret = GNUNET_SCHEDULER_add_select (sched,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ delay, NULL, ws, task, task_cls);
GNUNET_NETWORK_fdset_destroy (ws);
return ret;
}
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched,
+GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched,
enum GNUNET_SCHEDULER_Priority prio,
GNUNET_SCHEDULER_TaskIdentifier
prerequisite_task,
struct GNUNET_TIME_Relative delay,
const struct GNUNET_NETWORK_FDSet * rs,
- const struct GNUNET_NETWORK_FDSet * ws,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+ const struct GNUNET_NETWORK_FDSet * ws,
+ GNUNET_SCHEDULER_Task task, void *task_cls)
{
struct Task *t;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
{
server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- r, NULL, &process_listen_socket,
- server);
+ GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ r, NULL,
+ &process_listen_socket,
+ server);
GNUNET_NETWORK_fdset_destroy (r);
- return; /* ignore shutdown, someone else will take care of it! */
+ return; /* ignore shutdown, someone else will take care of it! */
}
GNUNET_assert (GNUNET_NETWORK_fdset_isset
- (tc->read_ready, server->listen_socket));
+ (tc->read_ready, server->listen_socket));
sock =
GNUNET_CONNECTION_create_from_accept (tc->sched, server->access,
server->access_cls,
}
/* listen for more! */
server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL,
- r, NULL, &process_listen_socket, server);
+ GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ r, NULL,
+ &process_listen_socket,
+ server);
GNUNET_NETWORK_fdset_destroy (r);
}
{
r = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (r, ret->listen_socket);
- ret->listen_task = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
- GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
- &process_listen_socket, ret);
+ ret->listen_task = GNUNET_SCHEDULER_add_select (sched,
+ GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ r, NULL,
+ &process_listen_socket,
+ ret);
GNUNET_NETWORK_fdset_destroy (r);
}
return ret;
#endif
if (GNUNET_SCHEDULER_NO_TASK != s->listen_task)
{
- GNUNET_SCHEDULER_cancel (s->sched,
- s->listen_task);
+ GNUNET_SCHEDULER_cancel (s->sched, s->listen_task);
s->listen_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_break (GNUNET_OK ==
- GNUNET_NETWORK_socket_close (s->listen_socket));
+ GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s->listen_socket));
s->listen_socket = NULL;
while (s->clients != NULL)
{
{
if (GNUNET_SYSERR ==
(disablev6 = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
- sctx->
- serviceName,
+ sctx->serviceName,
"DISABLEV6")))
return GNUNET_SYSERR;
}
* @param tc unused
*/
static void
-shutdown_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_SERVER_Handle *server = cls;
if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN))
{
/* install a task that will kill the server
- process if the scheduler ever gets a shutdown signal */
+ process if the scheduler ever gets a shutdown signal */
GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &shutdown_task,
- sctx->server);
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &shutdown_task, sctx->server);
}
sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
GNUNET_SERVICE_run (int argc,
char *const *argv,
const char *serviceName,
- enum GNUNET_SERVICE_Options opt,
- GNUNET_SERVICE_Main task,
- void *task_cls)
+ enum GNUNET_SERVICE_Options opt,
+ GNUNET_SERVICE_Main task, void *task_cls)
{
char *cfg_fn;
char *loglev;
#define TESTNUMBER64 100000L
static int
-test_normal_rw(void){
- char *msg;
- int64_t testNum;
- char *readResultString;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- struct GNUNET_CONTAINER_MetaData *metaDataW;
- struct GNUNET_CONTAINER_MetaData *metaDataR;
- metaDataW = GNUNET_CONTAINER_meta_data_create ();
- metaDataR = GNUNET_CONTAINER_meta_data_create ();
- GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, (int64_t)TESTNUMBER64));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR));
- GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_CONTAINER_meta_data_destroy (metaDataW);
- GNUNET_CONTAINER_meta_data_destroy (metaDataR);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
- return 0;
+test_normal_rw (void)
+{
+ char *msg;
+ int64_t testNum;
+ char *readResultString;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ struct GNUNET_CONTAINER_MetaData *metaDataW;
+ struct GNUNET_CONTAINER_MetaData *metaDataR;
+ metaDataW = GNUNET_CONTAINER_meta_data_create ();
+ metaDataR = GNUNET_CONTAINER_meta_data_create ();
+ GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_write_int64 (fileW, (int64_t) TESTNUMBER64));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_read_string (fileR, "Read string error",
+ &readResultString, 200));
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+ &metaDataR));
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_meta_data_test_equal (metaDataR,
+ metaDataW));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_CONTAINER_meta_data_destroy (metaDataW);
+ GNUNET_CONTAINER_meta_data_destroy (metaDataR);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+ return 0;
}
static int
-test_nullstring_rw(){
- char *msg;
- char *readResultString = (char*) "not null";
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
- GNUNET_assert (NULL == readResultString);
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
-
- return 0;
+test_nullstring_rw ()
+{
+ char *msg;
+ char *readResultString = (char *) "not null";
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_read_string (fileR, "Read string error",
+ &readResultString, 200));
+ GNUNET_assert (NULL == readResultString);
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+
+ return 0;
}
static int
-test_emptystring_rw(void){
- char *msg;
- char *readResultString;
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
- return 0;
+test_emptystring_rw (void)
+{
+ char *msg;
+ char *readResultString;
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_BIO_read_string (fileR, "Read string error",
+ &readResultString, 200));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+ return 0;
}
static int
-test_bigstring_rw(void){
- char *msg;
- char *readResultString;
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 1));
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
- return 0;
+test_bigstring_rw (void)
+{
+ char *msg;
+ char *readResultString;
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_string (fileR, "Read string error",
+ &readResultString, 1));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+ return 0;
}
static int
-test_bigmeta_rw(){
- char *msg;
- static char meta[1024 * 1024 * 10];
- memset(meta,'b',sizeof(meta));
- meta[sizeof(meta)-1]='\0';
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
- struct GNUNET_CONTAINER_MetaData *metaDataW;
- struct GNUNET_CONTAINER_MetaData *metaDataR;
- metaDataW = GNUNET_CONTAINER_meta_data_create ();
- metaDataR = GNUNET_CONTAINER_meta_data_create ();
- GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
- GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (metaDataW, EXTRACTOR_COMMENT, meta));
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR));
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
- return 0;
+test_bigmeta_rw ()
+{
+ char *msg;
+ static char meta[1024 * 1024 * 10];
+ memset (meta, 'b', sizeof (meta));
+ meta[sizeof (meta) - 1] = '\0';
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+ struct GNUNET_CONTAINER_MetaData *metaDataW;
+ struct GNUNET_CONTAINER_MetaData *metaDataR;
+ metaDataW = GNUNET_CONTAINER_meta_data_create ();
+ metaDataR = GNUNET_CONTAINER_meta_data_create ();
+ GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONTAINER_meta_data_insert (metaDataW,
+ EXTRACTOR_COMMENT, meta));
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+ &metaDataR));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+ return 0;
}
static int
-test_nullfile_rw(void){
- char *msg;
- int64_t testNum;
- char *readResultString;
- static char fileNameNO[102401];
- char readResult[200];
- memset(fileNameNO,'a',sizeof(fileNameNO));
- fileNameNO[sizeof(fileNameNO)-1] = '\0';
- const char *fileName = "/dev/full";
- const char *fileNameR = "/dev/null";
- struct GNUNET_BIO_WriteHandle *fileW,*fileWNO;
- struct GNUNET_BIO_ReadHandle *fileR,*fileRNO;
- struct GNUNET_CONTAINER_MetaData *metaDataW;
- struct GNUNET_CONTAINER_MetaData *metaDataR;
- metaDataW = GNUNET_CONTAINER_meta_data_create ();
- metaDataR = GNUNET_CONTAINER_meta_data_create ();
- GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
-
- fileWNO = GNUNET_BIO_write_open(fileNameNO);
- GNUNET_assert (NULL == fileWNO);
-
- fileRNO = GNUNET_BIO_read_open (fileNameNO);
- GNUNET_assert (NULL == fileRNO);
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write (fileW, TESTSTRING, 65537));
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_string (fileW, TESTSTRING));
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_meta_data (fileW, metaDataW));
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileNameR);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR));
- GNUNET_BIO_read_close (fileR, &msg);
- return 0;
+test_nullfile_rw (void)
+{
+ char *msg;
+ int64_t testNum;
+ char *readResultString;
+ static char fileNameNO[102401];
+ char readResult[200];
+ memset (fileNameNO, 'a', sizeof (fileNameNO));
+ fileNameNO[sizeof (fileNameNO) - 1] = '\0';
+ const char *fileName = "/dev/full";
+ const char *fileNameR = "/dev/null";
+ struct GNUNET_BIO_WriteHandle *fileW, *fileWNO;
+ struct GNUNET_BIO_ReadHandle *fileR, *fileRNO;
+ struct GNUNET_CONTAINER_MetaData *metaDataW;
+ struct GNUNET_CONTAINER_MetaData *metaDataR;
+ metaDataW = GNUNET_CONTAINER_meta_data_create ();
+ metaDataR = GNUNET_CONTAINER_meta_data_create ();
+ GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+
+ fileWNO = GNUNET_BIO_write_open (fileNameNO);
+ GNUNET_assert (NULL == fileWNO);
+
+ fileRNO = GNUNET_BIO_read_open (fileNameNO);
+ GNUNET_assert (NULL == fileRNO);
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_write (fileW, TESTSTRING, 65537));
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_write_string (fileW, TESTSTRING));
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_write_meta_data (fileW, metaDataW));
+ GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileNameR);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_string (fileR, "Read string error",
+ &readResultString, 200));
+ GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+ &metaDataR));
+ GNUNET_BIO_read_close (fileR, &msg);
+ return 0;
}
static int
-test_fakestring_rw(void){
- char *msg;
- int32_t tmpInt = 2;
- char *readResult;
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string(fileR, "Read string error", &readResult, 200));
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
- return 0;
+test_fakestring_rw (void)
+{
+ char *msg;
+ int32_t tmpInt = 2;
+ char *readResult;
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_string (fileR, "Read string error",
+ &readResult, 200));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+ return 0;
}
static int
-test_fakemeta_rw(void){
- char *msg;
- int32_t tmpInt = 2;
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
- struct GNUNET_CONTAINER_MetaData *metaDataR;
- metaDataR = GNUNET_CONTAINER_meta_data_create ();
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW,tmpInt));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR));
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
- return 0;
+test_fakemeta_rw (void)
+{
+ char *msg;
+ int32_t tmpInt = 2;
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+ struct GNUNET_CONTAINER_MetaData *metaDataR;
+ metaDataR = GNUNET_CONTAINER_meta_data_create ();
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+ &metaDataR));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+ return 0;
}
static int
-test_fakebigmeta_rw(void){
- char *msg;
- int32_t tmpInt = 1024*1024*10;
- struct GNUNET_BIO_WriteHandle *fileW;
- struct GNUNET_BIO_ReadHandle *fileR;
- char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
- struct GNUNET_CONTAINER_MetaData *metaDataR;
- metaDataR = GNUNET_CONTAINER_meta_data_create ();
-
- fileW = GNUNET_BIO_write_open (fileName);
- GNUNET_assert (NULL != fileW);
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
- GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
-
- fileR = GNUNET_BIO_read_open (fileName);
- GNUNET_assert (NULL != fileR);
- GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR));
- GNUNET_BIO_read_close (fileR, &msg);
- GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
- GNUNET_free (fileName);
- return 0;
+test_fakebigmeta_rw (void)
+{
+ char *msg;
+ int32_t tmpInt = 1024 * 1024 * 10;
+ struct GNUNET_BIO_WriteHandle *fileW;
+ struct GNUNET_BIO_ReadHandle *fileR;
+ char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+ struct GNUNET_CONTAINER_MetaData *metaDataR;
+ metaDataR = GNUNET_CONTAINER_meta_data_create ();
+
+ fileW = GNUNET_BIO_write_open (fileName);
+ GNUNET_assert (NULL != fileW);
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+ GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+ fileR = GNUNET_BIO_read_open (fileName);
+ GNUNET_assert (NULL != fileR);
+ GNUNET_assert (GNUNET_SYSERR ==
+ GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+ &metaDataR));
+ GNUNET_BIO_read_close (fileR, &msg);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+ GNUNET_free (fileName);
+ return 0;
}
static int
-check_string_rw(void){
- GNUNET_assert (0 == test_nullstring_rw());
- GNUNET_assert (0 == test_emptystring_rw());
- GNUNET_assert (0 == test_bigstring_rw());
- GNUNET_assert (0 == test_fakestring_rw());
- return 0;
+check_string_rw (void)
+{
+ GNUNET_assert (0 == test_nullstring_rw ());
+ GNUNET_assert (0 == test_emptystring_rw ());
+ GNUNET_assert (0 == test_bigstring_rw ());
+ GNUNET_assert (0 == test_fakestring_rw ());
+ return 0;
}
static int
-check_metadata_rw(void){
- GNUNET_assert (0 == test_fakebigmeta_rw());
- GNUNET_assert (0 == test_fakemeta_rw());
- GNUNET_assert (0 == test_bigmeta_rw());
- return 0;
+check_metadata_rw (void)
+{
+ GNUNET_assert (0 == test_fakebigmeta_rw ());
+ GNUNET_assert (0 == test_fakemeta_rw ());
+ GNUNET_assert (0 == test_bigmeta_rw ());
+ return 0;
}
static int
-check_file_rw(void){
- GNUNET_assert (0 == test_normal_rw());
- GNUNET_assert (0 == test_nullfile_rw());
- return 0;
+check_file_rw (void)
+{
+ GNUNET_assert (0 == test_normal_rw ());
+ GNUNET_assert (0 == test_nullfile_rw ());
+ return 0;
}
int
-main (int argc, char *argv[]){
- GNUNET_assert (0 == check_file_rw());
- GNUNET_assert (0 == check_metadata_rw());
- GNUNET_assert (0 == check_string_rw());
- return 0;
+main (int argc, char *argv[])
+{
+ GNUNET_assert (0 == check_file_rw ());
+ GNUNET_assert (0 == check_metadata_rw ());
+ GNUNET_assert (0 == check_string_rw ());
+ return 0;
} /* end of main */
}
}
printf ("%d RSA sign operations %llu ms\n", ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value);
GNUNET_CRYPTO_rsa_key_free (hostkey);
return ok;
}
GNUNET_assert (2 == *ok);
(*ok) = 3;
/* t3 will go before t4: higher priority */
- GNUNET_SCHEDULER_add_with_priority (tc->sched,
- GNUNET_SCHEDULER_PRIORITY_UI,
- &task3, cls);
+ GNUNET_SCHEDULER_add_with_priority (tc->sched,
+ GNUNET_SCHEDULER_PRIORITY_UI,
+ &task3, cls);
}
static void
GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1));
(*ok) = 8;
GNUNET_SCHEDULER_add_with_priority (tc->sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
- &taskLast, cls);
+ GNUNET_SCHEDULER_PRIORITY_IDLE,
+ &taskLast, cls);
GNUNET_SCHEDULER_shutdown (tc->sched);
}
t2 = GNUNET_SCHEDULER_add_after (tc->sched,
GNUNET_SCHEDULER_NO_TASK, &task2, cls);
/* t4 will go after t2 ('add after') and after t3 (priority) */
- t4 = GNUNET_SCHEDULER_add_after (tc->sched,
- t2, &task4, cls);
+ t4 = GNUNET_SCHEDULER_add_after (tc->sched, t2, &task4, cls);
/* t5 will go last (after p4) */
- GNUNET_SCHEDULER_add_after (tc->sched,
- t4, &task5, cls);
+ GNUNET_SCHEDULER_add_after (tc->sched, t4, &task5, cls);
}
GNUNET_assert (1 == *ok);
*ok = 8;
GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &taskLast, cls);
+ GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
GNUNET_SCHEDULER_shutdown (tc->sched);
}
GNUNET_assert (1 == *ok);
*ok = 8;
GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &taskLast, cls);
+ GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
#ifndef MINGW
GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM));
#else
GNUNET_assert (ok == 5);
ok = 0;
GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_ZERO,
- &clean_up, NULL);
+ GNUNET_TIME_UNIT_ZERO, &clean_up, NULL);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n");
GNUNET_CLIENT_service_shutdown (client);
- if (sctx != NULL)
+ if (sctx != NULL)
GNUNET_SERVICE_stop (sctx);
else
GNUNET_SCHEDULER_shutdown (sched);
GNUNET_SERVICE_run (5,
argv,
"test_service",
- GNUNET_SERVICE_OPTION_NONE,
+ GNUNET_SERVICE_OPTION_NONE,
&runner, &ok));
GNUNET_assert (0 == ok);
return ok;
}
-static void
+static void
ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
GNUNET_SERVICE_run (5,
argv,
"test_service6",
- GNUNET_SERVICE_OPTION_NONE,
+ GNUNET_SERVICE_OPTION_NONE,
&runner6, &ok));
GNUNET_assert (0 == ok);
return ok;
GNUNET_SERVICE_run (6,
argv,
"test_service6",
- GNUNET_SERVICE_OPTION_NONE,
+ GNUNET_SERVICE_OPTION_NONE,
&runner6, &ok));
GNUNET_break (0 == ok);
return ok;
projects / oweals / gnunet.git / commitdiff