if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
{
+#if DEBUG_ARM
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Looks like `%s' is already running.\n",
+ "gnunet-service-arm");
+#endif
/* arm is running! */
if (pos->callback != NULL)
pos->callback (pos->cls, GNUNET_YES);
GNUNET_free (pos);
return;
}
+#if DEBUG_ARM
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Looks like `%s' is not running, will start it.\n",
+ "gnunet-service-arm");
+#endif
/* FIXME: should we check that HOSTNAME for 'arm' is localhost? */
/* start service */
if (GNUNET_OK !=
if (msg == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Error receiving response from ARM service\n"));
+ _("Error receiving response to `%s' request from ARM service\n"),
+ (sc->type == GNUNET_MESSAGE_TYPE_ARM_START)
+ ? "START"
+ : "STOP");
GNUNET_CLIENT_disconnect (sc->h->client);
sc->h->client = GNUNET_CLIENT_connect (sc->h->sched,
"arm",
}
#if DEBUG_ARM
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("ARM requests starting of service `%s'.\n"), service_name);
+ (type == GNUNET_MESSAGE_TYPE_ARM_START)
+ ? _("Requesting start of service `%s'.\n")
+ : _("Requesting termination of service `%s'.\n"),
+ service_name);
#endif
sctx = GNUNET_malloc (sizeof (struct RequestContext) + slen);
sctx->h = h;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Starting service `%s'\n"), service_name);
- if (0 == strcmp ("arm", service_name))
+ if (0 == strcasecmp ("arm", service_name))
{
sctx = GNUNET_malloc (sizeof (struct RequestContext));
sctx->h = h;
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Stopping service `%s'\n"), service_name);
- if (0 == strcmp ("arm", service_name))
+ if (0 == strcasecmp ("arm", service_name))
{
GNUNET_CLIENT_service_shutdown (h->client);
h->client = NULL;
*/
static int in_shutdown;
+/**
+ * Handle to our server instance. Our server is a bit special in that
+ * its service is not immediately stopped once we get a shutdown
+ * request (since we need to continue service until all of our child
+ * processes are dead). This handle is used to shut down the server
+ * (and thus trigger process termination) once all child processes are
+ * also dead. A special option in the ARM configuration modifies the
+ * behaviour of the service implementation to not do the shutdown
+ * immediately.
+ */
+static struct GNUNET_SERVER_Handle *server;
/**
* Background task doing maintenance.
pos = running;
while (NULL != pos)
{
- if ( (pos->pid != 0) &&
- (0 != PLIBC_KILL (pos->pid, SIGTERM)) )
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+ if (pos->pid != 0)
+ {
+#if DEBUG_ARM
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending SIGTERM to `%s'\n",
+ pos->name);
+#endif
+ if (0 != PLIBC_KILL (pos->pid, SIGTERM))
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+ }
pos = pos->next;
}
}
{
if ( (in_shutdown == GNUNET_YES) &&
(running == NULL) )
- return; /* we are done! */
+ {
+#if DEBUG_ARM
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "ARM service terminates.\n");
+#endif
+ GNUNET_SERVER_destroy (server);
+ return; /* we are done! */
+ }
GNUNET_SCHEDULER_add_delayed (tc->sched,
(in_shutdown == GNUNET_YES)
? MAINT_FAST_FREQUENCY
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Service `%s' terminated with status %s/%d, will try to restart it!\n"),
pos->name, statstr, statcode);
+#if DEBUG_ARM
+ else
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Service `%s' terminated with status %s/%d\n",
+ pos->name, statstr, statcode);
+#endif
/* schedule restart */
pos->pid = 0;
prev = pos;
*
* @param cls closure
* @param s scheduler to use
- * @param server the initialized server
+ * @param serv the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
struct GNUNET_SCHEDULER_Handle *s,
- struct GNUNET_SERVER_Handle *server,
+ struct GNUNET_SERVER_Handle *serv,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *defaultservices;
char *pos;
+ GNUNET_assert (serv != NULL);
cfg = c;
sched = s;
+ server = serv;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg,
"ARM",
{
return (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
- argv, "arm", &run, NULL)) ? 0 : 1;
+ argv, "arm",
+ GNUNET_YES,
+ &run, NULL)) ? 0 : 1;
}
/* end of gnunet-service-arm.c */
#!/bin/sh
-exe="./gnunet-arm -c test_arm_api_data.conf"
+exe="valgrind --trace-children=yes ./gnunet-arm -c test_arm_api_data.conf"
out=`mktemp /tmp/test-gnunet-arm-logXXXXXXXX`
#DEBUG="-L DEBUG"
return (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
argv,
- "core", &run, NULL)) ? 0 : 1;
+ "core",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
}
/* end of gnunet-service-core.c */
ret = (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
argv,
- "datastore", &run, NULL)) ? 0 : 1;
+ "datastore",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
return ret;
}
return (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
argv,
- "fs", &run, NULL)) ? 0 : 1;
+ "fs",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
}
/* end of gnunet-service-fs.c */
[PATHS]
SERVICEHOME = /tmp/gnunet-test-fs-search/
-DEFAULTCONFIG = test_fs_download_data.conf
+DEFAULTCONFIG = test_fs_search_data.conf
[gnunetd]
HOSTKEY = $SERVICEHOME/.hostkey
cfg);
+/**
+ * Options for the service (bitmask).
+ */
+enum GNUNET_SERVICE_Options
+ {
+ /**
+ * Use defaults.
+ */
+ GNUNET_SERVICE_OPTION_NONE = 0,
+
+ /**
+ * Do not trigger server shutdown on signals, allow for the user
+ * to terminate the server explicitly when needed.
+ */
+ GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN = 1
+ };
+
+
/**
* Run a standard GNUnet service startup sequence (initialize loggers
* and configuration, parse options).
* @param argc number of command line arguments
* @param argv command line arguments
* @param serviceName our service name
+ * @param opt service options
* @param task main task of the service
* @param task_cls closure for task
* @return GNUNET_SYSERR on error, GNUNET_OK
int GNUNET_SERVICE_run (int argc,
char *const *argv,
const char *serviceName,
+ enum GNUNET_SERVICE_Options opt,
GNUNET_SERVICE_Main task,
void *task_cls);
ret = (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
argv,
- "peerinfo", &run, NULL)) ? 0 : 1;
+ "peerinfo",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
GNUNET_free_non_null (networkIdDirectory);
GNUNET_free_non_null (trustDirectory);
return ret;
return (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
argv,
- "statistics", &run, NULL)) ? 0 : 1;
+ "statistics",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
}
/* end of gnunet-service-statistics.c */
return (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
argv,
- "template", &run, NULL)) ? 0 : 1;
+ "template",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
}
/* end of gnunet-service-template.c */
#include "platform.h"
#include "gnunet_testing_lib.h"
-#define VERBOSE GNUNET_NO
+#define VERBOSE GNUNET_YES
/**
GNUNET_assert (emsg == NULL);
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Daemon terminated, will now exit.\n");
+ "Both daemons terminated, will now exit.\n");
#endif
ok = 0;
}
PORT = 12566
HOSTNAME = localhost
DEFAULTSERVICES = peerinfo transport core
+DEBUG = YES
[statistics]
PORT = 12567
[core]
PORT = 12570
HOSTNAME = localhost
+DEBUG = YES
[testing]
WEAKRANDOM = YES
PORT = 22566
DEFAULTSERVICES = peerinfo transport core
HOSTNAME = localhost
+DEBUG = YES
[statistics]
PORT = 22567
[core]
PORT = 22570
HOSTNAME = localhost
+DEBUG = YES
[testing]
WEAKRANDOM = YES
#include "gnunet_testing_lib.h"
#include "gnunet_transport_service.h"
-#define DEBUG_TESTING GNUNET_NO
+#define DEBUG_TESTING GNUNET_YES
/**
* How long do we wait after starting gnunet-service-arm
* for the core service to be alive?
*/
-#define ARM_START_WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+#define ARM_START_WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
/**
* How many times are we willing to try to wait for "scp" or
d->cb = NULL;
if (server == NULL)
{
+ d->server = NULL;
if (GNUNET_YES == d->dead)
GNUNET_TESTING_daemon_stop (d, d->dead_cb, d->dead_cb_cls);
else if (NULL != cb)
"gnunet-service-arm");
#endif
d->phase = SP_START_CORE;
- GNUNET_CORE_connect (d->sched,
- d->cfg,
- ARM_START_WAIT,
- d,
- &testing_init,
- NULL, NULL, NULL,
- NULL, GNUNET_NO,
- NULL, GNUNET_NO,
- no_handlers);
+ d->server = GNUNET_CORE_connect (d->sched,
+ d->cfg,
+ ARM_START_WAIT,
+ d,
+ &testing_init,
+ NULL, NULL, NULL,
+ NULL, GNUNET_NO,
+ NULL, GNUNET_NO,
+ no_handlers);
break;
case SP_START_CORE:
GNUNET_break (0);
{
/* FIXME: check that topology adds a few more links
in addition to those that were seeded */
- sleep (100);
+ /* For now, sleep so we can have the daemon do some work */
+ sleep (10);
GNUNET_TESTING_daemons_stop (pg);
ok = 0;
}
GNUNET_SERVICE_run (argc,
argv,
"transport",
+ GNUNET_SERVICE_OPTION_NONE,
&run, NULL)) ? 0 : 1;
}
return 0; /* client disconnected */
}
#if DEBUG_CLIENT
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Transmitting TEST request.\n"));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmitting `%s' request.\n",
+ "TEST");
#endif
msg = (struct GNUNET_MessageHeader *) buf;
msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
static size_t client_notify (void *cls, size_t size, void *buf);
-
/**
* This task is run if we should re-try connection to the
* service after a while.
struct GNUNET_CLIENT_TransmitHandle *th = cls;
th->task = GNUNET_SCHEDULER_NO_TASK;
+ if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+ {
+#if DEBUG_CLIENT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmission failed due to shutdown.\n");
+#endif
+ th->notify (th->notify_cls, 0, NULL);
+ GNUNET_free (th);
+ return;
+ }
th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock,
th->size,
GNUNET_TIME_absolute_get_remaining
th->sock->th = NULL;
if (buf == NULL)
{
+ // FIXME: need a way to check if the
+ // reason is SHUTDOWN (not timeout) and
+ // if so NOT retry!
delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
delay.value /= 2;
if ((GNUNET_YES != th->auto_retry) ||
(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);
+#endif
GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
GNUNET_free (th);
return 0;
th->sock->service_name, th->sock->cfg);
GNUNET_assert (NULL != th->sock->sock);
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);
+#endif
th->task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
delay,
&client_delayed_retry, th);
/* no data ready for writing, terminate write loop */
return;
}
+ GNUNET_assert (have <= sock->write_buffer_size);
+ GNUNET_assert (have + sock->write_buffer_pos <= sock->write_buffer_size);
+ GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size);
RETRY:
ret = GNUNET_NETWORK_socket_send (sock->sock,
&sock->write_buffer[sock->
ret = (GNUNET_OK ==
GNUNET_SERVICE_run (argc,
argv,
- "resolver", &run, NULL)) ? 0 : 1;
+ "resolver", GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
while (head != NULL)
{
timeout = GNUNET_TIME_UNIT_ZERO;
}
ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout);
+ if (ret == GNUNET_SYSERR)
+ {
+ if (errno == EINTR)
+ continue;
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");
+ break;
+ }
#ifndef MINGW
if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
{
_("Looks like we're busy waiting...\n"));
sleep (1); /* mitigate */
}
- if (ret == GNUNET_SYSERR)
- {
- if (errno == EINTR)
- continue;
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");
- break;
- }
check_ready (&sched, rs, ws);
run_ready (&sched);
}
*/
size_t maxbuf;
- /**
- * Pipe used to signal shutdown of the server.
- */
- struct GNUNET_DISK_PipeHandle *shutpipe;
-
/**
* Socket used to listen for new connections. Set to
* "-1" by GNUNET_SERVER_destroy to initiate shutdown.
struct GNUNET_NETWORK_Handle *listen_socket;
/**
- * Set to GNUNET_YES if we are shutting down.
+ * Task scheduled to do the listening.
*/
- int do_shutdown;
+ GNUNET_SCHEDULER_TaskIdentifier listen_task;
/**
* Do we ignore messages of types that we do not
};
-/**
- * Server has been asked to shutdown, free resources.
- */
-static void
-destroy_server (struct GNUNET_SERVER_Handle *server)
-{
- struct GNUNET_SERVER_Client *pos;
- struct HandlerList *hpos;
- struct NotifyList *npos;
-
-#if DEBUG_SERVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server shutting down.\n");
-#endif
- GNUNET_assert (server->listen_socket == NULL);
- if (GNUNET_OK != GNUNET_DISK_pipe_close (server->shutpipe))
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "pipe-close");
- while (server->clients != NULL)
- {
- pos = server->clients;
- server->clients = pos->next;
- pos->server = NULL;
- }
- while (NULL != (hpos = server->handlers))
- {
- server->handlers = hpos->next;
- GNUNET_free (hpos);
- }
- while (NULL != (npos = server->disconnect_notify_list))
- {
- server->disconnect_notify_list = npos->next;
- GNUNET_free (npos);
- }
- GNUNET_free (server);
-}
-
-
/**
* Scheduler says our listen socket is ready.
* Process it!
struct GNUNET_CONNECTION_Handle *sock;
struct GNUNET_SERVER_Client *client;
struct GNUNET_NETWORK_FDSet *r;
- const struct GNUNET_DISK_FileHandle *shutpipe;
- if ((server->do_shutdown) ||
- ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0))
+ server->listen_task = GNUNET_SCHEDULER_NO_TASK;
+ r = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_set (r, server->listen_socket);
+ if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
{
- /* shutdown was initiated */
- GNUNET_assert (server->listen_socket != NULL);
- GNUNET_break (GNUNET_OK ==
- GNUNET_NETWORK_socket_close (server->listen_socket));
- server->listen_socket = NULL;
- if (server->do_shutdown)
- destroy_server (server);
- return;
+ 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_NETWORK_fdset_destroy (r);
+ return; /* ignore shutdown, someone else will take care of it! */
}
- shutpipe = GNUNET_DISK_pipe_handle (server->shutpipe,
- GNUNET_DISK_PIPE_END_READ);
GNUNET_assert (GNUNET_NETWORK_fdset_isset
- (tc->read_ready, server->listen_socket));
- GNUNET_assert (!GNUNET_NETWORK_fdset_handle_isset
- (tc->read_ready, shutpipe));
+ (tc->read_ready, server->listen_socket));
sock =
GNUNET_CONNECTION_create_from_accept (tc->sched, server->access,
server->access_cls,
GNUNET_SERVER_client_drop (client);
}
/* listen for more! */
- r = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_set (r, server->listen_socket);
- GNUNET_NETWORK_fdset_handle_set (r, shutpipe);
- 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);
+ 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_NETWORK_fdset_destroy (r);
}
return NULL;
}
ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Handle));
- if (NULL == (ret->shutpipe = GNUNET_DISK_pipe (GNUNET_NO)))
- {
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (lsock));
- GNUNET_free (ret);
- return NULL;
- }
ret->sched = sched;
ret->maxbuf = maxbuf;
ret->idle_timeout = idle_timeout;
{
r = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_set (r, ret->listen_socket);
- GNUNET_NETWORK_fdset_handle_set (r,
- GNUNET_DISK_pipe_handle (ret->shutpipe,
- GNUNET_DISK_PIPE_END_READ));
- 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;
void
GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s)
{
- static char c;
-
- GNUNET_assert (s->do_shutdown == GNUNET_NO);
- s->do_shutdown = GNUNET_YES;
- if (s->listen_socket == NULL)
- destroy_server (s);
- else
- GNUNET_break (1 ==
- GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
- (s->shutpipe,
- GNUNET_DISK_PIPE_END_WRITE), &c,
- sizeof (c)));
+ struct GNUNET_SERVER_Client *pos;
+ struct HandlerList *hpos;
+ struct NotifyList *npos;
+
+#if DEBUG_SERVER
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Server shutting down.\n");
+#endif
+ if (GNUNET_SCHEDULER_NO_TASK != 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));
+ s->listen_socket = NULL;
+ while (s->clients != NULL)
+ {
+ pos = s->clients;
+ s->clients = pos->next;
+ pos->server = NULL;
+ }
+ while (NULL != (hpos = s->handlers))
+ {
+ s->handlers = hpos->next;
+ GNUNET_free (hpos);
+ }
+ while (NULL != (npos = s->disconnect_notify_list))
+ {
+ s->disconnect_notify_list = npos->next;
+ GNUNET_free (npos);
+ }
+ GNUNET_free (s);
+
}
*/
int allow_shutdown;
+ /**
+ * Our options.
+ */
+ enum GNUNET_SERVICE_Options options;
+
/**
* Length of addr.
*/
sctx->ret = GNUNET_SYSERR;
return;
}
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &shutdown_task,
- sctx->server);
+ 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 */
+ GNUNET_SCHEDULER_add_delayed (tc->sched,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &shutdown_task,
+ sctx->server);
+ }
sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
i = 0;
* @param argc number of command line arguments
* @param argv command line arguments
* @param serviceName our service name
+ * @param opt service options
* @param task main task of the service
* @param task_cls closure for task
* @return GNUNET_SYSERR on error, GNUNET_OK
GNUNET_SERVICE_run (int argc,
char *const *argv,
const char *serviceName,
+ enum GNUNET_SERVICE_Options opt,
GNUNET_SERVICE_Main task,
void *task_cls)
{
loglev = GNUNET_strdup ("WARNING");
cfg_fn = GNUNET_strdup (GNUNET_DEFAULT_DAEMON_CONFIG_FILE);
memset (&sctx, 0, sizeof (sctx));
+ sctx.options = opt;
sctx.ready_confirm_fd = -1;
sctx.ret = GNUNET_OK;
sctx.timeout = GNUNET_TIME_UNIT_FOREVER_REL;
return GNUNET_OK;
}
+
int
main (int argc, char **argv)
{
neighbor6.cost = 30;
GNUNET_CONTAINER_heap_insert (myHeap, &neighbor1, neighbor1.cost);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_insert (myHeap, &neighbor2, neighbor2.cost);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_insert (myHeap, &neighbor3, neighbor3.cost);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_insert (myHeap, &neighbor4, neighbor4.cost);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_insert (myHeap, &neighbor5, neighbor5.cost);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_insert (myHeap, &neighbor6, neighbor6.cost);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_remove_node (myHeap, &neighbor5);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_remove_root (myHeap);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_update_cost (myHeap, &neighbor6, 200);
- GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+ GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
GNUNET_CONTAINER_heap_destroy (myHeap);
return 0;
GNUNET_assert (ok == 7);
ok = 0;
GNUNET_CLIENT_disconnect (client);
- GNUNET_SCHEDULER_shutdown (sched);
+ client = NULL;
+ GNUNET_SERVER_destroy (server);
+ server = NULL;
GNUNET_CONFIGURATION_destroy (cfg);
+ cfg = NULL;
}
}
+static void
+clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ GNUNET_SERVER_destroy (server);
+ server = NULL;
+ GNUNET_CONFIGURATION_destroy (cfg);
+ cfg = NULL;
+}
+
+
/**
* Functions with this signature are called whenever a client
* is disconnected on the network level.
{
GNUNET_assert (ok == 5);
ok = 0;
- GNUNET_SCHEDULER_shutdown (sched);
- GNUNET_CONFIGURATION_destroy (cfg);
+ GNUNET_SCHEDULER_add_delayed (sched,
+ GNUNET_TIME_UNIT_ZERO,
+ &clean_up, NULL);
}
GNUNET_SERVICE_run (5,
argv,
"test_service",
+ GNUNET_SERVICE_OPTION_NONE,
&runner, &ok));
GNUNET_assert (0 == ok);
return ok;
GNUNET_SERVICE_run (5,
argv,
"test_service6",
+ GNUNET_SERVICE_OPTION_NONE,
&runner6, &ok));
GNUNET_assert (0 == ok);
return ok;
GNUNET_SERVICE_run (6,
argv,
"test_service6",
+ GNUNET_SERVICE_OPTION_NONE,
&runner6, &ok));
GNUNET_break (0 == ok);
return ok;
projects / oweals / gnunet.git / commitdiff