*/
struct GNUNET_CONFIGURATION_Handle *cfg;
- /**
- * Scheduler to use.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
};
*/
struct ShutdownContext
{
- /**
- * Scheduler to be used to call continuation
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Connection to the service that is being shutdown.
*/
/**
* Task set up to cancel the shutdown request on timeout.
*/
- GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ GNUNET_SCHEDULER_TaskIdentifier cancel_task;
/**
* Task to call once shutdown complete
};
-
/**
* Handler receiving response to service shutdown requests.
* First call with NULL: service misbehaving, or something.
* @param msg NULL, indicating socket closure.
*/
static void
-service_shutdown_handler (void *cls,
- const struct GNUNET_MessageHeader *msg)
+service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct ShutdownContext *shutdown_ctx = cls;
"Service handle shutdown before ACK!\n");
if (shutdown_ctx->cont != NULL)
shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);
- GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->timeout_task);
+ GNUNET_SCHEDULER_cancel(shutdown_ctx->cancel_task);
GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
GNUNET_free(shutdown_ctx);
}
if (shutdown_ctx->cont != NULL)
shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO);
- GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->timeout_task);
+ GNUNET_SCHEDULER_cancel(shutdown_ctx->cancel_task);
GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
GNUNET_free(shutdown_ctx);
}
if (shutdown_ctx->cont != NULL)
shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES);
- GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->timeout_task);
+ GNUNET_SCHEDULER_cancel(shutdown_ctx->cancel_task);
GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
GNUNET_free(shutdown_ctx);
break;
}
}
-
/**
* Shutting down took too long, cancel receive and return error.
*
* @param cls closure
* @param tc context information (why was this task triggered now)
*/
-static void
-service_shutdown_timeout (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext * tc)
+void service_shutdown_cancel (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext * tc)
{
struct ShutdownContext *shutdown_ctx = cls;
-
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
- _("Timeout during attempt to shutdown service. Hoping it is simply down already.\n"));
+ GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "service_shutdown_cancel called!\n");
shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);
GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
GNUNET_free(shutdown_ctx);
GNUNET_CLIENT_receive (shutdown_ctx->sock,
&service_shutdown_handler, shutdown_ctx,
GNUNET_TIME_UNIT_FOREVER_REL);
- shutdown_ctx->timeout_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched,
- GNUNET_TIME_absolute_get_remaining(shutdown_ctx->timeout),
- &service_shutdown_timeout,
- shutdown_ctx);
+ shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining(shutdown_ctx->timeout),
+ &service_shutdown_cancel,
+ shutdown_ctx);
msg = (struct GNUNET_MessageHeader *) buf;
msg->type = htons (GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN);
msg->size = htons (sizeof (struct GNUNET_MessageHeader));
* be used by the caller after this call
* (calling this function frees "sock" after a while).
*
- * @param sched the scheduler to use for calling shutdown continuation
* @param sock the socket connected to the service
* @param timeout how long to wait before giving up on transmission
* @param cont continuation to call once the service is really down
*
*/
static void
-arm_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_CLIENT_Connection *sock,
+arm_service_shutdown (struct GNUNET_CLIENT_Connection *sock,
struct GNUNET_TIME_Relative timeout,
GNUNET_CLIENT_ShutdownTask cont,
void *cont_cls)
{
struct ShutdownContext *shutdown_ctx;
-
shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext));
- shutdown_ctx->sched = sched;
shutdown_ctx->cont = cont;
shutdown_ctx->cont_cls = cont_cls;
shutdown_ctx->sock = sock;
* @param cfg configuration to use (needed to contact ARM;
* the ARM service may internally use a different
* configuration to determine how to start the service).
- * @param sched scheduler to use
* @param service service that *this* process is implementing/providing, can be NULL
* @return context to use for further ARM operations, NULL on error
*/
struct GNUNET_ARM_Handle *
GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
const char *service)
{
struct GNUNET_ARM_Handle *ret;
ret = GNUNET_malloc (sizeof (struct GNUNET_ARM_Handle));
ret->cfg = GNUNET_CONFIGURATION_dup (cfg);
- ret->sched = sched;
return ret;
}
: "STOP",
(const char*) &sc[1]);
GNUNET_CLIENT_disconnect (sc->h->client, GNUNET_NO);
- sc->h->client = GNUNET_CLIENT_connect (sc->h->sched,
- "arm",
+ sc->h->client = GNUNET_CLIENT_connect ("arm",
sc->h->cfg);
GNUNET_assert (NULL != sc->h->client);
GNUNET_CLIENT_ignore_shutdown (sc->h->client, GNUNET_YES);
struct RequestContext *sctx;
struct GNUNET_CLIENT_Connection *client;
size_t slen;
-
#if DEBUG_ARM
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Asked to start service `%s' within %llu ms\n"), service_name,
sctx->cls = cb_cls;
sctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
memcpy (&sctx[1], service_name, slen);
- GNUNET_CLIENT_service_test (h->sched,
- "arm",
+ GNUNET_CLIENT_service_test ("arm",
h->cfg, timeout, &arm_service_report, sctx);
return;
}
if (h->client == NULL)
{
- client = GNUNET_CLIENT_connect (h->sched, "arm", h->cfg);
+ client = GNUNET_CLIENT_connect ("arm", h->cfg);
if (client == NULL)
{
cb (cb_cls, GNUNET_SYSERR);
(unsigned long long) timeout.rel_value);
if (h->client == NULL)
{
- client = GNUNET_CLIENT_connect (h->sched, "arm", h->cfg);
+ client = GNUNET_CLIENT_connect ("arm", h->cfg);
if (client == NULL)
{
cb (cb_cls, GNUNET_SYSERR);
arm_shutdown_ctx = GNUNET_malloc(sizeof(struct ARM_ShutdownContext));
arm_shutdown_ctx->cb = cb;
arm_shutdown_ctx->cb_cls = cb_cls;
- arm_service_shutdown (h->sched, h->client, timeout, &arm_shutdown_callback, arm_shutdown_ctx);
+ arm_service_shutdown (h->client, timeout, &arm_shutdown_callback, arm_shutdown_ctx);
h->client = NULL;
return;
}
*/
static struct GNUNET_ARM_Handle *h;
-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
break;
}
- GNUNET_SCHEDULER_add_continuation (sched,
- &cps_loop,
+ GNUNET_SCHEDULER_add_continuation (&cps_loop,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
if (quiet != GNUNET_YES)
fprintf(stdout, _("Service `%s' is not running.\n"), service);
}
- GNUNET_SCHEDULER_add_continuation (sched,
- &cps_loop,
+ GNUNET_SCHEDULER_add_continuation (&cps_loop,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
- sched = s;
cfg = c;
config_file = cfgfile;
if (GNUNET_CONFIGURATION_get_value_string(cfg, "PATHS", "SERVICEHOME", &dir) != GNUNET_OK)
"PATHS");
return;
}
- h = GNUNET_ARM_connect (cfg, sched, NULL);
+ h = GNUNET_ARM_connect (cfg, NULL);
if (h == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
ret = 1;
return;
}
- GNUNET_SCHEDULER_add_continuation (sched,
- &cps_loop,
+ GNUNET_SCHEDULER_add_continuation (&cps_loop,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
case 4:
if (test != NULL)
{
- GNUNET_CLIENT_service_test (sched, test, cfg, TEST_TIMEOUT, &confirm_task, test);
+ GNUNET_CLIENT_service_test (test, cfg, TEST_TIMEOUT, &confirm_task, test);
return;
}
break;
end = 0;
start = 1;
restart = 0;
- h = GNUNET_ARM_connect (cfg, sched, NULL);
+ h = GNUNET_ARM_connect (cfg, NULL);
if (h == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
ret = 1;
return;
}
- GNUNET_SCHEDULER_add_now(sched, &cps_loop, NULL);
+ GNUNET_SCHEDULER_add_now(&cps_loop, NULL);
return;
}
/* Fall through */
*/
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Command to prepend to each actual command.
*/
{
GNUNET_SERVER_destroy (server);
server = NULL;
- GNUNET_SCHEDULER_cancel (sched, child_death_task);
+ GNUNET_SCHEDULER_cancel (child_death_task);
child_death_task = GNUNET_SCHEDULER_NO_TASK;
}
pos = pos->next;
}
#if DELAY_SHUTDOWN
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &dummy_task, NULL);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &dummy_task, NULL);
#endif
if (running == NULL)
do_shutdown ();
(unsigned long long) lowestRestartDelay.rel_value);
#endif
child_restart_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- lowestRestartDelay,
+ = GNUNET_SCHEDULER_add_delayed (lowestRestartDelay,
&delayed_restart_task,
NULL);
}
if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
{
child_death_task =
- GNUNET_SCHEDULER_add_read_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, pr,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
&maint_child_death, NULL);
return;
}
pos->backoff
= GNUNET_TIME_relative_multiply (pos->backoff, 2);
if (GNUNET_SCHEDULER_NO_TASK != child_restart_task)
- GNUNET_SCHEDULER_cancel (sched, child_restart_task);
+ GNUNET_SCHEDULER_cancel (child_restart_task);
child_restart_task
- = GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&delayed_restart_task,
NULL);
}
else
{
child_death_task =
- GNUNET_SCHEDULER_add_read_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, pr,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
&maint_child_death, NULL);
}
}
GNUNET_TIME_UNIT_FOREVER_REL,
&transmit_shutdown_ack, client);
GNUNET_SERVER_client_persist_ (client);
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
}
* Process arm requests.
*
* @param cls closure
- * @param s scheduler to use
* @param serv the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_SERVER_Handle *serv,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *pos;
cfg = c;
- sched = s;
server = serv;
GNUNET_assert (serv != NULL);
pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
GNUNET_assert (pr != NULL);
GNUNET_SERVER_ignore_shutdown (serv, GNUNET_YES);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
child_death_task =
- GNUNET_SCHEDULER_add_read_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, pr,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
&maint_child_death, NULL);
if (GNUNET_OK !=
}
/* create listening sockets for future services*/
- prepareServices (cfg, sched);
+ prepareServices (cfg);
/* process client requests */
GNUNET_SERVER_add_handlers (server, handlers);
/* manage services */
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&config_change_task, NULL);
}
int stop_listening (const char *serviceName);
void prepareServices (const struct GNUNET_CONFIGURATION_Handle
- *configurationHandle,
- struct GNUNET_SCHEDULER_Handle *sched);
+ *configurationHandle);
#endif
*/
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-/**
- *
- */
-static struct GNUNET_SCHEDULER_Handle *scheduler;
-
/**
*
*/
#endif
if (fc->service_to_client_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (scheduler, fc->service_to_client_task);
+ GNUNET_SCHEDULER_cancel (fc->service_to_client_task);
fc->service_to_client_task = GNUNET_SCHEDULER_NO_TASK;
}
if (fc->armClientSocket != NULL)
#endif
if (fc->client_to_service_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (scheduler,
- fc->client_to_service_task);
+ GNUNET_SCHEDULER_cancel ( fc->client_to_service_task);
fc->client_to_service_task = GNUNET_SCHEDULER_NO_TASK;
}
if (fc->armClientSocket != NULL)
"Closing forwarding connection (done with both directions)\n");
#endif
if (fc->start_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (scheduler,
- fc->start_task);
+ GNUNET_SCHEDULER_cancel ( fc->start_task);
if ( (NULL != fc->armClientSocket) &&
(GNUNET_SYSERR ==
GNUNET_NETWORK_socket_close (fc->armClientSocket)) )
fc->armClientSocket))
{
fc->service_to_client_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&forwardToClient, fc);
fc->service_to_client_bufferPos += numberOfBytesSent;
fc->service_to_client_bufferDataLength -= numberOfBytesSent;
fc->service_to_client_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&forwardToClient,
return;
}
fc->service_to_client_task =
- GNUNET_SCHEDULER_add_read_net (scheduler,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
fc->armServiceSocket,
&receiveFromService,
fc);
fc->armServiceSocket))
{
fc->service_to_client_task =
- GNUNET_SCHEDULER_add_read_net (scheduler,
+ GNUNET_SCHEDULER_add_read_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armServiceSocket,
&receiveFromService, fc);
if ( (fc->client_to_service_bufferDataLength > 0) &&
(fc->client_to_service_task != GNUNET_SCHEDULER_NO_TASK) )
{
- GNUNET_SCHEDULER_cancel (scheduler,
- fc->client_to_service_task);
+ GNUNET_SCHEDULER_cancel (fc->client_to_service_task);
fc->client_to_service_task = GNUNET_SCHEDULER_NO_TASK;
}
fc->back_off = GNUNET_TIME_relative_multiply (fc->back_off, 2);
rem = GNUNET_TIME_absolute_get_remaining (fc->timeout);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == fc->start_task);
fc->start_task
- = GNUNET_SCHEDULER_add_delayed (scheduler,
+ = GNUNET_SCHEDULER_add_delayed (
GNUNET_TIME_relative_min (fc->back_off,
rem),
&start_forwarding,
fc->service_to_client_bufferDataLength);
#endif
fc->service_to_client_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&forwardToClient, fc);
fc->armServiceSocket))
{
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armServiceSocket,
&forwardToService, fc);
if ( (fc->service_to_client_bufferDataLength == 0) &&
(fc->service_to_client_task != GNUNET_SCHEDULER_NO_TASK) )
{
- GNUNET_SCHEDULER_cancel (scheduler,
- fc->service_to_client_task);
+ GNUNET_SCHEDULER_cancel (fc->service_to_client_task);
fc->service_to_client_task = GNUNET_SCHEDULER_NO_TASK;
}
fc->back_off = GNUNET_TIME_relative_multiply (fc->back_off, 2);
rem = GNUNET_TIME_absolute_get_remaining (fc->timeout);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == fc->start_task);
fc->start_task
- = GNUNET_SCHEDULER_add_delayed (scheduler,
- GNUNET_TIME_relative_min (fc->back_off,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_min (fc->back_off,
rem),
&start_forwarding,
fc);
fc->client_to_service_bufferPos += numberOfBytesSent;
fc->client_to_service_bufferDataLength -= numberOfBytesSent;
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armServiceSocket,
&forwardToService, fc);
return;
}
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_read_net (scheduler,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&receiveFromClient, fc);
}
fc->armClientSocket))
{
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_read_net (scheduler,
+ GNUNET_SCHEDULER_add_read_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&receiveFromClient, fc);
#endif
if (fc->armServiceSocket != NULL)
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armServiceSocket,
&forwardToService, fc);
#endif
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == fc->start_task);
fc->start_task
- = GNUNET_SCHEDULER_add_delayed (scheduler,
- GNUNET_TIME_relative_min (fc->back_off,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_min (fc->back_off,
rem),
&start_forwarding,
fc);
{
if (fc->client_to_service_bufferDataLength == 0)
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_read_net (scheduler,
+ GNUNET_SCHEDULER_add_read_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&receiveFromClient, fc);
else
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armServiceSocket,
&forwardToService, fc);
{
if (fc->service_to_client_bufferDataLength == 0)
fc->service_to_client_task =
- GNUNET_SCHEDULER_add_read_net (scheduler,
+ GNUNET_SCHEDULER_add_read_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armServiceSocket,
&receiveFromService, fc);
else
fc->service_to_client_task =
- GNUNET_SCHEDULER_add_write_net (scheduler,
+ GNUNET_SCHEDULER_add_write_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&forwardToClient, fc);
(strcmp (pos->serviceName, serviceName) != 0) )
continue;
if (pos->acceptTask != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (scheduler, pos->acceptTask);
+ GNUNET_SCHEDULER_cancel (pos->acceptTask);
GNUNET_break (GNUNET_OK ==
GNUNET_NETWORK_socket_close (pos->listeningSocket));
GNUNET_CONTAINER_DLL_remove (serviceListeningInfoList_head,
serviceListeningInfoList_tail,
serviceListeningInfo);
serviceListeningInfo->acceptTask =
- GNUNET_SCHEDULER_add_read_net (scheduler,
+ GNUNET_SCHEDULER_add_read_net (
GNUNET_TIME_UNIT_FOREVER_REL,
serviceListeningInfo->listeningSocket,
&acceptConnection,
fc->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_SERVICE_TIMEOUT);
fc->back_off = GNUNET_TIME_UNIT_MILLISECONDS;
fc->client_to_service_task =
- GNUNET_SCHEDULER_add_read_net (scheduler,
+ GNUNET_SCHEDULER_add_read_net (
GNUNET_TIME_UNIT_FOREVER_REL,
fc->armClientSocket,
&receiveFromClient, fc);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == fc->start_task);
fc->start_task
- = GNUNET_SCHEDULER_add_now (scheduler,
- &start_forwarding,
+ = GNUNET_SCHEDULER_add_now (&start_forwarding,
fc);
}
GNUNET_free (pos->listeningSocket); /* deliberately no closing! */
GNUNET_free (pos->service_addr);
GNUNET_free (pos->serviceName);
- GNUNET_SCHEDULER_cancel (scheduler,
- pos->acceptTask);
+ GNUNET_SCHEDULER_cancel ( pos->acceptTask);
GNUNET_CONTAINER_DLL_remove (serviceListeningInfoList_head,
serviceListeningInfoList_tail,
pos);
serviceListeningInfo->service_addr_len = addr_len;
serviceListeningInfo->listeningSocket = sock;
serviceListeningInfo->acceptTask =
- GNUNET_SCHEDULER_add_read_net (scheduler,
+ GNUNET_SCHEDULER_add_read_net (
GNUNET_TIME_UNIT_FOREVER_REL, sock,
&acceptConnection,
serviceListeningInfo);
* Entry point to the Service Manager
*
* @param configurationHandle configuration to use to get services
- * @param sched scheduler to handle clients and services communications
*/
void
prepareServices (const struct GNUNET_CONFIGURATION_Handle
- *configurationHandle, struct GNUNET_SCHEDULER_Handle *sched)
+ *configurationHandle)
{
char *defaultServicesString;
- scheduler = sched;
cfg = configurationHandle;
/* Split the default services into a list */
if (GNUNET_OK ==
#include "gnunet_strings_lib.h"
#include "gnunet_time_lib.h"
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static size_t
transmit_shutdown_ack (void *cls, size_t size, void *buf)
GNUNET_TIME_UNIT_FOREVER_REL,
&transmit_shutdown_ack, client);
GNUNET_SERVER_client_persist_ (client);
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
sizeof (struct GNUNET_MessageHeader)},
{NULL, NULL, 0, 0}
};
- sched = s;
/* process client requests */
GNUNET_SERVER_ignore_shutdown (server, GNUNET_YES);
GNUNET_SERVER_add_handlers (server, handlers);
#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static const struct GNUNET_CONFIGURATION_Handle *cfg;
static struct GNUNET_ARM_Handle *arm;
#endif
return;
}
- GNUNET_RESOLVER_ip_get (sched,
- cfg,
+ GNUNET_RESOLVER_ip_get (cfg,
"localhost", AF_INET, TIMEOUT, &dns_notify, NULL);
}
static void
task (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
cfg = c;
- sched = s;
- arm = GNUNET_ARM_connect (cfg, sched, NULL);
+ arm = GNUNET_ARM_connect (cfg, NULL);
#if START_ARM
GNUNET_ARM_start_service (arm, "arm", START_TIMEOUT, &arm_notify, NULL);
#else
#define SERVICE_TEST_TIMEOUT GNUNET_TIME_UNIT_FOREVER_REL
#define FIVE_MILLISECONDS GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 5)
-static struct GNUNET_SCHEDULER_Handle *sched;
static const struct GNUNET_CONFIGURATION_Handle *cfg;
static struct GNUNET_ARM_Handle *arm;
static int ok = 1;
*/
struct ShutdownContext
{
- /**
- * Scheduler to be used to call continuation
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Connection to the service that is being shutdown.
*/
"Service handle shutdown before ACK!\n");
if (shutdown_ctx->cont != NULL)
shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);
- GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
+ GNUNET_SCHEDULER_cancel(shutdown_ctx->cancel_task);
GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
GNUNET_free(shutdown_ctx);
}
if (shutdown_ctx->cont != NULL)
shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO);
- GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
+ GNUNET_SCHEDULER_cancel(shutdown_ctx->cancel_task);
GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
GNUNET_free(shutdown_ctx);
}
if (shutdown_ctx->cont != NULL)
shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES);
- GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
+ GNUNET_SCHEDULER_cancel(shutdown_ctx->cancel_task);
GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
GNUNET_free(shutdown_ctx);
break;
GNUNET_CLIENT_receive (shutdown_ctx->sock,
&service_shutdown_handler, shutdown_ctx,
GNUNET_TIME_UNIT_FOREVER_REL);
- shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched,
- GNUNET_TIME_absolute_get_remaining(shutdown_ctx->timeout),
+ shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining(shutdown_ctx->timeout),
&service_shutdown_cancel,
shutdown_ctx);
msg = (struct GNUNET_MessageHeader *) buf;
* be used by the caller after this call
* (calling this function frees "sock" after a while).
*
- * @param sched the scheduler to use for calling shutdown continuation
* @param sock the socket connected to the service
* @param timeout how long to wait before giving up on transmission
* @param cont continuation to call once the service is really down
*
*/
static void
-arm_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_CLIENT_Connection *sock,
+arm_service_shutdown (struct GNUNET_CLIENT_Connection *sock,
struct GNUNET_TIME_Relative timeout,
GNUNET_CLIENT_ShutdownTask cont,
void *cont_cls)
{
struct ShutdownContext *shutdown_ctx;
shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext));
- shutdown_ctx->sched = sched;
shutdown_ctx->cont = cont;
shutdown_ctx->cont_cls = cont_cls;
shutdown_ctx->sock = sock;
{
GNUNET_assert (success == GNUNET_YES);
ok = 1;
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_UNIT_SECONDS,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&kill_task, NULL);
}
trialCount);
}
#endif
- GNUNET_SCHEDULER_add_now (sched, &kill_task, &a);
+ GNUNET_SCHEDULER_add_now (&kill_task, &a);
}
do_test (void *cbData,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_CLIENT_service_test(sched, "do-nothing",
+ GNUNET_CLIENT_service_test("do-nothing",
cfg, TIMEOUT,
&do_nothing_restarted_notify_task, NULL);
}
{
trialCount++;
startedWaitingAt = GNUNET_TIME_absolute_get();
- GNUNET_SCHEDULER_add_delayed (sched,
- waitedFor,
+ GNUNET_SCHEDULER_add_delayed (waitedFor,
&do_test,
NULL);
}
waitedFor.rel_value = 0;
}
/* Connect to the doNothing task */
- doNothingConnection = GNUNET_CLIENT_connect (sched, "do-nothing", cfg);
+ doNothingConnection = GNUNET_CLIENT_connect ("do-nothing", cfg);
#if LOG_BACKOFF
if (NULL == doNothingConnection)
fprintf(killLogFilePtr,
}
/* Use the created connection to kill the doNothingTask */
- arm_service_shutdown(sched,
- doNothingConnection,
+ arm_service_shutdown(doNothingConnection,
TIMEOUT,
&shutdown_cont, NULL);
}
static void
task (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
cfg = c;
- sched = s;
- arm = GNUNET_ARM_connect (cfg, sched, NULL);
+ arm = GNUNET_ARM_connect (cfg,NULL);
#if START_ARM
GNUNET_ARM_start_service (arm, "arm", GNUNET_TIME_UNIT_ZERO, &arm_notify, NULL);
#else
static int ret = 1;
-static struct GNUNET_SCHEDULER_Handle *sched;
static const struct GNUNET_CONFIGURATION_Handle *cfg;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Trying to resolve our own hostname!\n");
/* connect to the resolver service */
- if (NULL == GNUNET_RESOLVER_hostname_resolve (sched,
- cfg, AF_UNSPEC,
+ if (NULL == GNUNET_RESOLVER_hostname_resolve (cfg, AF_UNSPEC,
TIMEOUT,
&hostNameResolveCB,
NULL))
static void
-run(void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
+run(void *cls,
char * const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
cfg = c;
- sched = s;
#if START_ARM
- arm = GNUNET_ARM_connect (cfg, sched, NULL);
+ arm = GNUNET_ARM_connect (cfg, NULL);
GNUNET_ARM_start_service (arm, "arm", START_TIMEOUT, &arm_notify, NULL);
#else
arm_notify (NULL, GNUNET_YES);
struct GNUNET_CORE_Handle
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Configuration we're using.
if (h->client_notifications != NULL)
GNUNET_CLIENT_disconnect (h->client_notifications, GNUNET_NO);
h->currently_down = GNUNET_YES;
- h->client_notifications = GNUNET_CLIENT_connect (h->sched, "core", h->cfg);
+ h->client_notifications = GNUNET_CLIENT_connect ("core", h->cfg);
if (h->client_notifications == NULL)
- h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->sched,
- GNUNET_TIME_UNIT_SECONDS,
+ h->reconnect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&reconnect_task,
h);
else
{
if (th->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(h->sched, th->timeout_task);
+ GNUNET_SCHEDULER_cancel(th->timeout_task);
th->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
timeout_request (th, NULL);
h->startup_timeout =
GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
h->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (h->sched,
- delay, &reconnect_task, h);
+ GNUNET_SCHEDULER_add_delayed (delay, &reconnect_task, h);
return 0;
}
/* timeout on initial connect */
* Connect to the core service. Note that the connection may
* complete (or fail) asynchronously.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param timeout after how long should we give up trying to connect to the core service?
* @param cls closure for the various callbacks that follow (including handlers in the handlers array)
* NULL on error (in this case, init is never called)
*/
struct GNUNET_CORE_Handle *
-GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
void *cls,
GNUNET_CORE_StartupCallback init,
struct GNUNET_CORE_Handle *h;
h = GNUNET_malloc (sizeof (struct GNUNET_CORE_Handle));
- h->sched = sched;
h->cfg = cfg;
h->cls = cls;
h->init = init;
h->inbound_hdr_only = inbound_hdr_only;
h->outbound_hdr_only = outbound_hdr_only;
h->handlers = handlers;
- h->client_notifications = GNUNET_CLIENT_connect (sched, "core", cfg);
+ h->client_notifications = GNUNET_CLIENT_connect ("core", cfg);
if (h->client_notifications == NULL)
{
GNUNET_free (h);
if (handle->solicit_transmit_req != NULL)
GNUNET_CORE_notify_transmit_ready_cancel (handle->solicit_transmit_req);
if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (handle->sched, handle->reconnect_task);
+ GNUNET_SCHEDULER_cancel (handle->reconnect_task);
if (handle->client_notifications != NULL)
GNUNET_CLIENT_disconnect (handle->client_notifications, GNUNET_NO);
GNUNET_break (handle->pending_head == NULL);
th->notify_cls = notify_cls;
th->peer = *target;
th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay);
- th->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->sched,
- maxdelay,
+ th->timeout_task = GNUNET_SCHEDULER_add_delayed (maxdelay,
&timeout_request, th);
th->priority = priority;
th->msize = sizeof (struct SendMessage) + notify_size;
/**
* Cancel the specified transmission-ready notification.
- *
+ *s
* @param th handle that was returned by "notify_transmit_ready".
*/
void
h->pending_tail,
th);
if (th->timeout_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched, th->timeout_task);
+ GNUNET_SCHEDULER_cancel (th->timeout_task);
GNUNET_free (th);
}
/**
* Obtain statistics and/or change preferences for the given peer.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param peer_cb function to call with the peer information
* @param cb_cls closure for peer_cb
* @return GNUNET_OK if iterating, GNUNET_SYSERR on error
*/
int
-GNUNET_CORE_iterate_peers (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_CORE_ConnectEventHandler peer_cb,
void *cb_cls)
{
struct GNUNET_CORE_RequestContext *request_context;
struct GNUNET_CLIENT_Connection *client;
- client = GNUNET_CLIENT_connect (sched, "core", cfg);
+ client = GNUNET_CLIENT_connect ("core", cfg);
if (client == NULL)
return GNUNET_SYSERR;
request_context = GNUNET_malloc (sizeof (struct GNUNET_CORE_RequestContext));
/**
* Obtain statistics and/or change preferences for the given peer.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param peer identifies the peer
* @param timeout after how long should we give up (and call "info" with NULL
* @return NULL on error
*/
struct GNUNET_CORE_InformationRequestContext *
-GNUNET_CORE_peer_change_preference (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_change_preference (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct GNUNET_PeerIdentity *peer,
struct GNUNET_TIME_Relative timeout,
struct GNUNET_BANDWIDTH_Value32NBO bw_out,
struct GNUNET_CLIENT_Connection *client;
int retry;
- client = GNUNET_CLIENT_connect (sched, "core", cfg);
+ client = GNUNET_CLIENT_connect ("core", cfg);
if (client == NULL)
return NULL;
irc = GNUNET_malloc (sizeof (struct GNUNET_CORE_InformationRequestContext));
*/
struct GNUNET_CLIENT_Connection *client;
- /**
- * Scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Function to call once done.
if (buf == NULL)
{
if (prh->cont != NULL)
- GNUNET_SCHEDULER_add_continuation (prh->sched,
- prh->cont,
+ GNUNET_SCHEDULER_add_continuation (prh->cont,
prh->cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
GNUNET_CLIENT_disconnect (prh->client, GNUNET_NO);
memcpy (buf, &msg, sizeof (msg));
if (prh->cont != NULL)
{
- GNUNET_SCHEDULER_add_continuation (prh->sched,
- prh->cont,
+ GNUNET_SCHEDULER_add_continuation (prh->cont,
prh->cont_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
* to our connection attempt within the given time frame, 'cont' will
* be called with the TIMEOUT reason code.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param timeout how long to try to talk to core
* @param peer who should we connect to
* @return NULL on error (cont will not be called), otherwise handle for cancellation
*/
struct GNUNET_CORE_PeerRequestHandle *
-GNUNET_CORE_peer_request_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_request_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
const struct GNUNET_PeerIdentity * peer,
GNUNET_SCHEDULER_Task cont,
struct GNUNET_CORE_PeerRequestHandle *ret;
struct GNUNET_CLIENT_Connection *client;
- client = GNUNET_CLIENT_connect (sched, "core", cfg);
+ client = GNUNET_CLIENT_connect ("core", cfg);
if (client == NULL)
return NULL;
ret = GNUNET_malloc (sizeof (struct GNUNET_CORE_PeerRequestHandle));
ret->client = client;
- ret->sched = sched;
ret->cont = cont;
ret->cont_cls = cont_cls;
ret->peer = *peer;
*/
static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
/**
* Handle to peerinfo service.
n->th = NULL;
}
if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
+ GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+ GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
if (n->quota_update_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->quota_update_task);
+ GNUNET_SCHEDULER_cancel (n->quota_update_task);
if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
+ GNUNET_SCHEDULER_cancel (n->dead_clean_task);
if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+ GNUNET_SCHEDULER_cancel (n->keep_alive_task);
if (n->status == PEER_STATE_KEY_CONFIRMED)
GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), -1, GNUNET_NO);
GNUNET_free_non_null (n->public_key);
retry = GNUNET_TIME_relative_max (GNUNET_TIME_relative_divide (left, 2),
MIN_PING_FREQUENCY);
n->keep_alive_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- retry,
+ = GNUNET_SCHEDULER_add_delayed (retry,
&send_keep_alive,
n);
if (left.rel_value > 0)
{
if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
- n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
- left,
+ GNUNET_SCHEDULER_cancel (n->dead_clean_task);
+ n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (left,
&consider_free_task,
n);
return;
if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
+ GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
}
switch (n->status)
case PEER_STATE_KEY_SENT:
if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
n->retry_set_key_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- n->set_key_retry_frequency,
+ = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
&set_key_retry_task, n);
#if DEBUG_CORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
case PEER_STATE_KEY_RECEIVED:
if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
n->retry_set_key_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- n->set_key_retry_frequency,
+ = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
&set_key_retry_task, n);
#if DEBUG_CORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
#endif
/* no messages selected for sending, try again later... */
n->retry_plaintext_task =
- GNUNET_SCHEDULER_add_delayed (sched,
- retry_time,
+ GNUNET_SCHEDULER_add_delayed (retry_time,
&retry_plaintext_processing, n);
return;
}
GNUNET_assert (n->quota_update_task ==
GNUNET_SCHEDULER_NO_TASK);
n->quota_update_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- QUOTA_UPDATE_FREQUENCY,
+ = GNUNET_SCHEDULER_add_delayed (QUOTA_UPDATE_FREQUENCY,
&neighbour_quota_update,
n);
}
_("TRANSPORT connection to peer `%4s' is up, trying to establish CORE connection\n"),
GNUNET_i2s (&n->peer));
if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,
- n->retry_set_key_task);
- n->retry_set_key_task = GNUNET_SCHEDULER_add_now (sched,
- &set_key_retry_task,
+ GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
+ n->retry_set_key_task = GNUNET_SCHEDULER_add_now (&set_key_retry_task,
n);
return 0;
}
{
if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+ GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_STATISTICS_update (stats,
GNUNET_NO);
if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
n->retry_set_key_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- n->set_key_retry_frequency,
+ = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
&set_key_retry_task, n);
}
return;
if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+ GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
}
if (n->pitr != NULL)
if ( (n->status != PEER_STATE_KEY_CONFIRMED) &&
(GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task) )
n->retry_set_key_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- n->set_key_retry_frequency,
+ = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
&set_key_retry_task, n);
}
#endif
if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+ GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
}
cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
case PEER_STATE_KEY_CONFIRMED:
n->last_activity = GNUNET_TIME_absolute_get ();
if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+ GNUNET_SCHEDULER_cancel (n->keep_alive_task);
n->keep_alive_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
&send_keep_alive,
n);
handle_peer_status_change (n);
}
n->last_activity = GNUNET_TIME_absolute_get ();
if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+ GNUNET_SCHEDULER_cancel (n->keep_alive_task);
n->keep_alive_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
&send_keep_alive,
n);
GNUNET_STATISTICS_set (stats,
n->time_established = now;
}
if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+ GNUNET_SCHEDULER_cancel (n->keep_alive_task);
n->keep_alive_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
&send_keep_alive,
n);
}
-1,
GNUNET_NO);
if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,
- n->dead_clean_task);
+ GNUNET_SCHEDULER_cancel (n->dead_clean_task);
left = GNUNET_TIME_relative_subtract (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT);
n->last_activity = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (),
left);
- n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
+ n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
&consider_free_task,
n);
}
* Initiate core service.
*
* @param cls closure
- * @param s scheduler to use
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
};
char *keyfile;
- sched = s;
cfg = c;
/* parse configuration */
if (
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Core service is lacking key configuration settings. Exiting.\n"));
- GNUNET_SCHEDULER_shutdown (s);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
- peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
+ peerinfo = GNUNET_PEERINFO_connect (cfg);
if (NULL == peerinfo)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
- GNUNET_SCHEDULER_shutdown (s);
+ GNUNET_SCHEDULER_shutdown ();
GNUNET_free (keyfile);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Core service could not access hostkey. Exiting.\n"));
GNUNET_PEERINFO_disconnect (peerinfo);
- GNUNET_SCHEDULER_shutdown (s);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
MAX_NOTIFY_QUEUE);
GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
/* setup transport connection */
- transport = GNUNET_TRANSPORT_connect (sched,
- cfg,
+ transport = GNUNET_TRANSPORT_connect (cfg,
&my_identity,
NULL,
&handle_transport_receive,
&handle_transport_notify_connect,
&handle_transport_notify_disconnect);
GNUNET_assert (NULL != transport);
- stats = GNUNET_STATISTICS_create (sched, "core", cfg);
+ stats = GNUNET_STATISTICS_create ("core", cfg);
GNUNET_STATISTICS_set (stats, gettext_noop ("# discarded CORE_SEND requests"), 0, GNUNET_NO);
GNUNET_STATISTICS_set (stats, gettext_noop ("# discarded lower priority CORE_SEND requests"), 0, GNUNET_NO);
mst = GNUNET_SERVER_mst_create (&deliver_message,
NULL);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&cleaning_task, NULL);
/* process client requests */
GNUNET_SERVER_add_handlers (server, handlers);
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
static int ok;
"Receiving message from `%4s'.\n", GNUNET_i2s (peer));
GNUNET_assert (ok == 5);
OKPP;
- GNUNET_SCHEDULER_cancel (sched, err_task);
- GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+ GNUNET_SCHEDULER_cancel (err_task);
+ GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
return GNUNET_OK;
}
m->type = htons (MTYPE);
m->size = htons (sizeof (struct GNUNET_MessageHeader));
err_task =
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), &terminate_task_error, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), &terminate_task_error, NULL);
return sizeof (struct GNUNET_MessageHeader);
}
GNUNET_assert (ok == 2);
OKPP;
/* connect p2 */
- GNUNET_CORE_connect (sched,
- p2.cfg,
+ GNUNET_CORE_connect (p2.cfg,
TIMEOUT,
&p2,
&init_notify,
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL, p, NULL, NULL, NULL);
+ p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
GNUNET_assert (p->th != NULL);
GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
setup_peer (&p1, "test_core_api_peer1.conf");
setup_peer (&p2, "test_core_api_peer2.conf");
- GNUNET_CORE_connect (sched,
- p1.cfg,
+ GNUNET_CORE_connect (p1.cfg,
TIMEOUT,
&p1,
&init_notify,
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
#if VERBOSE
n, s,
ntohs (message->size),
ntohl (hdr->num));
- GNUNET_SCHEDULER_cancel (sched, err_task);
- err_task = GNUNET_SCHEDULER_add_now (sched, &terminate_task_error, NULL);
+ GNUNET_SCHEDULER_cancel (err_task);
+ err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
return GNUNET_SYSERR;
}
if (ntohl (hdr->num) != n)
n, s,
ntohs (message->size),
ntohl (hdr->num));
- GNUNET_SCHEDULER_cancel (sched, err_task);
- err_task = GNUNET_SCHEDULER_add_now (sched, &terminate_task_error, NULL);
+ GNUNET_SCHEDULER_cancel (err_task);
+ err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
return GNUNET_SYSERR;
}
#if VERBOSE
fprintf (stderr, ".");
if (n == TOTAL_MSGS)
{
- GNUNET_SCHEDULER_cancel (sched, err_task);
- GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+ GNUNET_SCHEDULER_cancel (err_task);
+ GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
}
else
{
break; /* sometimes pack buffer full, sometimes not */
}
while (size - ret >= s);
- GNUNET_SCHEDULER_cancel (sched, err_task);
+ GNUNET_SCHEDULER_cancel (err_task);
err_task =
- GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&terminate_task_error,
NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_assert (ok == 2);
OKPP;
/* connect p2 */
- GNUNET_CORE_connect (sched,
- p2.cfg,
+ GNUNET_CORE_connect (p2.cfg,
TIMEOUT,
&p2,
&init_notify,
"Asking core (1) for transmission to peer `%4s'\n",
GNUNET_i2s (&p2.id));
err_task =
- GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&terminate_task_error,
NULL);
start_time = GNUNET_TIME_absolute_get ();
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL, p, NULL, NULL, NULL);
+ p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
GNUNET_assert (p->th != NULL);
GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
setup_peer (&p1, "test_core_api_peer1.conf");
setup_peer (&p2, "test_core_api_peer2.conf");
- GNUNET_CORE_connect (sched,
- p1.cfg,
+ GNUNET_CORE_connect (p1.cfg,
TIMEOUT,
&p1,
&init_notify,
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
static int ok;
if (cls == &p1)
{
/* connect p2 */
- GNUNET_CORE_connect (sched,
- p2.cfg,
+ GNUNET_CORE_connect (p2.cfg,
TIMEOUT,
&p2,
&init_notify,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
setup_peer (&p1, "test_core_api_peer1.conf");
setup_peer (&p2, "test_core_api_peer2.conf");
- GNUNET_CORE_connect (sched,
- p1.cfg,
+ GNUNET_CORE_connect (p1.cfg,
TIMEOUT,
&p1,
&init_notify,
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
static int measurement_running;
{
GNUNET_break (0);
if (send_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,send_task);
+ GNUNET_SCHEDULER_cancel (send_task);
GNUNET_CORE_disconnect (p1.ch);
p1.ch = NULL;
GNUNET_CORE_disconnect (p2.ch);
return;
if (err_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, err_task);
+ GNUNET_SCHEDULER_cancel (err_task);
if (send_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,send_task);
+ GNUNET_SCHEDULER_cancel (send_task);
GNUNET_STATISTICS_get(p1.stats,"core","# discarded CORE_SEND requests",GNUNET_TIME_UNIT_SECONDS, &next_fin, &check_2, &p1);
GNUNET_STATISTICS_get(p1.stats,"core","# discarded CORE_SEND requests",GNUNET_TIME_UNIT_SECONDS, &next_fin, &check_2, &p2);
(total_bytes_sent/(duration.rel_value / 1000)/1024),current_quota_p1_in/1024);
- GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+ GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
}
static size_t
"Asking core (1) for transmission to peer `%4s'\n",
GNUNET_i2s (&p2.id));
#endif
- err_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&terminate_task_error,
NULL);
- measure_task = GNUNET_SCHEDULER_add_delayed (sched,
- MEASUREMENT_INTERVALL,
+ measure_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
&measurement_end,
NULL);
start_time = GNUNET_TIME_absolute_get ();
break; /* sometimes pack buffer full, sometimes not */
}
while (size - ret >= s);
- GNUNET_SCHEDULER_cancel (sched, err_task);
- err_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ GNUNET_SCHEDULER_cancel (err_task);
+ err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&terminate_task_error,
NULL);
total_bytes += ret;
total_bytes_sent += ret;
if (send_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, send_task);
- send_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 20), &send_tsk, NULL);
+ GNUNET_SCHEDULER_cancel(send_task);
+ send_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 20), &send_tsk, NULL);
return ret;
}
GNUNET_assert (ok == 2);
OKPP;
/* connect p2 */
- GNUNET_CORE_connect (sched,
- p2.cfg,
+ GNUNET_CORE_connect (p2.cfg,
TIMEOUT,
&p2,
&init_notify,
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- p->stats = GNUNET_STATISTICS_create (sched, "core", p->cfg);
+ p->stats = GNUNET_STATISTICS_create ("core", p->cfg);
GNUNET_assert (p->stats != NULL);
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL, p, NULL, NULL, NULL);
+ p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
GNUNET_assert (p->th != NULL);
GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
setup_peer (&p1, "test_core_quota_peer1.conf");
setup_peer (&p2, "test_core_quota_peer2.conf");
- GNUNET_CORE_connect (sched,
- p1.cfg,
+ GNUNET_CORE_connect (p1.cfg,
TIMEOUT,
&p1,
&init_notify,
/**
* Create a data cache.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param section section in the configuration that contains our options
* @return handle to use to access the service
*/
struct GNUNET_DATACACHE_Handle *
-GNUNET_DATACACHE_create (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *section)
{
unsigned int bf_size;
{
ret->filter = GNUNET_CONTAINER_bloomfilter_load (NULL, bf_size, 5); /* approx. 3% false positives at max use */
}
- ret->stats = GNUNET_STATISTICS_create (sched,
- "datacache",
+ ret->stats = GNUNET_STATISTICS_create ("datacache",
cfg);
ret->section = GNUNET_strdup (section);
- ret->env.sched = sched;
ret->env.cfg = cfg;
ret->env.delete_notify = &env_delete_notify;
ret->env.section = ret->section;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
unsigned int i;
ok = 0;
- h = GNUNET_DATACACHE_create (sched,
- cfg,
+ h = GNUNET_DATACACHE_create (cfg,
"perfcache");
if (h == NULL)
struct GNUNET_DATACACHE_PluginEnvironment
{
- /**
- * Scheduler to use.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Configuration to use.
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
unsigned int i;
ok = 0;
- h = GNUNET_DATACACHE_create (sched,
- cfg,
+ h = GNUNET_DATACACHE_create (cfg,
"testcache");
if (h == NULL)
{
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_TIME_Absolute exp;
ok = 0;
- h = GNUNET_DATACACHE_create (sched,
- cfg,
+ h = GNUNET_DATACACHE_create (cfg,
"testcache");
if (h == NULL)
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Current connection to the datastore service.
* Connect to the datastore service.
*
* @param cfg configuration to use
- * @param sched scheduler to use
* @return handle to use to access the service
*/
struct GNUNET_DATASTORE_Handle *
GNUNET_DATASTORE_connect (const struct
GNUNET_CONFIGURATION_Handle
- *cfg,
- struct
- GNUNET_SCHEDULER_Handle
- *sched)
+ *cfg)
{
struct GNUNET_CLIENT_Connection *c;
struct GNUNET_DATASTORE_Handle *h;
- c = GNUNET_CLIENT_connect (sched, "datastore", cfg);
+ c = GNUNET_CLIENT_connect ("datastore", cfg);
if (c == NULL)
return NULL; /* oops */
h = GNUNET_malloc (sizeof(struct GNUNET_DATASTORE_Handle) +
GNUNET_SERVER_MAX_MESSAGE_SIZE - 1);
h->client = c;
h->cfg = cfg;
- h->sched = sched;
- h->stats = GNUNET_STATISTICS_create (sched,
- "datastore-api",
+ h->stats = GNUNET_STATISTICS_create ("datastore-api",
cfg);
return h;
}
}
if (h->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sched,
- h->reconnect_task);
+ GNUNET_SCHEDULER_cancel (h->reconnect_task);
h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
while (NULL != (qe = h->queue_head))
}
if (GNUNET_YES == drop)
{
- h->client = GNUNET_CLIENT_connect (h->sched, "datastore", h->cfg);
+ h->client = GNUNET_CLIENT_connect ("datastore", h->cfg);
if (h->client != NULL)
{
if (NULL !=
response_proc (ret, NULL);
return NULL;
}
- ret->task = GNUNET_SCHEDULER_add_delayed (h->sched,
- timeout,
+ ret->task = GNUNET_SCHEDULER_add_delayed (timeout,
&timeout_queue_entry,
ret);
pos = ret->next;
if (h->retry_time.rel_value > GNUNET_CONSTANTS_SERVICE_TIMEOUT.rel_value)
h->retry_time = GNUNET_CONSTANTS_SERVICE_TIMEOUT;
h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
- h->client = GNUNET_CLIENT_connect (h->sched, "datastore", h->cfg);
+ h->client = GNUNET_CLIENT_connect ("datastore", h->cfg);
if (h->client == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
#endif
GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
h->client = NULL;
- h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->sched,
- h->retry_time,
+ h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->retry_time,
&try_reconnect,
h);
}
#endif
memcpy (buf, &qe[1], msize);
qe->was_transmitted = GNUNET_YES;
- GNUNET_SCHEDULER_cancel (h->sched,
- qe->task);
+ GNUNET_SCHEDULER_cancel (qe->task);
qe->task = GNUNET_SCHEDULER_NO_TASK;
h->in_receive = GNUNET_YES;
GNUNET_CLIENT_receive (h->client,
qe);
if (qe->task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sched,
- qe->task);
+ GNUNET_SCHEDULER_cancel (qe->task);
qe->task = GNUNET_SCHEDULER_NO_TASK;
}
h->queue_size--;
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
/**
* Handle for reporting statistics.
if (key == NULL)
{
expired_kill_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- MAX_EXPIRE_DELAY,
+ = GNUNET_SCHEDULER_add_delayed (MAX_EXPIRE_DELAY,
&delete_expired,
NULL);
return GNUNET_SYSERR;
}
ret = GNUNET_malloc (sizeof(struct DatastorePlugin));
ret->env.cfg = cfg;
- ret->env.sched = sched;
ret->env.duc = &disk_utilization_change_cb;
ret->env.cls = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
}
if (expired_kill_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- expired_kill_task);
+ GNUNET_SCHEDULER_cancel (expired_kill_task);
expired_kill_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_SCHEDULER_add_continuation (sched,
- &unload_task,
+ GNUNET_SCHEDULER_add_continuation (&unload_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
* Process datastore requests.
*
* @param cls closure
- * @param s scheduler to use
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *fn;
unsigned int bf_size;
- sched = s;
cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg,
"DATASTORE");
return;
}
- stats = GNUNET_STATISTICS_create (sched, "datastore", cfg);
+ stats = GNUNET_STATISTICS_create ("datastore", cfg);
GNUNET_STATISTICS_set (stats,
gettext_noop ("# quota"),
quota,
GNUNET_SERVER_disconnect_notify (server, &cleanup_reservations, NULL);
GNUNET_SERVER_add_handlers (server, handlers);
expired_kill_task
- = GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&delete_expired, NULL);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&cleaning_task, NULL);
}
struct CpsRunContext
{
- struct GNUNET_SCHEDULER_Handle *sched;
const struct GNUNET_CONFIGURATION_Handle *cfg;
enum RunPhase phase;
int j;
else
crc->phase = RP_CUT;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
fprintf (stderr, "D");
#endif
GNUNET_assert (GNUNET_OK == success);
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
if (stored_bytes < MAX_SIZE)
{
crc->phase = RP_REPORT;
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return;
}
- GNUNET_SCHEDULER_add_with_priority (crc->sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_HIGH,
&do_delete,
crc);
return;
1000 * stored_ops / (1 + GNUNET_TIME_absolute_get_duration(start_time).rel_value));
crc->phase = RP_PUT;
crc->j = 0;
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
GNUNET_free (crc);
return;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct CpsRunContext *crc;
static GNUNET_HashCode zkey;
- datastore = GNUNET_DATASTORE_connect (cfg, sched);
+ datastore = GNUNET_DATASTORE_connect (cfg);
start_time = GNUNET_TIME_absolute_get ();
crc = GNUNET_malloc(sizeof(struct CpsRunContext));
- crc->sched = sched;
crc->cfg = cfg;
crc->phase = RP_PUT;
if (NULL ==
unsigned int i;
struct GNUNET_TIME_Absolute start;
struct GNUNET_TIME_Absolute end;
- struct GNUNET_SCHEDULER_Handle *sched;
const struct GNUNET_CONFIGURATION_Handle *cfg;
struct GNUNET_DATASTORE_PluginFunctions * api;
const char *msg;
else
crc->phase = RP_PUT;
}
- GNUNET_SCHEDULER_add_after (crc->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&test, crc);
return GNUNET_OK;
}
(unsigned int) PUT_10);
crc->i++;
crc->phase = RP_LP_GET;
- GNUNET_SCHEDULER_add_after (crc->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&test, crc);
break;
case RP_LP_GET:
break;
case RP_DONE:
crc->api->drop (crc->api->cls);
- GNUNET_SCHEDULER_add_with_priority (crc->sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&cleaning_task, crc);
break;
}
* Load the datastore plugin.
*/
static struct GNUNET_DATASTORE_PluginFunctions *
-load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched)
+load_plugin (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static struct GNUNET_DATASTORE_PluginEnvironment env;
struct GNUNET_DATASTORE_PluginFunctions * ret;
return NULL;
}
env.cfg = cfg;
- env.sched = sched;
env.duc = &disk_utilization_change_cb;
env.cls = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
struct GNUNET_DATASTORE_PluginFunctions *api;
struct CpsRunContext *crc;
- api = load_plugin (c, s);
+ api = load_plugin (c);
if (api == NULL)
{
fprintf (stderr,
}
crc = GNUNET_malloc(sizeof(struct CpsRunContext));
crc->api = api;
- crc->sched = s;
crc->cfg = c;
crc->phase = RP_PUT;
- GNUNET_SCHEDULER_add_now (crc->sched,
- &test, crc);
+ GNUNET_SCHEDULER_add_now (&test, crc);
}
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
- /**
- * Scheduler to use.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Function to call on disk utilization change.
if (GNUNET_YES == end_it)
nrc->end_it = GNUNET_YES;
nrc->plugin->next_task_nc = nrc;
- nrc->plugin->next_task = GNUNET_SCHEDULER_add_now (nrc->plugin->env->sched,
- &mysql_next_request_cont,
+ nrc->plugin->next_task = GNUNET_SCHEDULER_add_now (&mysql_next_request_cont,
nrc);
}
iclose (plugin);
if (plugin->next_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (plugin->env->sched,
- plugin->next_task);
+ GNUNET_SCHEDULER_cancel (plugin->next_task);
plugin->next_task = GNUNET_SCHEDULER_NO_TASK;
plugin->next_task_nc->prep (plugin->next_task_nc->prep_cls, NULL);
GNUNET_free (plugin->next_task_nc);
if (GNUNET_YES == end_it)
nrc->end_it = GNUNET_YES;
nrc->plugin->next_task_nc = nrc;
- nrc->plugin->next_task = GNUNET_SCHEDULER_add_now (nrc->plugin->env->sched,
- &postgres_next_request_cont,
+ nrc->plugin->next_task = GNUNET_SCHEDULER_add_now (&postgres_next_request_cont,
nrc);
}
if (plugin->next_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (plugin->env->sched,
- plugin->next_task);
+ GNUNET_SCHEDULER_cancel (plugin->next_task);
plugin->next_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_free (plugin->next_task_nc);
plugin->next_task_nc = NULL;
if (GNUNET_YES == end_it)
nc->end_it = GNUNET_YES;
nc->plugin->next_task_nc = nc;
- nc->plugin->next_task = GNUNET_SCHEDULER_add_now (nc->plugin->env->sched,
- &sqlite_next_request_cont,
+ nc->plugin->next_task = GNUNET_SCHEDULER_add_now (&sqlite_next_request_cont,
nc);
}
if (plugin->next_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (plugin->env->sched,
- plugin->next_task);
+ GNUNET_SCHEDULER_cancel (plugin->next_task);
plugin->next_task = GNUNET_SCHEDULER_NO_TASK;
plugin->next_task_nc->prep (plugin->next_task_nc->prep_cls, NULL);
GNUNET_free (plugin->next_task_nc);
GNUNET_HashCode key;
int i;
int rid;
- struct GNUNET_SCHEDULER_Handle *sched;
const struct GNUNET_CONFIGURATION_Handle *cfg;
void *data;
size_t size;
ok = 42;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"%s\n", msg);
- GNUNET_SCHEDULER_shutdown (crc->sched);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_free_non_null (crc->data);
crc->data = NULL;
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
"%s\n", msg);
GNUNET_assert (0 < success);
crc->rid = success;
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
crc->phase = RP_DEL;
crc->i = ITERATIONS;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return;
{
crc->phase = RP_DO_DEL;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return;
{
crc->phase = RP_RESERVE;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
{
crc->phase = RP_UPDATE;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return;
{
crc->phase = RP_DONE;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return;
GNUNET_free (crc);
return;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
static GNUNET_HashCode zkey;
crc = GNUNET_malloc(sizeof(struct CpsRunContext));
- crc->sched = sched;
crc->cfg = cfg;
crc->phase = RP_PUT;
now = GNUNET_TIME_absolute_get ();
- datastore = GNUNET_DATASTORE_connect (cfg, sched);
+ datastore = GNUNET_DATASTORE_connect (cfg);
if (NULL ==
GNUNET_DATASTORE_put (datastore, 0,
&zkey, 4, "TEST",
GNUNET_HashCode key;
int i;
int found;
- struct GNUNET_SCHEDULER_Handle *sched;
const struct GNUNET_CONFIGURATION_Handle *cfg;
void *data;
enum RunPhase phase;
GNUNET_assert (GNUNET_OK == success);
GNUNET_free_non_null (crc->data);
crc->data = NULL;
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
}
if (0 == crc->i)
crc->phase = RP_DONE;
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return;
GNUNET_assert (key == NULL);
if (0 == --crc->i)
crc->phase = RP_DONE;
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
GNUNET_free (crc);
return;
}
- GNUNET_SCHEDULER_add_continuation (crc->sched,
- &run_continuation,
+ GNUNET_SCHEDULER_add_continuation (&run_continuation,
crc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
static GNUNET_HashCode zkey;
crc = GNUNET_malloc(sizeof(struct CpsRunContext));
- crc->sched = sched;
crc->cfg = cfg;
crc->phase = RP_PUT;
now = GNUNET_TIME_absolute_get ();
- datastore = GNUNET_DATASTORE_connect (cfg, sched);
+ datastore = GNUNET_DATASTORE_connect (cfg);
if (NULL ==
GNUNET_DATASTORE_put (datastore, 0,
&zkey, 4, "TEST",
*/
struct GNUNET_DHT_Handle
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Configuration to use.
{
if (handle->client != NULL)
return GNUNET_OK;
- handle->client = GNUNET_CLIENT_connect (handle->sched, "dht", handle->cfg);
+ handle->client = GNUNET_CLIENT_connect ("dht", handle->cfg);
if (handle->client == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
head);
if (head->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (handle->sched,
- head->timeout_task);
+ GNUNET_SCHEDULER_cancel (head->timeout_task);
head->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (NULL != head->cont)
{
- GNUNET_SCHEDULER_add_continuation (handle->sched,
- head->cont,
+ GNUNET_SCHEDULER_add_continuation (head->cont,
head->cont_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
head->cont = NULL;
/**
* Initialize the connection with the DHT service.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param ht_len size of the internal hash table to use for
* processing multiple GET/FIND requests in parallel
* @return handle to the DHT service, or NULL on error
*/
struct GNUNET_DHT_Handle *
-GNUNET_DHT_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
unsigned int ht_len)
{
struct GNUNET_DHT_Handle *handle;
handle = GNUNET_malloc (sizeof (struct GNUNET_DHT_Handle));
handle->cfg = cfg;
- handle->sched = sched;
handle->uid_gen = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
handle->active_requests = GNUNET_CONTAINER_multihashmap_create (ht_len);
if (GNUNET_NO == try_connect (handle))
pm);
GNUNET_assert (GNUNET_YES == pm->free_on_send);
if (GNUNET_SCHEDULER_NO_TASK != pm->timeout_task)
- GNUNET_SCHEDULER_cancel (handle->sched,
- pm->timeout_task);
+ GNUNET_SCHEDULER_cancel (pm->timeout_task);
if (NULL != pm->cont)
- GNUNET_SCHEDULER_add_continuation (handle->sched,
- pm->cont,
+ GNUNET_SCHEDULER_add_continuation (pm->cont,
pm->cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
pm->in_pending_queue = GNUNET_NO;
{
route_handle = NULL;
pending->free_on_send = GNUNET_YES;
- pending->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->sched,
- timeout,
+ pending->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
&timeout_route_request,
pending);
}
*/
static struct GNUNET_TESTING_PeerGroup *pg;
-/**
- * Global scheduler, used for all GNUNET_SCHEDULER_* functions.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* Global config handle.
while (test_put != NULL)
{
if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_put->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
if (test_put->dht_handle != NULL)
GNUNET_DHT_disconnect(test_put->dht_handle);
test_put = test_put->next;
while (test_get != NULL)
{
if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_get->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
if (test_get->get_handle != NULL)
GNUNET_DHT_get_stop(test_get->get_handle);
if (test_get->dht_handle != NULL)
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Topology iteration (%u/%u) finished (%u connections, %u peers)\n", topo_ctx->current_iteration, topo_ctx->total_iterations, topo_ctx->total_connections, topo_ctx->total_peers);
dhtlog_handle->update_topology(topo_ctx->total_connections);
if (topo_ctx->cont != NULL)
- GNUNET_SCHEDULER_add_now (sched, topo_ctx->cont, topo_ctx->cls);
+ GNUNET_SCHEDULER_add_now (topo_ctx->cont, topo_ctx->cls);
if (topo_ctx->peers_seen != NULL)
GNUNET_CONTAINER_multihashmap_destroy(topo_ctx->peers_seen);
GNUNET_free(topo_ctx);
fprintf(stderr, "Finished getting all peers statistics, iterating!\n");
GNUNET_CONTAINER_multihashmap_iterate(stats_map, &stats_iterate, NULL);
GNUNET_CONTAINER_multihashmap_destroy(stats_map);
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
/**
while (test_put != NULL)
{
if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_put->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
if (test_put->dht_handle != NULL)
GNUNET_DHT_disconnect(test_put->dht_handle);
test_put = test_put->next;
while (test_get != NULL)
{
if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_get->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
if (test_get->get_handle != NULL)
GNUNET_DHT_get_stop(test_get->get_handle);
if (test_get->dht_handle != NULL)
if ((0 == test_find_peer->find_peer_context->total) &&
(GNUNET_TIME_absolute_get_remaining(test_find_peer->find_peer_context->endtime).rel_value > 60))
{
- GNUNET_SCHEDULER_add_now(sched, &count_new_peers, test_find_peer->find_peer_context);
+ GNUNET_SCHEDULER_add_now(&count_new_peers, test_find_peer->find_peer_context);
}
GNUNET_free(test_find_peer);
}
struct TestFindPeer *test_find_peer = cls;
GNUNET_DHT_disconnect(test_find_peer->dht_handle);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_divide(find_peer_delay, 2), &decrement_find_peers, test_find_peer);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_divide(find_peer_delay, 2), &decrement_find_peers, test_find_peer);
}
if (test_find_peer->find_peer_context->outstanding > max_outstanding_find_peers)
{
- GNUNET_SCHEDULER_add_delayed(sched, find_peer_offset, &send_find_peer_request, test_find_peer);
+ GNUNET_SCHEDULER_add_delayed(find_peer_offset, &send_find_peer_request, test_find_peer);
return;
}
test_find_peer->find_peer_context->outstanding++;
if (GNUNET_TIME_absolute_get_remaining(test_find_peer->find_peer_context->endtime).rel_value == 0)
{
- GNUNET_SCHEDULER_add_now(sched, &decrement_find_peers, test_find_peer);
+ GNUNET_SCHEDULER_add_now(&decrement_find_peers, test_find_peer);
return;
}
- test_find_peer->dht_handle = GNUNET_DHT_connect(sched, test_find_peer->daemon->cfg, 1);
+ test_find_peer->dht_handle = GNUNET_DHT_connect(test_find_peer->daemon->cfg, 1);
GNUNET_assert(test_find_peer->dht_handle != NULL);
GNUNET_DHT_find_peers (test_find_peer->dht_handle,
&handle_find_peer_sent, test_find_peer);
{
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Found peer with no connections, will choose some peer(s) at random to connect to!\n");
GNUNET_CONTAINER_heap_iterate (find_peer_context->peer_min_heap, &iterate_min_heap_peers, find_peer_context);
- GNUNET_SCHEDULER_add_now(sched, &schedule_churn_find_peer_requests, find_peer_context);
+ GNUNET_SCHEDULER_add_now(&schedule_churn_find_peer_requests, find_peer_context);
}
else if ((GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0) && (find_peer_context->last_sent != 0))
{
- GNUNET_SCHEDULER_add_now(sched, &schedule_churn_find_peer_requests, find_peer_context);
+ GNUNET_SCHEDULER_add_now(&schedule_churn_find_peer_requests, find_peer_context);
}
else
{
topo_ctx->cls = all_gets;
topo_ctx->timeout = DEFAULT_GET_TIMEOUT;
topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
&end_badly, "from do gets (count_peers_churn_cb)");
- GNUNET_SCHEDULER_add_now(sched, &capture_current_topology, topo_ctx);
+ GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
}
else
{
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
&end_badly, "from do gets (count_peers_churn_cb)");
- GNUNET_SCHEDULER_add_now(sched, &do_get, all_gets);
+ GNUNET_SCHEDULER_add_now(&do_get, all_gets);
}
}
}
test_find_peer->daemon = GNUNET_TESTING_daemon_get_by_id(pg, &peer_count->peer_id);
GNUNET_assert(test_find_peer->daemon != NULL);
test_find_peer->find_peer_context = find_peer_ctx;
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer);
}
if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap == NULL))
if (emsg != NULL)
{
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Ending test, churning of peers failed with error `%s'", emsg);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, (void *)emsg);
+ GNUNET_SCHEDULER_add_now(&end_badly, (void *)emsg);
return;
}
}
}
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Added %d peers to heap, total size %d\n", count_added, GNUNET_CONTAINER_heap_get_size(find_peer_context->peer_min_heap));
- GNUNET_SCHEDULER_add_delayed(sched, DEFAULT_PEER_DISCONNECT_TIMEOUT, &schedule_churn_get_topology, find_peer_context);
+ GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &schedule_churn_get_topology, find_peer_context);
//GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_context);
}
else
calc_timeout = GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout);
calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT);
calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_PEER_DISCONNECT_TIMEOUT);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, calc_timeout,
+ die_task = GNUNET_SCHEDULER_add_delayed (calc_timeout,
&end_badly, "from do gets (churn_complete)");
- GNUNET_SCHEDULER_add_delayed(sched, DEFAULT_PEER_DISCONNECT_TIMEOUT, &capture_current_topology, topo_ctx);
+ GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &capture_current_topology, topo_ctx);
}
else
{
calc_timeout = GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout);
calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_PEER_DISCONNECT_TIMEOUT);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, calc_timeout,
+ die_task = GNUNET_SCHEDULER_add_delayed (calc_timeout,
&end_badly, "from do gets (churn_complete)");
if (dhtlog_handle != NULL)
dhtlog_handle->insert_round(DHT_ROUND_GET, rounds_finished);
- GNUNET_SCHEDULER_add_delayed(sched, DEFAULT_PEER_DISCONNECT_TIMEOUT, &do_get, all_gets);
+ GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &do_get, all_gets);
}
}
}
if ((gets_completed + gets_failed == num_gets) && (outstanding_gets == 0))
{
fprintf(stderr, "Canceling die task (get_stop_finished) %llu gets completed, %llu gets failed\n", gets_completed, gets_failed);
- GNUNET_SCHEDULER_cancel(sched, die_task);
+ GNUNET_SCHEDULER_cancel(die_task);
reset_meter(put_meter);
reset_meter(get_meter);
/**
topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
topo_ctx->cont = &log_dht_statistics;
topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
- GNUNET_SCHEDULER_add_now(sched, &capture_current_topology, topo_ctx);
+ GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
}
else
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
else if (current_churn_round < churns_per_round * (rounds_finished + 1)) /* Do next round of churn */
{
if (dhtlog_handle != NULL)
dhtlog_handle->insert_round(DHT_ROUND_CHURN, rounds_finished);
- GNUNET_SCHEDULER_add_now(sched, &churn_peers, NULL);
+ GNUNET_SCHEDULER_add_now(&churn_peers, NULL);
}
else if (rounds_finished < total_rounds - 1) /* Start a new complete round */
{
if (dhtlog_handle != NULL)
dhtlog_handle->insert_round(DHT_ROUND_GET, rounds_finished);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
&end_badly, "from do gets (next round)");
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_get, all_gets);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_get, all_gets);
}
else
{
if (dhtlog_handle != NULL)
dhtlog_handle->insert_round(DHT_ROUND_NORMAL, rounds_finished);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2)),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2)),
&end_badly, "from do puts");
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_put, all_puts);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_put, all_puts);
}
}
}
GNUNET_DHT_get_stop(test_get->get_handle);
test_get->get_handle = NULL;
test_get->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now (sched, &get_stop_finished, test_get);
+ GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get);
}
/**
#if VERBOSE > 1
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
#endif
- GNUNET_SCHEDULER_cancel(sched, test_get->disconnect_task);
- GNUNET_SCHEDULER_add_continuation(sched, &get_stop_task, test_get, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+ GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
+ GNUNET_SCHEDULER_add_continuation(&get_stop_task, test_get, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
if (num_gets == 0)
{
- GNUNET_SCHEDULER_cancel(sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&finish_testing, NULL);
}
if (test_get == NULL)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer we should issue get request from is down, skipping.\n");
gets_failed++;
- GNUNET_SCHEDULER_add_now (sched, &get_stop_finished, test_get);
- GNUNET_SCHEDULER_add_now (sched, &do_get, test_get->next);
+ GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get);
+ GNUNET_SCHEDULER_add_now (&do_get, test_get->next);
return;
}
/* Check if more gets are outstanding than should be */
if (outstanding_gets > max_outstanding_gets)
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_get, test_get);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_get, test_get);
return;
}
/* Connect to the first peer's DHT */
- test_get->dht_handle = GNUNET_DHT_connect(sched, test_get->daemon->cfg, 10);
+ test_get->dht_handle = GNUNET_DHT_connect(test_get->daemon->cfg, 10);
GNUNET_assert(test_get->dht_handle != NULL);
outstanding_gets++;
test_get->uid,
test_get->daemon->shortname);
#endif
- test_get->disconnect_task = GNUNET_SCHEDULER_add_delayed(sched, get_timeout, &get_stop_task, test_get);
+ test_get->disconnect_task = GNUNET_SCHEDULER_add_delayed(get_timeout, &get_stop_task, test_get);
/* Schedule the next request in the linked list of get requests */
- GNUNET_SCHEDULER_add_now (sched, &do_get, test_get->next);
+ GNUNET_SCHEDULER_add_now (&do_get, test_get->next);
}
/**
if (replicate_same == GNUNET_NO)
test_put->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers));
- GNUNET_SCHEDULER_cancel(sched, test_put->disconnect_task);
- test_put->disconnect_task = GNUNET_SCHEDULER_add_now(sched, &put_disconnect_task, test_put);
+ GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
+ test_put->disconnect_task = GNUNET_SCHEDULER_add_now(&put_disconnect_task, test_put);
if (GNUNET_YES == update_meter(put_meter))
{
GNUNET_assert(outstanding_puts == 0);
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
if (dhtlog_handle != NULL)
{
topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
topo_ctx->cls = all_gets;
topo_ctx->timeout = DEFAULT_GET_TIMEOUT;
topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
&end_badly, "from do gets (put finished)");
- GNUNET_SCHEDULER_add_now(sched, &capture_current_topology, topo_ctx);
+ GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
}
else
{
fprintf(stderr, "Scheduling die task (put finished)\n");
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout),
&end_badly, "from do gets (put finished)");
- GNUNET_SCHEDULER_add_delayed(sched, DEFAULT_GET_TIMEOUT, &do_get, all_gets);
+ GNUNET_SCHEDULER_add_delayed(DEFAULT_GET_TIMEOUT, &do_get, all_gets);
}
return;
}
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer we should issue put request at is down, skipping.\n");
update_meter(put_meter);
- GNUNET_SCHEDULER_add_now (sched, &do_put, test_put->next);
+ GNUNET_SCHEDULER_add_now (&do_put, test_put->next);
return;
}
if (outstanding_puts > max_outstanding_puts)
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_put, test_put);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_put, test_put);
return;
}
test_put->uid,
test_put->daemon->shortname);
#endif
- test_put->dht_handle = GNUNET_DHT_connect(sched, test_put->daemon->cfg, 10);
+ test_put->dht_handle = GNUNET_DHT_connect(test_put->daemon->cfg, 10);
GNUNET_assert(test_put->dht_handle != NULL);
outstanding_puts++;
GNUNET_TIME_UNIT_FOREVER_ABS,
put_delay,
&put_finished, test_put);
- test_put->disconnect_task = GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_get_forever(), &put_disconnect_task, test_put);
+ test_put->disconnect_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_get_forever(), &put_disconnect_task, test_put);
rand = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 2);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, rand), &do_put, test_put->next);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, rand), &do_put, test_put->next);
}
static void
(find_peer_context->current_peers < 2 * connection_estimate(num_peers, DEFAULT_BUCKET_SIZE)) &&
(GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0))
{
- GNUNET_SCHEDULER_add_now(sched, &schedule_find_peer_requests, find_peer_context);
+ GNUNET_SCHEDULER_add_now(&schedule_find_peer_requests, find_peer_context);
}
else
{
}
test_find_peer->find_peer_context = find_peer_ctx;
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer);
}
if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap == NULL))
all_gets = test_get;
}
- /*GNUNET_SCHEDULER_cancel (sched, die_task);*/
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2),
+ /*GNUNET_SCHEDULER_cancel (die_task);*/
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2),
&end_badly, "from do puts");
- GNUNET_SCHEDULER_add_now (sched, &do_put, all_puts);
+ GNUNET_SCHEDULER_add_now (&do_put, all_puts);
}
topo_ctx->total_iterations = max;
topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
//fprintf(stderr, "scheduled topology iteration in %d minutes\n", i);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, i * 3), &capture_current_topology, topo_ctx);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, i * 3), &capture_current_topology, topo_ctx);
}
topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
topo_ctx->cont = &setup_puts_and_gets;
topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 90)), &capture_current_topology, topo_ctx);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 90)), &capture_current_topology, topo_ctx);
}
else
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 90)), &setup_puts_and_gets, NULL);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 90)), &setup_puts_and_gets, NULL);
if (dhtlog_handle != NULL)
dhtlog_handle->insert_round(DHT_ROUND_NORMAL, rounds_finished);
find_peer_context = GNUNET_malloc(sizeof(struct FindPeerContext));
find_peer_context->count_peers_cb = &count_peers_cb;
find_peer_context->endtime = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time));
- GNUNET_SCHEDULER_add_now(sched, &schedule_find_peer_requests, find_peer_context);
+ GNUNET_SCHEDULER_add_now(&schedule_find_peer_requests, find_peer_context);
}
else
{
if (malicious_completed == malicious_getters + malicious_putters + malicious_droppers)
{
- GNUNET_SCHEDULER_cancel(sched, die_task);
+ GNUNET_SCHEDULER_cancel(die_task);
fprintf(stderr, "Finished setting all malicious peers up, calling continuation!\n");
if (dhtlog_handle != NULL)
- GNUNET_SCHEDULER_add_now (sched,
- &continue_puts_and_gets, NULL);
+ GNUNET_SCHEDULER_add_now (&continue_puts_and_gets, NULL);
else
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time),
&continue_puts_and_gets, NULL);
}
malicious_done_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
{
struct MaliciousContext *ctx = cls;
- GNUNET_SCHEDULER_cancel(sched, ctx->disconnect_task);
- GNUNET_SCHEDULER_add_now(sched, &malicious_disconnect_task, ctx);
+ GNUNET_SCHEDULER_cancel(ctx->disconnect_task);
+ GNUNET_SCHEDULER_add_now(&malicious_disconnect_task, ctx);
}
/**
if (outstanding_malicious > DEFAULT_MAX_OUTSTANDING_GETS)
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &set_malicious, ctx);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &set_malicious, ctx);
return;
}
if (ctx->dht_handle == NULL)
{
- ctx->dht_handle = GNUNET_DHT_connect(sched, ctx->daemon->cfg, 1);
+ ctx->dht_handle = GNUNET_DHT_connect(ctx->daemon->cfg, 1);
outstanding_malicious++;
}
{
case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET:
GNUNET_DHT_set_malicious_getter(ctx->dht_handle, malicious_get_frequency);
- GNUNET_SCHEDULER_add_now (sched,
- &malicious_done_task, ctx);
+ GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx);
break;
case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT:
GNUNET_DHT_set_malicious_putter(ctx->dht_handle, malicious_put_frequency);
- GNUNET_SCHEDULER_add_now (sched,
- &malicious_done_task, ctx);
+ GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx);
break;
case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP:
GNUNET_DHT_set_malicious_dropper(ctx->dht_handle);
- GNUNET_SCHEDULER_add_now (sched, &malicious_done_task, ctx);
+ GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx);
break;
default:
break;
}
- ctx->disconnect_task = GNUNET_SCHEDULER_add_delayed(sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ ctx->disconnect_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_FOREVER_REL,
&malicious_disconnect_task, ctx);
}
temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon);
ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET;
- GNUNET_SCHEDULER_add_now (sched, &set_malicious, ctx);
+ GNUNET_SCHEDULER_add_now (&set_malicious, ctx);
}
temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon);
ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT;
- GNUNET_SCHEDULER_add_now (sched, &set_malicious, ctx);
+ GNUNET_SCHEDULER_add_now (&set_malicious, ctx);
}
temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon);
ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP;
- GNUNET_SCHEDULER_add_now (sched, &set_malicious, ctx);
+ GNUNET_SCHEDULER_add_now (&set_malicious, ctx);
}
/**
if (malicious_getters + malicious_putters + malicious_droppers > 0)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Giving malicious set tasks some time before starting testing!\n");
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (malicious_getters + malicious_putters + malicious_droppers) * 2),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (malicious_getters + malicious_putters + malicious_droppers) * 2),
&end_badly, "from set malicious");
}
else /* Otherwise, continue testing */
{
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Scheduling continue_puts_and_gets now!\n");
- GNUNET_SCHEDULER_add_now (sched,
- &continue_puts_and_gets, NULL);
+ GNUNET_SCHEDULER_add_now (&continue_puts_and_gets, NULL);
}
}
dhtlog_handle->insert_topology(expected_connections);
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
- /*die_task = GNUNET_SCHEDULER_add_delayed (sched, DEFAULT_TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ /*die_task = GNUNET_SCHEDULER_add_delayed (DEFAULT_TIMEOUT,
&end_badly, "from setup puts/gets");*/
if ((dhtlog_handle != NULL) && (settle_time > 0))
{
topo_ctx->cont = &setup_malicious_peers;
topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
//topo_ctx->cont = &continue_puts_and_gets;
- GNUNET_SCHEDULER_add_now(sched, &capture_current_topology, topo_ctx);
+ GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
}
else
{
- GNUNET_SCHEDULER_add_now(sched, &setup_malicious_peers, NULL);
- /*GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time),
+ GNUNET_SCHEDULER_add_now(&setup_malicious_peers, NULL);
+ /*GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time),
&continue_puts_and_gets, NULL);*/
}
}
else if (total_connections + failed_connections == expected_connections)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
}
}
"All %d daemons started, now connecting peers!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
expected_connections = UINT_MAX;
if ((pg != NULL) && (peers_left == 0))
if (expected_connections == GNUNET_SYSERR)
{
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
}
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, DEFAULT_CONNECT_TIMEOUT * expected_connections),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, DEFAULT_CONNECT_TIMEOUT * expected_connections),
&end_badly, "from connect topology (timeout)");
ok = 0;
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from create topology (bad return)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");
}
GNUNET_free_non_null(blacklist_transports);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
&end_badly, "from continue startup (timeout)");
}
"All %d hostkeys created, now creating topology!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- DEFAULT_TOPOLOGY_TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (DEFAULT_TOPOLOGY_TIMEOUT,
&end_badly, "from create_topology");
- GNUNET_SCHEDULER_add_now(sched, &create_topology, NULL);
+ GNUNET_SCHEDULER_add_now(&create_topology, NULL);
ok = 0;
}
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char *churn_filename;
int count;
int ret;
- unsigned int line_number;
+ int line_number;
- sched = s;
config = cfg;
rounds_finished = 0;
memset(&trial_info, 0, sizeof(struct GNUNET_DHTLOG_TrialInfo));
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
&end_badly, "didn't generate all hostkeys within allowed startup time!");
if (dhtlog_handle == NULL)
put_meter = create_meter(num_puts, "Puts completed ", GNUNET_YES);
get_meter = create_meter(num_gets, "Gets completed ", GNUNET_YES);
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left,
GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
&hostkey_callback, NULL,
*/
static struct GNUNET_DHT_Handle *dht_handle;
-/**
- * Global handle of the scheduler
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* Global handle of the configuration
GNUNET_DHT_find_peer_stop (find_peer_handle);
find_peer_handle = NULL;
}
- GNUNET_SCHEDULER_add_now (sched, &shutdown_task, NULL);
+ GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
{
struct GNUNET_TIME_Relative timeout;
GNUNET_HashCode key;
- sched = s;
cfg = c;
if (query_key == NULL)
return;
}
- dht_handle = GNUNET_DHT_connect (sched, cfg, 1);
+ dht_handle = GNUNET_DHT_connect (cfg, 1);
if (dht_handle == NULL)
{
NULL);
if (NULL == find_peer_handle)
{
- GNUNET_SCHEDULER_add_now (sched, &shutdown_task, NULL);
+ GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
return;
}
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_absolute_get_remaining
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
(absolute_timeout),
&cleanup_task, NULL);
}
*/
static struct GNUNET_DHT_Handle *dht_handle;
-/**
- * Global handle of the scheduler
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* Global handle of the configuration
GNUNET_DHT_get_stop (get_handle);
get_handle = NULL;
}
- GNUNET_SCHEDULER_add_now (sched, &shutdown_task, NULL);
+ GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
{
struct GNUNET_TIME_Relative timeout;
GNUNET_HashCode key;
- sched = s;
cfg = c;
if (query_key == NULL)
return;
}
- dht_handle = GNUNET_DHT_connect (sched, cfg, 1);
+ dht_handle = GNUNET_DHT_connect (cfg, 1);
if (dht_handle == NULL)
{
if (verbose)
fprintf (stderr, "Issuing GET request for %s!\n", query_key);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_absolute_get_remaining
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
(absolute_timeout), &cleanup_task, NULL);
get_handle = GNUNET_DHT_get_start (dht_handle,
timeout,
*/
static struct GNUNET_DHT_Handle *dht_handle;
-/**
- * Global handle of the scheduler
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* Global handle of the configuration
if (verbose)
fprintf (stderr,
_("PUT request sent!\n"));
- GNUNET_SCHEDULER_add_now (sched, &shutdown_task, NULL);
+ GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
{
struct GNUNET_TIME_Relative timeout;
struct GNUNET_TIME_Absolute expiration;
GNUNET_HashCode key;
- sched = s;
cfg = c;
if ( (query_key == NULL) || (data == NULL) )
return;
}
- dht_handle = GNUNET_DHT_connect (sched, cfg, 1);
+ dht_handle = GNUNET_DHT_connect (cfg, 1);
if (dht_handle == NULL)
{
fprintf (stderr,
*/
struct GNUNET_STATISTICS_Handle *stats;
-/**
- * The main scheduler to use for the DHT service
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* The configuration the DHT service is running with
#endif
GNUNET_CONTAINER_DLL_insert_after(peer->head, peer->tail, peer->tail, pending);
if (peer->send_task == GNUNET_SCHEDULER_NO_TASK)
- peer->send_task = GNUNET_SCHEDULER_add_now(sched, &try_core_send, peer);
+ peer->send_task = GNUNET_SCHEDULER_add_now(&try_core_send, peer);
}
}
#endif
if ((peer->head != NULL) && (peer->send_task == GNUNET_SCHEDULER_NO_TASK))
- peer->send_task = GNUNET_SCHEDULER_add_now(sched, &try_core_send, peer);
+ peer->send_task = GNUNET_SCHEDULER_add_now(&try_core_send, peer);
#if DEBUG_DHT > 1
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "`%s:%s' : transmit_notify (core) called with size %d, available %d, returning %d\n", my_short_id, "dht service", msize, size, off);
#endif
{
struct PeerInfo *peer_info = cls;
peer_info->info_ctx = NULL;
- GNUNET_SCHEDULER_add_delayed(sched, DHT_DEFAULT_PREFERENCE_INTERVAL, &update_core_preference, peer_info);
+ GNUNET_SCHEDULER_add_delayed(DHT_DEFAULT_PREFERENCE_INTERVAL, &update_core_preference, peer_info);
}
static void
matching = 63;
}
preference = 1LL << matching;
- peer->info_ctx = GNUNET_CORE_peer_change_preference (sched, cfg,
+ peer->info_ctx = GNUNET_CORE_peer_change_preference (cfg,
&peer->id,
GNUNET_TIME_relative_get_forever(),
GNUNET_BANDWIDTH_value_init (UINT32_MAX),
if ((GNUNET_CRYPTO_hash_matching_bits(&my_identity.hashPubKey, &peer->hashPubKey) > 0) && (k_buckets[bucket].peers_size <= bucket_size))
{
#if DO_UPDATE_PREFERENCE
- new_peer->preference_task = GNUNET_SCHEDULER_add_now(sched, &update_core_preference, new_peer);
+ new_peer->preference_task = GNUNET_SCHEDULER_add_now(&update_core_preference, new_peer);
#endif
}
remove_peer(peer, bucket); /* First remove the peer from its bucket */
if (peer->send_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, peer->send_task);
+ GNUNET_SCHEDULER_cancel(peer->send_task);
if (peer->th != NULL)
GNUNET_CORE_notify_transmit_ready_cancel(peer->th);
#endif
GNUNET_CONTAINER_DLL_insert_after(peer->head, peer->tail, peer->tail, pending);
if (peer->send_task == GNUNET_SCHEDULER_NO_TASK)
- peer->send_task = GNUNET_SCHEDULER_add_now(sched, &try_core_send, peer);
+ peer->send_task = GNUNET_SCHEDULER_add_now(&try_core_send, peer);
}
#if DO_PING
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s:%s Sending periodic ping to %s\n", my_short_id, "DHT", GNUNET_i2s(&peer->id));
#endif
forward_message(&ping_message, peer, &message_context);
- peer->ping_task = GNUNET_SCHEDULER_add_delayed(sched, DHT_DEFAULT_PING_DELAY, &periodic_ping_task, peer);
+ peer->ping_task = GNUNET_SCHEDULER_add_delayed(DHT_DEFAULT_PING_DELAY, &periodic_ping_task, peer);
}
/**
while (pos != NULL)
{
if ((count < bucket_size) && (pos->ping_task == GNUNET_SCHEDULER_NO_TASK))
- GNUNET_SCHEDULER_add_now(sched, &periodic_ping_task, pos);
+ GNUNET_SCHEDULER_add_now(&periodic_ping_task, pos);
else if ((count >= bucket_size) && (pos->ping_task != GNUNET_SCHEDULER_NO_TASK))
{
- GNUNET_SCHEDULER_cancel(sched, pos->ping_task);
+ GNUNET_SCHEDULER_cancel(pos->ping_task);
pos->ping_task = GNUNET_SCHEDULER_NO_TASK;
}
pos = pos->next;
{
increment_stats(STAT_HELLOS_PROVIDED);
GNUNET_TRANSPORT_offer_hello(transport_handle, hello_msg);
- GNUNET_CORE_peer_request_connect(sched, cfg, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), &new_peer, NULL, NULL);
+ GNUNET_CORE_peer_request_connect(cfg, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), &new_peer, NULL, NULL);
}
}
}
{
increment_stats(STAT_HELLOS_PROVIDED);
GNUNET_TRANSPORT_offer_hello(transport_handle, other_hello);
- GNUNET_CORE_peer_request_connect(sched, cfg, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), &peer_id, NULL, NULL);
+ GNUNET_CORE_peer_request_connect(cfg, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), &peer_id, NULL, NULL);
route_message (find_msg, message_context);
GNUNET_free (other_hello);
return;
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding recent remove task for key `%s`!\n", GNUNET_h2s(&message_context->key));
/* Only add a task if there wasn't one for this key already! */
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30),
&remove_recent_find_peer, recent_hash);
}
else
put_context = GNUNET_malloc(sizeof(struct RepublishContext));
memcpy(&put_context->key, &message_context->key, sizeof(GNUNET_HashCode));
put_context->type = put_type;
- GNUNET_SCHEDULER_add_delayed (sched, dht_republish_frequency, &republish_content, put_context);
+ GNUNET_SCHEDULER_add_delayed (dht_republish_frequency, &republish_content, put_context);
}
}
else
GNUNET_free(record);
}
if (source_info->delete_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, source_info->delete_task);
+ GNUNET_SCHEDULER_cancel(source_info->delete_task);
if (source_info->find_peers_responded != NULL)
GNUNET_CONTAINER_bloomfilter_free(source_info->find_peers_responded);
GNUNET_free(source_info);
source_info = GNUNET_malloc(sizeof(struct DHTRouteSource));
source_info->record = record;
- source_info->delete_task = GNUNET_SCHEDULER_add_delayed(sched, DHT_FORWARD_TIMEOUT, &remove_forward_entry, source_info);
+ source_info->delete_task = GNUNET_SCHEDULER_add_delayed(DHT_FORWARD_TIMEOUT, &remove_forward_entry, source_info);
source_info->find_peers_responded = GNUNET_CONTAINER_bloomfilter_init (NULL, DHT_BLOOM_SIZE, DHT_BLOOM_K);
memcpy(&source_info->source, msg_ctx->peer, sizeof(struct GNUNET_PeerIdentity));
GNUNET_CONTAINER_DLL_insert_after(record->head, record->tail, record->tail, source_info);
recent_req = GNUNET_malloc(sizeof(struct RecentRequest));
recent_req->uid = message_context->unique_id;
memcpy(&recent_req->key, &message_context->key, sizeof(GNUNET_HashCode));
- recent_req->remove_task = GNUNET_SCHEDULER_add_delayed(sched, DEFAULT_RECENT_REMOVAL, &remove_recent, recent_req);
+ recent_req->remove_task = GNUNET_SCHEDULER_add_delayed(DEFAULT_RECENT_REMOVAL, &remove_recent, recent_req);
recent_req->heap_node = GNUNET_CONTAINER_heap_insert(recent.minHeap, recent_req, GNUNET_TIME_absolute_get().abs_value);
recent_req->bloom = GNUNET_CONTAINER_bloomfilter_init (NULL, DHT_BLOOM_SIZE, DHT_BLOOM_K);
GNUNET_CONTAINER_multihashmap_put(recent.hashmap, &unique_hash, recent_req, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
{
recent_req = GNUNET_CONTAINER_heap_peek(recent.minHeap);
GNUNET_assert(recent_req != NULL);
- GNUNET_SCHEDULER_cancel(sched, recent_req->remove_task);
- GNUNET_SCHEDULER_add_now(sched, &remove_recent, recent_req);
+ GNUNET_SCHEDULER_cancel(recent_req->remove_task);
+ GNUNET_SCHEDULER_add_now(&remove_recent, recent_req);
}
for (i = 0; i < forward_count; i++)
if (results == 0) /* Data must have expired */
GNUNET_free(put_context);
else /* Reschedule task for next time period */
- GNUNET_SCHEDULER_add_delayed(sched, dht_republish_frequency, &republish_content, put_context);
+ GNUNET_SCHEDULER_add_delayed(dht_republish_frequency, &republish_content, put_context);
}
GNUNET_CONTAINER_DLL_remove(record->head, record->tail, pos);
GNUNET_CONTAINER_heap_remove_node(forward_list.minHeap, pos->hnode);
if (pos->delete_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, pos->delete_task);
+ GNUNET_SCHEDULER_cancel(pos->delete_task);
if (pos->find_peers_responded != NULL)
GNUNET_CONTAINER_bloomfilter_free(pos->find_peers_responded);
increment_stats(STAT_PUT_START);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s:%s Sending malicious PUT message with hash %s\n", my_short_id, "DHT", GNUNET_h2s(&key));
demultiplex_message(&put_message.header, &message_context);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, malicious_put_frequency), &malicious_put_task, NULL);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, malicious_put_frequency), &malicious_put_task, NULL);
}
increment_stats(STAT_GET_START);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s:%s Sending malicious GET message with hash %s\n", my_short_id, "DHT", GNUNET_h2s(&key));
demultiplex_message (&get_message.header, &message_context);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, malicious_get_frequency), &malicious_get_task, NULL);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, malicious_get_frequency), &malicious_get_task, NULL);
}
/**
if ((newly_found_peers > bucket_size) && (GNUNET_YES == do_find_peer)) /* If we are finding peers already, no need to send out our request right now! */
{
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Have %d newly found peers since last find peer message sent!\n", newly_found_peers);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_MINUTES,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
&send_find_peer_message, NULL);
newly_found_peers = 0;
return;
find_peer_context.start = GNUNET_TIME_absolute_get();
if (GNUNET_YES == do_find_peer)
{
- GNUNET_SCHEDULER_add_delayed (sched,
- next_send_time,
+ GNUNET_SCHEDULER_add_delayed (next_send_time,
&send_find_peer_message, NULL);
}
}
{
case GNUNET_MESSAGE_TYPE_DHT_FIND_PEER:
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending self seeking find peer request!\n");
- GNUNET_SCHEDULER_add_now(sched, &send_find_peer_message, NULL);
+ GNUNET_SCHEDULER_add_now(&send_find_peer_message, NULL);
break;
case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET:
if (ntohs(dht_control_msg->variable) > 0)
if (malicious_get_frequency == 0)
malicious_get_frequency = DEFAULT_MALICIOUS_GET_FREQUENCY;
if (malicious_getter != GNUNET_YES)
- GNUNET_SCHEDULER_add_now(sched, &malicious_get_task, NULL);
+ GNUNET_SCHEDULER_add_now(&malicious_get_task, NULL);
malicious_getter = GNUNET_YES;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"%s:%s Initiating malicious GET behavior, frequency %d\n", my_short_id, "DHT", malicious_get_frequency);
if (malicious_put_frequency == 0)
malicious_put_frequency = DEFAULT_MALICIOUS_PUT_FREQUENCY;
if (malicious_putter != GNUNET_YES)
- GNUNET_SCHEDULER_add_now(sched, &malicious_put_task, NULL);
+ GNUNET_SCHEDULER_add_now(&malicious_put_task, NULL);
malicious_putter = GNUNET_YES;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"%s:%s Initiating malicious PUT behavior, frequency %d\n", my_short_id, "DHT", malicious_put_frequency);
{
if ((pos->client != NULL) && (pos->client->client_handle == client))
{
- GNUNET_SCHEDULER_cancel(sched, pos->delete_task);
+ GNUNET_SCHEDULER_cancel(pos->delete_task);
pos->delete_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now(sched, &remove_forward_entry, pos);
+ GNUNET_SCHEDULER_add_now(&remove_forward_entry, pos);
}
pos = pos->next;
}
"%s: Connection to core FAILED!\n", "dht",
GNUNET_i2s (identity));
#endif
- GNUNET_SCHEDULER_cancel (sched, cleanup_task);
- GNUNET_SCHEDULER_add_now (sched, &shutdown_task, NULL);
+ GNUNET_SCHEDULER_cancel (cleanup_task);
+ GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
return;
}
#if DEBUG_DHT
* Process dht requests.
*
* @param cls closure
- * @param scheduler scheduler to use
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *scheduler,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
unsigned long long temp_config_num;
char *converge_modifier_buf;
- sched = scheduler;
cfg = c;
- datacache = GNUNET_DATACACHE_create (sched, cfg, "dhtcache");
+ datacache = GNUNET_DATACACHE_create (cfg, "dhtcache");
GNUNET_SERVER_add_handlers (server, plugin_handlers);
GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
- coreAPI = GNUNET_CORE_connect (sched, /* Main scheduler */
- cfg, /* Main configuration */
+ coreAPI = GNUNET_CORE_connect (cfg, /* Main configuration */
GNUNET_TIME_UNIT_FOREVER_REL,
NULL, /* Closure passed to DHT functions */
&core_init, /* Call core_init once connected */
if (coreAPI == NULL)
return;
- transport_handle = GNUNET_TRANSPORT_connect(sched, cfg,
+ transport_handle = GNUNET_TRANSPORT_connect(cfg,
NULL, NULL, NULL, NULL, NULL);
if (transport_handle != NULL)
GNUNET_TRANSPORT_get_hello (transport_handle, &process_hello, NULL);
GNUNET_free(converge_modifier_buf);
}
- stats = GNUNET_STATISTICS_create(sched, "dht", cfg);
+ stats = GNUNET_STATISTICS_create("dht", cfg);
if (stats != NULL)
{
GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_STRONG,
(DHT_MAXIMUM_FIND_PEER_INTERVAL.rel_value / 2) - DHT_MINIMUM_FIND_PEER_INTERVAL.rel_value);
find_peer_context.start = GNUNET_TIME_absolute_get();
- GNUNET_SCHEDULER_add_delayed (sched,
- next_send_time,
+ GNUNET_SCHEDULER_add_delayed (next_send_time,
&send_find_peer_message, &find_peer_context);
}
/* Scheduled the task to clean up when shutdown is called */
- cleanup_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ cleanup_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task, NULL);
}
struct RetryContext retry_context;
-static struct GNUNET_SCHEDULER_Handle *sched;
static int ok;
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_DHT_disconnect (p1.dht_handle);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_DHT_get_stop (retry_context.peer_ctx->get_handle);
}
if (retry_context.retry_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, retry_context.retry_task);
+ GNUNET_SCHEDULER_cancel(retry_context.retry_task);
GNUNET_DHT_disconnect (p1.dht_handle);
ok = 1;
}
if (tc->reason == GNUNET_SCHEDULER_REASON_TIMEOUT)
{
GNUNET_break (0);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now (sched, &end_badly, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
GNUNET_DHT_set_malicious_putter (peer->dht_handle, GNUNET_TIME_UNIT_SECONDS);
GNUNET_DHT_set_malicious_dropper (peer->dht_handle);
#endif
- GNUNET_SCHEDULER_add_delayed(sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1),
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1),
&end, &p1);
}
if (retry_ctx->retry_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched, retry_ctx->retry_task);
+ GNUNET_SCHEDULER_cancel(retry_ctx->retry_task);
retry_ctx->retry_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_SCHEDULER_add_continuation (sched, &test_find_peer_stop, &p1,
+ GNUNET_SCHEDULER_add_continuation (&test_find_peer_stop, &p1,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
else
if (retry_ctx->peer_ctx->find_peer_handle == NULL)
{
GNUNET_break (0);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now (sched, &end_badly, &p1);
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now (&end_badly, &p1);
return;
}
- retry_ctx->retry_task = GNUNET_SCHEDULER_add_delayed(sched, retry_ctx->next_timeout, &retry_find_peer_stop, retry_ctx);
+ retry_ctx->retry_task = GNUNET_SCHEDULER_add_delayed(retry_ctx->next_timeout, &retry_find_peer_stop, retry_ctx);
}
/**
GNUNET_DHT_find_peer_stop(retry_ctx->peer_ctx->find_peer_handle);
retry_ctx->peer_ctx->find_peer_handle = NULL;
}
- GNUNET_SCHEDULER_add_now (sched, &retry_find_peer, retry_ctx);
+ GNUNET_SCHEDULER_add_now (&retry_find_peer, retry_ctx);
}
/**
if (peer->find_peer_handle == NULL)
{
GNUNET_break (0);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now (sched, &end_badly, &p1);
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now (&end_badly, &p1);
return;
}
- retry_context.retry_task = GNUNET_SCHEDULER_add_delayed(sched, retry_context.next_timeout, &retry_find_peer_stop, &retry_context);
+ retry_context.retry_task = GNUNET_SCHEDULER_add_delayed(retry_context.next_timeout, &retry_find_peer_stop, &retry_context);
}
/**
if (tc->reason == GNUNET_SCHEDULER_REASON_TIMEOUT)
{
GNUNET_break (0);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now (sched, &end_badly, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
GNUNET_assert (peer->dht_handle != NULL);
GNUNET_DHT_get_stop (peer->get_handle);
- GNUNET_SCHEDULER_add_now(sched,
- &test_find_peer,
+ GNUNET_SCHEDULER_add_now(&test_find_peer,
&p1);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"test_get_iterator called (we got a result), stopping get request!\n");
- GNUNET_SCHEDULER_add_continuation (sched, &test_get_stop, &p1,
+ GNUNET_SCHEDULER_add_continuation (&test_get_stop, &p1,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
if (peer->get_handle == NULL)
{
GNUNET_break (0);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now (sched, &end_badly, &p1);
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now (&end_badly, &p1);
return;
}
data = GNUNET_malloc (data_size);
memset (data, 43, data_size);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Called test_put!\n");
- peer->dht_handle = GNUNET_DHT_connect (sched, peer->cfg, 100);
+ peer->dht_handle = GNUNET_DHT_connect (peer->cfg, 100);
GNUNET_assert (peer->dht_handle != NULL);
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 1),
&end_badly, NULL);
setup_peer (&p1, "test_dht_api_peer1.conf");
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 1), &test_put,
&p1);
}
static struct GNUNET_TESTING_PeerGroup *pg;
-/**
- * Global scheduler, used for all GNUNET_SCHEDULER_* functions.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Total number of peers to run, set based on config file.
*/
while (test_put != NULL)
{
if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_put->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
if (test_put->dht_handle != NULL)
GNUNET_DHT_disconnect(test_put->dht_handle);
test_put = test_put->next;
while (test_get != NULL)
{
if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_get->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
if (test_get->get_handle != NULL)
GNUNET_DHT_get_stop(test_get->get_handle);
if (test_get->dht_handle != NULL)
while (test_put != NULL)
{
if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_put->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
if (test_put->dht_handle != NULL)
GNUNET_DHT_disconnect(test_put->dht_handle);
test_put = test_put->next;
while (test_get != NULL)
{
if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, test_get->disconnect_task);
+ GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
if (test_get->get_handle != NULL)
GNUNET_DHT_get_stop(test_get->get_handle);
if (test_get->dht_handle != NULL)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%d gets succeeded, %d gets failed!\n", gets_completed, gets_failed);
if ((gets_completed == num_gets) && (outstanding_gets == 0))/* All gets successful */
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- //GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5), &get_topology, NULL);
- GNUNET_SCHEDULER_add_now(sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ //GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5), &get_topology, NULL);
+ GNUNET_SCHEDULER_add_now(&finish_testing, NULL);
}
else if ((gets_completed + gets_failed == num_gets) && (outstanding_gets == 0)) /* Had some failures */
{
- GNUNET_SCHEDULER_cancel(sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "not all gets succeeded!\n");
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "not all gets succeeded!\n");
}
}
}
GNUNET_assert(test_get->get_handle != NULL);
GNUNET_DHT_get_stop(test_get->get_handle);
- GNUNET_SCHEDULER_add_now (sched, &get_stop_finished, test_get);
+ GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get);
test_get->get_handle = NULL;
test_get->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
- GNUNET_SCHEDULER_cancel(sched, test_get->disconnect_task);
- GNUNET_SCHEDULER_add_continuation(sched, &get_stop_task, test_get, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+ GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
+ GNUNET_SCHEDULER_add_continuation(&get_stop_task, test_get, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
if (outstanding_gets > MAX_OUTSTANDING_GETS)
{
- GNUNET_SCHEDULER_add_delayed (sched, GET_DELAY, &do_get, test_get);
+ GNUNET_SCHEDULER_add_delayed (GET_DELAY, &do_get, test_get);
return;
}
- test_get->dht_handle = GNUNET_DHT_connect(sched, test_get->daemon->cfg, 10);
+ test_get->dht_handle = GNUNET_DHT_connect(test_get->daemon->cfg, 10);
/* Insert the data at the first peer */
GNUNET_assert(test_get->dht_handle != NULL);
outstanding_gets++;
test_get->uid,
test_get->daemon->shortname);
#endif
- test_get->disconnect_task = GNUNET_SCHEDULER_add_delayed(sched, GET_TIMEOUT, &get_stop_task, test_get);
- GNUNET_SCHEDULER_add_now (sched, &do_get, test_get->next);
+ test_get->disconnect_task = GNUNET_SCHEDULER_add_delayed(GET_TIMEOUT, &get_stop_task, test_get);
+ GNUNET_SCHEDULER_add_now (&do_get, test_get->next);
}
/**
outstanding_puts--;
puts_completed++;
- GNUNET_SCHEDULER_cancel(sched, test_put->disconnect_task);
- test_put->disconnect_task = GNUNET_SCHEDULER_add_now(sched, &put_disconnect_task, test_put);
+ GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
+ test_put->disconnect_task = GNUNET_SCHEDULER_add_now(&put_disconnect_task, test_put);
if (puts_completed == num_puts)
{
GNUNET_assert(outstanding_puts == 0);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10), &do_get, all_gets);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10), &do_get, all_gets);
return;
}
}
if (outstanding_puts > MAX_OUTSTANDING_PUTS)
{
- GNUNET_SCHEDULER_add_delayed (sched, PUT_DELAY, &do_put, test_put);
+ GNUNET_SCHEDULER_add_delayed (PUT_DELAY, &do_put, test_put);
return;
}
test_put->uid,
test_put->daemon->shortname);
#endif
- test_put->dht_handle = GNUNET_DHT_connect(sched, test_put->daemon->cfg, 10);
+ test_put->dht_handle = GNUNET_DHT_connect(test_put->daemon->cfg, 10);
GNUNET_assert(test_put->dht_handle != NULL);
outstanding_puts++;
GNUNET_TIME_UNIT_FOREVER_ABS,
GNUNET_TIME_UNIT_FOREVER_REL,
&put_finished, test_put);
- test_put->disconnect_task = GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_get_forever(), &put_disconnect_task, test_put);
- GNUNET_SCHEDULER_add_now(sched, &do_put, test_put->next);
+ test_put->disconnect_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_get_forever(), &put_disconnect_task, test_put);
+ GNUNET_SCHEDULER_add_now(&do_put, test_put->next);
}
all_gets = test_get;
}
- GNUNET_SCHEDULER_add_now (sched, &do_put, all_puts);
+ GNUNET_SCHEDULER_add_now (&do_put, all_puts);
}
"Created %d total connections, which is our target number! Starting next phase of testing.\n",
total_connections);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from setup puts/gets");
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &setup_puts_and_gets, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &setup_puts_and_gets, NULL);
}
else if (total_connections + failed_connections == expected_connections)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
}
}
"All %d daemons started, now connecting peers!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
expected_connections = -1;
if ((pg != NULL) && (peers_left == 0))
if (expected_connections == GNUNET_SYSERR)
{
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
}
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from connect topology (timeout)");
ok = 0;
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from create topology (bad return)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from continue startup (timeout)");
}
"All %d hostkeys created, now creating topology!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from create_topology");
- GNUNET_SCHEDULER_add_now(sched, &create_topology, NULL);
+ GNUNET_SCHEDULER_add_now(&create_topology, NULL);
ok = 0;
}
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char * blacklist_topology_str;
char * connect_topology_option_str;
char * connect_topology_option_modifier_string;
- sched = s;
/* Get path from configuration file */
if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
peers_left = num_peers;
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, SECONDS_PER_PEER_START * num_peers),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, SECONDS_PER_PEER_START * num_peers),
&end_badly, "didn't generate all hostkeys within a reasonable amount of time!!!");
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, SECONDS_PER_PEER_START * num_peers), &hostkey_callback, NULL, &peers_started_callback, NULL,
&topology_callback, NULL, NULL);
static struct GNUNET_TESTING_PeerGroup *pg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static unsigned long long num_peers;
static unsigned int total_gets;
GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
if (curr_get_ctx.retry_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, curr_get_ctx.retry_task);
+ GNUNET_SCHEDULER_cancel(curr_get_ctx.retry_task);
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
{
if (curr_get_ctx.retry_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, curr_get_ctx.retry_task);
+ GNUNET_SCHEDULER_cancel(curr_get_ctx.retry_task);
if (curr_get_ctx.get_handle != NULL)
{
GNUNET_DHT_get_stop(curr_get_ctx.get_handle);
}
- GNUNET_SCHEDULER_add_now (sched, &end_badly_cont, NULL);
+ GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
ok = 1;
}
if (0 != memcmp(&get_context->peer->hashPubKey, key, sizeof (GNUNET_HashCode)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Key returned is not the same key as was searched for!\n");
- GNUNET_SCHEDULER_cancel(sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "key mismatch in get response!\n");
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "key mismatch in get response!\n");
return;
}
if (get_context->retry_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched, get_context->retry_task);
+ GNUNET_SCHEDULER_cancel(get_context->retry_task);
get_context->retry_task = GNUNET_SCHEDULER_NO_TASK;
}
get_context->dht_handle = peer2dht;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received first correct GET request response!\n");
GNUNET_DHT_get_stop(get_context->get_handle);
- GNUNET_SCHEDULER_add_now (sched, &do_get, get_context);
+ GNUNET_SCHEDULER_add_now (&do_get, get_context);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received second correct GET request response!\n");
- GNUNET_SCHEDULER_cancel(sched, die_task);
+ GNUNET_SCHEDULER_cancel(die_task);
GNUNET_DHT_get_stop(get_context->get_handle);
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
}
else
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Too many attempts failed, ending test!\n", get_context->get_attempts);
- GNUNET_SCHEDULER_cancel(sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "key mismatch in get response!\n");
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "key mismatch in get response!\n");
return;
}
get_context->get_attempts++;
- get_context->retry_task = GNUNET_SCHEDULER_add_delayed(sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
- &stop_retry_get, get_context);
+ get_context->retry_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
+ &stop_retry_get, get_context);
get_context->get_handle = GNUNET_DHT_get_start(get_context->dht_handle,
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5),
0 /* fixme: use real type */, &get_context->peer->hashPubKey,
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Get attempt %u failed, canceling request!\n", get_context->get_attempts);
GNUNET_DHT_get_stop(get_context->get_handle);
get_context->get_handle = NULL;
- GNUNET_SCHEDULER_add_now(sched, &get_stop_finished, get_context);
+ GNUNET_SCHEDULER_add_now(&get_stop_finished, get_context);
}
static void
{
struct PeerGetContext *get_context = cls;
- get_context->retry_task = GNUNET_SCHEDULER_add_delayed(sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
+ get_context->retry_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
&stop_retry_get, get_context);
get_context->get_handle = GNUNET_DHT_get_start(get_context->dht_handle,
"Created %d total connections, which is our target number! Starting next phase of testing.\n",
total_connections);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from test gets");
curr_get_ctx.dht_handle = peer1dht;
curr_get_ctx.peer = &peer2id;
- //GNUNET_SCHEDULER_add_now (sched, &do_get, &curr_get_ctx);
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_get, &curr_get_ctx);
+ //GNUNET_SCHEDULER_add_now (&do_get, &curr_get_ctx);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_get, &curr_get_ctx);
}
else if (total_connections + failed_connections == expected_connections)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
}
}
if ((pg != NULL) && (peers_left == 0))
expected_connections = GNUNET_TESTING_connect_topology (pg, GNUNET_TESTING_TOPOLOGY_CLIQUE, GNUNET_TESTING_TOPOLOGY_OPTION_ALL, 0.0, NULL, NULL);
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
if (expected_connections == GNUNET_SYSERR)
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from connect topology (timeout)");
}
if (peers_left == num_peers)
{
memcpy(&peer1id, id, sizeof(struct GNUNET_PeerIdentity));
- peer1dht = GNUNET_DHT_connect(sched, cfg, 100);
+ peer1dht = GNUNET_DHT_connect(cfg, 100);
if (peer1dht == NULL)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
}
}
else
{
memcpy(&peer2id, id, sizeof(struct GNUNET_PeerIdentity));
- peer2dht = GNUNET_DHT_connect(sched, cfg, 100);
+ peer2dht = GNUNET_DHT_connect(cfg, 100);
if (peer2dht == NULL)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
}
}
"All %d daemons started, now connecting peers!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from peers_started_callback");
- GNUNET_SCHEDULER_add_now(sched, &connect_topology, NULL);
+ GNUNET_SCHEDULER_add_now(&connect_topology, NULL);
ok = 0;
}
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
{
total_gets = num_peers;
gets_succeeded = 0;
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "didn't start all daemons in reasonable amount of time!!!");
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
num_peers, TIMEOUT, NULL, NULL, &peers_started_callback, NULL,
&topology_callback, NULL, NULL);
*/
struct GNUNET_DHT_GetHandle *global_get_handle;
-/**
- * Global scheduler, used for all GNUNET_SCHEDULER_* functions.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* Total number of peers to run, set based on config file.
GNUNET_DHT_get_stop(global_get_handle);
global_get_handle = NULL;
}
- GNUNET_SCHEDULER_add_now(sched, &end_badly_cont, NULL);
+ GNUNET_SCHEDULER_add_now(&end_badly_cont, NULL);
ok = 1;
}
if ((0 != memcmp(&original_key, key, sizeof (GNUNET_HashCode))) || (0 != memcmp(original_data, data, sizeof(original_data))))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Key or data is not the same as was inserted!\n");
- GNUNET_SCHEDULER_cancel(sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "key or data mismatch in get response!\n");
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "key or data mismatch in get response!\n");
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
- GNUNET_SCHEDULER_cancel(sched, die_task);
+ GNUNET_SCHEDULER_cancel(die_task);
GNUNET_DHT_get_stop(global_get_handle);
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
/**
static void
put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GET_TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT,
&end_badly, "waiting for get response (data not found)");
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10), &do_get, NULL);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10), &do_get, NULL);
}
/**
"Created %d total connections, which is our target number! Starting next phase of testing.\n",
total_connections);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from test gets");
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_put, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_put, NULL);
}
else if (total_connections + failed_connections == expected_connections)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
}
}
if (peers_left == num_peers)
{
memcpy(&peer1id, id, sizeof(struct GNUNET_PeerIdentity)); /* Save the peer id */
- peer1dht = GNUNET_DHT_connect(sched, cfg, 100); /* Connect to the first peers DHT service */
+ peer1dht = GNUNET_DHT_connect(cfg, 100); /* Connect to the first peers DHT service */
if (peer1dht == NULL) /* If DHT connect failed */
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
}
}
else /* This is the second peer started */
{
memcpy(&peer2id, id, sizeof(struct GNUNET_PeerIdentity)); /* Same as for first peer... */
- peer2dht = GNUNET_DHT_connect(sched, cfg, 100);
+ peer2dht = GNUNET_DHT_connect(cfg, 100);
if (peer2dht == NULL)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
}
}
}
/* Cancel current timeout fail task */
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
if (expected_connections == GNUNET_SYSERR) /* Some error happened */
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
/* Schedule timeout on failure task */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from connect topology (timeout)");
ok = 0;
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
/* Get path from configuration file */
if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
peers_left = num_peers;
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "didn't start all daemons in reasonable amount of time!!!");
/* Start num_peers peers, call peers_started_callback on peer start, topology_callback on peer connect */
/* Read the API documentation for other parameters! */
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
num_peers, TIMEOUT, NULL, NULL, &peers_started_callback, NULL,
&topology_callback, NULL, NULL);
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_DV_Handle *
-GNUNET_DV_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_DV_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_DV_MessageReceivedHandler receive_handler,
void *receive_handler_cls);
*/
struct GNUNET_DV_Handle
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Configuration to use.
{
if (ret->client != NULL)
return GNUNET_OK;
- ret->client = GNUNET_CLIENT_connect (ret->sched, "dv", ret->cfg);
+ ret->client = GNUNET_CLIENT_connect ("dv", ret->cfg);
if (ret->client != NULL)
return GNUNET_YES;
#if DEBUG_DV_MESSAGES
/**
* Connect to the DV service
*
- * @param sched the scheduler to use
* @param cfg the configuration to use
* @param receive_handler method call when on receipt from the service
* @param receive_handler_cls closure for receive_handler
* @return handle to the DV service
*/
struct GNUNET_DV_Handle *
-GNUNET_DV_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_DV_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_DV_MessageReceivedHandler receive_handler,
void *receive_handler_cls)
{
handle = GNUNET_malloc(sizeof(struct GNUNET_DV_Handle));
handle->cfg = cfg;
- handle->sched = sched;
handle->pending_list = NULL;
handle->current = NULL;
handle->th = NULL;
- handle->client = GNUNET_CLIENT_connect(sched, "dv", cfg);
+ handle->client = GNUNET_CLIENT_connect("dv", cfg);
handle->receive_handler = receive_handler;
handle->receive_cls = receive_handler_cls;
*/
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-/**
- * The scheduler for this service.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* The client, the DV plugin connected to us. Hopefully
}
/*reply = core_pending_head;*/
- GNUNET_SCHEDULER_add_now(sched, &try_core_send, NULL);
+ GNUNET_SCHEDULER_add_now(&try_core_send, NULL);
/*if (reply != NULL)
core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, reply->importance, reply->timeout, &reply->recipient, reply->msg_size, &core_transmit_notify, NULL);*/
core_pending_tail,
pending_message);
- GNUNET_SCHEDULER_add_now(sched, try_core_send, NULL);
+ GNUNET_SCHEDULER_add_now(try_core_send, NULL);
return GNUNET_YES;
}
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Notifying core of send size %d to destination `%s'\n", "DV SEND MESSAGE", msg_size, GNUNET_i2s(recipient));
#endif
- GNUNET_SCHEDULER_add_now(sched, try_core_send, NULL);
+ GNUNET_SCHEDULER_add_now(try_core_send, NULL);
return (int) cost;
}
memcpy(delayed_context->message, packed_message, packed_message_size);
delayed_context->message_size = packed_message_size;
delayed_context->uid = ntohl(incoming->uid);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 2500), &send_message_delayed, delayed_context);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 2500), &send_message_delayed, delayed_context);
return GNUNET_OK;
}
else
core_pending_tail,
pending_message);
- GNUNET_SCHEDULER_add_now(sched, try_core_send, NULL);
+ GNUNET_SCHEDULER_add_now(try_core_send, NULL);
/*if (core_transmit_handle == NULL)
core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, default_dv_priority, GNUNET_TIME_relative_get_forever(), &to->identity, sizeof(p2p_dv_MESSAGE_NeighborInfo), &core_transmit_notify, NULL);*/
#if DEBUG_DV_PEER_NUMBERS
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "DV SERVICE: still in fast send mode\n");
#endif
- send_context->task = GNUNET_SCHEDULER_add_now(sched, &neighbor_send_task, send_context);
+ send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context);
}
else
{
#if DEBUG_DV_PEER_NUMBERS
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "DV SERVICE: entering slow send mode\n");
#endif
- send_context->task = GNUNET_SCHEDULER_add_delayed(sched, GNUNET_DV_DEFAULT_SEND_INTERVAL, &neighbor_send_task, send_context);
+ send_context->task = GNUNET_SCHEDULER_add_delayed(GNUNET_DV_DEFAULT_SEND_INTERVAL, &neighbor_send_task, send_context);
}
return;
send_context = direct->send_context;
if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, send_context->task);
+ GNUNET_SCHEDULER_cancel(send_context->task);
about_list = send_context->fast_gossip_list_head;
while (about_list != NULL)
core_pending_tail,
pending_message);
- GNUNET_SCHEDULER_add_now(sched, try_core_send, NULL);
+ GNUNET_SCHEDULER_add_now(try_core_send, NULL);
/*if (core_transmit_handle == NULL)
core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, default_dv_priority, GNUNET_TIME_relative_get_forever(), ¬ify->identity, sizeof(p2p_dv_MESSAGE_Disconnect), &core_transmit_notify, NULL);*/
if (server == NULL)
{
- GNUNET_SCHEDULER_cancel(sched, cleanup_task);
- GNUNET_SCHEDULER_add_now(sched, &shutdown_task, NULL);
+ GNUNET_SCHEDULER_cancel(cleanup_task);
+ GNUNET_SCHEDULER_add_now(&shutdown_task, NULL);
return;
}
#if DEBUG_DV
GNUNET_free(encPeerTo);
#endif
/*if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, send_context->task);*/
+ GNUNET_SCHEDULER_cancel(send_context->task);*/
- send_context->task = GNUNET_SCHEDULER_add_now(sched, &neighbor_send_task, send_context);
+ send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context);
return GNUNET_YES;
}
GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &add_all_extended_peers, direct->send_context);
if (direct->send_context->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, direct->send_context->task);
+ GNUNET_SCHEDULER_cancel(direct->send_context->task);
- direct->send_context->task = GNUNET_SCHEDULER_add_now(sched, &neighbor_send_task, direct->send_context);
+ direct->send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, direct->send_context);
return GNUNET_YES;
}
{
GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, &gossip_all_to_all_iterator, NULL);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5),
&gossip_all_to_all,
NULL);
send_context->fast_gossip_list_tail,
gossip_entry);
if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, send_context->task);
+ GNUNET_SCHEDULER_cancel(send_context->task);
- send_context->task = GNUNET_SCHEDULER_add_now(sched, &neighbor_send_task, send_context);
+ send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context);
//tc.reason = GNUNET_SCHEDULER_REASON_TIMEOUT;
//neighbor_send_task(send_context, &tc);
return GNUNET_YES;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Gossipped about %s to %d direct peers\n", GNUNET_i2s(&my_identity), neighbor_pid, sent);
GNUNET_free(neighbor_pid);
#endif
- neighbor->send_context->task = GNUNET_SCHEDULER_add_now(sched, &neighbor_send_task, neighbor->send_context);
+ neighbor->send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, neighbor->send_context);
}
}
GNUNET_break(0);
}
if ((neighbor->send_context != NULL) && (neighbor->send_context->task != GNUNET_SCHEDULER_NO_TASK))
- GNUNET_SCHEDULER_cancel(sched, neighbor->send_context->task);
+ GNUNET_SCHEDULER_cancel(neighbor->send_context->task);
GNUNET_free (neighbor);
}
* Process dv requests.
*
* @param cls closure
- * @param scheduler scheduler to use
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *scheduler,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
unsigned long long max_hosts;
- sched = scheduler;
cfg = c;
/* FIXME: Read from config, or calculate, or something other than this! */
GNUNET_SERVER_add_handlers (server, plugin_handlers);
coreAPI =
- GNUNET_CORE_connect (sched,
- cfg,
+ GNUNET_CORE_connect (cfg,
GNUNET_TIME_relative_get_forever(),
NULL, /* FIXME: anything we want to pass around? */
&core_init,
coreMST = GNUNET_SERVER_mst_create (&tokenized_message_handler,
NULL);
- peerinfo_handle = GNUNET_PEERINFO_connect(sched, cfg);
+ peerinfo_handle = GNUNET_PEERINFO_connect(cfg);
if (peerinfo_handle == NULL)
{
}
/* Scheduled the task to clean up when shutdown is called */
- cleanup_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ cleanup_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
plugin = GNUNET_malloc (sizeof (struct Plugin));
plugin->env = env;
- plugin->dv_handle = GNUNET_DV_connect(env->sched, env->cfg, &handle_dv_message_received, plugin);
+ plugin->dv_handle = GNUNET_DV_connect(env->cfg, &handle_dv_message_received, plugin);
if (plugin->dv_handle == NULL)
{
static struct GNUNET_TESTING_PeerGroup *pg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
const struct GNUNET_CONFIGURATION_Handle *main_cfg;
GNUNET_SCHEDULER_TaskIdentifier die_task;
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+ GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
}
GNUNET_free(free_pos);
}
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+ GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
}
GNUNET_free(free_pos);
}
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+ GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
}
GNUNET_free(free_pos);
}
if ((total_messages_received == expected_messages) && (total_other_messages == 0))
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "waiting for DV peers to connect!");
/*
if ((num_peers == 3) && (total_other_expected_messages == 2))
{
- GNUNET_SCHEDULER_add_now (sched, &send_other_messages, NULL);
+ GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);
}
else
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL);
}*/
}
else if ((total_other_expected_messages > 0) && (total_other_messages == total_other_expected_messages))
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
else
{
- pos->disconnect_task = GNUNET_SCHEDULER_add_now(sched, &disconnect_cores, pos);
+ pos->disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cores, pos);
}
return GNUNET_OK;
/*
* Connect to the receiving peer
*/
- pos->peer2handle = GNUNET_CORE_connect (sched,
- pos->peer2->cfg,
+ pos->peer2handle = GNUNET_CORE_connect (pos->peer2->cfg,
TIMEOUT,
pos,
&init_notify_peer2,
if (die_task == GNUNET_SCHEDULER_NO_TASK)
{
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from create topology (timeout)");
}
if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
&send_test_messages, pos);
return; /* Otherwise we'll double schedule messages here! */
}
/*
* Connect to the sending peer
*/
- pos->peer1handle = GNUNET_CORE_connect (sched,
- pos->peer1->cfg,
+ pos->peer1handle = GNUNET_CORE_connect (pos->peer1->cfg,
TIMEOUT,
pos,
&init_notify_peer1,
if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)
{
- GNUNET_SCHEDULER_add_now (sched,
- &send_test_messages, pos->next);
+ GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next);
}
else
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
&send_test_messages, pos->next);
}
}
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+ GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
}
GNUNET_free(free_pos);
}
total_other_expected_messages = temp_total_other_messages;
if (total_other_expected_messages == 0)
{
- GNUNET_SCHEDULER_add_now (sched, &end_badly, "send_other_messages had 0 messages to send, no DV connections made!");
+ GNUNET_SCHEDULER_add_now (&end_badly, "send_other_messages had 0 messages to send, no DV connections made!");
}
#if VERBOSE
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Preparing to send %d other test messages\n", total_other_expected_messages);
#endif
- GNUNET_SCHEDULER_add_now (sched, &send_test_messages, other_test_messages);
- GNUNET_SCHEDULER_cancel(sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages");
+ GNUNET_SCHEDULER_add_now (&send_test_messages, other_test_messages);
+ GNUNET_SCHEDULER_cancel(die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages");
}
void
total_connections);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now (sched, &send_test_messages, test_messages);
+ GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);
}
else if (total_connections + failed_connections == expected_connections)
{
if (failed_connections < (unsigned int)(fail_percentage * total_connections))
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now (sched, &send_test_messages, test_messages);
+ GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
}
}
else
#endif
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
if (expected_connections == GNUNET_SYSERR)
{
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
}
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from connect topology (timeout)");
}
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from create topology (bad return)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from continue startup (timeout)");
}
if (temp_total_other_messages == num_additional_messages)
{
- GNUNET_SCHEDULER_add_now (sched, &send_other_messages, NULL);
+ GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);
}
}
GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put(peer_daemon_hash, &id->hashPubKey, d, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
new_peer = GNUNET_malloc(sizeof(struct PeerContext));
- new_peer->peer_handle = GNUNET_CORE_connect(sched, cfg, GNUNET_TIME_UNIT_FOREVER_REL, d, NULL, &all_connect_handler, NULL, NULL, NULL, GNUNET_NO, NULL, GNUNET_NO, no_handlers);
+ new_peer->peer_handle = GNUNET_CORE_connect(cfg, GNUNET_TIME_UNIT_FOREVER_REL, d, NULL, &all_connect_handler, NULL, NULL, NULL, GNUNET_NO, NULL, GNUNET_NO, no_handlers);
new_peer->daemon = d;
new_peer->next = all_peers;
all_peers = new_peer;
"All %d daemons started, now creating topology!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "from peers_started_callback");
"All %d hostkeys created, now creating topology!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "from hostkey_callback");
- GNUNET_SCHEDULER_add_now(sched, &create_topology, NULL);
+ GNUNET_SCHEDULER_add_now(&create_topology, NULL);
ok = 0;
}
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char * blacklist_topology_str;
char * connect_topology_option_str;
char * connect_topology_option_modifier_string;
- sched = s;
ok = 1;
dotOutFile = fopen (dotOutFileName, "w");
peers_left = num_peers;
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "didn't start all daemons in reasonable amount of time!!!");
peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create(peers_left);
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left, TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, NULL,
&topology_callback, NULL, NULL);
static void
start_job (struct GNUNET_FS_QueueEntry *qe)
{
- qe->client = GNUNET_CLIENT_connect (qe->h->sched, "fs", qe->h->cfg);
+ qe->client = GNUNET_CLIENT_connect ("fs", qe->h->cfg);
if (qe->client == NULL)
{
GNUNET_break (0);
continue;
stop_job (qe);
}
- h->queue_job = GNUNET_SCHEDULER_add_delayed (h->sched,
- restart_at,
+ h->queue_job = GNUNET_SCHEDULER_add_delayed (restart_at,
&process_job_queue,
h);
}
h->pending_tail,
qe);
if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->queue_job);
+ GNUNET_SCHEDULER_cancel (h->queue_job);
h->queue_job
- = GNUNET_SCHEDULER_add_now (h->sched,
- &process_job_queue,
+ = GNUNET_SCHEDULER_add_now (&process_job_queue,
h);
return qe;
}
qh);
GNUNET_free (qh);
if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->queue_job);
+ GNUNET_SCHEDULER_cancel (h->queue_job);
h->queue_job
- = GNUNET_SCHEDULER_add_now (h->sched,
- &process_job_queue,
+ = GNUNET_SCHEDULER_add_now (&process_job_queue,
h);
}
if ( (0 == (pc->options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) &&
(GNUNET_YES != pc->all_done) )
{
- pc->dsh = GNUNET_DATASTORE_connect (h->cfg,
- h->sched);
+ pc->dsh = GNUNET_DATASTORE_connect (h->cfg);
if (NULL == pc->dsh)
goto cleanup;
}
/* re-start publishing (if needed)... */
if (pc->all_done != GNUNET_YES)
pc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
pc);
if (GNUNET_OK !=
switch (uc->state)
{
case UNINDEX_STATE_HASHING:
- uc->fhc = GNUNET_CRYPTO_hash_file (uc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ uc->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
uc->filename,
HASHING_BLOCKSIZE,
&GNUNET_FS_unindex_process_hash_,
/**
* Setup a connection to the file-sharing service.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param client_name unique identifier for this client
* @param upcb function to call to notify about FS actions
* @return NULL on error
*/
struct GNUNET_FS_Handle *
-GNUNET_FS_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *client_name,
GNUNET_FS_ProgressCallback upcb,
void *upcb_cls,
va_list ap;
ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Handle));
- ret->sched = sched;
ret->cfg = cfg;
ret->client_name = GNUNET_strdup (client_name);
ret->upcb = upcb;
while (h->top_head != NULL)
h->top_head->ssf (h->top_head->ssf_cls);
if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->queue_job);
+ GNUNET_SCHEDULER_cancel (h->queue_job);
GNUNET_free (h->client_name);
GNUNET_free (h);
}
*/
struct GNUNET_FS_Handle
{
- /**
- * Scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Configuration to use.
*/
struct GNUNET_CLIENT_Connection *client;
dc->task = GNUNET_SCHEDULER_NO_TASK;
- client = GNUNET_CLIENT_connect (dc->h->sched,
- "fs",
+ client = GNUNET_CLIENT_connect ("fs",
dc->h->cfg);
if (NULL == client)
{
"Will try to reconnect in 1s\n");
#endif
dc->task
- = GNUNET_SCHEDULER_add_delayed (dc->h->sched,
- GNUNET_TIME_UNIT_SECONDS,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&do_reconnect,
dc);
}
pi.status = GNUNET_FS_STATUS_DOWNLOAD_SUSPEND;
GNUNET_FS_download_make_status_ (&pi, dc);
if (GNUNET_SCHEDULER_NO_TASK != dc->task)
- GNUNET_SCHEDULER_cancel (dc->h->sched,
- dc->task);
+ GNUNET_SCHEDULER_cancel (dc->task);
GNUNET_CONTAINER_multihashmap_iterate (dc->active,
&free_entry,
NULL);
pi.status = GNUNET_FS_STATUS_DOWNLOAD_STOPPED;
GNUNET_FS_download_make_status_ (&pi, dc);
if (GNUNET_SCHEDULER_NO_TASK != dc->task)
- GNUNET_SCHEDULER_cancel (dc->h->sched,
- dc->task);
+ GNUNET_SCHEDULER_cancel (dc->task);
GNUNET_CONTAINER_multihashmap_iterate (dc->active,
&free_entry,
NULL);
_("Failed to receive response for `%s' request from `%s' service.\n"),
"GET_INDEXED",
"fs");
- GNUNET_SCHEDULER_add_continuation (gic->h->sched,
- gic->cont,
+ GNUNET_SCHEDULER_add_continuation (gic->cont,
gic->cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END)
{
/* normal end-of-list */
- GNUNET_SCHEDULER_add_continuation (gic->h->sched,
- gic->cont,
+ GNUNET_SCHEDULER_add_continuation (gic->cont,
gic->cont_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
_("Failed to receive valid response for `%s' request from `%s' service.\n"),
"GET_INDEXED",
"fs");
- GNUNET_SCHEDULER_add_continuation (gic->h->sched,
- gic->cont,
+ GNUNET_SCHEDULER_add_continuation (gic->cont,
gic->cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
filename,
&iim->file_id))
{
- GNUNET_SCHEDULER_add_continuation (gic->h->sched,
- gic->cont,
+ GNUNET_SCHEDULER_add_continuation (gic->cont,
gic->cont_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
struct GetIndexedContext *gic;
struct GNUNET_MessageHeader msg;
- client = GNUNET_CLIENT_connect (h->sched,
- "fs",
+ client = GNUNET_CLIENT_connect ("fs",
h->cfg);
if (NULL == client)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Failed to not connect to `%s' service.\n"),
"fs");
- GNUNET_SCHEDULER_add_continuation (h->sched,
- cont,
+ GNUNET_SCHEDULER_add_continuation (cont,
cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
return;
*/
struct GNUNET_DATASTORE_Handle *dsh;
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our KSK URI.
*/
if (GNUNET_OK != success)
{
/* error! */
- GNUNET_SCHEDULER_add_continuation (ac->sched,
- &do_disconnect,
+ GNUNET_SCHEDULER_add_continuation (&do_disconnect,
ac->dsh,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
if (ac->cont != NULL)
if (ac->pos == ac->ksk_uri->data.ksk.keywordCount)
{
/* done! */
- GNUNET_SCHEDULER_add_continuation (ac->sched,
- &do_disconnect,
+ GNUNET_SCHEDULER_add_continuation (&do_disconnect,
ac->dsh,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
if (ac->cont != NULL)
nb->ns_purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK);
nb->ksk_purpose.size = htonl (size - sizeof (struct GNUNET_CRYPTO_RsaSignature));
nb->ksk_purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK_KSIG);
- dsh = GNUNET_DATASTORE_connect (h->cfg, h->sched);
+ dsh = GNUNET_DATASTORE_connect (h->cfg);
if (NULL == dsh)
{
GNUNET_free (nb);
ctx->cont = cont;
ctx->cont_cls = cont_cls;
ctx->dsh = dsh;
- ctx->sched = h->sched;
ctx->ksk_uri = GNUNET_FS_uri_dup (ksk_uri);
ctx->nb = nb;
ctx->pt = pt;
NULL);
return;
}
- psc->dsh = GNUNET_DATASTORE_connect (h->cfg, h->sched);
+ psc->dsh = GNUNET_DATASTORE_connect (h->cfg);
if (NULL == psc->dsh)
{
GNUNET_free (sb_enc);
if (GNUNET_SYSERR == pcc->sc->in_network_wait)
{
/* we were aborted in the meantime, finish shutdown! */
- GNUNET_SCHEDULER_add_continuation (pcc->sc->h->sched,
- &publish_cleanup,
+ GNUNET_SCHEDULER_add_continuation (&publish_cleanup,
pcc->sc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
GNUNET_free (pcc);
}
if (NULL != pcc->cont)
pcc->sc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (pcc->sc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
pcc->cont,
pcc->cont_cls);
GNUNET_free (pcc);
GNUNET_FS_file_information_sync_ (p);
GNUNET_FS_publish_sync_ (pc);
pc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (pc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
pc);
return;
pc->fi_pos = p->dir;
GNUNET_FS_publish_sync_ (pc);
pc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (pc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
pc);
}
/* continue with main */
sc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (sc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
sc);
}
"Waiting for datastore connection\n");
#endif
sc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (sc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
sc);
return;
p->filename,
GNUNET_h2s (res));
#endif
- client = GNUNET_CLIENT_connect (sc->h->sched,
- "fs",
+ client = GNUNET_CLIENT_connect ("fs",
sc->h->cfg);
if (NULL == client)
{
else
{
p->start_time = GNUNET_TIME_absolute_get ();
- pc->fhc = GNUNET_CRYPTO_hash_file (pc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ pc->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
p->filename,
HASHING_BLOCKSIZE,
&hash_for_index_cb,
if (GNUNET_SCHEDULER_NO_TASK != pc->upload_task)
{
- GNUNET_SCHEDULER_cancel (pc->h->sched, pc->upload_task);
+ GNUNET_SCHEDULER_cancel (pc->upload_task);
pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_FS_file_information_inspect (pc->fi,
}
pc->rid = success;
pc->upload_task
- = GNUNET_SCHEDULER_add_with_priority (pc->h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
pc);
}
GNUNET_assert (NULL != h);
if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
{
- dsh = GNUNET_DATASTORE_connect (h->cfg,
- h->sched);
+ dsh = GNUNET_DATASTORE_connect (h->cfg);
if (NULL == dsh)
return NULL;
}
else
{
ret->upload_task
- = GNUNET_SCHEDULER_add_with_priority (h->sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+ = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
&GNUNET_FS_publish_main_,
ret);
}
}
if (GNUNET_SCHEDULER_NO_TASK != pc->upload_task)
{
- GNUNET_SCHEDULER_cancel (pc->h->sched, pc->upload_task);
+ GNUNET_SCHEDULER_cancel (pc->upload_task);
pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
}
if (pc->serialization != NULL)
GNUNET_free (pkc);
return;
}
- GNUNET_SCHEDULER_add_continuation (pkc->h->sched,
- &publish_ksk_cont,
+ GNUNET_SCHEDULER_add_continuation (&publish_ksk_cont,
pkc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
pkc->cont_cls = cont_cls;
if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
{
- pkc->dsh = GNUNET_DATASTORE_connect (h->cfg,
- h->sched);
+ pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
if (pkc->dsh == NULL)
{
cont (cont_cls, NULL, _("Could not connect to datastore."));
pkc->slen);
pkc->cpy->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK);
pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri);
- GNUNET_SCHEDULER_add_continuation (h->sched,
- &publish_ksk_cont,
+ GNUNET_SCHEDULER_add_continuation (&publish_ksk_cont,
pkc,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
- sr->probe_cancel_task);
+ GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
}
- sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->sc->h->sched,
- sr->remaining_probe_time,
+ sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
&probe_failure_handler,
sr);
break;
case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
- sr->probe_cancel_task);
+ GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
}
- sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->sc->h->sched,
- sr->remaining_probe_time,
+ sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
&probe_success_handler,
sr);
break;
case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
- sr->probe_cancel_task);
+ GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
}
sr = NULL;
case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
GNUNET_assert (sr->probe_cancel_task == GNUNET_SCHEDULER_NO_TASK);
sr->probe_active_time = GNUNET_TIME_absolute_get ();
- sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->sc->h->sched,
- sr->remaining_probe_time,
+ sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
&probe_failure_handler,
sr);
break;
case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sr->sc->h->sched,
- sr->probe_cancel_task);
+ GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
}
dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
size_t size;
sc->task = GNUNET_SCHEDULER_NO_TASK;
- client = GNUNET_CLIENT_connect (sc->h->sched,
- "fs",
+ client = GNUNET_CLIENT_connect ("fs",
sc->h->cfg);
if (NULL == client)
{
sc->client = NULL;
}
sc->task
- = GNUNET_SCHEDULER_add_delayed (sc->h->sched,
- GNUNET_TIME_UNIT_SECONDS,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&do_reconnect,
sc);
}
&sc->requests[i].key);
}
}
- sc->client = GNUNET_CLIENT_connect (sc->h->sched,
- "fs",
+ sc->client = GNUNET_CLIENT_connect ("fs",
sc->h->cfg);
if (NULL == sc->client)
return GNUNET_SYSERR;
const GNUNET_HashCode * key,
void *value)
{
- struct GNUNET_FS_SearchContext *sc = cls;
- struct GNUNET_FS_Handle *h = sc->h;
struct GNUNET_FS_SearchResult *sr = value;
if (sr->probe_ctx != NULL)
}
if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sched,
- sr->probe_cancel_task);
+ GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
}
if (sr->update_search != NULL)
void *value)
{
struct GNUNET_FS_SearchContext *sc = cls;
- struct GNUNET_FS_Handle *h = sc->h;
struct GNUNET_FS_SearchResult *sr = value;
struct GNUNET_FS_ProgressInfo pi;
if (sr->probe_ctx != NULL)
GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- sr->probe_cancel_task);
+ GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
GNUNET_free (sr);
return GNUNET_OK;
}
sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
GNUNET_break (NULL == sc->client_info);
if (sc->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sc->h->sched,
- sc->task);
+ GNUNET_SCHEDULER_cancel (sc->task);
if (NULL != sc->client)
GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
struct GNUNET_FS_ProgressInfo pi;
if (sc->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sc->h->sched,
- sc->task);
+ GNUNET_SCHEDULER_cancel (sc->task);
sc->task = GNUNET_SCHEDULER_NO_TASK;
if (NULL != sc->client)
GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
void *value)
{
struct GNUNET_FS_SearchContext *sc = cls;
- struct GNUNET_FS_Handle *h = sc->h;
struct GNUNET_FS_SearchResult *sr = value;
struct GNUNET_FS_ProgressInfo pi;
if (sr->probe_ctx != NULL)
GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched,
- sr->probe_cancel_task);
+ GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
GNUNET_free (sr);
return GNUNET_OK;
}
sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
GNUNET_break (NULL == sc->client_info);
if (sc->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sc->h->sched,
- sc->task);
+ GNUNET_SCHEDULER_cancel (sc->task);
if (NULL != sc->client)
GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
*/
struct GNUNET_PeerIdentity id;
- /**
- * Scheduler to use (for publish_cont).
- */
- struct GNUNET_SCHEDULER_Handle *publish_sched;
-
/**
* Function to call when upload is done.
*/
*/
char *publish_tmp_file;
- /**
- * Scheduler to use (for download_cont).
- */
- struct GNUNET_SCHEDULER_Handle *download_sched;
-
/**
* Function to call when download is done.
*/
GNUNET_FS_publish_stop (daemon->publish_context);
daemon->publish_context = NULL;
- daemon->publish_sched = NULL;
cont = daemon->publish_cont;
daemon->publish_cont = NULL;
uri = daemon->publish_uri;
GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES);
daemon->download_context = NULL;
- GNUNET_SCHEDULER_add_continuation (daemon->download_sched,
- daemon->download_cont,
+ GNUNET_SCHEDULER_add_continuation (daemon->download_cont,
daemon->download_cont_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
daemon->download_cont = NULL;
- daemon->download_sched = NULL;
}
switch (info->status)
{
case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
- GNUNET_SCHEDULER_cancel (daemon->publish_sched,
- daemon->publish_timeout_task);
+ GNUNET_SCHEDULER_cancel (daemon->publish_timeout_task);
daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
daemon->publish_uri = GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
- GNUNET_SCHEDULER_add_continuation (daemon->publish_sched,
- &report_uri,
+ GNUNET_SCHEDULER_add_continuation (&report_uri,
daemon,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
(unsigned long long) info->value.download.size);
break;
case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
- GNUNET_SCHEDULER_cancel (daemon->download_sched,
- daemon->download_timeout_task);
+ GNUNET_SCHEDULER_cancel (daemon->download_timeout_task);
daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_continuation (daemon->download_sched,
- &report_success,
+ GNUNET_SCHEDULER_add_continuation (&report_success,
daemon,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
struct StartContext
{
- struct GNUNET_SCHEDULER_Handle *sched;
struct GNUNET_TIME_Relative timeout;
unsigned int total;
unsigned int have;
sctx->have++;
if (sctx->have == sctx->total)
{
- GNUNET_SCHEDULER_add_continuation (sctx->sched,
- sctx->cont,
+ GNUNET_SCHEDULER_add_continuation (sctx->cont,
sctx->cont_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
sctx->daemons[0]->gcfg = sctx->cfg;
- GNUNET_SCHEDULER_cancel (sctx->sched,
- sctx->timeout_task);
+ GNUNET_SCHEDULER_cancel (sctx->timeout_task);
for (i=0;i<sctx->total;i++)
{
- sctx->daemons[i]->fs = GNUNET_FS_start (sctx->sched,
- sctx->daemons[i]->cfg,
+ sctx->daemons[i]->fs = GNUNET_FS_start (sctx->daemons[i]->cfg,
"<tester>",
&progress_cb,
sctx->daemons[i],
sctx->daemons[i] = NULL;
}
GNUNET_CONFIGURATION_destroy (sctx->cfg);
- GNUNET_SCHEDULER_add_continuation (sctx->sched,
- sctx->cont,
+ GNUNET_SCHEDULER_add_continuation (sctx->cont,
sctx->cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
GNUNET_free (sctx);
/**
* Start daemons for testing.
*
- * @param sched scheduler to use
* @param template_cfg_file configuration template to use
* @param timeout if this operation cannot be completed within the
* given period, call the continuation with an error code
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_daemons_start (struct GNUNET_SCHEDULER_Handle *sched,
- const char *template_cfg_file,
+GNUNET_FS_TEST_daemons_start (const char *template_cfg_file,
struct GNUNET_TIME_Relative timeout,
unsigned int total,
struct GNUNET_FS_TestDaemon **daemons,
GNUNET_assert (total > 0);
sctx = GNUNET_malloc (sizeof (struct StartContext));
- sctx->sched = sched;
sctx->daemons = daemons;
sctx->total = total;
sctx->cont = cont;
GNUNET_break (0);
GNUNET_CONFIGURATION_destroy (sctx->cfg);
GNUNET_free (sctx);
- GNUNET_SCHEDULER_add_continuation (sched,
- cont,
+ GNUNET_SCHEDULER_add_continuation (cont,
cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
return;
}
for (i=0;i<total;i++)
daemons[i] = GNUNET_malloc (sizeof (struct GNUNET_FS_TestDaemon));
- sctx->group = GNUNET_TESTING_daemons_start (sched,
- sctx->cfg,
+ sctx->group = GNUNET_TESTING_daemons_start (sctx->cfg,
total,
timeout,
NULL,
sctx,
NULL, NULL,
NULL);
- sctx->timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- timeout,
+ sctx->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
&start_timeout,
sctx);
}
struct ConnectContext
{
- struct GNUNET_SCHEDULER_Handle *sched;
GNUNET_SCHEDULER_Task cont;
void *cont_cls;
};
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Failed to connect peers: %s\n",
emsg);
- GNUNET_SCHEDULER_add_continuation (cc->sched,
- cc->cont,
+ GNUNET_SCHEDULER_add_continuation (cc->cont,
cc->cont_cls,
(emsg != NULL)
? GNUNET_SCHEDULER_REASON_TIMEOUT
/**
* Connect two daemons for testing.
*
- * @param sched scheduler to use
* @param daemon1 first daemon to connect
* @param daemon2 second first daemon to connect
* @param timeout if this operation cannot be completed within the
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_daemons_connect (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_FS_TestDaemon *daemon1,
+GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1,
struct GNUNET_FS_TestDaemon *daemon2,
struct GNUNET_TIME_Relative timeout,
GNUNET_SCHEDULER_Task cont,
struct ConnectContext *ncc;
ncc = GNUNET_malloc (sizeof (struct ConnectContext));
- ncc->sched = sched;
ncc->cont = cont;
ncc->cont_cls = cont_cls;
GNUNET_TESTING_daemons_connect (daemon1->daemon,
/**
* Stop daemons used for testing.
*
- * @param sched scheduler to use
* @param total number of daemons to stop
* @param daemons array with the daemons (values will be clobbered)
*/
void
-GNUNET_FS_TEST_daemons_stop (struct GNUNET_SCHEDULER_Handle *sched,
- unsigned int total,
+GNUNET_FS_TEST_daemons_stop (unsigned int total,
struct GNUNET_FS_TestDaemon **daemons)
{
unsigned int i;
/**
* Publish a file at the given daemon.
*
- * @param sched scheduler to use
* @param daemon where to publish
* @param timeout if this operation cannot be completed within the
* given period, call the continuation with an error code
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_publish (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_FS_TestDaemon *daemon,
+GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon,
struct GNUNET_TIME_Relative timeout,
uint32_t anonymity,
int do_index,
daemon->publish_cont_cls = cont_cls;
daemon->publish_seed = seed;
daemon->verbose = verbose;
- daemon->publish_sched = sched;
if (GNUNET_YES == do_index)
{
GNUNET_assert (daemon->publish_tmp_file == NULL);
fi,
NULL, NULL, NULL,
GNUNET_FS_PUBLISH_OPTION_NONE);
- daemon->publish_timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- timeout,
+ daemon->publish_timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
&publish_timeout,
daemon);
}
daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES);
daemon->download_context = NULL;
- GNUNET_SCHEDULER_add_continuation (daemon->download_sched,
- daemon->download_cont,
+ GNUNET_SCHEDULER_add_continuation (daemon->download_cont,
daemon->download_cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
daemon->download_cont = NULL;
- daemon->download_sched = NULL;
}
/**
* Perform test download.
*
- * @param sched scheduler to use
* @param daemon which peer to download from
* @param timeout if this operation cannot be completed within the
* given period, call the continuation with an error code
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_download (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_FS_TestDaemon *daemon,
+GNUNET_FS_TEST_download (struct GNUNET_FS_TestDaemon *daemon,
struct GNUNET_TIME_Relative timeout,
uint32_t anonymity,
uint32_t seed,
GNUNET_assert (daemon->download_cont == NULL);
size = GNUNET_FS_uri_chk_get_file_size (uri);
daemon->verbose = verbose;
- daemon->download_sched = sched;
daemon->download_cont = cont;
daemon->download_cont_cls = cont_cls;
daemon->download_seed = seed;
GNUNET_FS_DOWNLOAD_OPTION_NONE,
NULL,
NULL);
- daemon->download_timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- timeout,
+ daemon->download_timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
&download_timeout,
daemon);
}
/**
* Start daemons for testing.
*
- * @param sched scheduler to use
* @param template_cfg_file configuration template to use
* @param timeout if this operation cannot be completed within the
* given period, call the continuation with an error code
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_daemons_start (struct GNUNET_SCHEDULER_Handle *sched,
- const char *template_cfg_file,
+GNUNET_FS_TEST_daemons_start (const char *template_cfg_file,
struct GNUNET_TIME_Relative timeout,
unsigned int total,
struct GNUNET_FS_TestDaemon **daemons,
/**
* Connect two daemons for testing.
*
- * @param sched scheduler to use
* @param daemon1 first daemon to connect
* @param daemon2 second first daemon to connect
* @param timeout if this operation cannot be completed within the
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_daemons_connect (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_FS_TestDaemon *daemon1,
+GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1,
struct GNUNET_FS_TestDaemon *daemon2,
struct GNUNET_TIME_Relative timeout,
GNUNET_SCHEDULER_Task cont,
/**
* Stop daemons used for testing.
*
- * @param sched scheduler to use
* @param total number of daemons to stop
* @param daemons array with the daemons (values will be clobbered)
*/
void
-GNUNET_FS_TEST_daemons_stop (struct GNUNET_SCHEDULER_Handle *sched,
- unsigned int total,
+GNUNET_FS_TEST_daemons_stop (unsigned int total,
struct GNUNET_FS_TestDaemon **daemons);
/**
* Publish a file at the given daemon.
*
- * @param sched scheduler to use
* @param daemon where to publish
* @param timeout if this operation cannot be completed within the
* given period, call the continuation with an error code
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_publish (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_FS_TestDaemon *daemon,
+GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon,
struct GNUNET_TIME_Relative timeout,
uint32_t anonymity,
int do_index,
/**
* Perform test download.
*
- * @param sched scheduler to use
* @param daemon which peer to download from
* @param timeout if this operation cannot be completed within the
* given period, call the continuation with an error code
* @param cont_cls closure for cont
*/
void
-GNUNET_FS_TEST_download (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_FS_TestDaemon *daemon,
+GNUNET_FS_TEST_download (struct GNUNET_FS_TestDaemon *daemon,
struct GNUNET_TIME_Relative timeout,
uint32_t anonymity,
uint32_t seed,
iob,
&te->emsg))
{
- GNUNET_SCHEDULER_add_continuation (te->h->sched,
- te->cont,
+ GNUNET_SCHEDULER_add_continuation (te->cont,
te->cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
return;
te->uri->type = chk;
te->uri->data.chk.chk = te->chk_tree[0];
te->uri->data.chk.file_length = GNUNET_htonll (te->size);
- GNUNET_SCHEDULER_add_continuation (te->h->sched,
- te->cont,
+ GNUNET_SCHEDULER_add_continuation (te->cont,
te->cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return;
uc->dsh = NULL;
uc->state = UNINDEX_STATE_FS_NOTIFY;
GNUNET_FS_unindex_sync_ (uc);
- uc->client = GNUNET_CLIENT_connect (uc->h->sched,
- "fs",
+ uc->client = GNUNET_CLIENT_connect ("fs",
uc->h->cfg);
if (uc->client == NULL)
{
void
GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
{
- uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg,
- uc->h->sched);
+ uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
if (NULL == uc->dsh)
{
uc->state = UNINDEX_STATE_ERROR;
pi.status = GNUNET_FS_STATUS_UNINDEX_START;
pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
GNUNET_FS_unindex_make_status_ (&pi, ret, 0);
- ret->fhc = GNUNET_CRYPTO_hash_file (h->sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ ret->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
filename,
HASHING_BLOCKSIZE,
&GNUNET_FS_unindex_process_hash_,
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
static struct GNUNET_FS_Handle *ctx;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_DownloadContext *dc;
static unsigned int anonymity = 1;
fprintf (stderr,
_("Error downloading: %s.\n"),
info->value.download.specifics.error.message);
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
break;
case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
s = GNUNET_STRINGS_byte_size_fancy(info->value.download.completed * 1000 / (info->value.download.duration.rel_value + 1));
s);
GNUNET_free (s);
if (info->value.download.dc == dc)
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
break;
case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
if (info->value.download.dc == dc)
- GNUNET_SCHEDULER_add_continuation (sched,
- &cleanup_task,
+ GNUNET_SCHEDULER_add_continuation (&cleanup_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
char *emsg;
enum GNUNET_FS_DownloadOptions options;
- sched = s;
uri = GNUNET_FS_uri_parse (args[0],
&emsg);
if (NULL == uri)
return;
}
cfg = c;
- ctx = GNUNET_FS_start (sched,
- cfg,
+ ctx = GNUNET_FS_start (cfg,
"gnunet-download",
&progress_cb,
NULL,
ctx = NULL;
return;
}
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
char *emsg;
cfg = c;
- h = GNUNET_FS_start (sched,
- cfg,
+ h = GNUNET_FS_start (cfg,
"gnunet-pseudonym",
&progress_cb,
NULL,
static struct GNUNET_FS_Handle *ctx;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_PublishContext *pc;
static struct GNUNET_CONTAINER_MetaData *meta;
info->value.publish.specifics.error.message);
if (kill_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- kill_task);
+ GNUNET_SCHEDULER_cancel (kill_task);
kill_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_SCHEDULER_add_continuation (sched,
- &do_stop_task,
+ GNUNET_SCHEDULER_add_continuation (&do_stop_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
{
if (kill_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- kill_task);
+ GNUNET_SCHEDULER_cancel (kill_task);
kill_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_SCHEDULER_add_continuation (sched,
- &do_stop_task,
+ GNUNET_SCHEDULER_add_continuation (&do_stop_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
char *ex;
char *emsg;
- sched = s;
/* check arguments */
if ((uri_string != NULL) && (extract_only))
{
}
}
cfg = c;
- ctx = GNUNET_FS_start (sched,
- cfg,
+ ctx = GNUNET_FS_start (cfg,
"gnunet-publish",
&progress_cb,
NULL,
ret = 1;
return;
}
- kill_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ kill_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&do_stop_task,
NULL);
}
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *ctx;
static struct GNUNET_FS_SearchContext *sc;
fprintf (stderr,
_("Error searching: %s.\n"),
info->value.search.specifics.error.message);
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
break;
case GNUNET_FS_STATUS_SEARCH_STOPPED:
- GNUNET_SCHEDULER_add_continuation (sched,
- &clean_task,
+ GNUNET_SCHEDULER_add_continuation (&clean_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
unsigned int argc;
enum GNUNET_FS_SearchOptions options;
- sched = s;
argc = 0;
while (NULL != args[argc])
argc++;
return;
}
cfg = c;
- ctx = GNUNET_FS_start (sched,
- cfg,
+ ctx = GNUNET_FS_start (cfg,
"gnunet-search",
&progress_cb,
NULL,
ret = 1;
return;
}
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
*/
static struct GNUNET_CONFIGURATION_Handle *block_cfg;
-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
#endif
if (cp->delayed_transmission_request_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, cp->delayed_transmission_request_task);
+ GNUNET_SCHEDULER_cancel (cp->delayed_transmission_request_task);
cp->delayed_transmission_request_task = GNUNET_SCHEDULER_NO_TASK;
}
cp->cth
MAX_MIGRATION_QUEUE);
delay = GNUNET_TIME_relative_max (delay,
min_migration_delay);
- mig_task = GNUNET_SCHEDULER_add_delayed (sched,
- delay,
+ mig_task = GNUNET_SCHEDULER_add_delayed (delay,
&gather_migration_blocks,
NULL);
}
(hopefully) appear */
delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5);
}
- dht_task = GNUNET_SCHEDULER_add_delayed (sched,
- delay,
+ dht_task = GNUNET_SCHEDULER_add_delayed (delay,
&gather_dht_put_blocks,
cls);
}
}
if (pr->task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- pr->task);
+ GNUNET_SCHEDULER_cancel (pr->task);
pr->task = GNUNET_SCHEDULER_NO_TASK;
}
while (NULL != pr->pending_head)
return;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- TRUST_FLUSH_FREQ, &cron_flush_trust, NULL);
+ GNUNET_SCHEDULER_add_delayed (TRUST_FLUSH_FREQ, &cron_flush_trust, NULL);
}
}
if (cp->delayed_transmission_request_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, cp->delayed_transmission_request_task);
+ GNUNET_SCHEDULER_cancel (cp->delayed_transmission_request_task);
cp->delayed_transmission_request_task = GNUNET_SCHEDULER_NO_TASK;
}
while (NULL != (pm = cp->pending_messages_head))
}
if (GNUNET_SCHEDULER_NO_TASK != mig_task)
{
- GNUNET_SCHEDULER_cancel (sched, mig_task);
+ GNUNET_SCHEDULER_cancel (mig_task);
mig_task = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_SCHEDULER_NO_TASK != dht_task)
{
- GNUNET_SCHEDULER_cancel (sched, dht_task);
+ GNUNET_SCHEDULER_cancel (dht_task);
dht_task = GNUNET_SCHEDULER_NO_TASK;
}
while (client_list != NULL)
block_ctx = NULL;
GNUNET_CONFIGURATION_destroy (block_cfg);
block_cfg = NULL;
- sched = NULL;
cfg = NULL;
GNUNET_free_non_null (trustDirectory);
trustDirectory = NULL;
{
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == cp->delayed_transmission_request_task);
cp->delayed_transmission_request_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- min_delay,
+ = GNUNET_SCHEDULER_add_delayed (min_delay,
&delayed_transmission_request,
cp);
}
}
if (cp->delayed_transmission_request_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, cp->delayed_transmission_request_task);
+ GNUNET_SCHEDULER_cancel (cp->delayed_transmission_request_task);
cp->delayed_transmission_request_task = GNUNET_SCHEDULER_NO_TASK;
}
/* need to schedule transmission */
"Transmission of request failed, will try again later.\n");
#endif
if (pr->task == GNUNET_SCHEDULER_NO_TASK)
- pr->task = GNUNET_SCHEDULER_add_delayed (sched,
- get_processing_delay (),
+ pr->task = GNUNET_SCHEDULER_add_delayed (get_processing_delay (),
&forward_request_task,
pr);
return;
pr->used_targets[i].last_request_time = GNUNET_TIME_absolute_get ();
pr->used_targets[i].num_requests++;
if (pr->task == GNUNET_SCHEDULER_NO_TASK)
- pr->task = GNUNET_SCHEDULER_add_delayed (sched,
- get_processing_delay (),
+ pr->task = GNUNET_SCHEDULER_add_delayed (get_processing_delay (),
&forward_request_task,
pr);
}
{
/* error in communication with core, try again later */
if (pr->task == GNUNET_SCHEDULER_NO_TASK)
- pr->task = GNUNET_SCHEDULER_add_delayed (sched,
- get_processing_delay (),
+ pr->task = GNUNET_SCHEDULER_add_delayed (get_processing_delay (),
&forward_request_task,
pr);
return;
"Selected peer disconnected!\n");
#endif
if (pr->task == GNUNET_SCHEDULER_NO_TASK)
- pr->task = GNUNET_SCHEDULER_add_delayed (sched,
- get_processing_delay (),
+ pr->task = GNUNET_SCHEDULER_add_delayed (get_processing_delay (),
&forward_request_task,
pr);
return;
1,
GNUNET_NO);
if (pr->task == GNUNET_SCHEDULER_NO_TASK)
- pr->task = GNUNET_SCHEDULER_add_delayed (sched,
- get_processing_delay (),
+ pr->task = GNUNET_SCHEDULER_add_delayed (get_processing_delay (),
&forward_request_task,
pr);
return; /* this target round failed */
GNUNET_h2s (&pr->query),
delay.rel_value);
#endif
- pr->task = GNUNET_SCHEDULER_add_delayed (sched,
- delay,
+ pr->task = GNUNET_SCHEDULER_add_delayed (delay,
&forward_request_task,
pr);
return; /* nobody selected */
cp = GNUNET_CONTAINER_multihashmap_get (connected_peers,
&psc.target.hashPubKey);
GNUNET_assert (NULL != cp);
- pr->irc = GNUNET_CORE_peer_change_preference (sched, cfg,
+ pr->irc = GNUNET_CORE_peer_change_preference (cfg,
&psc.target,
GNUNET_CONSTANTS_SERVICE_TIMEOUT,
GNUNET_BANDWIDTH_value_init (UINT32_MAX),
pr->do_remove = GNUNET_YES;
if (pr->task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- pr->task);
+ GNUNET_SCHEDULER_cancel (pr->task);
pr->task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_break (GNUNET_YES ==
}
/* no more results */
if (pr->task == GNUNET_SCHEDULER_NO_TASK)
- pr->task = GNUNET_SCHEDULER_add_now (sched,
- &forward_request_task,
+ pr->task = GNUNET_SCHEDULER_add_now (&forward_request_task,
pr);
return;
}
}
default:
if (pr->task == GNUNET_SCHEDULER_NO_TASK)
- pr->task = GNUNET_SCHEDULER_add_now (sched,
- &forward_request_task,
+ pr->task = GNUNET_SCHEDULER_add_now (&forward_request_task,
pr);
}
/**
* Process fs requests.
*
- * @param s scheduler to use
* @param server the initialized server
* @param c configuration to use
*/
static int
-main_init (struct GNUNET_SCHEDULER_Handle *s,
- struct GNUNET_SERVER_Handle *server,
+main_init (struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
static const struct GNUNET_CORE_MessageHandler p2p_handlers[] =
};
unsigned long long enc = 128;
- sched = s;
cfg = c;
- stats = GNUNET_STATISTICS_create (sched, "fs", cfg);
+ stats = GNUNET_STATISTICS_create ("fs", cfg);
min_migration_delay = GNUNET_TIME_UNIT_SECONDS;
if ( (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg,
rt_entry_lifetime = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_FOREVER_REL);
peer_request_map = GNUNET_CONTAINER_multihashmap_create (enc);
requests_by_expiration_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
- core = GNUNET_CORE_connect (sched,
- cfg,
+ core = GNUNET_CORE_connect (cfg,
GNUNET_TIME_UNIT_FOREVER_REL,
NULL,
NULL,
"TRUST",
&trustDirectory));
GNUNET_DISK_directory_create (trustDirectory);
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_HIGH,
&cron_flush_trust, NULL);
GNUNET_SERVER_add_handlers (server, handlers);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
return GNUNET_OK;
* Process fs requests.
*
* @param cls closure
- * @param sched scheduler to use
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
active_migration = GNUNET_CONFIGURATION_get_value_yesno (cfg,
"FS",
"ACTIVEMIGRATION");
- dsh = GNUNET_DATASTORE_connect (cfg,
- sched);
+ dsh = GNUNET_DATASTORE_connect (cfg);
if (dsh == NULL)
{
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
datastore_get_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
"fs");
block_ctx = GNUNET_BLOCK_context_create (block_cfg);
GNUNET_assert (NULL != block_ctx);
- dht_handle = GNUNET_DHT_connect (sched,
- cfg,
+ dht_handle = GNUNET_DHT_connect (cfg,
FS_DHT_HT_SIZE);
- if ( (GNUNET_OK != GNUNET_FS_indexing_init (sched, cfg, dsh)) ||
- (GNUNET_OK != main_init (sched, server, cfg)) )
+ if ( (GNUNET_OK != GNUNET_FS_indexing_init (cfg, dsh)) ||
+ (GNUNET_OK != main_init (server, cfg)) )
{
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
GNUNET_DATASTORE_disconnect (dsh, GNUNET_NO);
dsh = NULL;
GNUNET_DHT_disconnect (dht_handle);
*/
static struct GNUNET_CONTAINER_MultiHashMap *ifm;
-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
(unsigned int) mydev);
#endif
/* slow validation, need to hash full file (again) */
- ii->fhc = GNUNET_CRYPTO_hash_file (sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ ii->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
fn,
HASHING_BLOCKSIZE,
&hash_for_index_val,
indexed_files = pos->next;
GNUNET_free (pos);
}
- sched = NULL;
cfg = NULL;
}
/**
* Initialize the indexing submodule.
*
- * @param s scheduler to use
* @param c configuration to use
* @param d datastore to use
*/
int
-GNUNET_FS_indexing_init (struct GNUNET_SCHEDULER_Handle *s,
- const struct GNUNET_CONFIGURATION_Handle *c,
+GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_DATASTORE_Handle *d)
{
- sched = s;
cfg = c;
dsh = d;
ifm = GNUNET_CONTAINER_multihashmap_create (128);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
read_index_list ();
/**
* Initialize the indexing submodule.
*
- * @param s scheduler to use
* @param c configuration to use
* @param d datastore to use
* @return GNUNET_OK on success
*/
int
-GNUNET_FS_indexing_init (struct GNUNET_SCHEDULER_Handle *s,
- const struct GNUNET_CONFIGURATION_Handle *c,
+GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_DATASTORE_Handle *d);
static struct GNUNET_FS_UnindexContext *uc;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static void
cleanup_task (void *cls,
fprintf (stderr,
_("Error unindexing: %s.\n"),
info->value.unindex.specifics.error.message);
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
break;
case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
fprintf (stdout,
_("Unindexing done.\n"));
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
break;
case GNUNET_FS_STATUS_UNINDEX_STOPPED:
- GNUNET_SCHEDULER_add_continuation (sched,
- &cleanup_task,
+ GNUNET_SCHEDULER_add_continuation (&cleanup_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
ret = -1;
return;
}
- sched = s;
cfg = c;
- ctx = GNUNET_FS_start (sched,
- cfg,
+ ctx = GNUNET_FS_start (cfg,
"gnunet-unindex",
&progress_cb,
NULL,
GNUNET_FS_stop (ctx);
return;
}
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS];
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
static struct GNUNET_TIME_Absolute start_time;
do_stop (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_FS_TEST_daemons_stop (sched,
- NUM_DAEMONS,
+ GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
daemons);
}
struct StatMaster *sm = cls;
GNUNET_break (GNUNET_OK == success);
sm->value++;
- GNUNET_SCHEDULER_add_now (sched, &stat_run, sm);
+ GNUNET_SCHEDULER_add_now (&stat_run, sm);
}
if (sm->daemon == NUM_DAEMONS)
{
GNUNET_free (sm);
- GNUNET_SCHEDULER_add_now (sched, &do_stop, NULL);
+ GNUNET_SCHEDULER_add_now (&do_stop, NULL);
return;
}
- sm->stat = GNUNET_STATISTICS_create (sched, "<driver>",
+ sm->stat = GNUNET_STATISTICS_create ("<driver>",
GNUNET_FS_TEST_get_configuration (daemons,
sm->daemon));
- GNUNET_SCHEDULER_add_now (sched, &stat_run, sm);
+ GNUNET_SCHEDULER_add_now (&stat_run, sm);
}
"Finished download, shutting down\n",
(unsigned long long) FILESIZE);
sm = GNUNET_malloc (sizeof (struct StatMaster));
- sm->stat = GNUNET_STATISTICS_create (sched, "<driver>",
+ sm->stat = GNUNET_STATISTICS_create ("<driver>",
GNUNET_FS_TEST_get_configuration (daemons,
sm->daemon));
- GNUNET_SCHEDULER_add_now (sched, &stat_run, sm);
+ GNUNET_SCHEDULER_add_now (&stat_run, sm);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Timeout during download, shutting down with error\n");
ok = 1;
- GNUNET_SCHEDULER_add_now (sched, &do_stop, NULL);
+ GNUNET_SCHEDULER_add_now (&do_stop, NULL);
}
}
if (NULL == uri)
{
- GNUNET_FS_TEST_daemons_stop (sched,
- NUM_DAEMONS,
+ GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
daemons);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Timeout during upload attempt, shutting down with error\n");
anonymity = 0;
else
anonymity = 1;
- GNUNET_FS_TEST_download (sched,
- daemons[0],
+ GNUNET_FS_TEST_download (daemons[0],
TIMEOUT,
anonymity, SEED, uri,
VERBOSE,
if (NULL != emsg)
{
- GNUNET_FS_TEST_daemons_stop (sched,
- NUM_DAEMONS,
+ GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
daemons);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Error trying to connect: %s\n",
else
anonymity = 1;
- GNUNET_FS_TEST_publish (sched,
- daemons[NUM_DAEMONS-1],
+ GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS-1],
TIMEOUT,
anonymity,
do_index, FILESIZE, SEED,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
- GNUNET_FS_TEST_daemons_start (sched,
- "fs_test_lib_data.conf",
+ GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
TIMEOUT,
NUM_DAEMONS,
daemons,
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_DownloadContext *download;
GNUNET_DISK_directory_remove (fn);
GNUNET_free (fn);
fn = NULL;
- GNUNET_SCHEDULER_cancel (sched, timeout_kill);
+ GNUNET_SCHEDULER_cancel (timeout_kill);
timeout_kill = GNUNET_SCHEDULER_NO_TASK;
}
case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
printf ("Download complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
- GNUNET_SCHEDULER_add_now (sched,
- &abort_download_task,
+ GNUNET_SCHEDULER_add_now (&abort_download_task,
NULL);
break;
case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
"Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
fprintf (stderr,
"Error downloading file: %s\n",
event->value.download.specifics.error.message);
- GNUNET_SCHEDULER_add_now (sched,
- &abort_download_task,
+ GNUNET_SCHEDULER_add_now (&abort_download_task,
NULL);
break;
case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
GNUNET_assert (publish == event->value.publish.pc);
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (1 == event->value.publish.anonymity);
- GNUNET_SCHEDULER_add_now (sched,
- &stop_fs_task,
+ GNUNET_SCHEDULER_add_now (&stop_fs_task,
NULL);
break;
case GNUNET_FS_STATUS_DOWNLOAD_START:
break;
case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
GNUNET_assert (download == event->value.download.dc);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_FS_FileInformation *fi;
size_t i;
- sched = s;
setup_peer (&p1, "test_fs_download_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-download",
&progress_cb,
NULL,
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fi);
- timeout_kill = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&timeout_kill_task,
NULL);
start = GNUNET_TIME_absolute_get ();
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_DownloadContext *download;
GNUNET_DISK_directory_remove (fn);
GNUNET_free (fn);
fn = NULL;
- GNUNET_SCHEDULER_cancel (sched, timeout_kill);
+ GNUNET_SCHEDULER_cancel (timeout_kill);
timeout_kill = GNUNET_SCHEDULER_NO_TASK;
}
case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
printf ("Download complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
- GNUNET_SCHEDULER_add_now (sched,
- &abort_download_task,
+ GNUNET_SCHEDULER_add_now (&abort_download_task,
NULL);
break;
case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
"Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
fprintf (stderr,
"Error downloading file: %s\n",
event->value.download.specifics.error.message);
- GNUNET_SCHEDULER_add_now (sched,
- &abort_download_task,
+ GNUNET_SCHEDULER_add_now (&abort_download_task,
NULL);
break;
case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
GNUNET_assert (publish == event->value.publish.pc);
GNUNET_assert (FILESIZE == event->value.publish.size);
GNUNET_assert (1 == event->value.publish.anonymity);
- GNUNET_SCHEDULER_add_now (sched,
- &stop_fs_task,
+ GNUNET_SCHEDULER_add_now (&stop_fs_task,
NULL);
break;
case GNUNET_FS_STATUS_DOWNLOAD_START:
break;
case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
GNUNET_assert (download == event->value.download.dc);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_FS_FileInformation *fi;
size_t i;
- sched = s;
setup_peer (&p1, "test_fs_download_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-download-indexed",
&progress_cb,
NULL,
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fi);
- timeout_kill = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&timeout_kill_task,
NULL);
start = GNUNET_TIME_absolute_get ();
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static const struct GNUNET_CONFIGURATION_Handle *cfg;
static struct GNUNET_FS_Handle *fs;
GNUNET_DISK_directory_remove (fn);
GNUNET_free (fn);
fn = NULL;
- GNUNET_SCHEDULER_cancel (sched, timeout_kill);
+ GNUNET_SCHEDULER_cancel (timeout_kill);
timeout_kill = GNUNET_SCHEDULER_NO_TASK;
}
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_FS_stop (fs);
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-download-persistence",
&progress_cb,
NULL,
if (prev[i] == ev)
return;
prev[off++] = ev;
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_URGENT,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
&restart_fs_task,
NULL);
}
consider_restart (event->status);
printf ("Download complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
- GNUNET_SCHEDULER_add_now (sched,
- &abort_download_task,
+ GNUNET_SCHEDULER_add_now (&abort_download_task,
NULL);
break;
case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
"Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
fprintf (stderr,
"Error downloading file: %s\n",
event->value.download.specifics.error.message);
- GNUNET_SCHEDULER_add_now (sched,
- &abort_download_task,
+ GNUNET_SCHEDULER_add_now (&abort_download_task,
NULL);
break;
case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
break;
case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
GNUNET_assert (download == event->value.download.dc);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
download = NULL;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
struct GNUNET_FS_FileInformation *fi;
size_t i;
- sched = s;
cfg = c;
setup_peer (&p1, "test_fs_download_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-download-persistence",
&progress_cb,
NULL,
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fi);
- timeout_kill = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&timeout_kill_task,
NULL);
start = GNUNET_TIME_absolute_get ();
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_FS_Handle *fs;
size_t i;
- fs = GNUNET_FS_start (s, cfg, "test-fs-file-information", NULL, NULL,
+ fs = GNUNET_FS_start (cfg, "test-fs-file-information", NULL, NULL,
GNUNET_FS_FLAGS_NONE,
GNUNET_FS_OPTIONS_END);
fn1 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_PublishContext *publish;
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
(unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
if (0 == strcmp ("list_indexed-context-dir",
event->value.publish.cctx))
- GNUNET_SCHEDULER_add_continuation (sched,
- &list_indexed_task,
+ GNUNET_SCHEDULER_add_continuation (&list_indexed_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
err = 1;
if (0 == strcmp ("list_indexed-context-dir",
event->value.publish.cctx))
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_FS_FileInformation *fidir;
size_t i;
- sched = s;
setup_peer (&p1, "test_fs_list_indexed_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-list_indexed",
&progress_cb,
NULL,
#define START_ARM GNUNET_YES
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct PeerContext p1;
static GNUNET_HashCode nsid;
err = 1;
}
/* give system 1ms to initiate update search! */
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_MILLISECONDS,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
&abort_sks_search_task,
NULL);
}
"Wrong result for ksk search!\n");
err = 1;
}
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_ksk_search_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
"Error searching file: %s\n",
event->value.search.specifics.error.message);
if (sks_search == event->value.search.sc)
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_sks_search_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_sks_search_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
else if (ksk_search == event->value.search.sc)
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_ksk_search_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
else
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
setup_peer (&p1, "test_fs_namespace_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-namespace",
&progress_cb,
NULL,
#define START_ARM GNUNET_YES
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct PeerContext p1;
static struct GNUNET_FS_Handle *fs;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
setup_peer (&p1, "test_fs_namespace_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-namespace",
&progress_cb,
NULL,
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_PublishContext *publish;
(unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
if (0 == strcmp ("publish-context-dir",
event->value.publish.cctx))
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
{
fprintf (stderr, "Scheduling abort task for error on `%s'\n",
(const char*) event->value.publish.cctx);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_FS_FileInformation *fidir;
size_t i;
- sched = s;
setup_peer (&p1, "test_fs_publish_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-publish",
&progress_cb,
NULL,
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static const struct GNUNET_CONFIGURATION_Handle *cfg;
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_FS_stop (fs);
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-publish-persistence",
&progress_cb,
NULL,
if (prev[i] == ev)
return;
prev[off++] = ev;
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_URGENT,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
&restart_fs_task,
NULL);
}
(unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
if (0 == strcmp ("publish-context-dir",
event->value.publish.cctx))
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
err = 1;
if (0 == strcmp ("publish-context-dir",
event->value.publish.cctx))
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
struct GNUNET_FS_FileInformation *fidir;
size_t i;
- sched = s;
cfg = c;
setup_peer (&p1, "test_fs_publish_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-publish-persistence",
&progress_cb,
NULL,
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_SearchContext *search;
#if VERBOSE
printf ("Search complete.\n");
#endif
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_search_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_search_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
"Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
fprintf (stderr,
"Error searching file: %s\n",
event->value.search.specifics.error.message);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_search_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_search_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
break;
case GNUNET_FS_STATUS_SEARCH_STOPPED:
GNUNET_assert (search == event->value.search.sc);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_FS_FileInformation *fi;
size_t i;
- sched = s;
setup_peer (&p1, "test_fs_search_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-search",
&progress_cb,
NULL,
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_SearchContext *search;
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_FS_stop (fs);
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-search-persistence",
&progress_cb,
NULL,
if (prev[i] == ev)
return;
prev[off++] = ev;
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_URGENT,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
&restart_fs_task,
NULL);
}
#if VERBOSE
printf ("Search complete.\n");
#endif
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_search_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_search_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
"Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
fprintf (stderr,
"Error searching file: %s\n",
event->value.search.specifics.error.message);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_search_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_search_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
break;
case GNUNET_FS_STATUS_SEARCH_STOPPED:
GNUNET_assert (search == event->value.search.sc);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
search = NULL;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
struct GNUNET_FS_FileInformation *fi;
size_t i;
- sched = s;
cfg = c;
setup_peer (&p1, "test_fs_search_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-search-persistence",
&progress_cb,
NULL,
#define START_ARM GNUNET_YES
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct PeerContext p1;
struct PeerContext
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_FS_Handle *fs;
- sched = s;
setup_peer (&p1, "test_fs_data.conf");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-start-stop",
&progress_cb,
NULL,
static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS];
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ret;
static void
"Finished download, shutting down\n",
(unsigned long long) FILESIZE);
}
- GNUNET_FS_TEST_daemons_stop (sched,
- NUM_DAEMONS,
+ GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
daemons);
}
if (NULL == uri)
{
GNUNET_break (0);
- GNUNET_SCHEDULER_add_now (sched,
- &do_stop,
+ GNUNET_SCHEDULER_add_now (&do_stop,
NULL);
ret = 1;
return;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Downloading %llu bytes\n",
(unsigned long long) FILESIZE);
- GNUNET_FS_TEST_download (sched,
- daemons[0],
+ GNUNET_FS_TEST_download (daemons[0],
TIMEOUT,
1, SEED, uri,
VERBOSE,
{
GNUNET_break (0);
ret = 1;
- GNUNET_SCHEDULER_add_now (sched,
- &do_stop,
+ GNUNET_SCHEDULER_add_now (&do_stop,
NULL);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Publishing %llu bytes\n",
(unsigned long long) FILESIZE);
- GNUNET_FS_TEST_publish (sched,
- daemons[0],
+ GNUNET_FS_TEST_publish (daemons[0],
TIMEOUT,
1, GNUNET_NO, FILESIZE, SEED,
VERBOSE,
{
GNUNET_break (0);
ret = 1;
- GNUNET_SCHEDULER_add_now (sched,
- &do_stop,
+ GNUNET_SCHEDULER_add_now (&do_stop,
NULL);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Daemons started, will now try to connect them\n");
- GNUNET_FS_TEST_daemons_connect (sched,
- daemons[0],
+ GNUNET_FS_TEST_daemons_connect (daemons[0],
daemons[1],
TIMEOUT,
&do_publish,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
- GNUNET_FS_TEST_daemons_start (sched,
- "fs_test_lib_data.conf",
+ GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
TIMEOUT,
NUM_DAEMONS,
daemons,
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_UnindexContext *unindex;
case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
printf ("Unindex complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_unindex_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
"Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
fprintf (stderr,
"Error unindexing file: %s\n",
event->value.unindex.specifics.error.message);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_unindex_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
break;
case GNUNET_FS_STATUS_UNINDEX_STOPPED:
GNUNET_assert (unindex == event->value.unindex.uc);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_FS_FileInformation *fi;
size_t i;
- sched = s;
setup_peer (&p1, "test_fs_unindex_data.conf");
fn = GNUNET_DISK_mktemp ("gnunet-unindex-test-dst");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-unindex",
&progress_cb,
NULL,
static struct GNUNET_TIME_Absolute start;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_FS_Handle *fs;
static struct GNUNET_FS_UnindexContext *unindex;
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_FS_stop (fs);
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-unindex-persistence",
&progress_cb,
NULL,
if (prev[i] == ev)
return;
prev[off++] = ev;
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_URGENT,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
&restart_fs_task,
NULL);
}
case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
printf ("Unindex complete, %llu kbps.\n",
(unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_unindex_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
"Error publishing file: %s\n",
event->value.publish.specifics.error.message);
GNUNET_break (0);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
fprintf (stderr,
"Error unindexing file: %s\n",
event->value.unindex.specifics.error.message);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_unindex_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
break;
case GNUNET_FS_STATUS_UNINDEX_STOPPED:
GNUNET_assert (unindex == event->value.unindex.uc);
- GNUNET_SCHEDULER_add_continuation (sched,
- &abort_publish_task,
+ GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
NULL,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
break;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
struct GNUNET_FS_FileInformation *fi;
size_t i;
- sched = s;
cfg = c;
setup_peer (&p1, "test_fs_unindex_data.conf");
fn = GNUNET_DISK_mktemp ("gnunet-unindex-test-dst");
- fs = GNUNET_FS_start (sched,
- cfg,
+ fs = GNUNET_FS_start (cfg,
"test-fs-unindex-persistence",
&progress_cb,
NULL,
static struct GNUNET_FS_TestDaemon *daemons[2];
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
static struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Relative del;
char *fancy;
- GNUNET_FS_TEST_daemons_stop (sched,
- 2,
+ GNUNET_FS_TEST_daemons_stop (2,
daemons);
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
{
if (emsg != NULL)
{
- GNUNET_FS_TEST_daemons_stop (sched,
- 2,
+ GNUNET_FS_TEST_daemons_stop (2,
daemons);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to stop source daemon: %s\n",
"Downloading %llu bytes\n",
(unsigned long long) FILESIZE);
start_time = GNUNET_TIME_absolute_get ();
- GNUNET_FS_TEST_download (sched,
- daemons[0],
+ GNUNET_FS_TEST_download (daemons[0],
TIMEOUT,
1, SEED, uri,
VERBOSE,
if (NULL == uri)
{
- GNUNET_FS_TEST_daemons_stop (sched,
- 2,
+ GNUNET_FS_TEST_daemons_stop (2,
daemons);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout during upload attempt, shutting down with error\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Waiting to allow content to migrate\n");
d = GNUNET_FS_uri_dup (uri);
- (void) GNUNET_SCHEDULER_add_delayed (sched,
- MIGRATION_DELAY,
+ (void) GNUNET_SCHEDULER_add_delayed (MIGRATION_DELAY,
&stop_source_peer,
d);
}
{
if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
{
- GNUNET_FS_TEST_daemons_stop (sched,
- 2,
+ GNUNET_FS_TEST_daemons_stop (2,
daemons);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout during connect attempt, shutting down with error\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Publishing %llu bytes\n",
(unsigned long long) FILESIZE);
- GNUNET_FS_TEST_publish (sched,
- daemons[1],
+ GNUNET_FS_TEST_publish (daemons[1],
TIMEOUT,
1, GNUNET_NO, FILESIZE, SEED,
VERBOSE,
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Daemons started, will now try to connect them\n");
- GNUNET_FS_TEST_daemons_connect (sched,
- daemons[0],
+ GNUNET_FS_TEST_daemons_connect (daemons[0],
daemons[1],
TIMEOUT,
&do_publish,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
- GNUNET_FS_TEST_daemons_start (sched,
- "test_gnunet_service_fs_migration_data.conf",
+ GNUNET_FS_TEST_daemons_start ("test_gnunet_service_fs_migration_data.conf",
TIMEOUT,
2,
daemons,
static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS];
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
static struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Relative del;
char *fancy;
- GNUNET_FS_TEST_daemons_stop (sched,
- NUM_DAEMONS,
+ GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
daemons);
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
{
{
if (NULL == uri)
{
- GNUNET_FS_TEST_daemons_stop (sched,
- NUM_DAEMONS,
+ GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
daemons);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout during upload attempt, shutting down with error\n");
"Downloading %llu bytes\n",
(unsigned long long) FILESIZE);
start_time = GNUNET_TIME_absolute_get ();
- GNUNET_FS_TEST_download (sched,
- daemons[0],
+ GNUNET_FS_TEST_download (daemons[0],
TIMEOUT,
1, SEED, uri,
VERBOSE,
{
if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
{
- GNUNET_FS_TEST_daemons_stop (sched,
- NUM_DAEMONS,
+ GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
daemons);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout during connect attempt, shutting down with error\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Publishing %llu bytes\n",
(unsigned long long) FILESIZE);
- GNUNET_FS_TEST_publish (sched,
- daemons[1],
+ GNUNET_FS_TEST_publish (daemons[1],
TIMEOUT,
1, GNUNET_NO, FILESIZE, SEED,
VERBOSE,
GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Daemons started, will now try to connect them\n");
- GNUNET_FS_TEST_daemons_connect (sched,
- daemons[0],
+ GNUNET_FS_TEST_daemons_connect (daemons[0],
daemons[1],
TIMEOUT,
&do_publish,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
- GNUNET_FS_TEST_daemons_start (sched,
- "fs_test_lib_data.conf",
+ GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
TIMEOUT,
NUM_DAEMONS,
daemons,
* Main function that will be run.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle * sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle * cfg)
- stats = GNUNET_STATISTICS_create (sched, "hostlist", cfg);
+ stats = GNUNET_STATISTICS_create ("hostlist", cfg);
- core = GNUNET_CORE_connect (sched, cfg,
+ core = GNUNET_CORE_connect (cfg,
GNUNET_TIME_UNIT_FOREVER_REL,
NULL,
&core_init,
if (bootstrapping)
{
- GNUNET_HOSTLIST_client_start (cfg, sched, stats,
+ GNUNET_HOSTLIST_client_start (cfg, stats,
&client_ch, &client_dh, &client_adv_handler, learning);
}
#if HAVE_MHD
if (provide_hostlist)
{
- GNUNET_HOSTLIST_server_start (cfg, sched, stats, core, &server_ch, &server_dh, advertising );
+ GNUNET_HOSTLIST_server_start (cfg, stats, core, &server_ch, &server_dh, advertising );
}
#endif
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&cleaning_task, NULL);
if (NULL == core)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to `%s' service.\n"),
"core");
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
}
*/
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Statistics handle.
*/
"Scheduling task for hostlist download using cURL\n");
#endif
ti_download
- = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
rtime,
grs,
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Download in progess, have to wait...\n");
- ti_download_dispatcher_task = GNUNET_SCHEDULER_add_delayed (sched,
- WAITING_INTERVALL,
+ ti_download_dispatcher_task = GNUNET_SCHEDULER_add_delayed (WAITING_INTERVALL,
&task_download_dispatcher,
NULL);
}
if (stat_connection_count < MIN_CONNECTIONS)
{
- ti_download_dispatcher_task = GNUNET_SCHEDULER_add_now ( sched,
- &task_download_dispatcher,
+ ti_download_dispatcher_task = GNUNET_SCHEDULER_add_now (&task_download_dispatcher,
NULL);
}
stat_connection_count,
MIN_CONNECTIONS,
(unsigned long long) delay.rel_value);
- ti_check_download = GNUNET_SCHEDULER_add_delayed (sched,
- delay,
+ ti_check_download = GNUNET_SCHEDULER_add_delayed (delay,
&task_check,
NULL);
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Hostlists will be saved to file again in %llums\n"),
(unsigned long long) SAVING_INTERVALL.rel_value);
- ti_saving_task = GNUNET_SCHEDULER_add_delayed (sched,
- SAVING_INTERVALL,
+ ti_saving_task = GNUNET_SCHEDULER_add_delayed (SAVING_INTERVALL,
&task_hostlist_saving,
NULL);
}
stat_testing_hostlist = GNUNET_YES;
stat_testing_allowed = GNUNET_NO;
- ti_testing_intervall_task = GNUNET_SCHEDULER_add_delayed (sched,
- TESTING_INTERVAL,
+ ti_testing_intervall_task = GNUNET_SCHEDULER_add_delayed (TESTING_INTERVAL,
&task_testing_intervall_reset,
NULL);
"Testing new hostlist advertisements is locked for the next %u ms\n",
TESTING_INTERVAL.rel_value);
- ti_download_dispatcher_task = GNUNET_SCHEDULER_add_now (sched,
- &task_download_dispatcher,
+ ti_download_dispatcher_task = GNUNET_SCHEDULER_add_now (&task_download_dispatcher,
NULL);
return GNUNET_OK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Statistics request done, scheduling hostlist download\n");
#endif
- ti_check_download = GNUNET_SCHEDULER_add_now (sched,
- &task_check,
+ ti_check_download = GNUNET_SCHEDULER_add_now (&task_check,
NULL);
}
*/
int
GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_STATISTICS_Handle *st,
GNUNET_CORE_ConnectEventHandler *ch,
GNUNET_CORE_DisconnectEventHandler *dh,
GNUNET_break (0);
return GNUNET_SYSERR;
}
- transport = GNUNET_TRANSPORT_connect (s, c, NULL, NULL, NULL, NULL, NULL);
+ transport = GNUNET_TRANSPORT_connect (c, NULL, NULL, NULL, NULL, NULL);
if (NULL == transport)
{
curl_global_cleanup ();
return GNUNET_SYSERR;
}
cfg = c;
- sched = s;
stats = st;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg,
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Hostlists will be saved to file again in %llums\n"),
(unsigned long long) SAVING_INTERVALL.rel_value);
- ti_saving_task = GNUNET_SCHEDULER_add_delayed (sched,
- SAVING_INTERVALL,
+ ti_saving_task = GNUNET_SCHEDULER_add_delayed (SAVING_INTERVALL,
&task_hostlist_saving,
NULL);
}
if (ti_saving_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- ti_saving_task);
+ GNUNET_SCHEDULER_cancel (ti_saving_task);
}
if (ti_download_dispatcher_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- ti_download_dispatcher_task);
+ GNUNET_SCHEDULER_cancel (ti_download_dispatcher_task);
}
if (ti_testing_intervall_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- ti_testing_intervall_task);
+ GNUNET_SCHEDULER_cancel (ti_testing_intervall_task);
}
if (ti_download != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- ti_download);
+ GNUNET_SCHEDULER_cancel (ti_download);
}
if (ti_check_download != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- ti_check_download);
+ GNUNET_SCHEDULER_cancel (ti_check_download);
curl_global_cleanup ();
}
if (transport != NULL)
GNUNET_free_non_null (proxy);
proxy = NULL;
cfg = NULL;
- sched = NULL;
}
/* end of hostlist-client.c */
* Start downloading hostlists from hostlist servers as necessary.
*
* @param c the configuration to use
- * @param s the scheduler to use
* @param st hande for publishing statistics
* @param ch set to handler for connect notifications
* @param dh set to handler for disconnect notifications
*/
int
GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_STATISTICS_Handle *st,
GNUNET_CORE_ConnectEventHandler *ch,
GNUNET_CORE_DisconnectEventHandler *dh,
*/
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* For keeping statistics.
*/
GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
GNUNET_NETWORK_fdset_copy_native (wes, &es, max + 1);
- ret = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
+ ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
GNUNET_SCHEDULER_NO_TASK,
tv,
wrs,
*/
int
GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_STATISTICS_Handle *st,
struct GNUNET_CORE_Handle *co,
GNUNET_CORE_ConnectEventHandler *server_ch,
else
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Advertising enabled on this hostlist server\n");
- sched = s;
cfg = c;
stats = st;
- peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
+ peerinfo = GNUNET_PEERINFO_connect (cfg);
if (peerinfo == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
if (daemon_handle_v6 != NULL)
hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
- notify = GNUNET_PEERINFO_notify ( cfg, sched, process_notify, NULL);
+ notify = GNUNET_PEERINFO_notify ( cfg, process_notify, NULL);
return GNUNET_OK;
}
}
if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v6)
{
- GNUNET_SCHEDULER_cancel (sched, hostlist_task_v6);
+ GNUNET_SCHEDULER_cancel (hostlist_task_v6);
hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v4)
{
- GNUNET_SCHEDULER_cancel (sched, hostlist_task_v4);
+ GNUNET_SCHEDULER_cancel (hostlist_task_v4);
hostlist_task_v4 = GNUNET_SCHEDULER_NO_TASK;
}
if (pitr != NULL)
peerinfo = NULL;
}
cfg = NULL;
- sched = NULL;
stats = NULL;
core = NULL;
}
*/
int
GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_STATISTICS_Handle *st,
struct GNUNET_CORE_Handle *core,
GNUNET_CORE_ConnectEventHandler *server_ch,
static int ok;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
struct PeerContext
GNUNET_TRANSPORT_disconnect (p2.th);
p2.th = NULL;
}
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
}
/**
ok = 0;
if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- timeout_task);
+ GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_SCHEDULER_add_now (sched,
- &clean_up, NULL);
+ GNUNET_SCHEDULER_add_now (&clean_up, NULL);
}
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL, p, NULL,
+ p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL,
¬ify_connect, NULL);
GNUNET_assert (p->th != NULL);
GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Asking ARM to stop core service\n");
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_SECONDS,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&waitpid_task, p);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
ok++;
- sched = s;
- timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&timeout_error,
NULL);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
setup_peer (&p1, "test_gnunet_daemon_hostlist_peer1.conf");
#include "gnunet_resolver_service.h"
#include "gnunet_statistics_service.h"
-#define VERBOSE GNUNET_NO
+#define VERBOSE GNUNET_YES
#define START_ARM GNUNET_YES
-
#define MAX_URL_LEN 1000
/**
* How long until wait until testcases fails
*/
#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180)
-
#define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
static int timeout;
-
static int adv_sent;
-
static int adv_arrived;
static int learned_hostlist_saved;
-
static int learned_hostlist_downloaded;
static char * current_adv_uri;
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
-
static GNUNET_SCHEDULER_TaskIdentifier check_task;
struct PeerContext
static struct PeerContext learn_peer;
static struct GNUNET_STATISTICS_GetHandle * download_stats;
-
static struct GNUNET_STATISTICS_GetHandle * urisrecv_stat;
-
static struct GNUNET_STATISTICS_GetHandle * advsent_stat;
-
static void shutdown_testcase()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Timeout Task.\n");
if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, timeout_task);
+ GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_STATISTICS_get_cancel (advsent_stat);
*/
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Statistics Check Task.\n");
- if ((check_task != GNUNET_SCHEDULER_NO_TASK) && (sched !=NULL))
+ if (check_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, check_task);
+ GNUNET_SCHEDULER_cancel (check_task);
check_task = GNUNET_SCHEDULER_NO_TASK;
}
#endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down scheduler\n");
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n");
}
&process_adv_sent,
NULL);
}
- check_task = GNUNET_SCHEDULER_add_delayed (sched,
- CHECK_INTERVALL,
+ check_task = GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL,
&check_statistics,
NULL);
}
}
if ( NULL != filename) GNUNET_free ( filename );
- p->core = GNUNET_CORE_connect (sched, p->cfg,
+ p->core = GNUNET_CORE_connect (p->cfg,
GNUNET_TIME_UNIT_FOREVER_REL,
NULL,
NULL,
NULL, GNUNET_NO,
learn_handlers );
GNUNET_assert ( NULL != p->core );
- p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg);
+ p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
GNUNET_assert ( NULL != p->stats );
}
"-c", cfgname, NULL);
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg);
+ p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
GNUNET_assert ( NULL != p->stats );
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
learned_hostlist_downloaded = GNUNET_NO;
cfg = c;
- sched = s;
setup_adv_peer (&adv_peer, "test_learning_adv_peer.conf");
setup_learn_peer (&learn_peer, "test_learning_learn_peer.conf");
- timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&timeout_error,
NULL);
- check_task = GNUNET_SCHEDULER_add_delayed (sched,
- CHECK_INTERVALL,
+ check_task = GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL,
&check_statistics,
NULL);
}
return ret;
}
-/* end of test_gnunet_daemon_hostlist_learning.c */
+/* end of test_gnunet_daemon_hostlist.c */
* @param cfg configuration to use (needed to contact ARM;
* the ARM service may internally use a different
* configuration to determine how to start the service).
- * @param sched scheduler to use
* @param service service that *this* process is implementing/providing, can be NULL
* @return context to use for further ARM operations, NULL on error
*/
struct GNUNET_ARM_Handle *
GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
const char *service);
/**
* Get a connection with a service.
*
- * @param sched scheduler to use
* @param service_name name of the service
* @param cfg configuration to use
* @return NULL on error (service unknown to configuration)
*/
-struct GNUNET_CLIENT_Connection *GNUNET_CLIENT_connect (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- const char
+struct GNUNET_CLIENT_Connection *GNUNET_CLIENT_connect (const char
*service_name,
const struct
GNUNET_CONFIGURATION_Handle
/**
* Wait until the service is running.
*
- * @param sched scheduler to use
* @param service name of the service to wait for
* @param cfg configuration to use
* @param timeout how long to wait at most in ms
* or "TIMEOUT" (service not known to be running))
* @param task_cls closure for task
*/
-void GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
- const char *service,
+void GNUNET_CLIENT_service_test (const char *service,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
GNUNET_SCHEDULER_Task task, void *task_cls);
* socket should henceforth be no longer used directly.
* GNUNET_socket_destroy will close it.
*
- * @param sched scheduler to use
* @param osSocket existing socket to box
* @return the boxed socket handle
*/
struct GNUNET_CONNECTION_Handle
*GNUNET_CONNECTION_create_from_existing (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- struct
GNUNET_NETWORK_Handle
*osSocket);
* Create a socket handle by accepting on a listen socket. This
* function may block if the listen socket has no connection ready.
*
- * @param sched scheduler to use
* @param access function to use to check if access is allowed
* @param access_cls closure for access
* @param lsock listen socket
* @return the socket handle, NULL on error (for example, access refused)
*/
struct GNUNET_CONNECTION_Handle
- *GNUNET_CONNECTION_create_from_accept (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- GNUNET_CONNECTION_AccessCheck
+ *GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck
access, void *access_cls,
struct
GNUNET_NETWORK_Handle
* This function returns immediately, even if the connection has not
* yet been established. This function only creates TCP connections.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param hostname name of the host to connect to
* @param port port to connect to
* @return the socket handle
*/
struct GNUNET_CONNECTION_Handle
- *GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+ *GNUNET_CONNECTION_create_from_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *hostname,
uint16_t port);
* This function returns immediately, even if the connection has not
* yet been established. This function only creates UNIX connections.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param unixpath path to connect to)
* @return the socket handle, NULL on systems without UNIX support
*/
struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handle *sched,
- const struct
+GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
GNUNET_CONFIGURATION_Handle *cfg,
const char *unixpath);
* This function returns immediately, even if the connection has not
* yet been established. This function only creates TCP connections.
*
- * @param sched scheduler to use
* @param af_family address family to use
* @param serv_addr server address
* @param addrlen length of server address
* @return the socket handle
*/
struct GNUNET_CONNECTION_Handle
- *GNUNET_CONNECTION_create_from_sockaddr (struct
- GNUNET_SCHEDULER_Handle
- *sched, int af_family,
+ *GNUNET_CONNECTION_create_from_sockaddr (int af_family,
const struct sockaddr
*serv_addr,
socklen_t addrlen);
* Certain events (such as connect/disconnect notifications) are not
* subject to queue size limitations.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param timeout after how long should we give up trying to connect to the core service?
* @param cls closure for the various callbacks that follow (including handlers in the handlers array)
* NULL on error (in this case, init is never called)
*/
struct GNUNET_CORE_Handle *
-GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
void *cls,
GNUNET_CORE_StartupCallback init,
* to our connection attempt within the given time frame, 'cont' will
* be called with the TIMEOUT reason code.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param timeout how long to try to talk to core
* @param peer who should we connect to
* @return NULL on error (cont will not be called), otherwise handle for cancellation
*/
struct GNUNET_CORE_PeerRequestHandle *
-GNUNET_CORE_peer_request_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_request_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
const struct GNUNET_PeerIdentity * peer,
GNUNET_SCHEDULER_Task cont,
/**
* Obtain statistics and/or change preferences for the given peer.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param peer identifies the peer
* @param timeout after how long should we give up (and call "info" with NULL
* @return NULL on error
*/
struct GNUNET_CORE_InformationRequestContext *
-GNUNET_CORE_peer_change_preference (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_change_preference (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct GNUNET_PeerIdentity *peer,
struct GNUNET_TIME_Relative timeout,
struct GNUNET_BANDWIDTH_Value32NBO bw_out,
/**
* Obtain statistics and/or change preferences for the given peer.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param peer_cb function to call with the peer information
* @param cb_cls closure for peer_cb
* @return GNUNET_OK if iterating, GNUNET_SYSERR on error
*/
int
-GNUNET_CORE_iterate_peers (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_CORE_ConnectEventHandler peer_cb,
void *cb_cls);
/**
* Compute the hash of an entire file.
*
- * @param sched scheduler to use
* @param priority scheduling priority to use
* @param filename name of file to hash
* @param blocksize number of bytes to process in one task
* @return NULL on (immediate) errror
*/
struct GNUNET_CRYPTO_FileHashContext *
-GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority priority,
+GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
const char *filename,
size_t blocksize,
GNUNET_CRYPTO_HashCompletedCallback callback,
/**
* Create a data cache.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param section section in the configuration that contains our options
* @return handle to use to access the service
*/
struct GNUNET_DATACACHE_Handle *
-GNUNET_DATACACHE_create (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *section);
* Connect to the datastore service.
*
* @param cfg configuration to use
- * @param sched scheduler to use
* @return handle to use to access the service
*/
struct GNUNET_DATASTORE_Handle *GNUNET_DATASTORE_connect (const struct
GNUNET_CONFIGURATION_Handle
- *cfg,
- struct
- GNUNET_SCHEDULER_Handle
- *sched);
+ *cfg);
/**
/**
* Initialize the connection with the DHT service.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param ht_len size of the internal hash table to use for
* processing multiple GET/FIND requests in parallel
* @return NULL on error
*/
struct GNUNET_DHT_Handle *
-GNUNET_DHT_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
unsigned int ht_len);
* If a scheduler does not need to be used, GNUNET_DISK_directory_scan
* may provide a simpler API.
*
- * @param sched scheduler to use
* @param prio priority to use
* @param dirName the name of the directory
* @param callback the method to call for each file
* @param callback_cls closure for callback
*/
-void GNUNET_DISK_directory_iterator_start (struct GNUNET_SCHEDULER_Handle
- *sched,
- enum GNUNET_SCHEDULER_Priority
+void GNUNET_DISK_directory_iterator_start (enum GNUNET_SCHEDULER_Priority
prio, const char *dirName,
GNUNET_DISK_DirectoryIteratorCallback
callback, void *callback_cls);
/**
* Setup a connection to the file-sharing service.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param client_name unique identifier for this client
* @param upcb function to call to notify about FS actions
* @return NULL on error
*/
struct GNUNET_FS_Handle *
-GNUNET_FS_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *client_name,
GNUNET_FS_ProgressCallback upcb,
void *upcb_cls,
* of the local host's addresses should the external port be mapped. The port
* is taken from the corresponding sockaddr_in[6] field.
*
- * @param sched the sheduler used in the program
* @param addr the local address packets should be redirected to
* @param addrlen actual lenght of the address
* @param callback function to call everytime the public IP address changes
* @return NULL on error, otherwise handle that can be used to unregister
*/
struct GNUNET_NAT_Handle *
-GNUNET_NAT_register (struct GNUNET_SCHEDULER_Handle *sched,
- const struct sockaddr *addr,
+GNUNET_NAT_register (const struct sockaddr *addr,
socklen_t addrlen,
GNUNET_NAT_AddressCallback callback,
void *callback_cls);
/**
* Connect to the peerinfo service.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @return NULL on error (configuration related, actual connection
* etablishment may happen asynchronously).
*/
struct GNUNET_PEERINFO_Handle *
-GNUNET_PEERINFO_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg);
+GNUNET_PEERINFO_connect (const struct GNUNET_CONFIGURATION_Handle *cfg);
* twice with the same peer information.
*
* @param cfg configuration to use
- * @param sched scheduler to use
* @param callback the method to call for each peer
* @param callback_cls closure for callback
* @return NULL on error
*/
struct GNUNET_PEERINFO_NotifyContext *
GNUNET_PEERINFO_notify (const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
GNUNET_PEERINFO_Processor callback,
void *callback_cls);
* Main function that will be run.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
typedef void (*GNUNET_PROGRAM_Main) (void *cls,
- struct GNUNET_SCHEDULER_Handle * sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *
/**
* Convert a string to one or more IP addresses.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param hostname the hostname to resolve
* @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
* @return handle that can be used to cancel the request, NULL on error
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_RESOLVER_ip_get (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *hostname,
int domain,
struct GNUNET_TIME_Relative timeout,
/**
* Resolve our hostname to an IP address.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
* @param callback function to call with addresses
* @return handle that can be used to cancel the request, NULL on error
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_RESOLVER_hostname_resolve (const struct GNUNET_CONFIGURATION_Handle *cfg,
int domain,
struct GNUNET_TIME_Relative timeout,
GNUNET_RESOLVER_AddressCallback callback,
/**
* Perform a reverse DNS lookup.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param sa host address
* @param salen length of host address
* @return handle that can be used to cancel the request, NULL on error
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_RESOLVER_hostname_get (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct sockaddr *sa,
socklen_t salen,
int do_resolve,
#endif
#endif
-
-/**
- * Opaque handle for the scheduling service.
- */
-struct GNUNET_SCHEDULER_Handle;
-
/**
* Opaque reference to a task.
*/
*/
struct GNUNET_SCHEDULER_TaskContext
{
-
- /**
- * Scheduler running the task
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Reason why the task is run now
*/
* cause all tasks to run (as soon as possible, respecting
* priorities and prerequisite tasks). Note that tasks
* scheduled AFTER this call may still be delayed arbitrarily.
- *
- * @param sched the scheduler
*/
-void GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched);
+void GNUNET_SCHEDULER_shutdown ();
/**
* dropped (if the decision should be made based on the number of
* tasks ready to run).
*
- * @param sched scheduler to query
- * @param p priority-level to query, use KEEP to query the level
+ * * @param p priority-level to query, use KEEP to query the level
* of the current task, use COUNT to get the sum over
* all priority levels
* @return number of tasks pending right now
*/
-unsigned int GNUNET_SCHEDULER_get_load (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority p);
+unsigned int GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p);
/**
* started. Will return the same value as
* the GNUNET_SCHEDULER_TaskContext's reason field.
*
- * @param sched scheduler to query
- * @return reason(s) why the current task is run
+ * * @return reason(s) why the current task is run
*/
enum GNUNET_SCHEDULER_Reason
-GNUNET_SCHEDULER_get_reason (struct GNUNET_SCHEDULER_Handle *sched);
+GNUNET_SCHEDULER_get_reason ();
/**
* Cancel the task with the specified identifier.
* The task must not yet have run.
*
- * @param sched scheduler to use
- * @param task id of the task to cancel
+ * * @param task id of the task to cancel
* @return the closure of the callback of the cancelled task
*/
-void *GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_TaskIdentifier task);
+void *GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task);
/**
* similar to the other "add" functions except that there is no delay
* and the reason code can be specified.
*
- * @param sched scheduler to use
- * @param task main function of the task
+ * * @param task main function of the task
* @param task_cls closure of task
* @param reason reason for task invocation
*/
void
-GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_Task task,
+GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task,
void *task_cls,
enum GNUNET_SCHEDULER_Reason reason);
* has completed. It will be run with the priority of the calling
* task.
*
- * @param sched scheduler to use
- * @param prerequisite_task run this task after the task with the given
+ * * @param prerequisite_task run this task after the task with the given
* task identifier completes (and any of our other
* conditions, such as delay, read or write-readiness
* are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
GNUNET_SCHEDULER_Task task,
void *task_cls);
/**
* Schedule a new task to be run with a specified priority.
*
- * @param sched scheduler to use
- * @param prio how important is the new task?
+ * * @param prio how important is the new task?
* @param task main function of the task
* @param task_cls closure of task
* @return unique task identifier for the job
* 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_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
GNUNET_SCHEDULER_Task task,
void *task_cls);
* Schedule a new task to be run as soon as possible. The task
* will be run with the priority of the calling task.
*
- * @param sched scheduler to use
- * @param task main function of the task
+ * * @param task main function of the task
* @param task_cls closure of task
* @return unique task identifier for the job
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_now (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_Task task,
+GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task,
void *task_cls);
* will be scheduled for execution once the delay has expired. It
* will be run with the priority of the calling task.
*
- * @param sched scheduler to use
- * @param delay when should this operation time out? Use
+ * * @param delay when should this operation time out? Use
* GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
* @param task main function of the task
* @param task_cls closure of task
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
GNUNET_SCHEDULER_Task task,
void *task_cls);
* socket operation is ready. It will be run with the priority of
* the calling task.
*
- * @param sched scheduler to use
- * @param delay when should this operation time out? Use
+ * * @param delay when should this operation time out? Use
* GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
* @param rfd read file-descriptor
* @param task main function of the task
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
struct GNUNET_NETWORK_Handle *rfd,
GNUNET_SCHEDULER_Task task,
void *task_cls);
* socket operation is ready. It will be run with the priority of
* the calling task.
*
- * @param sched scheduler to use
- * @param delay when should this operation time out? Use
+ * * @param delay when should this operation time out? Use
* GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
* @param wfd write file-descriptor
* @param task main function of the task
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
struct GNUNET_NETWORK_Handle *wfd,
GNUNET_SCHEDULER_Task task,
void *task_cls);
* socket operation is ready. It will be run with the priority of
* the calling task.
*
- * @param sched scheduler to use
- * @param delay when should this operation time out? Use
+ * * @param delay when should this operation time out? Use
* GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
* @param rfd read file-descriptor
* @param task main function of the task
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
const struct GNUNET_DISK_FileHandle *rfd,
GNUNET_SCHEDULER_Task task,
void *task_cls);
* socket operation is ready. It will be run with the priority of
* the calling task.
*
- * @param sched scheduler to use
- * @param delay when should this operation time out? Use
+ * * @param delay when should this operation time out? Use
* GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
* @param wfd write file-descriptor
* @param task main function of the task
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
const struct GNUNET_DISK_FileHandle *wfd,
GNUNET_SCHEDULER_Task task,
void *task_cls);
* || shutdown-active)
* </code>
*
- * @param sched scheduler to use
- * @param prio how important is this task?
+ * * @param prio how important is this task?
* @param prerequisite_task run this task after the task with the given
* task identifier completes (and any of our other
* conditions, such as delay, read or write-readiness
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority prio,
+GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
GNUNET_SCHEDULER_TaskIdentifier
prerequisite_task,
struct GNUNET_TIME_Relative delay,
/**
* Create a new server.
*
- * @param sched scheduler to use
* @param access function for access control
* @param access_cls closure for access
* @param lsocks NULL-terminated array of listen sockets
* (typically, "port" already in use)
*/
struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_CONNECTION_AccessCheck access, void *access_cls,
+GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
struct GNUNET_NETWORK_Handle **lsocks,
struct GNUNET_TIME_Relative
idle_timeout,
/**
* Create a new server.
*
- * @param sched scheduler to use
* @param access function for access control
* @param access_cls closure for access
* @param serverAddr address toes listen on (including port), NULL terminated array
* @return handle for the new server, NULL on error
* (typically, "port" already in use)
*/
-struct GNUNET_SERVER_Handle *GNUNET_SERVER_create (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- GNUNET_CONNECTION_AccessCheck
+struct GNUNET_SERVER_Handle *GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck
access, void *access_cls,
struct sockaddr *const*serverAddr,
const socklen_t *socklen,
* method to run service-specific setup code.
*
* @param cls closure
- * @param sched scheduler to use
* @param server the initialized server
* @param cfg configuration to use
*/
typedef void (*GNUNET_SERVICE_Main) (void *cls,
- struct GNUNET_SCHEDULER_Handle * sched,
struct GNUNET_SERVER_Handle * server,
const struct GNUNET_CONFIGURATION_Handle *
cfg);
* initialized system.
*
* @param serviceName our service name
- * @param sched scheduler to use
* @param cfg configuration to use
* @return NULL on error, service handle
*/
struct GNUNET_SERVICE_Context *GNUNET_SERVICE_start (const char *serviceName,
- struct
- GNUNET_SCHEDULER_Handle
- *sched,
const struct
GNUNET_CONFIGURATION_Handle
*cfg);
/**
* Get handle for the statistics service.
*
- * @param sched scheduler to use
* @param subsystem name of subsystem using the service
* @param cfg services configuration in use
* @return handle to use
*/
struct GNUNET_STATISTICS_Handle
- *GNUNET_STATISTICS_create (struct GNUNET_SCHEDULER_Handle *sched,
- const char *subsystem,
+ *GNUNET_STATISTICS_create (const char *subsystem,
const struct GNUNET_CONFIGURATION_Handle *cfg);
*/
struct GNUNET_TESTING_Daemon
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
* reachable via "ssh" (unless the hostname is "NULL") without the
* need to enter a password.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param timeout how long to wait starting up peers
* @param hostname name of the machine where to run GNUnet
* @return handle to the daemon (actual start will be completed asynchronously)
*/
struct GNUNET_TESTING_Daemon *
-GNUNET_TESTING_daemon_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TESTING_daemon_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
const char *hostname,
const char *ssh_username,
* adjusted to ensure that no two peers running on the same system
* have the same port(s) in their respective configurations.
*
- * @param sched scheduler to use
* @param cfg configuration template to use
* @param total number of daemons to start
* @param timeout total time allowed for peers to start
* @return NULL on error, otherwise handle to control peer group
*/
struct GNUNET_TESTING_PeerGroup *
-GNUNET_TESTING_daemons_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TESTING_daemons_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
unsigned int total,
struct GNUNET_TIME_Relative timeout,
GNUNET_TESTING_NotifyHostkeyCreated hostkey_callback,
* Connect to the transport service. Note that the connection may
* complete (or fail) asynchronously.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param self our own identity (API should check that it matches
* the identity found by transport), or NULL (no check)
* @param nd function to call on disconnect events
* @return NULL on error
*/
-struct GNUNET_TRANSPORT_Handle *GNUNET_TRANSPORT_connect (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- const struct
+struct GNUNET_TRANSPORT_Handle *GNUNET_TRANSPORT_connect (const struct
GNUNET_CONFIGURATION_Handle
*cfg,
const struct GNUNET_PeerIdentity *self,
/**
* Convert a binary address into a human readable address.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param address address to convert (binary format)
* @param addressLen number of bytes in address
* @param aluc_cls closure for aluc
*/
void
-GNUNET_TRANSPORT_address_lookup (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TRANSPORT_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char * address,
size_t addressLen,
int numeric,
* only way to re-enable connections from peers that were previously
* blacklisted.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param cb callback to invoke to check if connections are allowed
* @param cb_cls closure for cb
* @return NULL on error, otherwise handle for cancellation
*/
struct GNUNET_TRANSPORT_Blacklist *
-GNUNET_TRANSPORT_blacklist (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TRANSPORT_blacklist (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_TRANSPORT_BlacklistCallback cb,
void *cb_cls);
* install a port mapping if possible. The external port
* will be returned as part of the address.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param domain communication domain (i.e. PF_INET or PF_INET6)
* @param type communication semantics (SOCK_STREAM, SOCK_DGRAM)
* function will be called with NULL on error
* @param cls closure for callback
*/
-int GNUNET_UPNP_get_ip (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_CONFIGURATION_Handle *cfg,
+int GNUNET_UPNP_get_ip (struct GNUNET_CONFIGURATION_Handle *cfg,
int domain,
int type,
int protocol,
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
*/
struct GNUNET_NAT_NATPMP_Handle *natpmp;
- /**
- * Scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* LAN address as passed by the caller
*/
notify_change (h, h->ext_addr_natpmp, addrlen, port_mapped);
}
- h->pulse_timer = GNUNET_SCHEDULER_add_delayed (h->sched,
- GNUNET_TIME_UNIT_SECONDS,
+ h->pulse_timer = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&nat_pulse, h);
}
* of the local host's addresses should the external port be mapped. The port
* is taken from the corresponding sockaddr_in[6] field.
*
- * @param sched the sheduler used in the program
* @param addr the local address packets should be redirected to
* @param addrlen actual lenght of the address
* @param callback function to call everytime the public IP address changes
* @return NULL on error, otherwise handle that can be used to unregister
*/
struct GNUNET_NAT_Handle *
-GNUNET_NAT_register (struct GNUNET_SCHEDULER_Handle
- *sched,
- const struct sockaddr *addr,
+GNUNET_NAT_register (const struct sockaddr *addr,
socklen_t addrlen,
GNUNET_NAT_AddressCallback callback, void *callback_cls)
{
}
}
h->should_change = GNUNET_YES;
- h->sched = sched;
h->is_enabled = GNUNET_YES;
h->upnp_status = GNUNET_NAT_PORT_UNMAPPED;
h->natpmp_status = GNUNET_NAT_PORT_UNMAPPED;
h->callback = callback;
h->callback_cls = callback_cls;
h->upnp =
- GNUNET_NAT_UPNP_init (h->sched, h->local_addr, addrlen, h->public_port,
+ GNUNET_NAT_UPNP_init (h->local_addr, addrlen, h->public_port,
&upnp_pulse_cb, h);
#if 0
h->natpmp =
- GNUNET_NAT_NATPMP_init (h->sched, h->local_addr, addrlen, h->public_port,
+ GNUNET_NAT_NATPMP_init (h->local_addr, addrlen, h->public_port,
&natpmp_pulse_cb, h);
#endif
- h->pulse_timer = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_SECONDS,
+ h->pulse_timer = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&nat_pulse, h);
return h;
}
#endif
if (GNUNET_SCHEDULER_NO_TASK != h->pulse_timer)
- GNUNET_SCHEDULER_cancel (h->sched, h->pulse_timer);
+ GNUNET_SCHEDULER_cancel (h->pulse_timer);
GNUNET_free_non_null (h->local_addr);
GNUNET_free_non_null (h->ext_addr);
time_t command_time;
enum NATPMP_state state;
struct natpmp_t natpmp;
- struct GNUNET_SCHEDULER_Handle *sched;
};
}
struct GNUNET_NAT_NATPMP_Handle *
-GNUNET_NAT_NATPMP_init (struct GNUNET_SCHEDULER_Handle *sched,
- const struct sockaddr *addr, socklen_t addrlen,
+GNUNET_NAT_NATPMP_init (const struct sockaddr *addr, socklen_t addrlen,
u_short port)
{
struct GNUNET_NAT_NATPMP_Handle *nat;
nat = GNUNET_malloc (sizeof (struct GNUNET_NAT_NATPMP_Handle));
- nat->sched = sched;
nat->state = NATPMP_DISCOVER;
nat->port = port;
nat->addr = addr;
struct GNUNET_NAT_NATPMP_Handle;
-struct GNUNET_NAT_NATPMP_Handle *GNUNET_NAT_NATPMP_init (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- const struct sockaddr
+struct GNUNET_NAT_NATPMP_Handle *GNUNET_NAT_NATPMP_init (const struct sockaddr
*addr,
socklen_t addrlen,
unsigned short port);
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
"Requesting NAT redirection from address %s...\n",
GNUNET_a2s (addr, data.addrlen));
- nat = GNUNET_NAT_register (sched, addr, data.addrlen, addr_callback, NULL);
+ nat = GNUNET_NAT_register (addr, data.addrlen, addr_callback, NULL);
GNUNET_free (addr);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, TIMEOUT), stop,
nat);
}
/**
* Send UPnP command to the device identified by url and service.
*
- * @param sched scheduler to use for network tasks
* @param url control URL of the device
* @param service type of the service corresponding to the command
* @param action action to send
* @param caller_cls closure to pass to caller_cb
*/
void
-UPNP_command_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *url, const char *service,
+UPNP_command_ (const char *url, const char *service,
const char *action, struct UPNP_Arg_ *args,
char *buffer, size_t buf_size,
UPNP_command_cb_ caller_cb, void *caller_cls)
dest.sin_len = sizeof (dest);
#endif
- s = GNUNET_CONNECTION_create_from_sockaddr (sched, PF_INET,
+ s = GNUNET_CONNECTION_create_from_sockaddr (PF_INET,
(struct sockaddr *) &dest,
sizeof (dest));
}
dest6.sin6_len = sizeof (dest6);
#endif
- s = GNUNET_CONNECTION_create_from_sockaddr (sched, PF_INET6,
+ s = GNUNET_CONNECTION_create_from_sockaddr (PF_INET6,
(struct sockaddr *) &dest6,
sizeof (dest6));
}
* 501 Action Failed - See UPnP Device Architecture section on Control.
*/
void
-UPNP_get_external_ip_address_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url,
+UPNP_get_external_ip_address_ (const char *control_url,
const char *service_type,
UPNP_get_external_ip_address_cb_ caller_cb,
void *caller_cls)
buffer = GNUNET_malloc (UPNP_COMMAND_BUFSIZE);
- UPNP_command_ (sched, control_url, service_type, "GetExternalIPAddress",
+ UPNP_command_ (control_url, service_type, "GetExternalIPAddress",
NULL, buffer, UPNP_COMMAND_BUFSIZE,
(UPNP_command_cb_) get_external_ip_address_receiver, cls);
}
}
void
-UPNP_add_port_mapping_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url, const char *service_type,
+UPNP_add_port_mapping_ (const char *control_url, const char *service_type,
const char *ext_port,
const char *in_port,
const char *inClient,
buffer = GNUNET_malloc (UPNP_COMMAND_BUFSIZE);
- UPNP_command_ (sched, control_url, service_type, "AddPortMapping",
+ UPNP_command_ (control_url, service_type, "AddPortMapping",
args, buffer, UPNP_COMMAND_BUFSIZE,
add_delete_port_mapping_receiver, cls);
}
void
-UPNP_delete_port_mapping_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url, const char *service_type,
+UPNP_delete_port_mapping_ (const char *control_url, const char *service_type,
const char *ext_port, const char *proto,
const char *remoteHost,
UPNP_port_mapping_cb_ caller_cb, void *caller_cls)
buffer = GNUNET_malloc (UPNP_COMMAND_BUFSIZE);
- UPNP_command_ (sched, control_url, service_type,
+ UPNP_command_ (control_url, service_type,
"DeletePortMapping",
args, buffer, UPNP_COMMAND_BUFSIZE,
add_delete_port_mapping_receiver, cls);
* the result is returned in the in_client and in_port strings
* please provide 128 and 6 bytes of data */
void
-UPNP_get_specific_port_mapping_entry_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url,
+UPNP_get_specific_port_mapping_entry_ (const char *control_url,
const char *service_type,
const char *ext_port,
const char *proto,
buffer = GNUNET_malloc (UPNP_COMMAND_BUFSIZE);
- UPNP_command_ (sched, control_url, service_type,
+ UPNP_command_ (control_url, service_type,
"GetSpecificPortMappingEntry",
args, buffer, UPNP_COMMAND_BUFSIZE,
get_specific_port_mapping_entry_receiver, cls);
/**
* Send UPnP command to the device identified by url and service.
*
- * @param sched scheduler to use for network tasks
* @param url control URL of the device
* @param service type of the service corresponding to the command
* @param action action to send
* @param caller_cb user callback to trigger when done
* @param caller_cls closure to pass to caller_cb
*/
-void UPNP_command_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *url, const char *service,
+void UPNP_command_ (const char *url, const char *service,
const char *action, struct UPNP_Arg_ *args,
char *buffer, size_t buf_size,
UPNP_command_cb_ caller_cb, void *caller_cls);
* Get the IP address associated with the WAN connection of the device.
* See UPNP_get_external_ip_address_cb_.
*
- * @param sched the scheduler to use for networking
* @param control_url the control URL corresponding to service_type on the device
* @param service_type service type to call the command on
* @param caller_cb function to call when done
* @param cls closure passed to caller_cb
*/
void
-UPNP_get_external_ip_address_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url,
+UPNP_get_external_ip_address_ (const char *control_url,
const char *service_type,
UPNP_get_external_ip_address_cb_ caller_cb,
void *caller_cls);
* Request opening a port on the IGD device.
* (remote_host is usually NULL because IGDs don't support it.)
*
- * @param sched the scheduler to use for networking
* @param control_url the control URL corresponding to service_type on the device
* @param service_type service type to call the command on
* @param ext_port port that should be opened on the WAN side
* @param cls closure passed to caller_cb
*/
void
-UPNP_add_port_mapping_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url, const char *service_type,
+UPNP_add_port_mapping_ (const char *control_url, const char *service_type,
const char *ext_port,
const char *in_port,
const char *in_client,
* used when opening the port.
* (remote_host is usually NULL because IGDs don't support it.)
*
- * @param sched the scheduler to use for networking
* @param control_url the control URL the command was called on
* @param service_type service the command was called on
* @param in_port port on the gateway on the LAN side which was requested
* @param cls closure passed to caller_cb
*/
void
-UPNP_delete_port_mapping_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url, const char *service_type,
+UPNP_delete_port_mapping_ (const char *control_url, const char *service_type,
const char *ext_port, const char *proto,
const char *remote_host,
UPNP_port_mapping_cb_ caller_cb, void *caller_cls);
* Check that a port mapping set up with UPNP_add_port_mapping_()
* is alive.
*
- * @param sched the scheduler to use for networking
* @param control_url the control URL the command was called on
* @param service_type service the command was called on
* @param in_port port on the gateway on the LAN side which was requested
* @param cls closure passed to caller_cb
*/
void
-UPNP_get_specific_port_mapping_entry_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *control_url,
+UPNP_get_specific_port_mapping_entry_ (const char *control_url,
const char *service_type,
const char *ext_port,
const char *proto,
*/
struct download_cls
{
- /**
- * Scheduler used for the download task.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* curl_easy handle.
*/
GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
- GNUNET_SCHEDULER_add_select (cls->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
rtime,
grs,
/**
* Download description from devices.
*
- * @param sched the scheduler to use for the download task
* @param url URL of the file to download
* @param caller_cb user function to call when done
* @caller_cls closure to pass to caller_cb
*/
void
-download_device_description (struct GNUNET_SCHEDULER_Handle *sched,
- char *url, download_cb caller_cb,
+download_device_description (char *url, download_cb caller_cb,
void *caller_cls)
{
CURL *curl;
url);
#endif
- cls->sched = sched;
cls->curl = curl;
cls->multi = multi;
cls->url = url;
*/
struct UPNP_discover_cls
{
- /**
- * Scheduler to use for networking tasks.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Remote address used for multicast emission and reception.
*/
/* Check whether device is connected */
buffer = GNUNET_malloc (UPNP_COMMAND_BUFSIZE);
- UPNP_command_ (cls->sched,
- cls->current_dev->control_url,
+ UPNP_command_ (cls->current_dev->control_url,
cls->current_dev->data->service_type,
"GetStatusInfo", NULL, buffer, UPNP_COMMAND_BUFSIZE,
get_valid_igd_connected_cb, cls);
}
/* There are still devices to ask, go on */
- download_device_description (cls->sched, cls->current_dev->desc_url,
+ download_device_description (cls->current_dev->desc_url,
get_valid_igd_receive, cls);
}
GNUNET_NETWORK_fdset_zero (cls->fdset);
GNUNET_NETWORK_fdset_set (cls->fdset, cls->sudp);
- task_w = GNUNET_SCHEDULER_add_select (cls->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ task_w = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 15),
NULL, cls->fdset, &discover_send,
cls);
- GNUNET_SCHEDULER_add_select (cls->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
task_w,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 5), cls->fdset,
* If several devices are found, a device that is connected to the WAN
* is returned first (if any).
*
- * @param sched scheduler to use for network tasks
* @param multicastif network interface to send discovery messages, or NULL
* @param addr address used to send messages on multicastif, or NULL
* @param caller_cb user function to call when done
* @param caller_cls closure to pass to caller_cb
*/
void
-UPNP_discover_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *multicastif,
+UPNP_discover_ (const char *multicastif,
const struct sockaddr *addr,
UPNP_discover_cb_ caller_cb, void *caller_cls)
{
cls = GNUNET_malloc (sizeof (struct UPNP_discover_cls));
- cls->sched = sched;
cls->sudp = sudp;
cls->type_index = 0;
cls->dev_list = NULL;
GNUNET_NETWORK_fdset_zero (cls->fdset);
GNUNET_NETWORK_fdset_set (cls->fdset, sudp);
- task_w = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ task_w = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 15), NULL,
cls->fdset, &discover_send, cls);
- GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
task_w,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 15), cls->fdset,
* If several devices are found, a device that is connected to the WAN
* is returned first (if any).
*
- * @param sched scheduler to use for network tasks
* @param multicastif network interface to send discovery messages, or NULL
* @param addr address used to send messages on multicastif, or NULL
* @param caller_cb user function to call when done
* @param caller_cls closure to pass to caller_cb
*/
-void UPNP_discover_ (struct GNUNET_SCHEDULER_Handle *sched,
- const char *multicastif,
+void UPNP_discover_ (const char *multicastif,
const struct sockaddr *addr,
UPNP_discover_cb_ caller_cb, void *caller_cls);
struct GNUNET_NAT_UPNP_Handle
{
- struct GNUNET_SCHEDULER_Handle *sched;
int hasDiscovered;
char *control_url;
char *service_type;
struct GNUNET_NAT_UPNP_Handle *
-GNUNET_NAT_UPNP_init (struct GNUNET_SCHEDULER_Handle *sched,
- const struct sockaddr *addr,
+GNUNET_NAT_UPNP_init (const struct sockaddr *addr,
socklen_t addrlen,
u_short port,
GNUNET_NAT_UPNP_pulse_cb pulse_cb, void *pulse_cls)
struct GNUNET_NAT_UPNP_Handle *handle;
handle = GNUNET_malloc (sizeof (struct GNUNET_NAT_UPNP_Handle));
- handle->sched = sched;
handle->processing = GNUNET_NO;
handle->state = UPNP_DISCOVER;
handle->addr = addr;
if (is_enabled && (handle->state == UPNP_DISCOVER))
{
handle->processing = GNUNET_YES;
- UPNP_discover_ (handle->sched, handle->iface, handle->addr, discover_cb,
+ UPNP_discover_ (handle->iface, handle->addr, discover_cb,
handle);
}
GNUNET_snprintf (portStr, sizeof (portStr), "%d", handle->port);
handle->processing = GNUNET_YES;
- UPNP_get_specific_port_mapping_entry_ (handle->sched,
- handle->control_url,
+ UPNP_get_specific_port_mapping_entry_ (handle->control_url,
handle->service_type, portStr,
"TCP", check_port_mapping_cb,
handle);
GNUNET_snprintf (portStr, sizeof (portStr), "%d", handle->port);
handle->processing = GNUNET_YES;
- UPNP_delete_port_mapping_ (handle->sched, handle->control_url,
+ UPNP_delete_port_mapping_ (handle->control_url,
handle->service_type, portStr, "TCP", NULL,
delete_port_mapping_cb, handle);
}
GNUNET_snprintf (desc, sizeof (desc), "GNUnet at %d", handle->port);
handle->processing = GNUNET_YES;
- UPNP_add_port_mapping_ (handle->sched, handle->control_url,
+ UPNP_add_port_mapping_ (handle->control_url,
handle->service_type,
portStr, portStr, GNUNET_a2s (handle->addr,
handle->addrlen),
if (handle->state != UPNP_DISCOVER)
{
handle->processing = GNUNET_YES;
- UPNP_get_external_ip_address_ (handle->sched, handle->control_url,
+ UPNP_get_external_ip_address_ (handle->control_url,
handle->service_type,
get_ip_address_cb, handle);
}
struct sockaddr * ext_addr,
void *cls);
-struct GNUNET_NAT_UPNP_Handle *GNUNET_NAT_UPNP_init (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- const struct sockaddr
+struct GNUNET_NAT_UPNP_Handle *GNUNET_NAT_UPNP_init (const struct sockaddr
*addr, socklen_t addrlen,
unsigned short port,
GNUNET_NAT_UPNP_pulse_cb
static int get_self;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_PEERINFO_Handle *peerinfo;
static const struct GNUNET_CONFIGURATION_Handle *cfg;
const void *addr, uint16_t addrlen)
{
struct PrintContext *pc = cls;
- GNUNET_TRANSPORT_address_lookup (sched,
- cfg,
+ GNUNET_TRANSPORT_address_lookup (cfg,
addr,
addrlen,
no_resolve,
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
struct GNUNET_CRYPTO_HashAsciiEncoded enc;
char *fn;
- sched = s;
cfg = c;
if (args[0] != NULL)
{
}
if (get_self != GNUNET_YES)
{
- peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
+ peerinfo = GNUNET_PEERINFO_connect (cfg);
if (peerinfo == NULL)
{
fprintf (stderr,
GNUNET_log (GNUNET_ERROR_TYPE_WARNING |
GNUNET_ERROR_TYPE_BULK,
_("Still no peers found in `%s'!\n"), networkIdDirectory);
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- DATA_HOST_FREQ,
+ GNUNET_SCHEDULER_add_delayed (DATA_HOST_FREQ,
&cron_scan_directory_data_hosts, NULL);
}
now = GNUNET_TIME_absolute_get ();
GNUNET_DISK_directory_scan (networkIdDirectory,
&discard_hosts_helper, &now);
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- DATA_HOST_CLEAN_FREQ,
+ GNUNET_SCHEDULER_add_delayed (DATA_HOST_CLEAN_FREQ,
&cron_clean_data_hosts, NULL);
}
* Process statistics requests.
*
* @param cls closure
- * @param sched scheduler to use
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
};
hostmap = GNUNET_CONTAINER_multihashmap_create (1024);
- stats = GNUNET_STATISTICS_create (sched, "peerinfo", cfg);
+ stats = GNUNET_STATISTICS_create ("peerinfo", cfg);
notify_list = GNUNET_SERVER_notification_context_create (server, 0);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_filename (cfg,
"HOSTS",
&networkIdDirectory));
GNUNET_DISK_directory_create (networkIdDirectory);
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&cron_scan_directory_data_hosts, NULL);
- GNUNET_SCHEDULER_add_with_priority (sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&cron_clean_data_hosts, NULL);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task, NULL);
GNUNET_SERVER_add_handlers (server, handlers);
}
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Connection to the service.
*/
/**
* Connect to the peerinfo service.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @return NULL on error (configuration related, actual connection
* establishment may happen asynchronously).
*/
struct GNUNET_PEERINFO_Handle *
-GNUNET_PEERINFO_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_PEERINFO_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_CLIENT_Connection *client;
struct GNUNET_PEERINFO_Handle *ret;
- client = GNUNET_CLIENT_connect (sched, "peerinfo", cfg);
+ client = GNUNET_CLIENT_connect ("peerinfo", cfg);
if (client == NULL)
return NULL;
ret = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_Handle));
ret->client = client;
ret->cfg = cfg;
- ret->sched = sched;
return ret;
}
{
GNUNET_CLIENT_disconnect (h->client, GNUNET_SYSERR);
h->th = NULL;
- h->client = GNUNET_CLIENT_connect (h->sched, "peerinfo", h->cfg);
+ h->client = GNUNET_CLIENT_connect ("peerinfo", h->cfg);
GNUNET_assert (h->client != NULL);
}
reconnect (ic->h);
trigger_transmit (ic->h);
if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (ic->h->sched,
- ic->timeout_task);
+ GNUNET_SCHEDULER_cancel (ic->timeout_task);
if (ic->callback != NULL)
ic->callback (ic->callback_cls, NULL, NULL);
GNUNET_free (ic);
#endif
trigger_transmit (ic->h);
if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (ic->h->sched,
- ic->timeout_task);
+ GNUNET_SCHEDULER_cancel (ic->timeout_task);
if (ic->callback != NULL)
ic->callback (ic->callback_cls, NULL, NULL);
GNUNET_free (ic);
reconnect (ic->h);
trigger_transmit (ic->h);
if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (ic->h->sched,
- ic->timeout_task);
+ GNUNET_SCHEDULER_cancel (ic->timeout_task);
if (ic->callback != NULL)
ic->callback (ic->callback_cls, NULL, NULL);
GNUNET_free (ic);
reconnect (ic->h);
trigger_transmit (ic->h);
if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (ic->h->sched,
- ic->timeout_task);
+ GNUNET_SCHEDULER_cancel (ic->timeout_task);
if (ic->callback != NULL)
ic->callback (ic->callback_cls, NULL, NULL);
GNUNET_free (ic);
transmit_success);
if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (ic->h->sched,
- ic->timeout_task);
+ GNUNET_SCHEDULER_cancel (ic->timeout_task);
ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
reconnect (ic->h);
ic->callback = callback;
ic->callback_cls = callback_cls;
ic->timeout = GNUNET_TIME_relative_to_absolute (timeout);
- ic->timeout_task = GNUNET_SCHEDULER_add_delayed (h->sched,
- timeout,
+ ic->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
&signal_timeout,
ic);
tqe->timeout = ic->timeout;
{
if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (ic->h->sched,
- ic->timeout_task);
+ GNUNET_SCHEDULER_cancel (ic->timeout_task);
ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
ic->callback = NULL;
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
- /**
- * Scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
};
if (msg == NULL)
{
GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
- nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
+ nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
request_notifications (nc);
return;
}
{
GNUNET_break (0);
GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
- nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
+ nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
request_notifications (nc);
return;
}
{
GNUNET_break (0);
GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
- nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
+ nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
request_notifications (nc);
return;
}
if (buf == NULL)
{
GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
- nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
+ nc->client = GNUNET_CLIENT_connect ("peerinfo", nc->cfg);
request_notifications (nc);
return 0;
}
* peers and then only signals changes.
*
* @param cfg configuration to use
- * @param sched scheduler to use
* @param callback the method to call for each peer
* @param callback_cls closure for callback
* @return NULL on error
*/
struct GNUNET_PEERINFO_NotifyContext *
GNUNET_PEERINFO_notify (const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_SCHEDULER_Handle *sched,
GNUNET_PEERINFO_Processor callback,
void *callback_cls)
{
struct GNUNET_PEERINFO_NotifyContext *nc;
struct GNUNET_CLIENT_Connection *client;
- client = GNUNET_CLIENT_connect (sched, "peerinfo", cfg);
+ client = GNUNET_CLIENT_connect ("peerinfo", cfg);
if (client == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
return NULL;
}
nc = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_NotifyContext));
- nc->sched = sched;
nc->cfg = cfg;
nc->client = client;
nc->callback = callback;
#define NUM_REQUESTS 5000
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static const struct GNUNET_CONFIGURATION_Handle *cfg;
static struct GNUNET_PEERINFO_IteratorContext *ic[NUM_REQUESTS];
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
size_t i;
- sched = s;
cfg = c;
- h = GNUNET_PEERINFO_connect (sched, cfg);
+ h = GNUNET_PEERINFO_connect (cfg);
GNUNET_assert (h != NULL);
for (i = 0; i < NUM_REQUESTS; i++)
{
#include "gnunet_time_lib.h"
#include "peerinfo.h"
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static const struct GNUNET_CONFIGURATION_Handle *cfg;
static struct GNUNET_PEERINFO_IteratorContext *ic;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
- sched = s;
cfg = c;
- h = GNUNET_PEERINFO_connect (sched, cfg);
+ h = GNUNET_PEERINFO_connect (cfg);
GNUNET_assert (h != NULL);
add_peer ();
ic = GNUNET_PEERINFO_iterate (h,
* Process statistics requests.
*
* @param cls closure
- * @param sched scheduler to use
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
&handle_client_disconnect,
NULL);
load (server);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
ret = 1;
return;
}
- h = GNUNET_STATISTICS_create (sched, subsystem, cfg);
+ h = GNUNET_STATISTICS_create (subsystem, cfg);
if (h == NULL)
{
ret = 1;
GNUNET_STATISTICS_destroy (h, GNUNET_YES);
return;
}
- h = GNUNET_STATISTICS_create (sched, "gnunet-statistics", cfg);
+ h = GNUNET_STATISTICS_create ("gnunet-statistics", cfg);
if (h == NULL)
{
ret = 1;
*/
struct GNUNET_STATISTICS_Handle
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Name of our subsystem.
*/
unsigned int i;
if (ret->client != NULL)
return GNUNET_YES;
- ret->client = GNUNET_CLIENT_connect (ret->sched, "statistics", ret->cfg);
+ ret->client = GNUNET_CLIENT_connect ("statistics", ret->cfg);
if (ret->client != NULL)
{
for (i=0;i<ret->watches_size;i++)
/**
* Get handle for the statistics service.
*
- * @param sched scheduler to use
* @param subsystem name of subsystem using the service
* @param cfg services configuration in use
* @return handle to use
*/
struct GNUNET_STATISTICS_Handle *
-GNUNET_STATISTICS_create (struct GNUNET_SCHEDULER_Handle *sched,
- const char *subsystem,
+GNUNET_STATISTICS_create (const char *subsystem,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_STATISTICS_Handle *ret;
GNUNET_assert (subsystem != NULL);
- GNUNET_assert (sched != NULL);
GNUNET_assert (cfg != NULL);
ret = GNUNET_malloc (sizeof (struct GNUNET_STATISTICS_Handle));
- ret->sched = sched;
ret->cfg = cfg;
ret->subsystem = GNUNET_strdup (subsystem);
ret->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
int i;
if (GNUNET_SCHEDULER_NO_TASK != h->backoff_task)
- GNUNET_SCHEDULER_cancel (h->sched,
- h->backoff_task);
+ GNUNET_SCHEDULER_cancel (h->backoff_task);
if (sync_first)
{
if (h->current != NULL)
return; /* action already pending */
if (GNUNET_YES != try_connect (h))
{
- h->backoff_task = GNUNET_SCHEDULER_add_delayed (h->sched,
- h->backoff,
+ h->backoff_task = GNUNET_SCHEDULER_add_delayed (h->backoff,
&finish_task,
h);
h->backoff = GNUNET_TIME_relative_multiply (h->backoff, 2);
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- h = GNUNET_STATISTICS_create (sched, "test-statistics-api", cfg);
+ h = GNUNET_STATISTICS_create ("test-statistics-api", cfg);
GNUNET_STATISTICS_set (h, "test-1", 1, GNUNET_NO);
GNUNET_STATISTICS_set (h, "test-2", 2, GNUNET_NO);
GNUNET_STATISTICS_set (h, "test-3", 2, GNUNET_NO);
static void
run_more (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- h = GNUNET_STATISTICS_create (sched, "test-statistics-api", cfg);
+ h = GNUNET_STATISTICS_create ("test-statistics-api", cfg);
GNUNET_break (NULL !=
GNUNET_STATISTICS_get (h, NULL, "test-3",
GNUNET_TIME_UNIT_SECONDS, &next_fin, &check_3, cls));
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
int i;
char name[128];
- h = GNUNET_STATISTICS_create (sched, "test-statistics-api-loop", cfg);
+ h = GNUNET_STATISTICS_create ("test-statistics-api-loop", cfg);
for (i=0;i<ROUNDS;i++)
{
GNUNET_snprintf (name, sizeof (name), "test-%d", i % 256);
* Process template requests.
*
* @param cls closure
- * @param sched scheduler to use
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
};
/* FIXME: do setup here */
GNUNET_SERVER_add_handlers (server, handlers);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&cleanup_task,
NULL);
}
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemon.\n");
#endif
- d = GNUNET_TESTING_daemon_start (sched, cfg, TIMEOUT, NULL, NULL, 0, NULL, NULL, &my_cb, NULL);
+ d = GNUNET_TESTING_daemon_start (cfg, TIMEOUT, NULL, NULL, 0, NULL, NULL, &my_cb, NULL);
GNUNET_assert (d != NULL);
}
static struct GNUNET_CONFIGURATION_Handle *c2;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static void
end2_cb (void *cls, const char *emsg)
{
struct GNUNET_TESTING_Daemon *second_daemon,
const char *emsg)
{
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Daemon `%s' started.\n", GNUNET_i2s (id));
#endif
- d2 = GNUNET_TESTING_daemon_start (sched, c2, TIMEOUT, NULL, NULL, 0, NULL, NULL, &my_cb2, NULL);
+ d2 = GNUNET_TESTING_daemon_start (c2, TIMEOUT, NULL, NULL, 0, NULL, NULL, &my_cb2, NULL);
GNUNET_assert (d2 != NULL);
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
ok = 1;
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemon.\n");
GNUNET_CONFIGURATION_parse (c1, "test_testing_connect_peer1.conf");
c2 = GNUNET_CONFIGURATION_create ();
GNUNET_CONFIGURATION_parse (c2, "test_testing_connect_peer2.conf");
- d1 = GNUNET_TESTING_daemon_start (sched, c1, TIMEOUT, NULL, NULL, 0, NULL, NULL, &my_cb1, NULL);
+ d1 = GNUNET_TESTING_daemon_start (c1, TIMEOUT, NULL, NULL, 0, NULL, NULL, &my_cb1, NULL);
GNUNET_assert (d1 != NULL);
}
static struct GNUNET_TESTING_PeerGroup *pg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Check whether peers successfully shut down.
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
ok = 1;
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n");
#endif
peers_left = NUM_PEERS;
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left,
TIMEOUT,
NULL, NULL,
static struct GNUNET_TESTING_PeerGroup *pg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static unsigned long long num_peers;
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char *data;
int count;
int ret;
- sched = s;
ok = 1;
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n");
}
peers_left = num_peers;
- pg = GNUNET_TESTING_daemons_start (sched,
- cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left,
TIMEOUT,
NULL,
static struct GNUNET_TESTING_PeerGroup *pg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
const struct GNUNET_CONFIGURATION_Handle *main_cfg;
GNUNET_SCHEDULER_TaskIdentifier die_task;
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+ GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
}
GNUNET_free(free_pos);
}
static void stats_finished (void *cls, int result)
{
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
/**
fprintf(outfile, "}\n");
fclose(outfile);
GNUNET_TESTING_get_statistics(pg, &stats_finished, &stats_print, NULL);
- //GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ //GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
}
}
#if VERBOSE
fprintf(stdout, "100%%]\n");
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
GNUNET_asprintf(&dotOutFileNameFinished, "%s.dot", "final_topology");
dotOutFileFinished = fopen (dotOutFileNameFinished, "w");
GNUNET_free(dotOutFileNameFinished);
}
topology_connections = 0;
GNUNET_TESTING_get_topology (pg, &topology_cb, dotOutFileFinished);
- //GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ //GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
else
{
- pos->disconnect_task = GNUNET_SCHEDULER_add_now(sched, &disconnect_cores, pos);
+ pos->disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cores, pos);
}
return GNUNET_OK;
/*
* Connect to the receiving peer
*/
- pos->peer2handle = GNUNET_CORE_connect (sched,
- pos->peer2->cfg,
+ pos->peer2handle = GNUNET_CORE_connect (pos->peer2->cfg,
TIMEOUT,
pos,
&init_notify_peer2,
if (die_task == GNUNET_SCHEDULER_NO_TASK)
{
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from send test messages (timeout)");
}
if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
&send_test_messages, pos);
return; /* Otherwise we'll double schedule messages here! */
}
/*
* Connect to the sending peer
*/
- pos->peer1handle = GNUNET_CORE_connect (sched,
- pos->peer1->cfg,
+ pos->peer1handle = GNUNET_CORE_connect (pos->peer1->cfg,
TIMEOUT,
pos,
&init_notify_peer1,
if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)
{
- GNUNET_SCHEDULER_add_now (sched,
- &send_test_messages, pos->next);
+ GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next);
}
else
{
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
&send_test_messages, pos->next);
}
}
#endif
modnum = expected_messages / 4;
dotnum = (expected_messages / 50) + 1;
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
#if DELAY_FOR_LOGGING
fprintf(stdout, "Sending test messages in 10 seconds.\n");
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 10),
&send_test_messages, test_messages);
gather_log_data();
{
GNUNET_TESTING_get_topology (pg, &topology_cb, NULL);
}
- GNUNET_SCHEDULER_add_delayed (sched, settle_time, &send_test_messages, test_messages);
+ GNUNET_SCHEDULER_add_delayed (settle_time, &send_test_messages, test_messages);
#endif
#if VERBOSE
fprintf(stdout, "Test message progress: [");
{
if (failed_connections < (unsigned int)(fail_percentage * total_connections))
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SCHEDULER_add_now (sched, &send_test_messages, test_messages);
+ GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
}
}
else
#endif
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
if (expected_connections == GNUNET_SYSERR)
{
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
}
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from connect topology (timeout)");
modnum = expected_connections / 4;
dotnum = (expected_connections / 50) + 1;
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from create topology (bad return)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from continue startup (timeout)");
}
"All %d daemons started, now connecting peers!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 8),
&end_badly, "from peers_started_callback");
#if DELAY_FOR_LOGGING
fprintf(stdout, "Connecting topology in 10 seconds\n");
gather_log_data();
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 10),
&connect_topology, NULL);
#else
"All %d hostkeys created, now creating topology!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from create_topology");
- GNUNET_SCHEDULER_add_now(sched, &create_topology, NULL);
+ GNUNET_SCHEDULER_add_now(&create_topology, NULL);
ok = 0;
}
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char * connect_topology_option_str;
char * connect_topology_option_modifier_string;
unsigned long long temp_settle;
- sched = s;
ok = 1;
dotOutFile = fopen (dotOutFileName, "w");
fprintf (stdout, "Hostkey generation progress: [");
#endif
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, SECONDS_PER_PEER_START * num_peers),
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, SECONDS_PER_PEER_START * num_peers),
&end_badly, "didn't generate all hostkeys within a reasonable amount of time!!!");
GNUNET_assert(num_peers > 0 && num_peers < (unsigned int)-1);
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, SECONDS_PER_PEER_START * num_peers), &hostkey_callback, NULL, &peers_started_callback, NULL,
&topology_callback, NULL, NULL);
static struct GNUNET_TESTING_PeerGroup *pg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
const struct GNUNET_CONFIGURATION_Handle *main_cfg;
GNUNET_SCHEDULER_TaskIdentifier die_task;
total_connections);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many successful connections)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many successful connections)");
}
else if (total_connections + failed_connections == expected_connections)
{
if ((failed_connections == expected_failed_connections) && (total_connections == expected_connections - expected_failed_connections))
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &finish_testing, NULL);
+ die_task = GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (wrong number of failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (wrong number of failed connections)");
}
}
else
#endif
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
if (expected_connections == GNUNET_SYSERR)
{
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
}
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from connect topology (timeout)");
}
}
else
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from create topology (bad return)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");
}
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TEST_TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
&end_badly, "from continue startup (timeout)");
}
"All %d daemons started, now creating topology!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "from peers_started_callback");
connect_topology ();
"All %d hostkeys created, now creating topology!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "from hostkey_callback");
- GNUNET_SCHEDULER_add_now(sched, &create_topology, NULL);
+ GNUNET_SCHEDULER_add_now(&create_topology, NULL);
ok = 0;
}
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
unsigned long long blacklist_topology_num;
unsigned long long connect_topology_option_num;
char *connect_topology_option_modifier_string;
- sched = s;
ok = 1;
dotOutFile = fopen (dotOutFileName, "w");
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "didn't start all daemons in reasonable amount of time!!!");
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left, TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, NULL,
&topology_callback, NULL, NULL);
static struct GNUNET_TESTING_PeerGroup *pg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
const struct GNUNET_CONFIGURATION_Handle *main_cfg;
GNUNET_SCHEDULER_TaskIdentifier die_task;
GNUNET_assert (pg != NULL);
if (die_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel(sched, die_task);
+ GNUNET_SCHEDULER_cancel(die_task);
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
if (emsg == NULL)
{
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Successfully churned peers!\n", emsg);
- GNUNET_SCHEDULER_add_now(sched, churn_ctx.next_task, NULL);
+ GNUNET_SCHEDULER_add_now(churn_ctx.next_task, NULL);
}
else
{
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to churn peers with error `%s'\n", emsg);
- GNUNET_SCHEDULER_cancel(sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now(sched, &end_badly, NULL);
+ GNUNET_SCHEDULER_cancel(die_task);
+ die_task = GNUNET_SCHEDULER_add_now(&end_badly, NULL);
}
}
"All %d daemons started, now testing churn!\n",
num_peers);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
/* Set up task in case topology creation doesn't finish
* within a reasonable amount of time */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "from peers_started_callback");
churn_peers_off ();
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
ok = 1;
#if VERBOSE
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5),
&end_badly, "didn't start all daemons in reasonable amount of time!!!");
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left, TIMEOUT, NULL, NULL, &peers_started_callback, NULL,
NULL, NULL, NULL);
#endif
- d->th = GNUNET_TRANSPORT_connect (d->sched,
- d->cfg,
+ d->th = GNUNET_TRANSPORT_connect (d->cfg,
&d->id,
d, NULL, NULL, NULL);
if (d->th == NULL)
}
/* wait some more */
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
return;
}
#endif
d->phase = SP_HOSTKEY_CREATE;
d->task
- = GNUNET_SCHEDULER_add_read_file (d->sched,
- GNUNET_TIME_absolute_get_remaining(d->max_timeout),
+ = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining(d->max_timeout),
GNUNET_DISK_pipe_handle(d->pipe_stdout,
GNUNET_DISK_PIPE_END_READ),
&start_fsm,
{
/* keep reading */
d->task
- = GNUNET_SCHEDULER_add_read_file (d->sched,
- GNUNET_TIME_absolute_get_remaining(d->max_timeout),
+ = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining(d->max_timeout),
GNUNET_DISK_pipe_handle(d->pipe_stdout,
GNUNET_DISK_PIPE_END_READ),
&start_fsm,
}
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
break;
case SP_TOPOLOGY_SETUP:
#endif
d->phase = SP_START_ARMING;
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
break;
case SP_START_ARMING:
}
/* wait some more */
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
return;
}
"Successfully started `%s'.\n", "gnunet-arm");
#endif
d->phase = SP_START_CORE;
- d->server = GNUNET_CORE_connect (d->sched,
- d->cfg,
+ d->server = GNUNET_CORE_connect (d->cfg,
ARM_START_WAIT,
d,
&testing_init,
}
/* wait some more */
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
return;
}
}
/* wait some more */
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
return;
}
daemon->phase = SP_TOPOLOGY_SETUP;
daemon->max_timeout = GNUNET_TIME_relative_to_absolute(timeout);
- GNUNET_SCHEDULER_add_continuation (daemon->sched,
- &start_fsm,
+ GNUNET_SCHEDULER_add_continuation (&start_fsm,
daemon,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
* reachable via "ssh" (unless the hostname is "NULL") without the
* need to enter a password.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param timeout how long to wait starting up peers
* @param hostname name of the machine where to run GNUnet
* @return handle to the daemon (actual start will be completed asynchronously)
*/
struct GNUNET_TESTING_Daemon *
-GNUNET_TESTING_daemon_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TESTING_daemon_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
const char *hostname,
const char *ssh_username,
char *username;
ret = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Daemon));
- ret->sched = sched;
ret->hostname = (hostname == NULL) ? NULL : GNUNET_strdup (hostname);
if (sshport != 0)
{
return NULL;
}
ret->task
- = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, ret);
return ret;
}
"No need to copy configuration file since we are running locally.\n");
#endif
ret->phase = SP_COPIED;
- GNUNET_SCHEDULER_add_continuation (sched,
- &start_fsm,
+ GNUNET_SCHEDULER_add_continuation (&start_fsm,
ret,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
return ret;
if (d->phase == SP_CONFIG_UPDATE)
{
- GNUNET_SCHEDULER_cancel (d->sched, d->task);
+ GNUNET_SCHEDULER_cancel (d->task);
d->phase = SP_START_DONE;
}
if (d->server != NULL)
GNUNET_free_non_null(del_arg);
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
}
if (d->phase == SP_CONFIG_UPDATE)
{
- GNUNET_SCHEDULER_cancel (d->sched, d->task);
+ GNUNET_SCHEDULER_cancel (d->task);
d->phase = SP_START_DONE;
}
if (d->server != NULL)
GNUNET_free_non_null(del_arg);
d->max_timeout = GNUNET_TIME_relative_to_absolute(timeout);
d->task
- = GNUNET_SCHEDULER_add_now (d->sched,
- &start_fsm, d);
+ = GNUNET_SCHEDULER_add_now (&start_fsm, d);
}
d->update_cb = cb;
d->update_cb_cls = cb_cls;
d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
&start_fsm, d);
}
ctx->timeout_task = GNUNET_SCHEDULER_NO_TASK;
if (ctx->hello_send_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(ctx->d1->sched, ctx->hello_send_task);
+ GNUNET_SCHEDULER_cancel(ctx->hello_send_task);
ctx->hello_send_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_TRANSPORT_disconnect(ctx->d2th);
ctx->d2th = NULL;
}
- GNUNET_SCHEDULER_add_now(ctx->d1->sched, &reattempt_daemons_connect, ctx);
+ GNUNET_SCHEDULER_add_now(&reattempt_daemons_connect, ctx);
return;
}
else
{
ctx->connected = GNUNET_YES;
ctx->distance = distance;
- GNUNET_SCHEDULER_cancel(ctx->d1->sched, ctx->timeout_task);
- ctx->timeout_task = GNUNET_SCHEDULER_add_now (ctx->d1->sched,
- ¬ify_connect_result,
+ GNUNET_SCHEDULER_cancel(ctx->timeout_task);
+ ctx->timeout_task = GNUNET_SCHEDULER_add_now (¬ify_connect_result,
ctx);
}
{
ctx->connected = GNUNET_YES;
ctx->distance = distance;
- GNUNET_SCHEDULER_cancel(ctx->d1->sched, ctx->timeout_task);
- ctx->timeout_task = GNUNET_SCHEDULER_add_now (ctx->d1->sched,
- ¬ify_connect_result,
+ GNUNET_SCHEDULER_cancel(ctx->timeout_task);
+ ctx->timeout_task = GNUNET_SCHEDULER_add_now (¬ify_connect_result,
ctx);
}
GNUNET_assert(hello != NULL);
GNUNET_TRANSPORT_offer_hello (ctx->d2th, hello);
- ctx->connect_request_handle = GNUNET_CORE_peer_request_connect (ctx->d1->sched,
- ctx->d2->cfg,
+ ctx->connect_request_handle = GNUNET_CORE_peer_request_connect (ctx->d2->cfg,
GNUNET_TIME_relative_divide(ctx->relative_timeout,
ctx->max_connect_attempts + 1),
&ctx->d1->id,
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,
500));
}
- ctx->hello_send_task = GNUNET_SCHEDULER_add_delayed(ctx->d1->sched,
- ctx->timeout_hello,
+ ctx->hello_send_task = GNUNET_SCHEDULER_add_delayed(ctx->timeout_hello,
&send_hello, ctx);
}
d1->shortname, d2->shortname);
#endif
- ctx->d1core = GNUNET_CORE_connect (d1->sched,
- d1->cfg,
+ ctx->d1core = GNUNET_CORE_connect (d1->cfg,
timeout,
ctx,
NULL,
}
#if CONNECT_CORE2
- ctx->d2core = GNUNET_CORE_connect (d2->sched,
- d2->cfg,
+ ctx->d2core = GNUNET_CORE_connect (d2->cfg,
timeout,
ctx,
NULL,
#endif
- ctx->d2th = GNUNET_TRANSPORT_connect (d2->sched,
- d2->cfg,
+ ctx->d2th = GNUNET_TRANSPORT_connect (d2->cfg,
&d2->id,
d2, NULL, NULL, NULL);
if (ctx->d2th == NULL)
return;
}
- ctx->timeout_task = GNUNET_SCHEDULER_add_delayed (d1->sched,
- GNUNET_TIME_relative_divide(ctx->relative_timeout,
+ ctx->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide(ctx->relative_timeout,
ctx->max_connect_attempts),
¬ify_connect_result, ctx);
- ctx->hello_send_task = GNUNET_SCHEDULER_add_now(ctx->d1->sched, &send_hello, ctx);
+ ctx->hello_send_task = GNUNET_SCHEDULER_add_now(&send_hello, ctx);
}
static void
GNUNET_assert(ctx->d1core == NULL);
- ctx->d1core = GNUNET_CORE_connect (ctx->d1->sched,
- ctx->d1->cfg,
+ ctx->d1core = GNUNET_CORE_connect (ctx->d1->cfg,
GNUNET_TIME_absolute_get_remaining(ctx->timeout),
ctx,
NULL,
return;
}
- ctx->d2th = GNUNET_TRANSPORT_connect (ctx->d2->sched,
- ctx->d2->cfg,
+ ctx->d2th = GNUNET_TRANSPORT_connect (ctx->d2->cfg,
&ctx->d2->id,
ctx->d2, NULL, NULL, NULL);
if (ctx->d2th == NULL)
return;
}
- ctx->timeout_task = GNUNET_SCHEDULER_add_delayed (ctx->d1->sched,
- GNUNET_TIME_relative_divide(ctx->relative_timeout, ctx->max_connect_attempts),
+ ctx->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide(ctx->relative_timeout, ctx->max_connect_attempts),
¬ify_connect_result, ctx);
- ctx->hello_send_task = GNUNET_SCHEDULER_add_now(ctx->d1->sched, &send_hello, ctx);
+ ctx->hello_send_task = GNUNET_SCHEDULER_add_now(&send_hello, ctx);
}
/* end of testing.c */
*/
struct GNUNET_TESTING_PeerGroup
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Configuration template.
*/
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Delaying connect, we have too many outstanding connections!\n"));
#endif
- GNUNET_SCHEDULER_add_delayed(connect_context->ct_ctx->pg->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_connect, connect_context);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_connect, connect_context);
}
else
{
connect_context->first = first->daemon;
connect_context->second = second;
connect_context->ct_ctx = ct_ctx;
- GNUNET_SCHEDULER_add_now(first->pg->sched, &schedule_connect, connect_context);
+ GNUNET_SCHEDULER_add_now(&schedule_connect, connect_context);
return GNUNET_YES;
}
connect_context->pg = pg;
connect_context->first = FIXME;
connect_context->second = connection_iter->daemon;
- GNUNET_SCHEDULER_add_now(pg->sched, &schedule_connect, connect_context);
+ GNUNET_SCHEDULER_add_now(&schedule_connect, connect_context);
connection_iter = connection_iter->next;
}
#endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Delaying connect, we have too many outstanding connections!\n"));
#endif
- GNUNET_SCHEDULER_add_delayed(core_context->daemon->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_get_topology, core_context);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_get_topology, core_context);
}
else
{
_("Creating connection, outstanding_connections is %d\n"), outstanding_connects);
#endif
topology_context->connected++;
- if (GNUNET_OK != GNUNET_CORE_iterate_peers (core_context->daemon->sched, core_context->daemon->cfg, &internal_topology_callback, core_context))
+ if (GNUNET_OK != GNUNET_CORE_iterate_peers (core_context->daemon->cfg, &internal_topology_callback, core_context))
internal_topology_callback(core_context, NULL, GNUNET_TIME_relative_get_zero(), 0);
}
core_ctx->daemon = pg->peers[i].daemon;
/* Set back pointer to topology iteration context */
core_ctx->iter_context = topology_context;
- GNUNET_SCHEDULER_add_now(pg->sched, &schedule_get_topology, core_ctx);
+ GNUNET_SCHEDULER_add_now(&schedule_get_topology, core_ctx);
total_count++;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Delaying connect, we have too many outstanding connections!\n"));
#endif
- GNUNET_SCHEDULER_add_delayed(core_context->daemon->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_get_statistics, core_context);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_get_statistics, core_context);
}
else
{
#endif
stats_context->connected++;
- core_context->stats_handle = GNUNET_STATISTICS_create(core_context->daemon->sched, "testing", core_context->daemon->cfg);
+ core_context->stats_handle = GNUNET_STATISTICS_create("testing", core_context->daemon->cfg);
if (core_context->stats_handle == NULL)
{
internal_stats_cont (core_context, GNUNET_NO);
core_ctx->daemon = pg->peers[i].daemon;
/* Set back pointer to topology iteration context */
core_ctx->iter_context = stats_context;
- GNUNET_SCHEDULER_add_now(pg->sched, &schedule_get_statistics, core_ctx);
+ GNUNET_SCHEDULER_add_now(&schedule_get_statistics, core_ctx);
total_count++;
}
}
}
else
{
- GNUNET_SCHEDULER_add_delayed(internal_context->peer->pg->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &internal_continue_startup, internal_context);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &internal_continue_startup, internal_context);
}
}
struct ChurnRestartContext *startup_ctx = peer_restart_ctx->churn_restart_ctx;
if (startup_ctx->outstanding > MAX_CONCURRENT_STARTING)
- GNUNET_SCHEDULER_add_delayed(peer_restart_ctx->daemon->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_churn_restart, peer_restart_ctx);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_churn_restart, peer_restart_ctx);
else
{
GNUNET_TESTING_daemon_start_stopped(peer_restart_ctx->daemon,
if (internal_context->peer->pg->starting < MAX_CONCURRENT_HOSTKEYS)
{
internal_context->peer->pg->starting++;
- internal_context->peer->daemon = GNUNET_TESTING_daemon_start (internal_context->peer->pg->sched,
- internal_context->peer->cfg,
+ internal_context->peer->daemon = GNUNET_TESTING_daemon_start (internal_context->peer->cfg,
internal_context->timeout,
internal_context->hostname,
internal_context->username,
}
else
{
- GNUNET_SCHEDULER_add_delayed(internal_context->peer->pg->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &internal_start, internal_context);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &internal_start, internal_context);
}
}
pg->starting = 0;
for (i = 0; i < pg->total; i++)
{
- GNUNET_SCHEDULER_add_now (pg->sched, &internal_continue_startup, &pg->peers[i].internal_context);
+ GNUNET_SCHEDULER_add_now (&internal_continue_startup, &pg->peers[i].internal_context);
//GNUNET_TESTING_daemon_continue_startup(pg->peers[i].daemon);
}
}
* adjusted to ensure that no two peers running on the same system
* have the same port(s) in their respective configurations.
*
- * @param sched scheduler to use
* @param cfg configuration template to use
* @param total number of daemons to start
* @param timeout total time allowed for peers to start
* @return NULL on error, otherwise handle to control peer group
*/
struct GNUNET_TESTING_PeerGroup *
-GNUNET_TESTING_daemons_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TESTING_daemons_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
unsigned int total,
struct GNUNET_TIME_Relative timeout,
GNUNET_TESTING_NotifyHostkeyCreated hostkey_callback,
upnum = 0;
fdnum = 0;
pg = GNUNET_malloc (sizeof (struct GNUNET_TESTING_PeerGroup));
- pg->sched = sched;
pg->cfg = cfg;
pg->notify_connection = connect_callback;
pg->notify_connection_cls = connect_callback_cls;
pg->peers[off].internal_context.start_cb = cb;
pg->peers[off].internal_context.start_cb_cls = cb_cls;
- GNUNET_SCHEDULER_add_now (sched, &internal_start, &pg->peers[off].internal_context);
+ GNUNET_SCHEDULER_add_now (&internal_start, &pg->peers[off].internal_context);
}
return pg;
GNUNET_assert(shutdown_ctx != NULL);
if (shutdown_ctx->outstanding > MAX_CONCURRENT_SHUTDOWN)
- GNUNET_SCHEDULER_add_delayed(peer_shutdown_ctx->daemon->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_churn_shutdown_task, peer_shutdown_ctx);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_churn_shutdown_task, peer_shutdown_ctx);
else
{
shutdown_ctx->outstanding++;
peer_shutdown_ctx = GNUNET_malloc(sizeof(struct PeerShutdownContext));
peer_shutdown_ctx->daemon = pg->peers[running_arr[running_permute[i]]].daemon;
peer_shutdown_ctx->shutdown_ctx = shutdown_ctx;
- GNUNET_SCHEDULER_add_now(peer_shutdown_ctx->daemon->sched, &schedule_churn_shutdown_task, peer_shutdown_ctx);
+ GNUNET_SCHEDULER_add_now(&schedule_churn_shutdown_task, peer_shutdown_ctx);
/*
GNUNET_TESTING_daemon_stop (pg->peers[running_arr[running_permute[i]]].daemon,
peer_restart_ctx = GNUNET_malloc(sizeof(struct PeerRestartContext));
peer_restart_ctx->churn_restart_ctx = churn_startup_ctx;
peer_restart_ctx->daemon = pg->peers[stopped_arr[stopped_permute[i]]].daemon;
- GNUNET_SCHEDULER_add_now(peer_restart_ctx->daemon->sched, &schedule_churn_restart, peer_restart_ctx);
+ GNUNET_SCHEDULER_add_now(&schedule_churn_restart, peer_restart_ctx);
/*
GNUNET_TESTING_daemon_start_stopped(pg->peers[stopped_arr[stopped_permute[i]]].daemon,
timeout, &churn_start_callback, churn_ctx);*/
GNUNET_assert(shutdown_ctx != NULL);
if (shutdown_ctx->outstanding > MAX_CONCURRENT_SHUTDOWN)
- GNUNET_SCHEDULER_add_delayed(peer_shutdown_ctx->daemon->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_shutdown_task, peer_shutdown_ctx);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &schedule_shutdown_task, peer_shutdown_ctx);
else
{
shutdown_ctx->outstanding++;
peer_shutdown_ctx = GNUNET_malloc(sizeof(struct PeerShutdownContext));
peer_shutdown_ctx->daemon = pg->peers[off].daemon;
peer_shutdown_ctx->shutdown_ctx = shutdown_ctx;
- GNUNET_SCHEDULER_add_now(pg->peers[off].daemon->sched, &schedule_shutdown_task, peer_shutdown_ctx);
+ GNUNET_SCHEDULER_add_now(&schedule_shutdown_task, peer_shutdown_ctx);
//GNUNET_TESTING_daemon_stop (pg->peers[off].daemon, timeout, shutdown_cb, shutdown_ctx, GNUNET_YES, GNUNET_NO);
if (NULL != pg->peers[off].cfg)
GNUNET_CONFIGURATION_destroy (pg->peers[off].cfg);
*/
static struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify;
-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
if (pos->connect_req != NULL)
GNUNET_CORE_peer_request_connect_cancel (pos->connect_req);
if (pos->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,
- pos->hello_delay_task);
+ GNUNET_SCHEDULER_cancel (pos->hello_delay_task);
if (pos->greylist_clean_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,
- pos->greylist_clean_task);
+ GNUNET_SCHEDULER_cancel (pos->greylist_clean_task);
GNUNET_free_non_null (pos->hello);
if (pos->filter != NULL)
GNUNET_CONTAINER_bloomfilter_free (pos->filter);
GREYLIST_AFTER_ATTEMPT_MAX);
pos->greylisted_until = GNUNET_TIME_relative_to_absolute (rem);
if (pos->greylist_clean_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,
- pos->greylist_clean_task);
+ GNUNET_SCHEDULER_cancel (pos->greylist_clean_task);
pos->greylist_clean_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- rem,
+ = GNUNET_SCHEDULER_add_delayed (rem,
&remove_from_greylist,
pos);
#if DEBUG_TOPOLOGY
gettext_noop ("# connect requests issued to core"),
1,
GNUNET_NO);
- pos->connect_req = GNUNET_CORE_peer_request_connect (sched, cfg,
+ pos->connect_req = GNUNET_CORE_peer_request_connect (cfg,
GNUNET_TIME_UNIT_MINUTES,
&pos->pid,
&connect_completed_callback,
else
{
pos->greylist_clean_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- rem,
+ = GNUNET_SCHEDULER_add_delayed (rem,
&remove_from_greylist,
pos);
}
&find_advertisable_hello,
&fah);
pl->hello_delay_task
- = GNUNET_SCHEDULER_add_delayed (sched,
- fah.next_adv,
+ = GNUNET_SCHEDULER_add_delayed (fah.next_adv,
&schedule_next_hello,
pl);
if (fah.result == NULL)
}
if (peer->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- peer->hello_delay_task);
+ GNUNET_SCHEDULER_cancel (peer->hello_delay_task);
peer->hello_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
peer->hello_delay_task
- = GNUNET_SCHEDULER_add_now (sched,
- &schedule_next_hello,
+ = GNUNET_SCHEDULER_add_now (&schedule_next_hello,
peer);
return GNUNET_YES;
}
NULL);
if ( (friend_count < minimum_friend_count) &&
(blacklist == NULL) )
- blacklist = GNUNET_TRANSPORT_blacklist (sched, cfg,
+ blacklist = GNUNET_TRANSPORT_blacklist (cfg,
&blacklist_check, NULL);
}
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to core service, can not manage topology!\n"));
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
handle = server;
"I am peer `%s'\n",
GNUNET_i2s (my_id));
#endif
- peerinfo_notify = GNUNET_PEERINFO_notify (cfg, sched,
- &process_peer,
+ peerinfo_notify = GNUNET_PEERINFO_notify (cfg, &process_peer,
NULL);
}
}
pl->next_hello_allowed = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
pl->hello_delay_task
- = GNUNET_SCHEDULER_add_now (sched,
- &schedule_next_hello,
+ = GNUNET_SCHEDULER_add_now (&schedule_next_hello,
pl);
return want;
}
* Main function that will be run.
*
* @param cls closure
- * @param s the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param c configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle * s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle * c)
};
unsigned long long opt;
- sched = s;
cfg = c;
- stats = GNUNET_STATISTICS_create (sched, "topology", cfg);
+ stats = GNUNET_STATISTICS_create ("topology", cfg);
autoconnect = GNUNET_CONFIGURATION_get_value_yesno (cfg,
"TOPOLOGY",
"AUTOCONNECT");
autoconnect ? "autoconnect enabled" : "autoconnect disabled");
#endif
if (friend_count < minimum_friend_count)
- blacklist = GNUNET_TRANSPORT_blacklist (sched, cfg,
+ blacklist = GNUNET_TRANSPORT_blacklist (cfg,
&blacklist_check, NULL);
- transport = GNUNET_TRANSPORT_connect (sched,
- cfg,
+ transport = GNUNET_TRANSPORT_connect (cfg,
NULL,
NULL,
NULL,
NULL,
NULL);
- handle = GNUNET_CORE_connect (sched,
- cfg,
+ handle = GNUNET_CORE_connect (cfg,
GNUNET_TIME_UNIT_FOREVER_REL,
NULL,
&core_init,
NULL, GNUNET_NO,
NULL, GNUNET_NO,
handlers);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&cleaning_task, NULL);
if (NULL == transport)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to `%s' service.\n"),
"transport");
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
if (NULL == handle)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to `%s' service.\n"),
"core");
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
}
static struct GNUNET_TESTING_Daemon *last;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Check whether peers successfully shut down.
*/
{
/* FIXME: check that topology adds a few more links
in addition to those that were seeded */
- GNUNET_SCHEDULER_add_now (sched,
- &clean_up_task,
+ GNUNET_SCHEDULER_add_now (&clean_up_task,
NULL);
}
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
ok = 1;
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting daemons.\n");
#endif
peers_left = NUM_PEERS;
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
+ pg = GNUNET_TESTING_daemons_start (cfg,
peers_left,
TIMEOUT,
NULL, NULL,
*/
static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
1,
GNUNET_NO);
if (neighbour->retry_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched,
- neighbour->retry_task);
- neighbour->retry_task = GNUNET_SCHEDULER_add_delayed (sched,
- timeout,
+ GNUNET_SCHEDULER_cancel (neighbour->retry_task);
+ neighbour->retry_task = GNUNET_SCHEDULER_add_delayed (timeout,
&retry_transmission_task,
neighbour);
#if DEBUG_TRANSPORT
int expired;
if (plugin->address_update_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (plugin->env.sched, plugin->address_update_task);
+ GNUNET_SCHEDULER_cancel (plugin->address_update_task);
plugin->address_update_task = GNUNET_SCHEDULER_NO_TASK;
now = GNUNET_TIME_absolute_get ();
min_remaining = GNUNET_TIME_UNIT_FOREVER_REL;
GNUNET_TIME_relative_divide (HELLO_ADDRESS_EXPIRATION,
2));
plugin->address_update_task
- = GNUNET_SCHEDULER_add_delayed (plugin->env.sched,
- min_remaining,
+ = GNUNET_SCHEDULER_add_delayed (min_remaining,
&expire_address_task, plugin);
}
prev->next = pos->next;
if (GNUNET_SCHEDULER_NO_TASK != pos->revalidate_task)
{
- GNUNET_SCHEDULER_cancel (sched,
- pos->revalidate_task);
+ GNUNET_SCHEDULER_cancel (pos->revalidate_task);
pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_free (pos);
struct ValidationEntry *va = value;
if (GNUNET_SCHEDULER_NO_TASK != va->timeout_task)
- GNUNET_SCHEDULER_cancel (sched, va->timeout_task);
+ GNUNET_SCHEDULER_cancel (va->timeout_task);
GNUNET_free (va->transport_name);
if (va->chvc != NULL)
{
}
n->latency = GNUNET_TIME_UNIT_FOREVER_REL;
n->distance = -1;
- n->timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+ n->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
&neighbour_timeout_task, n);
if (do_hello)
{
if (size == 0)
{
GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
- bc->task = GNUNET_SCHEDULER_add_now (sched,
- &do_blacklist_check,
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
bc);
return 0;
}
bc->cont = cont;
bc->cont_cls = cont_cls;
bc->bl_pos = bl_head;
- bc->task = GNUNET_SCHEDULER_add_now (sched,
- &do_blacklist_check,
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
bc);
}
bc->bl_pos = bl;
if (n == neighbours) /* all would wait for the same client, no need to
create more than just the first task right now */
- bc->task = GNUNET_SCHEDULER_add_now (sched,
- &do_blacklist_check,
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
bc);
n = n->next;
}
else
{
bc->bl_pos = bc->bl_pos->next;
- bc->task = GNUNET_SCHEDULER_add_now (sched,
- &do_blacklist_check,
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
bc);
}
/* check if any other bc's are waiting for this blacklister */
{
if ( (bc->bl_pos == bl) &&
(GNUNET_SCHEDULER_NO_TASK == bc->task) )
- bc->task = GNUNET_SCHEDULER_add_now (sched,
- &do_blacklist_check,
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
bc);
bc = bc->next;
}
&neighbour->publicKey,
sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
- va->timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- HELLO_VERIFICATION_TIMEOUT,
+ va->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
&timeout_hello_validation,
va);
GNUNET_CONTAINER_multihashmap_put (validation_map,
GNUNET_TIME_UNIT_SECONDS);
/* randomize a bit (to avoid doing all at the same time) */
delay.rel_value += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000);
- fal->revalidate_task = GNUNET_SCHEDULER_add_delayed(sched,
- delay,
+ fal->revalidate_task = GNUNET_SCHEDULER_add_delayed(delay,
&send_periodic_ping,
fal);
}
}
if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched,
- n->retry_task);
+ GNUNET_SCHEDULER_cancel (n->retry_task);
n->retry_task = GNUNET_SCHEDULER_NO_TASK;
try_transmission_to_peer (n);
}
va->addrlen = addrlen;
GNUNET_HELLO_get_key (chvc->hello,
&va->publicKey);
- va->timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
- HELLO_VERIFICATION_TIMEOUT,
+ va->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
&timeout_hello_validation,
va);
GNUNET_CONTAINER_multihashmap_put (validation_map,
GNUNET_NO);
/* first, check if load is too high */
- if (GNUNET_SCHEDULER_get_load (sched,
- GNUNET_SCHEDULER_PRIORITY_BACKGROUND) > MAX_HELLO_LOAD)
+ if (GNUNET_SCHEDULER_get_load (GNUNET_SCHEDULER_PRIORITY_BACKGROUND) > MAX_HELLO_LOAD)
{
GNUNET_STATISTICS_update (stats,
gettext_noop ("# HELLOs ignored due to high load"),
GNUNET_NO);
if (GNUNET_SCHEDULER_NO_TASK != peer_pos->revalidate_task)
{
- GNUNET_SCHEDULER_cancel (sched,
- peer_pos->revalidate_task);
+ GNUNET_SCHEDULER_cancel (peer_pos->revalidate_task);
peer_pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_free(peer_pos);
}
if (n->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, n->timeout_task);
+ GNUNET_SCHEDULER_cancel (n->timeout_task);
n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, n->retry_task);
+ GNUNET_SCHEDULER_cancel (n->retry_task);
n->retry_task = GNUNET_SCHEDULER_NO_TASK;
}
if (n->piter != NULL)
n->peer_timeout =
GNUNET_TIME_relative_to_absolute
(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
- GNUNET_SCHEDULER_cancel (sched,
- n->timeout_task);
+ GNUNET_SCHEDULER_cancel (n->timeout_task);
n->timeout_task =
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
&neighbour_timeout_task, n);
if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
{
create_environment (struct TransportPlugin *plug)
{
plug->env.cfg = cfg;
- plug->env.sched = sched;
plug->env.my_identity = &my_identity;
plug->env.our_hello = &our_hello;
plug->env.cls = plug;
bc->th = NULL;
}
if (bc->task == GNUNET_SCHEDULER_NO_TASK)
- bc->task = GNUNET_SCHEDULER_add_now (sched,
- &do_blacklist_check,
+ bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
bc);
break;
}
plugins = plug->next;
if (plug->address_update_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (plug->env.sched,
- plug->address_update_task);
+ GNUNET_SCHEDULER_cancel (plug->address_update_task);
plug->address_update_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
* Initiate transport service.
*
* @param cls closure
- * @param s scheduler to use
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
unsigned long long tneigh;
char *keyfile;
- sched = s;
cfg = c;
- stats = GNUNET_STATISTICS_create (sched, "transport", cfg);
+ stats = GNUNET_STATISTICS_create ("transport", cfg);
validation_map = GNUNET_CONTAINER_multihashmap_create (64);
/* parse configuration */
if ((GNUNET_OK !=
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Transport service is lacking key configuration settings. Exiting.\n"));
- GNUNET_SCHEDULER_shutdown (s);
+ GNUNET_SCHEDULER_shutdown ();
if (stats != NULL)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
return;
}
max_connect_per_transport = (uint32_t) tneigh;
- peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
+ peerinfo = GNUNET_PEERINFO_connect (cfg);
if (peerinfo == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
- GNUNET_SCHEDULER_shutdown (s);
+ GNUNET_SCHEDULER_shutdown ();
if (stats != NULL)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Transport service could not access hostkey. Exiting.\n"));
- GNUNET_SCHEDULER_shutdown (s);
+ GNUNET_SCHEDULER_shutdown ();
if (stats != NULL)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
}
GNUNET_free (plugs);
}
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task, NULL);
if (no_transports)
refresh_hello ();
*/
const struct GNUNET_CONFIGURATION_Handle *cfg;
- /**
- * Scheduler to use.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Identity of this peer.
*/
0);
pc->delay = delay;
if (pc->reset_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (pc->plugin->env->sched, pc->reset_task);
+ GNUNET_SCHEDULER_cancel (pc->reset_task);
if (delay.rel_value > 0)
{
#if DEBUG_HTTP
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: Inbound quota management: delay next read for %llu ms \n", ps, delay.rel_value);
#endif
- pc->reset_task = GNUNET_SCHEDULER_add_delayed (pc->plugin->env->sched, delay, &reset_inbound_quota_delay, pc);
+ pc->reset_task = GNUNET_SCHEDULER_add_delayed (delay, &reset_inbound_quota_delay, pc);
}
}
{
if (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v4);
+ GNUNET_SCHEDULER_cancel(plugin->http_server_task_v4);
plugin->http_server_daemon_v4 = GNUNET_SCHEDULER_NO_TASK;
}
- ret = GNUNET_SCHEDULER_add_select (plugin->env->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
tv,
wrs,
{
if (plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v6);
+ GNUNET_SCHEDULER_cancel(plugin->http_server_task_v6);
plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
}
- ret = GNUNET_SCHEDULER_add_select (plugin->env->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
tv,
wrs,
pc->delay = delay;
if (pc->reset_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (pc->plugin->env->sched, pc->reset_task);
+ GNUNET_SCHEDULER_cancel (pc->reset_task);
if (delay.rel_value > 0)
{
#if DEBUG_HTTP
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: Inbound quota management: delay next read for %llu ms \n", ps, delay.abs_value);
#endif
- pc->reset_task = GNUNET_SCHEDULER_add_delayed (pc->plugin->env->sched, delay, &reset_inbound_quota_delay, pc);
+ pc->reset_task = GNUNET_SCHEDULER_add_delayed (delay, &reset_inbound_quota_delay, pc);
}
}
/* Cancel previous scheduled task */
if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
}
gws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
- plugin->http_curl_task = GNUNET_SCHEDULER_add_select (plugin->env->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ plugin->http_curl_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
(to == -1) ? GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) : GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to),
grs,
}
if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
}
- plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
+ plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
}
/* waiting for receive direction */
ps->send_active=GNUNET_YES;
if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
}
- plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
+ plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
return GNUNET_YES;
}
else
}
if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
}
- plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
+ plugin->http_curl_task = GNUNET_SCHEDULER_add_now (&curl_perform, plugin);
return GNUNET_YES;
}
if (ps->direction == INBOUND)
if ( plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v4);
+ GNUNET_SCHEDULER_cancel(plugin->http_server_task_v4);
plugin->http_server_task_v4 = GNUNET_SCHEDULER_NO_TASK;
}
if ( plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v6);
+ GNUNET_SCHEDULER_cancel(plugin->http_server_task_v6);
plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
}
if ( plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ GNUNET_SCHEDULER_cancel(plugin->http_curl_task);
plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_break (session->client != NULL);
if (session->receive_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (session->plugin->env->sched,
- session->receive_delay_task);
+ GNUNET_SCHEDULER_cancel (session->receive_delay_task);
if (session->client != NULL)
GNUNET_SERVER_receive_done (session->client,
GNUNET_SYSERR);
/* Only do one NAT punch attempt per peer identity */
return -1;
}
- sa = GNUNET_CONNECTION_create_from_sockaddr (plugin->env->sched,
- af, sb, sbs);
+ sa = GNUNET_CONNECTION_create_from_sockaddr (af, sb, sbs);
if (sa == NULL)
{
#if DEBUG_TCP
ppc->asc = asc;
ppc->asc_cls = asc_cls;
ppc->port = port;
- GNUNET_RESOLVER_hostname_get (plugin->env->sched,
- plugin->env->cfg,
+ GNUNET_RESOLVER_hostname_get (plugin->env->cfg,
sb,
sbs,
!numeric, timeout, &append_port, ppc);
GNUNET_SERVER_receive_done (session->client, GNUNET_OK);
else
session->receive_delay_task =
- GNUNET_SCHEDULER_add_delayed (session->plugin->env->sched,
- delay, &delayed_done, session);
+ GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
}
GNUNET_SERVER_receive_done (client, GNUNET_OK);
else
session->receive_delay_task =
- GNUNET_SCHEDULER_add_delayed (session->plugin->env->sched,
- delay, &delayed_done, session);
+ GNUNET_SCHEDULER_add_delayed (delay, &delayed_done, session);
}
else
{
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &tcp_plugin_server_read, plugin);
return;
}
_("nat-server-read malformed address\n"), &mybuf, port);
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &tcp_plugin_server_read, plugin);
return;
}
* We have received an ICMP response, ostensibly from a non-NAT'd peer
* that wants to connect to us! Send a message to establish a connection.
*/
- sock = GNUNET_CONNECTION_create_from_sockaddr (plugin->env->sched, AF_INET, (struct sockaddr *)&in_addr,
+ sock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, (struct sockaddr *)&in_addr,
sizeof(in_addr));
if (sock == NULL)
{
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &tcp_plugin_server_read, plugin);
return;
}
/*GNUNET_SERVER_connect_socket(plugin->server, sock);*/
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &tcp_plugin_server_read, plugin);
}
plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout, GNUNET_DISK_PIPE_END_READ);
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &tcp_plugin_server_read, plugin);
return GNUNET_YES;
}
struct sockaddr_in in_addr;
struct IPv4TcpAddress t4;
- service = GNUNET_SERVICE_start ("transport-tcp", env->sched, env->cfg);
+ service = GNUNET_SERVICE_start ("transport-tcp", env->cfg);
if (service == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
GNUNET_OS_network_interfaces_list (&process_interfaces, plugin);
}
- plugin->hostname_dns = GNUNET_RESOLVER_hostname_resolve (env->sched,
- env->cfg,
+ plugin->hostname_dns = GNUNET_RESOLVER_hostname_resolve (env->cfg,
AF_UNSPEC,
HOSTNAME_RESOLVE_TIMEOUT,
&process_hostname_ips,
if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (plugin->env->sched, plugin->select_task);
+ GNUNET_SCHEDULER_cancel (plugin->select_task);
plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
}
if (plugin->udp_sockv4.desc != NULL)
udp_probe_continuation (void *cls, const struct GNUNET_PeerIdentity *target, int result)
{
struct UDP_NAT_Probes *probe = cls;
- struct Plugin *plugin = probe->plugin;
+ /*struct Plugin *plugin = probe->plugin;*/
if ((result == GNUNET_OK) && (probe->count < MAX_PROBES))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Scheduling next probe for 10000 milliseconds\n"));
#endif
- probe->task = GNUNET_SCHEDULER_add_delayed(plugin->env->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10000), &send_udp_probe_message, probe);
+ probe->task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10000), &send_udp_probe_message, probe);
}
else /* Destroy the probe context. */
{
else
{
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &udp_plugin_server_read, plugin);
return;
}
_("nat-server-read malformed address\n"), &mybuf, port);
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &udp_plugin_server_read, plugin);
return;
}
temp_probe->addr.u_port = htons(port);
temp_probe->next = plugin->probes;
temp_probe->plugin = plugin;
- temp_probe->task = GNUNET_SCHEDULER_add_delayed(plugin->env->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500), &send_udp_probe_message, temp_probe);
+ temp_probe->task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500), &send_udp_probe_message, temp_probe);
plugin->probes = temp_probe;
}
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &udp_plugin_server_read, plugin);
}
if (outgoing_probe->task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(plugin->env->sched, outgoing_probe->task);
+ GNUNET_SCHEDULER_cancel(outgoing_probe->task);
outgoing_probe->task = GNUNET_SCHEDULER_NO_TASK;
/* Schedule task to timeout and remove probe if confirmation not received */
}
{
GNUNET_break_op (0);
plugin->select_task =
- GNUNET_SCHEDULER_add_select (plugin->env->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
NULL, &udp_plugin_select, plugin);
{
GNUNET_break_op (0);
plugin->select_task =
- GNUNET_SCHEDULER_add_select (plugin->env->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
NULL, &udp_plugin_select, plugin);
count++;
}
plugin->select_task =
- GNUNET_SCHEDULER_add_select (plugin->env->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
NULL, &udp_plugin_select, plugin);
plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout, GNUNET_DISK_PIPE_END_READ);
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &udp_plugin_server_read, plugin);
}
plugin->udp_sockv6.desc);
plugin->select_task =
- GNUNET_SCHEDULER_add_select (plugin->env->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
NULL, &udp_plugin_select, plugin);
ppc->asc = asc;
ppc->asc_cls = asc_cls;
ppc->port = port;
- GNUNET_RESOLVER_hostname_get (plugin->env->sched,
- plugin->env->cfg,
+ GNUNET_RESOLVER_hostname_get (plugin->env->cfg,
sb,
sbs,
!numeric, timeout, &append_port, ppc);
char *external_address;
struct IPv4UdpAddress v4_address;
- service = GNUNET_SERVICE_start ("transport-udp", env->sched, env->cfg);
+ service = GNUNET_SERVICE_start ("transport-udp", env->cfg);
if (service == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _
GNUNET_OS_network_interfaces_list (&process_interfaces, plugin);
}
- plugin->hostname_dns = GNUNET_RESOLVER_hostname_resolve (env->sched,
- env->cfg,
+ plugin->hostname_dns = GNUNET_RESOLVER_hostname_resolve (env->cfg,
AF_UNSPEC,
HOSTNAME_RESOLVE_TIMEOUT,
&process_hostname_ips,
} else {
//nothing to send at the moment
plugin->server_read_task =
- GNUNET_SCHEDULER_add_delayed (plugin->env->sched,
- GNUNET_TIME_absolute_get_remaining(nextsend),
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining(nextsend),
&do_transmit, plugin);
}
}
//plugin->server_read_task =
- //GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- // GNUNET_TIME_UNIT_FOREVER_REL,
+ //GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
// plugin->server_stdout_handle, &wlan_plugin_helper_read, plugin);
}
// GNUNET_TIME_UNIT_FOREVER_REL is needed to clean up old msg
plugin->server_write_task
- = GNUNET_SCHEDULER_add_write_file(plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ = GNUNET_SCHEDULER_add_write_file(GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdin_handle,
&do_transmit,
plugin);
plugin->server_stdin_handle = GNUNET_DISK_pipe_handle(plugin->server_stdin, GNUNET_DISK_PIPE_END_WRITE);
plugin->server_read_task =
- GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
plugin->server_stdout_handle, &wlan_plugin_helper_read, plugin);
return GNUNET_YES;
}
GNUNET_assert(cls !=NULL);
- service = GNUNET_SERVICE_start ("transport-wlan", env->sched, env->cfg);
+ service = GNUNET_SERVICE_start ("transport-wlan", env->cfg);
if (service == NULL){
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Failed to start service for `%s' transport plugin.\n"),
*/
static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
api->check_address (api->cls,
&soaddr, sizeof (soaddr)));
ok = 0;
- GNUNET_SCHEDULER_add_continuation (sched,
- &unload_task,
+ GNUNET_SCHEDULER_add_continuation (&unload_task,
(void *) cfg,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
setup_plugin_environment ()
{
env.cfg = cfg;
- env.sched = sched;
env.my_identity = &my_identity;
env.cls = &env;
env.receive = &receive;
* Runs the test.
*
* @param cls closure
- * @param s scheduler to use
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
char *libname;
- sched = s;
cfg = c;
/* parse configuration */
if ((GNUNET_OK !=
*/
static char * test_addr;
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our statistics handle.
*/
if (ti_send != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched,ti_send);
+ GNUNET_SCHEDULER_cancel(ti_send);
ti_send = GNUNET_SCHEDULER_NO_TASK;
}
if (http_task_send != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched,http_task_send);
+ GNUNET_SCHEDULER_cancel(http_task_send);
http_task_send = GNUNET_SCHEDULER_NO_TASK;
}
if (ti_timeout != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched,ti_timeout);
+ GNUNET_SCHEDULER_cancel(ti_timeout);
ti_timeout = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unloading http plugin\n");
GNUNET_assert (NULL == GNUNET_PLUGIN_unload ("libgnunet_plugin_transport_http", api));
- GNUNET_SCHEDULER_shutdown(sched);
+ GNUNET_SCHEDULER_shutdown();
GNUNET_DISK_directory_remove ("/tmp/test_plugin_transport_http");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Exiting testcase\n");
gws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
- http_task_send = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ http_task_send = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 0),
grs,
setup_plugin_environment ()
{
env.cfg = cfg;
- env.sched = sched;
env.stats = stats;
env.my_identity = &my_identity;
env.cls = &env;
* Runs the test.
*
* @param cls closure
- * @param s scheduler to use
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
{
char * libname;
- sched = s;
cfg = c;
char *keyfile;
unsigned long long tneigh;
}
- ti_timeout = GNUNET_SCHEDULER_add_delayed (sched, TEST_TIMEOUT, &task_timeout, NULL);
+ ti_timeout = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &task_timeout, NULL);
/* testing plugin functionality */
GNUNET_assert (0!=fail_notify_address_count);
*/
static char * test_addr;
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our statistics handle.
*/
if (ti_send != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched,ti_send);
+ GNUNET_SCHEDULER_cancel(ti_send);
ti_send = GNUNET_SCHEDULER_NO_TASK;
}
if (http_task_send != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched,http_task_send);
+ GNUNET_SCHEDULER_cancel(http_task_send);
http_task_send = GNUNET_SCHEDULER_NO_TASK;
}
if (ti_timeout != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(sched,ti_timeout);
+ GNUNET_SCHEDULER_cancel(ti_timeout);
ti_timeout = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unloading https plugin\n");
GNUNET_assert (NULL == GNUNET_PLUGIN_unload ("libgnunet_plugin_transport_https", api));
- GNUNET_SCHEDULER_shutdown(sched);
+ GNUNET_SCHEDULER_shutdown();
GNUNET_DISK_directory_remove ("/tmp/test_plugin_transport_http");
struct stat sbuf;
gws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
- http_task_send = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ http_task_send = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 0),
grs,
setup_plugin_environment ()
{
env.cfg = cfg;
- env.sched = sched;
env.stats = stats;
env.my_identity = &my_identity;
env.cls = &env;
* Runs the test.
*
* @param cls closure
- * @param s scheduler to use
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
{
char * libname;
- sched = s;
cfg = c;
char *keyfile;
unsigned long long tneigh;
return;
}
- ti_timeout = GNUNET_SCHEDULER_add_delayed (sched, TEST_TIMEOUT, &task_timeout, NULL);
+ ti_timeout = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &task_timeout, NULL);
/* testing plugin functionality */
GNUNET_assert (0!=fail_notify_address_count);
*/
static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
setup_plugin_environment ()
{
env.cfg = cfg;
- env.sched = sched;
env.my_identity = &my_identity;
env.cls = &env;
env.receive = &receive;
* Runs the test.
*
* @param cls closure
- * @param s scheduler to use
* @param c configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
char *libname;
- sched = s;
cfg = c;
/* parse configuration */
if ((GNUNET_OK !=
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
static int connected;
static void
end ()
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, measurement_task);
+ GNUNET_SCHEDULER_cancel (measurement_task);
measurement_task = GNUNET_SCHEDULER_NO_TASK;
}
if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, measurement_counter_task);
+ GNUNET_SCHEDULER_cancel (measurement_counter_task);
measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
}
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
#if DEBUG_CONNECTIONS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
#endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transports disconnected, returning success!\n");
#endif
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
}
{
if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, measurement_task);
+ GNUNET_SCHEDULER_cancel (measurement_task);
measurement_task = GNUNET_SCHEDULER_NO_TASK;
}
if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, measurement_counter_task);
+ GNUNET_SCHEDULER_cancel (measurement_counter_task);
measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_break (0);
#if VERBOSE
fprintf(stderr,".");
#endif
- measurement_counter_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_SECONDS,
+ measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&measurement_counter,
NULL);
}
if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sched, measurement_counter_task);
+ GNUNET_SCHEDULER_cancel (measurement_counter_task);
measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
}
#if VERBOSE
GNUNET_TIME_UNIT_FOREVER_REL,
NULL, NULL);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly,
NULL);
if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sched, measurement_counter_task);
- measurement_counter_task = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_SECONDS,
+ GNUNET_SCHEDULER_cancel (measurement_counter_task);
+ measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&measurement_counter,
NULL);
- measurement_task = GNUNET_SCHEDULER_add_delayed (sched,
- MEASUREMENT_INTERVALL,
+ measurement_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
&measurement_end,
NULL);
total_bytes_sent = 0;
#endif
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL,
+ p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
p,
¬ify_receive_new,
¬ify_connect,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly,
NULL);
measurement_running = GNUNET_NO;
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
static int is_tcp;
{
/* do work here */
GNUNET_assert (ok == 6);
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
GNUNET_TRANSPORT_disconnect (p1.th);
GNUNET_TRANSPORT_disconnect (p2.th);
{
if (cls == &p1)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT_TRANSMIT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT,
&end_badly, NULL);
GNUNET_TRANSPORT_notify_transmit_ready (p1.th,
}
}
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg,
+ p->th = GNUNET_TRANSPORT_connect (p->cfg,
NULL, p,
¬ify_receive,
¬ify_connect, ¬ify_disconnect);
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, NULL);
if (is_udp)
static struct PeerContext p2;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
static int is_tcp;
{
unsigned long long delta;
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
n, s,
ntohs (message->size),
ntohl (hdr->num));
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched, &end_badly, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
if (ntohl (hdr->num) != n)
n, s,
ntohs (message->size),
ntohl (hdr->num));
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched, &end_badly, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
memset (cbuf, n, s - sizeof (struct TestMessage));
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Expected message %u with bits %u, but body did not match\n",
n, (unsigned char) n);
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched, &end_badly, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
#if VERBOSE
if (0 == (n % (TOTAL_MSGS/100)))
{
fprintf (stderr, ".");
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly,
NULL);
}
}
}
- p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL,
+ p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
p,
¬ify_receive,
¬ify_connect,
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_assert (ok == 1);
OKPP;
- sched = s;
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly,
NULL);
if (is_tcp)
*/
struct HelloWaitList *hwl_head;
- /**
- * My scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* My configuration.
*/
if (h->quota_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sched,
- h->quota_task);
+ GNUNET_SCHEDULER_cancel (h->quota_task);
h->quota_task = GNUNET_SCHEDULER_NO_TASK;
}
retry_time = GNUNET_TIME_UNIT_FOREVER_REL;
#endif
if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sched, th->notify_delay_task);
+ GNUNET_SCHEDULER_cancel (th->notify_delay_task);
th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
n->transmit_stage = TS_NEW;
ret = th;
}
if (ret == NULL)
- h->quota_task = GNUNET_SCHEDULER_add_delayed (h->sched,
- retry_time,
+ h->quota_task = GNUNET_SCHEDULER_add_delayed (retry_time,
"a_transmit_ready,
h);
return ret;
{
if (cm->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sched, cm->notify_delay_task);
+ GNUNET_SCHEDULER_cancel (cm->notify_delay_task);
cm->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_CONTAINER_DLL_remove (h->control_head,
{
if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sched, th->notify_delay_task);
+ GNUNET_SCHEDULER_cancel (th->notify_delay_task);
th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
n = th->neighbour;
th->notify_cls = notify_cls;
th->notify_size = size;
th->notify_delay_task
- = GNUNET_SCHEDULER_add_delayed (h->sched,
- timeout, &control_transmit_timeout, th);
+ = GNUNET_SCHEDULER_add_delayed (timeout, &control_transmit_timeout, th);
if (at_head)
GNUNET_CONTAINER_DLL_insert (h->control_head,
h->control_tail,
if (buf == NULL)
{
- GNUNET_SCHEDULER_add_continuation (sqc->handle->sched,
- sqc->cont,
+ GNUNET_SCHEDULER_add_continuation (sqc->cont,
sqc->cont_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
GNUNET_free (sqc);
msg->quota = sqc->quota_in;
memcpy (&msg->peer, &sqc->target, sizeof (struct GNUNET_PeerIdentity));
if (sqc->cont != NULL)
- GNUNET_SCHEDULER_add_continuation (sqc->handle->sched,
- sqc->cont,
+ GNUNET_SCHEDULER_add_continuation (sqc->cont,
sqc->cont_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
GNUNET_free (sqc);
"Connecting to transport service.\n");
#endif
GNUNET_assert (h->client == NULL);
- h->client = GNUNET_CLIENT_connect (h->sched, "transport", h->cfg);
+ h->client = GNUNET_CLIENT_connect ("transport", h->cfg);
GNUNET_assert (h->client != NULL);
/* make sure we don't send "START" twice, remove existing entry from
queue (if present) */
pos);
if (GNUNET_SCHEDULER_NO_TASK != pos->notify_delay_task)
{
- GNUNET_SCHEDULER_cancel (h->sched, pos->notify_delay_task);
+ GNUNET_SCHEDULER_cancel (pos->notify_delay_task);
pos->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_free (pos);
GNUNET_assert (h->client == NULL);
GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
h->reconnect_task
- = GNUNET_SCHEDULER_add_delayed (h->sched,
- h->reconnect_delay, &reconnect, h);
+ = GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
if (h->reconnect_delay.rel_value == 0)
{
h->reconnect_delay = GNUNET_TIME_UNIT_MILLISECONDS;
* Connect to the transport service. Note that the connection may
* complete (or fail) asynchronously.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param self our own identity (API should check that it matches
* the identity found by transport), or NULL (no check)
* @param nd function to call on disconnect events
*/
struct GNUNET_TRANSPORT_Handle *
-GNUNET_TRANSPORT_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TRANSPORT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct GNUNET_PeerIdentity *self,
void *cls,
GNUNET_TRANSPORT_ReceiveCallback rec,
ret->self = *self;
ret->check_self = GNUNET_YES;
}
- ret->sched = sched;
ret->cfg = cfg;
ret->cls = cls;
ret->rec = rec;
th = &n->transmit_handle;
if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (handle->sched,
- th->notify_delay_task);
+ GNUNET_SCHEDULER_cancel (th->notify_delay_task);
th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_assert (0 == th->notify (th->notify_cls, 0, NULL));
#endif
if (cm->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (handle->sched, cm->notify_delay_task);
+ GNUNET_SCHEDULER_cancel (cm->notify_delay_task);
cm->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_CONTAINER_DLL_remove (handle->control_head,
if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (handle->sched, handle->reconnect_task);
+ GNUNET_SCHEDULER_cancel (handle->reconnect_task);
handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
if (handle->quota_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (handle->sched, handle->quota_task);
+ GNUNET_SCHEDULER_cancel (handle->quota_task);
handle->quota_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_free_non_null (handle->my_hello);
th->notify_size = size + sizeof (struct OutboundMessage);
th->priority = priority;
th->notify_delay_task
- = GNUNET_SCHEDULER_add_delayed (handle->sched, timeout,
+ = GNUNET_SCHEDULER_add_delayed (timeout,
&peer_transmit_timeout, th);
schedule_transmission (handle);
return th;
}
if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (n->h->sched,
- th->notify_delay_task);
+ GNUNET_SCHEDULER_cancel (th->notify_delay_task);
th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
}
/**
* Convert a binary address into a human readable address.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param address address to convert (binary format)
* @param addressLen number of bytes in address
* @param aluc_cls closure for aluc
*/
void
-GNUNET_TRANSPORT_address_lookup (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TRANSPORT_address_lookup (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *address,
size_t addressLen,
int numeric,
aluc (aluc_cls, NULL);
return;
}
- client = GNUNET_CLIENT_connect (sched, "transport", cfg);
+ client = GNUNET_CLIENT_connect ("transport", cfg);
if (client == NULL)
{
aluc (aluc_cls, NULL);
*/
struct GNUNET_CLIENT_Connection * client;
- /**
- * Scheduler to use.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Configuration to use.
*/
{
if (br->client != NULL)
GNUNET_CLIENT_disconnect (br->client, GNUNET_NO);
- br->client = GNUNET_CLIENT_connect (br->sched,
- "transport",
+ br->client = GNUNET_CLIENT_connect ("transport",
br->cfg);
GNUNET_assert (br->client != NULL);
br->th = GNUNET_CLIENT_notify_transmit_ready (br->client,
* only way to re-enable connections from peers that were previously
* blacklisted.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param cb callback to invoke to check if connections are allowed
* @param cb_cls closure for cb
* @return NULL on error, otherwise handle for cancellation
*/
struct GNUNET_TRANSPORT_Blacklist *
-GNUNET_TRANSPORT_blacklist (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TRANSPORT_blacklist (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_TRANSPORT_BlacklistCallback cb,
void *cb_cls)
{
struct GNUNET_CLIENT_Connection * client;
struct GNUNET_TRANSPORT_Blacklist *ret;
- client = GNUNET_CLIENT_connect (sched, "transport", cfg);
+ client = GNUNET_CLIENT_connect ("transport", cfg);
if (NULL == client)
return NULL;
ret = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_Blacklist));
ret->client = client;
- ret->sched = sched;
ret->cfg = cfg;
ret->th = GNUNET_CLIENT_notify_transmit_ready (client,
sizeof (struct GNUNET_MessageHeader),
*/
struct GNUNET_CONNECTION_Handle *sock;
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
* FIXME: why do we DUP the configuration? Avoid this!
/**
* Try to connect to the service.
*
- * @param sched scheduler to use
* @param service_name name of service to connect to
* @param cfg configuration to use
* @param attempt counter used to alternate between IP and UNIX domain sockets
* @return NULL on error
*/
static struct GNUNET_CONNECTION_Handle *
-do_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const char *service_name,
+do_connect (const char *service_name,
const struct GNUNET_CONFIGURATION_Handle *cfg,
unsigned int attempt)
{
service_name,
"UNIXPATH", &unixpath))
{
- sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (sched,
- cfg,
+ sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg,
unixpath);
GNUNET_free (unixpath);
if (sock != NULL)
service_name);
return NULL;
}
- sock = GNUNET_CONNECTION_create_from_connect (sched,
- cfg,
+ sock = GNUNET_CONNECTION_create_from_connect (cfg,
hostname,
port);
GNUNET_free (hostname);
/**
* Get a connection with a service.
*
- * @param sched scheduler to use
* @param service_name name of the service
* @param cfg configuration to use
* @return NULL on error (service unknown to configuration)
*/
struct GNUNET_CLIENT_Connection *
-GNUNET_CLIENT_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const char *service_name,
+GNUNET_CLIENT_connect (const char *service_name,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_CLIENT_Connection *ret;
struct GNUNET_CONNECTION_Handle *sock;
- sock = do_connect (sched,
- service_name,
+ sock = do_connect (service_name,
cfg, 0);
if (sock == NULL)
return NULL;
ret = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_Connection));
ret->attempts = 1;
ret->sock = sock;
- ret->sched = sched;
ret->service_name = GNUNET_strdup (service_name);
ret->cfg = GNUNET_CONFIGURATION_dup (cfg);
ret->back_off = GNUNET_TIME_UNIT_MILLISECONDS;
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->receive_task);
sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
if (GNUNET_YES == sock->msg_complete)
{
- sock->receive_task = GNUNET_SCHEDULER_add_after (sock->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ sock->receive_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&receive_task, sock);
}
else
* Report service unavailable.
*/
static void
-service_test_error (struct GNUNET_SCHEDULER_Handle *s,
- GNUNET_SCHEDULER_Task task, void *task_cls)
+service_test_error (GNUNET_SCHEDULER_Task task, void *task_cls)
{
- GNUNET_SCHEDULER_add_continuation (s,
- task,
+ GNUNET_SCHEDULER_add_continuation (task,
task_cls,
GNUNET_SCHEDULER_REASON_TIMEOUT);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received confirmation that service is running.\n");
#endif
- GNUNET_SCHEDULER_add_continuation (conn->sched,
- conn->test_cb,
+ GNUNET_SCHEDULER_add_continuation (conn->test_cb,
conn->test_cb_cls,
GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
else
{
- service_test_error (conn->sched, conn->test_cb, conn->test_cb_cls);
+ service_test_error (conn->test_cb, conn->test_cb_cls);
}
GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Failure to transmit TEST request.\n"));
#endif
- service_test_error (conn->sched, conn->test_cb, conn->test_cb_cls);
+ service_test_error (conn->test_cb, conn->test_cb_cls);
GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
return 0; /* client disconnected */
}
/**
* Wait until the service is running.
*
- * @param sched scheduler to use
* @param service name of the service to wait for
* @param cfg configuration to use
* @param timeout how long to wait at most in ms
* @param task_cls closure for task
*/
void
-GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
- const char *service,
+GNUNET_CLIENT_service_test (const char *service,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
GNUNET_SCHEDULER_Task task, void *task_cls)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Testing if service `%s' is running.\n", service);
#endif
- conn = GNUNET_CLIENT_connect (sched, service, cfg);
+ conn = GNUNET_CLIENT_connect (service, cfg);
if (conn == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_
("Could not connect to service `%s', must not be running.\n"),
service);
- service_test_error (sched, task, task_cls);
+ service_test_error (task, task_cls);
return;
}
conn->test_cb = task;
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Failure to transmit request to service `%s'\n"),
service);
- service_test_error (sched, task, task_cls);
+ service_test_error (task, task_cls);
GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
return;
}
{
delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
delay.rel_value /= 2;
- if ( (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason (th->sock->sched))) ||
+ if ( (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason ())) ||
(GNUNET_YES != th->auto_retry) ||
(0 == --th->attempts_left) ||
(delay.rel_value < 1) )
}
/* auto-retry */
GNUNET_CONNECTION_destroy (th->sock->sock, GNUNET_NO);
- th->sock->sock = do_connect (th->sock->sched,
- th->sock->service_name,
+ th->sock->sock = do_connect (th->sock->service_name,
th->sock->cfg,
th->sock->attempts++);
GNUNET_assert (NULL != th->sock->sock);
MAX_ATTEMPTS - th->attempts_left,
(unsigned long long) delay.rel_value);
#endif
- th->reconnect_task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
- delay,
+ th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
&client_delayed_retry,
th);
th->sock->th = th;
if (th->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_break (NULL == th->th);
- GNUNET_SCHEDULER_cancel (th->sock->sched, th->reconnect_task);
+ GNUNET_SCHEDULER_cancel (th->reconnect_task);
th->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
else
struct GNUNET_CONNECTION_Handle
{
- /**
- * Scheduler that was used for the connect task.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Configuration to use.
*/
* socket should henceforth be no longer used directly.
* GNUNET_socket_destroy will close it.
*
- * @param sched scheduler to use
* @param osSocket existing socket to box
* @return the boxed socket handle
*/
struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
- *sched,
- struct GNUNET_NETWORK_Handle
+GNUNET_CONNECTION_create_from_existing (struct GNUNET_NETWORK_Handle
*osSocket)
{
struct GNUNET_CONNECTION_Handle *ret;
ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
ret->sock = osSocket;
- ret->sched = sched;
return ret;
}
* Create a socket handle by accepting on a listen socket. This
* function may block if the listen socket has no connection ready.
*
- * @param sched scheduler to use
* @param access function to use to check if access is allowed
* @param access_cls closure for access
* @param lsock listen socket
* @return the socket handle, NULL on error
*/
struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
- *sched,
- GNUNET_CONNECTION_AccessCheck access,
+GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
void *access_cls,
struct GNUNET_NETWORK_Handle *lsock)
{
ret->addr = uaddr;
ret->addrlen = addrlen;
ret->sock = sock;
- ret->sched = sched;
#if DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Accepting connection from `%s': %p\n"),
#endif
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
sock->destroy_task
- = GNUNET_SCHEDULER_add_after (sock->sched,
- sock->write_task,
+ = GNUNET_SCHEDULER_add_after (sock->write_task,
&destroy_continuation, sock);
return;
}
{
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
sock->destroy_task
- = GNUNET_SCHEDULER_add_after (sock->sched,
- sock->read_task,
+ = GNUNET_SCHEDULER_add_after (sock->read_task,
&destroy_continuation, sock);
return;
}
while (NULL != (pos = sock->ap_head))
{
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
- GNUNET_SCHEDULER_cancel (sock->sched, pos->task);
+ GNUNET_SCHEDULER_cancel (pos->task);
GNUNET_CONTAINER_DLL_remove (sock->ap_head, sock->ap_tail, pos);
GNUNET_free (pos);
}
h);
#endif
h->ccs -= COCO_RECEIVE_AGAIN;
- h->read_task = GNUNET_SCHEDULER_add_after (h->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ h->read_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&receive_again, h);
}
if (0 != (h->ccs & COCO_TRANSMIT_READY))
h);
#endif
GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
- GNUNET_SCHEDULER_cancel (h->sched, h->nth.timeout_task);
+ GNUNET_SCHEDULER_cancel (h->nth.timeout_task);
h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
h->ccs -= COCO_TRANSMIT_READY;
GNUNET_assert (h->write_task == GNUNET_SCHEDULER_NO_TASK);
- h->write_task = GNUNET_SCHEDULER_add_after (h->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ h->write_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&transmit_ready, h);
}
if (0 != (h->ccs & COCO_DESTROY_CONTINUATION))
h->ccs -= COCO_DESTROY_CONTINUATION;
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->destroy_task);
h->destroy_task
- = GNUNET_SCHEDULER_add_now (h->sched,
- &destroy_continuation,
+ = GNUNET_SCHEDULER_add_now (&destroy_continuation,
h);
}
}
h);
#endif
h->ccs -= COCO_RECEIVE_AGAIN;
- h->read_task = GNUNET_SCHEDULER_add_after (h->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ h->read_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&receive_again, h);
}
if (0 != (h->ccs & COCO_TRANSMIT_READY))
h);
#endif
GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
- GNUNET_SCHEDULER_cancel (h->sched, h->nth.timeout_task);
+ GNUNET_SCHEDULER_cancel (h->nth.timeout_task);
h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
h->ccs -= COCO_TRANSMIT_READY;
GNUNET_assert (h->write_task == GNUNET_SCHEDULER_NO_TASK);
h->write_task =
- GNUNET_SCHEDULER_add_write_net (h->sched,
- GNUNET_TIME_absolute_get_remaining
+ GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
(h->nth.transmit_timeout), h->sock,
&transmit_ready, h);
}
h->ccs -= COCO_DESTROY_CONTINUATION;
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->destroy_task);
h->destroy_task
- = GNUNET_SCHEDULER_add_now (h->sched,
- &destroy_continuation,
- h);
+ = GNUNET_SCHEDULER_add_now (&destroy_continuation,
+ h);
}
}
while (NULL != (pos = h->ap_head))
{
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
- GNUNET_SCHEDULER_cancel (h->sched, pos->task);
+ GNUNET_SCHEDULER_cancel (pos->task);
GNUNET_CONTAINER_DLL_remove (h->ap_head, h->ap_tail, pos);
GNUNET_free (pos);
}
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 (delay, ap->sock,
&connect_probe_continuation, ap);
}
* This function returns immediately, even if the connection has not
* yet been established. This function only creates TCP connections.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param hostname name of the host to connect to
* @param port port to connect to
* @return the socket handle
*/
struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct
+GNUNET_CONNECTION_create_from_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
const char *hostname, uint16_t port)
{
GNUNET_assert (0 < strlen (hostname)); /* sanity check */
ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
ret->cfg = cfg;
- ret->sched = sched;
ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
ret->port = port;
ret->hostname = GNUNET_strdup (hostname);
- ret->dns_active = GNUNET_RESOLVER_ip_get (sched,
- cfg,
+ ret->dns_active = GNUNET_RESOLVER_ip_get (cfg,
ret->hostname,
AF_UNSPEC,
GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
* This function returns immediately, even if the connection has not
* yet been established. This function only creates UNIX connections.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param unixpath path to connect to
* @return the socket handle, NULL on systems without UNIX support
*/
struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handle *sched,
- const struct
+GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
GNUNET_CONFIGURATION_Handle *cfg,
const char *unixpath)
{
#endif
ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
ret->cfg = cfg;
- ret->sched = sched;
ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
ret->port = 0;
* This function returns immediately, even if the connection has not
* yet been established. This function only creates TCP connections.
*
- * @param sched scheduler to use
* @param af_family address family to use
* @param serv_addr server address
* @param addrlen length of server address
* @return the socket handle
*/
struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
- *sched, int af_family,
+GNUNET_CONNECTION_create_from_sockaddr (int af_family,
const struct sockaddr *serv_addr,
socklen_t addrlen)
{
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
return NULL;
}
- ret = GNUNET_CONNECTION_create_from_existing (sched, s);
+ ret = GNUNET_CONNECTION_create_from_existing (s);
ret->addr = GNUNET_malloc (addrlen);
memcpy (ret->addr, serv_addr, addrlen);
ret->addrlen = addrlen;
{
if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sock->sched,
- sock->write_task);
+ GNUNET_SCHEDULER_cancel (sock->write_task);
sock->write_task = GNUNET_SCHEDULER_NO_TASK;
sock->write_buffer_off = 0;
}
GNUNET_RESOLVER_request_cancel (sock->dns_active);
sock->dns_active = NULL;
}
- GNUNET_assert (sock->sched != NULL);
+
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
sock->destroy_task
- = GNUNET_SCHEDULER_add_now (sock->sched,
- &destroy_continuation, sock);
+ = GNUNET_SCHEDULER_add_now (&destroy_continuation, sock);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Ignoring shutdown signal per configuration\n");
#endif
- sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_TIME_absolute_get_remaining
+ sh->read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining
(sh->receive_timeout),
sh->sock,
&receive_ready, sh);
}
GNUNET_assert (sh->sock != NULL);
/* connect succeeded, wait for data! */
- sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_TIME_absolute_get_remaining
+ sh->read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining
(sh->receive_timeout),
sh->sock,
&receive_ready, sh);
if (sock->sock != NULL)
{
memset (&tc, 0, sizeof (tc));
- tc.sched = sock->sched;
tc.reason = GNUNET_SCHEDULER_REASON_PREREQ_DONE;
receive_again (sock, &tc);
return;
{
if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->sched,
- sock->read_task));
+ GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->read_task));
sock->read_task = GNUNET_SCHEDULER_NO_TASK;
}
else
}
if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (sock->sched,
- sock->read_task);
+ GNUNET_SCHEDULER_cancel (sock->read_task);
sock->read_task = GNUNET_SCHEDULER_NO_TASK;
signal_timeout (sock);
return;
#endif
if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
sock->write_task =
- GNUNET_SCHEDULER_add_write_net (tc->sched,
- GNUNET_TIME_absolute_get_remaining
+ GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
(sock->nth.transmit_timeout),
sock->sock, &transmit_ready, sock);
}
(sock->ap_head == NULL) && (sock->dns_active == NULL))
{
if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (sock->sched,
- sock->write_task);
- sock->write_task = GNUNET_SCHEDULER_add_now (sock->sched,
- &connect_error, sock);
+ GNUNET_SCHEDULER_cancel (sock->write_task);
+ sock->write_task = GNUNET_SCHEDULER_add_now (&connect_error, sock);
return &sock->nth;
}
if (GNUNET_SCHEDULER_NO_TASK != sock->write_task)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Scheduling transmit_ready (%p).\n", sock);
#endif
- sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched,
- GNUNET_TIME_absolute_get_remaining
+ sock->write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
(sock->nth.
transmit_timeout),
sock->sock,
sock);
#endif
sock->ccs |= COCO_TRANSMIT_READY;
- sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
- timeout,
+ sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
&transmit_timeout,
sock);
}
"notify_transmit_ready_cancel cancels timeout_task (%p)\n",
h);
#endif
- GNUNET_SCHEDULER_cancel (h->sh->sched, h->timeout_task);
+ GNUNET_SCHEDULER_cancel (h->timeout_task);
h->timeout_task = GNUNET_SCHEDULER_NO_TASK;
h->sh->ccs -= COCO_TRANSMIT_READY;
}
{
if (h->sh->write_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (h->sh->sched, h->sh->write_task);
+ GNUNET_SCHEDULER_cancel (h->sh->write_task);
h->sh->write_task = GNUNET_SCHEDULER_NO_TASK;
}
}
*/
struct GNUNET_DISK_FileHandle *fh;
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Cummulated hash.
*/
return;
}
fhc->task
- = GNUNET_SCHEDULER_add_after (tc->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&file_hash_task, fhc);
}
/**
* Compute the hash of an entire file.
*
- * @param sched scheduler to use
* @param priority scheduling priority to use
* @param filename name of file to hash
* @param blocksize number of bytes to process in one task
* @return NULL on (immediate) errror
*/
struct GNUNET_CRYPTO_FileHashContext *
-GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority priority,
+GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
const char *filename,
size_t blocksize,
GNUNET_CRYPTO_HashCompletedCallback callback,
fhc = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize);
fhc->callback = callback;
fhc->callback_cls = callback_cls;
- fhc->sched = sched;
fhc->buffer = (unsigned char *) &fhc[1];
fhc->filename = GNUNET_strdup (filename);
if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0))
return NULL;
}
fhc->task
- = GNUNET_SCHEDULER_add_with_priority (sched, priority,
+ = GNUNET_SCHEDULER_add_with_priority (priority,
&file_hash_task, fhc);
return fhc;
}
void
GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
{
- GNUNET_SCHEDULER_cancel (fhc->sched,
- fhc->task);
+ GNUNET_SCHEDULER_cancel (fhc->task);
GNUNET_free (fhc->filename);
GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
GNUNET_free (fhc);
*/
struct GNUNET_DISK_DirectoryIterator
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Function to call on directory entries.
GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES);
return GNUNET_NO;
}
- GNUNET_SCHEDULER_add_with_priority (iter->sched,
- iter->priority,
+ GNUNET_SCHEDULER_add_with_priority (iter->priority,
&directory_iterator_task, iter);
return GNUNET_YES;
}
* If a scheduler does not need to be used, GNUNET_DISK_directory_scan
* may provide a simpler API.
*
- * @param sched scheduler to use
* @param prio priority to use
* @param dirName the name of the directory
* @param callback the method to call for each file
* @param callback_cls closure for callback
*/
void
-GNUNET_DISK_directory_iterator_start (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority prio,
+GNUNET_DISK_directory_iterator_start (enum GNUNET_SCHEDULER_Priority prio,
const char *dirName,
GNUNET_DISK_DirectoryIteratorCallback
callback, void *callback_cls)
struct GNUNET_DISK_DirectoryIterator *di;
di = GNUNET_malloc (sizeof (struct GNUNET_DISK_DirectoryIterator));
- di->sched = sched;
di->callback = callback;
di->callback_cls = callback_cls;
di->directory = OPENDIR (dirName);
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
if (args[0] == NULL)
return;
- GNUNET_RESOLVER_ip_get (sched, cfg,
+ GNUNET_RESOLVER_ip_get (cfg,
args[0],
AF_UNSPEC,
GET_TIMEOUT,
* Process resolver requests.
*
* @param cls closure
- * @param sched scheduler to use
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
{
struct CommandContext *cc = cls;
- cc->task (cc->task_cls, tc->sched, cc->args, cc->cfgfile, cc->cfg);
+ cc->task (cc->task_cls, cc->args, cc->cfgfile, cc->cfg);
}
*/
struct GNUNET_CLIENT_Connection *client;
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Name of the host that we are resolving.
*/
/**
* Convert a string to one or more IP addresses.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param hostname the hostname to resolve
* @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
* @return handle that can be used to cancel the request, NULL on error
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_RESOLVER_ip_get (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *hostname,
int domain,
struct GNUNET_TIME_Relative timeout,
return NULL;
}
rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + slen);
- rh->sched = sched;
rh->domain = domain;
rh->addr_callback = callback;
rh->cls = callback_cls;
&v6)) &&
((domain == AF_INET6) || (domain == AF_UNSPEC))))
{
- rh->task = GNUNET_SCHEDULER_add_now (sched,
- &numeric_resolution, rh);
+ rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution, rh);
return rh;
}
/* then, check if this is a loopback address */
while (loopback[i] != NULL)
if (0 == strcasecmp (loopback[i++], hostname))
{
- rh->task = GNUNET_SCHEDULER_add_now (sched,
- &loopback_resolution, rh);
+ rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution, rh);
return rh;
}
- client = GNUNET_CLIENT_connect (sched, "resolver", cfg);
+ client = GNUNET_CLIENT_connect ("resolver", cfg);
if (client == NULL)
{
GNUNET_free (rh);
/**
* Get an IP address as a string.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param sa host address
* @param salen length of host address
* @return handle that can be used to cancel the request
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_RESOLVER_hostname_get (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct sockaddr *sa,
socklen_t salen,
int do_resolve,
rh->name_callback = callback;
rh->cls = cls;
rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
- rh->sched = sched;
rh->salen = salen;
memcpy (&rh[1], sa, salen);
if (GNUNET_NO == do_resolve)
{
- rh->task = GNUNET_SCHEDULER_add_now (sched,
- &numeric_reverse, rh);
+ rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse, rh);
return rh;
}
if (salen + sizeof (struct GNUNET_RESOLVER_GetMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
GNUNET_free (rh);
return NULL;
}
- client = GNUNET_CLIENT_connect (sched, "resolver", cfg);
+ client = GNUNET_CLIENT_connect ("resolver", cfg);
if (client == NULL)
{
GNUNET_free (rh);
/**
* Looking our own hostname.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
* @param callback function to call with addresses
* @return handle that can be used to cancel the request, NULL on error
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle
+GNUNET_RESOLVER_hostname_resolve (const struct GNUNET_CONFIGURATION_Handle
*cfg, int domain,
struct GNUNET_TIME_Relative timeout,
GNUNET_RESOLVER_AddressCallback callback,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Resolving our hostname `%s'\n"), hostname);
#endif
- return GNUNET_RESOLVER_ip_get (sched,
- cfg, hostname, domain, timeout, callback,
+ return GNUNET_RESOLVER_ip_get (cfg, hostname, domain, timeout, callback,
cls);
}
if (h->client != NULL)
GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
if (h->task != GNUNET_SCHEDULER_NO_TASK)
- GNUNET_SCHEDULER_cancel (h->sched, h->task);
+ GNUNET_SCHEDULER_cancel (h->task);
GNUNET_free (h);
}
/**
- * Handle for the scheduling service.
- */
-struct GNUNET_SCHEDULER_Handle
-{
-
- /**
- * List of tasks waiting for an event.
- */
- struct Task *pending;
-
- /**
- * List of tasks waiting ONLY for a timeout event.
- * Sorted by timeout (earliest first). Used so that
- * we do not traverse the list of these tasks when
- * building select sets (we just look at the head
- * to determine the respective timeout ONCE).
- */
- struct Task *pending_timeout;
+* List of tasks waiting for an event.
+*/
+struct Task *pending;
- /**
- * Last inserted task waiting ONLY for a timeout event.
- * Used to (heuristically) speed up insertion.
- */
- struct Task *pending_timeout_last;
+/**
+* List of tasks waiting ONLY for a timeout event.
+* Sorted by timeout (earliest first). Used so that
+* we do not traverse the list of these tasks when
+* building select sets (we just look at the head
+* to determine the respective timeout ONCE).
+*/
+struct Task *pending_timeout;
- /**
- * ID of the task that is running right now.
- */
- struct Task *active_task;
+/**
+* Last inserted task waiting ONLY for a timeout event.
+* Used to (heuristically) speed up insertion.
+*/
+struct Task *pending_timeout_last;
- /**
- * List of tasks ready to run right now,
- * grouped by importance.
- */
- struct Task *ready[GNUNET_SCHEDULER_PRIORITY_COUNT];
+/**
+* ID of the task that is running right now.
+*/
+struct Task *active_task;
- /**
- * Identity of the last task queued. Incremented for each task to
- * generate a unique task ID (it is virtually impossible to start
- * more than 2^64 tasks during the lifetime of a process).
- */
- GNUNET_SCHEDULER_TaskIdentifier last_id;
+/**
+* List of tasks ready to run right now,
+* grouped by importance.
+*/
+struct Task *ready[GNUNET_SCHEDULER_PRIORITY_COUNT];
- /**
- * Highest number so that all tasks with smaller identifiers
- * have already completed. Also the lowest number of a task
- * still waiting to be executed.
- */
- GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id;
+/**
+* Identity of the last task queued. Incremented for each task to
+* generate a unique task ID (it is virtually impossible to start
+* more than 2^64 tasks during the lifetime of a process).
+*/
+GNUNET_SCHEDULER_TaskIdentifier last_id;
- /**
- * Number of tasks on the ready list.
- */
- unsigned int ready_count;
+/**
+* Highest number so that all tasks with smaller identifiers
+* have already completed. Also the lowest number of a task
+* still waiting to be executed.
+*/
+GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id;
- /**
- * How many tasks have we run so far?
- */
- unsigned long long tasks_run;
+/**
+* Number of tasks on the ready list.
+*/
+unsigned int ready_count;
- /**
- * Priority of the task running right now. Only
- * valid while a task is running.
- */
- enum GNUNET_SCHEDULER_Priority current_priority;
+/**
+* How many tasks have we run so far?
+*/
+unsigned long long tasks_run;
- /**
- * Priority of the highest task added in the current select
- * iteration.
- */
- enum GNUNET_SCHEDULER_Priority max_priority_added;
+/**
+* Priority of the task running right now. Only
+* valid while a task is running.
+*/
+enum GNUNET_SCHEDULER_Priority current_priority;
- /**
- * How 'nice' are we right now?
- */
- int nice_level;
+/**
+* Priority of the highest task added in the current select
+* iteration.
+*/
+enum GNUNET_SCHEDULER_Priority max_priority_added;
-};
+/**
+* How 'nice' are we right now?
+*/
+int nice_level;
/**
* @return GNUNET_YES if so, GNUNET_NO if not
*/
static int
-is_pending (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_TaskIdentifier id)
+is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
{
struct Task *pos;
enum GNUNET_SCHEDULER_Priority p;
GNUNET_SCHEDULER_TaskIdentifier min;
- if (id < sched->lowest_pending_id)
+ if (id < lowest_pending_id)
return GNUNET_NO;
min = -1; /* maximum value */
- pos = sched->pending;
+ pos = pending;
while (pos != NULL)
{
if (pos->id == id)
min = pos->id;
pos = pos->next;
}
- pos = sched->pending_timeout;
+ pos = pending_timeout;
while (pos != NULL)
{
if (pos->id == id)
}
for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++)
{
- pos = sched->ready[p];
+ pos = ready[p];
while (pos != NULL)
{
if (pos->id == id)
pos = pos->next;
}
}
- sched->lowest_pending_id = min;
+ lowest_pending_id = min;
return GNUNET_NO;
}
* @param timeout next timeout (updated)
*/
static void
-update_sets (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_NETWORK_FDSet *rs,
+update_sets (struct GNUNET_NETWORK_FDSet *rs,
struct GNUNET_NETWORK_FDSet *ws,
struct GNUNET_TIME_Relative *timeout)
{
struct GNUNET_TIME_Relative to;
now = GNUNET_TIME_absolute_get ();
- pos = sched->pending_timeout;
+ pos = pending_timeout;
if (pos != NULL)
{
to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
if (pos->reason != 0)
*timeout = GNUNET_TIME_UNIT_ZERO;
}
- pos = sched->pending;
+ pos = pending;
while (pos != NULL)
{
if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) &&
- (GNUNET_YES == is_pending (sched, pos->prereq_id)))
+ (GNUNET_YES == is_pending (pos->prereq_id)))
{
pos = pos->next;
continue;
* @return GNUNET_YES if we can run it, GNUNET_NO if not.
*/
static int
-is_ready (struct GNUNET_SCHEDULER_Handle *sched,
- struct Task *task,
+is_ready (struct Task *task,
struct GNUNET_TIME_Absolute now,
const struct GNUNET_NETWORK_FDSet *rs,
const struct GNUNET_NETWORK_FDSet *ws)
return GNUNET_NO; /* not ready */
if (task->prereq_id != GNUNET_SCHEDULER_NO_TASK)
{
- if (GNUNET_YES == is_pending (sched, task->prereq_id))
+ if (GNUNET_YES == is_pending (task->prereq_id))
{
task->reason = reason;
return GNUNET_NO; /* prereq waiting */
* @param task task ready for execution
*/
static void
-queue_ready_task (struct GNUNET_SCHEDULER_Handle *handle,
- struct Task *task)
+queue_ready_task (struct Task *task)
{
enum GNUNET_SCHEDULER_Priority p = task->priority;
if (0 != (task->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
p = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
- task->next = handle->ready[check_priority (p)];
- handle->ready[check_priority (p)] = task;
- handle->ready_count++;
+ task->next = ready[check_priority (p)];
+ ready[check_priority (p)] = task;
+ ready_count++;
}
* @param ws FDs ready for writing
*/
static void
-check_ready (struct GNUNET_SCHEDULER_Handle *handle,
- const struct GNUNET_NETWORK_FDSet *rs,
+check_ready (const struct GNUNET_NETWORK_FDSet *rs,
const struct GNUNET_NETWORK_FDSet *ws)
{
struct Task *pos;
now = GNUNET_TIME_absolute_get ();
prev = NULL;
- pos = handle->pending_timeout;
+ pos = pending_timeout;
while (pos != NULL)
{
next = pos->next;
pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
if (0 == pos->reason)
break;
- handle->pending_timeout = next;
- if (handle->pending_timeout_last == pos)
- handle->pending_timeout_last = NULL;
- queue_ready_task (handle, pos);
+ pending_timeout = next;
+ if (pending_timeout_last == pos)
+ pending_timeout_last = NULL;
+ queue_ready_task (pos);
pos = next;
}
- pos = handle->pending;
+ pos = pending;
while (pos != NULL)
{
#if DEBUG_TASKS
pos->id, pos->callback_cls);
#endif
next = pos->next;
- if (GNUNET_YES == is_ready (handle, pos, now, rs, ws))
+ if (GNUNET_YES == is_ready (pos, now, rs, ws))
{
if (prev == NULL)
- handle->pending = next;
+ pending = next;
else
prev->next = next;
- queue_ready_task (handle, pos);
+ queue_ready_task (pos);
pos = next;
continue;
}
* @param sched the scheduler
*/
void
-GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched)
+GNUNET_SCHEDULER_shutdown ()
{
struct Task *pos;
int i;
- pos = sched->pending_timeout;
+ pos = pending_timeout;
while (pos != NULL)
{
pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
readiness-factors */
pos = pos->next;
}
- pos = sched->pending;
+ pos = pending;
while (pos != NULL)
{
pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
}
for (i=0;i<GNUNET_SCHEDULER_PRIORITY_COUNT;i++)
{
- pos = sched->ready[i];
+ pos = ready[i];
while (pos != NULL)
{
pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
* @param ws FDs ready for writing
*/
static void
-run_ready (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_NETWORK_FDSet *rs,
+run_ready (struct GNUNET_NETWORK_FDSet *rs,
struct GNUNET_NETWORK_FDSet *ws)
{
enum GNUNET_SCHEDULER_Priority p;
struct Task *pos;
struct GNUNET_SCHEDULER_TaskContext tc;
- sched->max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
+ max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
do
{
- if (sched->ready_count == 0)
+ if (ready_count == 0)
return;
- GNUNET_assert (sched->ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
+ GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
/* yes, p>0 is correct, 0 is "KEEP" which should
always be an empty queue (see assertion)! */
for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
{
- pos = sched->ready[p];
+ pos = ready[p];
if (pos != NULL)
break;
}
GNUNET_assert (pos != NULL); /* ready_count wrong? */
- sched->ready[p] = pos->next;
- sched->ready_count--;
- if (sched->current_priority != pos->priority)
+ ready[p] = pos->next;
+ ready_count--;
+ if (current_priority != pos->priority)
{
- sched->current_priority = pos->priority;
+ current_priority = pos->priority;
(void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (), pos->priority);
}
- sched->active_task = pos;
+ active_task = pos;
#if PROFILE_DELAYS
if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value >
DELAY_THRESHOLD.rel_value)
(unsigned long long) GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value);
}
#endif
- tc.sched = sched;
tc.reason = pos->reason;
tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set;
if ( (pos->read_fd != -1) &&
i,
pos->backtrace_strings[i]);
#endif
- sched->active_task = NULL;
+ active_task = NULL;
destroy_task (pos);
- sched->tasks_run++;
+ tasks_run++;
}
- while ( (sched->pending == NULL) || (p >= sched->max_priority_added) );
+ while ( (pending == NULL) || (p >= max_priority_added) );
}
/**
void
GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
{
- struct GNUNET_SCHEDULER_Handle sched;
struct GNUNET_NETWORK_FDSet *rs;
struct GNUNET_NETWORK_FDSet *ws;
struct GNUNET_TIME_Relative timeout;
shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &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,
+ current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
+ GNUNET_SCHEDULER_add_continuation (task,
task_cls,
GNUNET_SCHEDULER_REASON_STARTUP);
last_tr = 0;
busy_wait_warning = 0;
- while ((sched.pending != NULL) ||
- (sched.pending_timeout != NULL) ||
- (sched.ready_count > 0))
+ while ((pending != NULL) ||
+ (pending_timeout != NULL) ||
+ (ready_count > 0))
{
GNUNET_NETWORK_fdset_zero (rs);
GNUNET_NETWORK_fdset_zero (ws);
timeout = GNUNET_TIME_UNIT_FOREVER_REL;
- update_sets (&sched, rs, ws, &timeout);
+ update_sets (rs, ws, &timeout);
GNUNET_NETWORK_fdset_handle_set (rs, pr);
- if (sched.ready_count > 0)
+ if (ready_count > 0)
{
/* no blocking, more work already ready! */
timeout = GNUNET_TIME_UNIT_ZERO;
_("Looks like we're busy waiting...\n"));
sleep (1); /* mitigate */
}
- check_ready (&sched, rs, ws);
- run_ready (&sched, rs, ws);
+ check_ready (rs, ws);
+ run_ready (rs, ws);
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);
+ GNUNET_SCHEDULER_shutdown ();
}
- if (last_tr == sched.tasks_run)
+ if (last_tr == tasks_run)
{
busy_wait_warning++;
}
else
{
- last_tr = sched.tasks_run;
+ last_tr = tasks_run;
busy_wait_warning = 0;
}
}
* @return reason(s) why the current task is run
*/
enum GNUNET_SCHEDULER_Reason
-GNUNET_SCHEDULER_get_reason (struct GNUNET_SCHEDULER_Handle *sched)
+GNUNET_SCHEDULER_get_reason ()
{
- return sched->active_task->reason;
+ return active_task->reason;
}
* @return number of tasks pending right now
*/
unsigned int
-GNUNET_SCHEDULER_get_load (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority p)
+GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
{
struct Task *pos;
unsigned int ret;
if (p == GNUNET_SCHEDULER_PRIORITY_COUNT)
- return sched->ready_count;
+ return ready_count;
if (p == GNUNET_SCHEDULER_PRIORITY_KEEP)
- p = sched->current_priority;
+ p = current_priority;
ret = 0;
- pos = sched->ready[check_priority (p)];
+ pos = ready[check_priority (p)];
while (pos != NULL)
{
pos = pos->next;
* @return original closure of the task
*/
void *
-GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_TaskIdentifier task)
+GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
{
struct Task *t;
struct Task *prev;
to = 0;
prev = NULL;
- t = sched->pending;
+ t = pending;
while (t != NULL)
{
if (t->id == task)
{
prev = NULL;
to = 1;
- t = sched->pending_timeout;
+ t = pending_timeout;
while (t != NULL)
{
if (t->id == task)
prev = t;
t = t->next;
}
- if (sched->pending_timeout_last == t)
- sched->pending_timeout_last = NULL;
+ if (pending_timeout_last == t)
+ pending_timeout_last = NULL;
}
p = 0;
while (t == NULL)
p++;
GNUNET_assert (p < GNUNET_SCHEDULER_PRIORITY_COUNT);
prev = NULL;
- t = sched->ready[p];
+ t = ready[p];
while (t != NULL)
{
if (t->id == task)
{
- sched->ready_count--;
+ ready_count--;
break;
}
prev = t;
{
if (to == 0)
{
- sched->pending = t->next;
+ pending = t->next;
}
else
{
- sched->pending_timeout = t->next;
+ pending_timeout = t->next;
}
}
else
{
- sched->ready[p] = t->next;
+ ready[p] = t->next;
}
}
else
* @param reason reason for task invocation
*/
void
-GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_Task task,
+GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task,
void *task_cls,
enum GNUNET_SCHEDULER_Reason reason)
{
t->write_fd = -1;
t->callback = task;
t->callback_cls = task_cls;
- t->id = ++sched->last_id;
+ t->id = ++last_id;
#if PROFILE_DELAYS
t->start_time = GNUNET_TIME_absolute_get ();
#endif
t->reason = reason;
- t->priority = sched->current_priority;
+ t->priority = current_priority;
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Adding continuation task: %llu / %p\n",
t->id, t->callback_cls);
#endif
- queue_ready_task (sched, t);
+ queue_ready_task (t);
}
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
GNUNET_SCHEDULER_Task task, void *task_cls)
{
- return GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
+ return GNUNET_SCHEDULER_add_select (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_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
GNUNET_SCHEDULER_Task task,
void *task_cls)
{
- return GNUNET_SCHEDULER_add_select (sched,
- prio,
+ return GNUNET_SCHEDULER_add_select (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,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
GNUNET_SCHEDULER_Task task, void *task_cls)
{
#if 1
#endif
t->read_fd = -1;
t->write_fd = -1;
- t->id = ++sched->last_id;
+ t->id = ++last_id;
#if PROFILE_DELAYS
t->start_time = GNUNET_TIME_absolute_get ();
#endif
t->timeout = GNUNET_TIME_relative_to_absolute (delay);
- t->priority = sched->current_priority;
+ t->priority = current_priority;
/* try tail first (optimization in case we are
appending to a long list of tasks with timeouts) */
- prev = sched->pending_timeout_last;
+ prev = pending_timeout_last;
if (prev != NULL)
{
if (prev->timeout.abs_value > t->timeout.abs_value)
if (prev == NULL)
{
/* heuristic failed, do traversal of timeout list */
- pos = sched->pending_timeout;
+ pos = pending_timeout;
}
while ( (pos != NULL) &&
( (pos->timeout.abs_value <= t->timeout.abs_value) ||
pos = pos->next;
}
if (prev == NULL)
- sched->pending_timeout = t;
+ pending_timeout = t;
else
prev->next = t;
t->next = pos;
/* hyper-optimization... */
- sched->pending_timeout_last = t;
+ pending_timeout_last = t;
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_now (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_SCHEDULER_Task task,
- void *task_cls)
+GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task,
+ void *task_cls)
{
- return GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
+ return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_ZERO,
NULL, NULL, task, task_cls);
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-add_without_sets (struct GNUNET_SCHEDULER_Handle * sched,
- struct GNUNET_TIME_Relative delay,
+add_without_sets (struct GNUNET_TIME_Relative delay,
int rfd,
int wfd,
GNUNET_SCHEDULER_Task task, void *task_cls)
#endif
t->read_fd = rfd;
t->write_fd = wfd;
- t->id = ++sched->last_id;
+ t->id = ++last_id;
#if PROFILE_DELAYS
t->start_time = GNUNET_TIME_absolute_get ();
#endif
t->prereq_id = GNUNET_SCHEDULER_NO_TASK;
t->timeout = GNUNET_TIME_relative_to_absolute (delay);
- t->priority = check_priority (sched->current_priority);
- t->next = sched->pending;
- sched->pending = t;
- sched->max_priority_added = GNUNET_MAX (sched->max_priority_added,
+ t->priority = check_priority (current_priority);
+ t->next = pending;
+ pending = t;
+ max_priority_added = GNUNET_MAX (max_priority_added,
t->priority);
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
struct GNUNET_NETWORK_Handle * rfd,
GNUNET_SCHEDULER_Task task, void *task_cls)
{
- return add_without_sets (sched,
- delay,
+ return add_without_sets (delay,
GNUNET_NETWORK_get_fd (rfd),
-1,
task,
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
struct GNUNET_NETWORK_Handle * wfd,
GNUNET_SCHEDULER_Task task, void *task_cls)
{
- return add_without_sets (sched,
- delay,
+ return add_without_sets (delay,
-1,
GNUNET_NETWORK_get_fd (wfd),
task,
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
const struct GNUNET_DISK_FileHandle * rfd,
GNUNET_SCHEDULER_Task task, void *task_cls)
{
int fd;
GNUNET_DISK_internal_file_handle_ (rfd, &fd, sizeof (int));
- return add_without_sets (sched,
- delay,
+ return add_without_sets (delay,
fd,
-1,
task,
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched,
- struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
const struct GNUNET_DISK_FileHandle * wfd,
GNUNET_SCHEDULER_Task task, void *task_cls)
{
int fd;
GNUNET_DISK_internal_file_handle_ (wfd, &fd, sizeof (int));
- return add_without_sets (sched,
- delay,
+ return add_without_sets (delay,
-1,
fd,
task,
* only valid until "task" is started!
*/
GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched,
- enum GNUNET_SCHEDULER_Priority prio,
+GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
GNUNET_SCHEDULER_TaskIdentifier
prerequisite_task,
struct GNUNET_TIME_Relative delay,
t->write_set = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy (t->write_set, ws);
}
- t->id = ++sched->last_id;
+ t->id = ++last_id;
#if PROFILE_DELAYS
t->start_time = GNUNET_TIME_absolute_get ();
#endif
t->timeout = GNUNET_TIME_relative_to_absolute (delay);
t->priority =
check_priority ((prio ==
- GNUNET_SCHEDULER_PRIORITY_KEEP) ? sched->current_priority
+ GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority
: prio);
- t->next = sched->pending;
- sched->pending = t;
- sched->max_priority_added = GNUNET_MAX (sched->max_priority_added,
+ t->next = pending;
+ pending = t;
+ max_priority_added = GNUNET_MAX (max_priority_added,
t->priority);
#if DEBUG_TASKS
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
*/
struct GNUNET_SERVER_Handle
{
- /**
- * My scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* List of handlers for incoming messages.
*/
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
{
/* ignore shutdown, someone else will take care of it! */
- server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
+ server->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL,
r, NULL,
(tc->read_ready, server->listen_sockets[i]))
{
sock =
- GNUNET_CONNECTION_create_from_accept (tc->sched, server->access,
+ GNUNET_CONNECTION_create_from_accept (server->access,
server->access_cls,
server->listen_sockets[i]);
if (sock != NULL)
i++;
}
/* listen for more! */
- server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
+ server->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL,
r, NULL,
/**
* Create a new server.
*
- * @param sched scheduler to use
* @param access function for access control
* @param access_cls closure for access
* @param lsocks NULL-terminated array of listen sockets
* (typically, "port" already in use)
*/
struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_CONNECTION_AccessCheck access, void *access_cls,
+GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
struct GNUNET_NETWORK_Handle **lsocks,
struct GNUNET_TIME_Relative
idle_timeout,
int i;
ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Handle));
- ret->sched = sched;
ret->idle_timeout = idle_timeout;
ret->listen_sockets = lsocks;
ret->access = access;
i = 0;
while (NULL != ret->listen_sockets[i])
GNUNET_NETWORK_fdset_set (r, ret->listen_sockets[i++]);
- ret->listen_task = GNUNET_SCHEDULER_add_select (sched,
- GNUNET_SCHEDULER_PRIORITY_HIGH,
+ ret->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_UNIT_FOREVER_REL,
r, NULL,
/**
* Create a new server.
*
- * @param sched scheduler to use
* @param access function for access control
* @param access_cls closure for access
* @param serverAddr address to listen on (including port), NULL terminated array
* (typically, "port" already in use)
*/
struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
- GNUNET_CONNECTION_AccessCheck access,
+GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access,
void *access_cls,
struct sockaddr *const *serverAddr,
const socklen_t * socklen,
{
lsocks = NULL;
}
- return GNUNET_SERVER_create_with_sockets (sched,
- access, access_cls,
+ return GNUNET_SERVER_create_with_sockets (access, access_cls,
lsocks,
idle_timeout,
require_found);
#endif
if (GNUNET_SCHEDULER_NO_TASK != s->listen_task)
{
- GNUNET_SCHEDULER_cancel (s->sched, s->listen_task);
+ GNUNET_SCHEDULER_cancel (s->listen_task);
s->listen_task = GNUNET_SCHEDULER_NO_TASK;
}
if (s->listen_sockets != NULL)
#endif
if (client->restart_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (client->server->sched,
- client->restart_task);
+ GNUNET_SCHEDULER_cancel (client->restart_task);
client->restart_task = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_YES == client->receive_pending)
prev->next = pos->next;
if (client->restart_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel (server->sched,
- client->restart_task);
+ GNUNET_SCHEDULER_cancel (client->restart_task);
client->restart_task = GNUNET_SCHEDULER_NO_TASK;
}
n = server->disconnect_notify_list;
"GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
#endif
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == client->restart_task);
- client->restart_task = GNUNET_SCHEDULER_add_now (client->server->sched,
- &restart_processing,
+ client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing,
client);
}
*/
struct GNUNET_SERVER_Handle *server;
- /**
- * Scheduler for the server.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* NULL-terminated array of addresses to bind to, NULL if we got pre-bound
* listen sockets.
struct GNUNET_SERVICE_Context *sctx = cls;
unsigned int i;
- sctx->sched = tc->sched;
if (sctx->lsocks != NULL)
- sctx->server = GNUNET_SERVER_create_with_sockets (tc->sched,
- &check_access,
+ sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
sctx,
sctx->lsocks,
sctx->timeout, sctx->require_found);
else
- sctx->server = GNUNET_SERVER_create (tc->sched,
- &check_access,
+ sctx->server = GNUNET_SERVER_create (&check_access,
sctx,
sctx->addrs,
sctx->addrlens,
{
/* 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,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task, sctx->server);
}
sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
i++;
}
}
- sctx->task (sctx->task_cls, tc->sched, sctx->server, sctx->cfg);
+ sctx->task (sctx->task_cls, sctx->server, sctx->cfg);
}
* initialized system.
*
* @param serviceName our service name
- * @param sched scheduler to use
* @param cfg configuration to use
* @return NULL on error, service handle
*/
struct GNUNET_SERVICE_Context *
GNUNET_SERVICE_start (const char *serviceName,
- struct GNUNET_SCHEDULER_Handle *sched,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
int i;
sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
sctx->serviceName = serviceName;
sctx->cfg = cfg;
- sctx->sched = sched;
/* setup subsystems */
if (GNUNET_OK != setup_service (sctx))
return NULL;
}
if (sctx->lsocks != NULL)
- sctx->server = GNUNET_SERVER_create_with_sockets (sched,
- &check_access,
+ sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
sctx,
sctx->lsocks,
sctx->timeout, sctx->require_found);
else
- sctx->server = GNUNET_SERVER_create (sched,
- &check_access,
+ sctx->server = GNUNET_SERVER_create (&check_access,
sctx,
sctx->addrs,
sctx->addrlens,
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
- server = GNUNET_SERVER_create (tc->sched,
- NULL,
+ server = GNUNET_SERVER_create (NULL,
NULL,
sap,
slens,
handlers[0].callback_cls = cls;
handlers[1].callback_cls = cls;
GNUNET_SERVER_add_handlers (server, handlers);
- client = GNUNET_CLIENT_connect (tc->sched, MYNAME, cfg);
+ client = GNUNET_CLIENT_connect (MYNAME, cfg);
GNUNET_assert (client != NULL);
GNUNET_assert (NULL !=
GNUNET_CLIENT_notify_transmit_ready (client,
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test accepts connection\n");
#endif
- asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
- NULL, NULL, ls);
+ asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
GNUNET_assert (asock != NULL);
GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
#if VERBOSE
task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
ls = open_listen_socket ();
- lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+ lsock = GNUNET_CONNECTION_create_from_existing (ls);
GNUNET_assert (lsock != NULL);
- csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
- cfg,
+ csock = GNUNET_CONNECTION_create_from_connect (cfg,
"localhost", PORT);
GNUNET_assert (csock != NULL);
#if VERBOSE
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n");
#endif
- GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
ls, &run_accept, cls);
}
struct sockaddr_in *v4;
struct sockaddr_in expect;
- asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
- NULL, NULL, ls);
+ asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
GNUNET_assert (asock != NULL);
GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
GNUNET_assert (GNUNET_OK ==
{
struct sockaddr_in v4;
ls = open_listen_socket ();
- lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+ lsock = GNUNET_CONNECTION_create_from_existing (ls);
GNUNET_assert (lsock != NULL);
#if HAVE_SOCKADDR_IN_SIN_LEN
v4.sin_family = AF_INET;
v4.sin_port = htons (PORT);
v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
- csock = GNUNET_CONNECTION_create_from_sockaddr (tc->sched,
- AF_INET,
+ csock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET,
(const struct sockaddr
*) &v4, sizeof (v4));
GNUNET_assert (csock != NULL);
GNUNET_TIME_UNIT_SECONDS,
&make_hello, NULL));
GNUNET_CONNECTION_destroy (csock, GNUNET_YES);
- GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
ls, &run_accept, cls);
}
run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
- NULL, NULL, ls);
+ asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
GNUNET_assert (asock != NULL);
GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
GNUNET_CONNECTION_destroy (lsock, GNUNET_YES);
task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
ls = open_listen_socket ();
- lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+ lsock = GNUNET_CONNECTION_create_from_existing (ls);
GNUNET_assert (lsock != NULL);
- csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+ csock = GNUNET_CONNECTION_create_from_connect (cfg,
"localhost", PORT);
GNUNET_assert (csock != NULL);
- GNUNET_SCHEDULER_add_read_net (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
ls, &run_accept_cancel, cls);
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_UNIT_SECONDS,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&receive_cancel_task, cls);
}
{
ls = open_listen_socket ();
- lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+ lsock = GNUNET_CONNECTION_create_from_existing (ls);
GNUNET_assert (lsock != NULL);
- csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+ csock = GNUNET_CONNECTION_create_from_connect (cfg,
"localhost", PORT);
GNUNET_assert (csock != NULL);
GNUNET_assert (NULL !=
static void
task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+ csock = GNUNET_CONNECTION_create_from_connect (cfg,
"localhost", PORT);
GNUNET_assert (csock != NULL);
GNUNET_assert (NULL !=
struct GNUNET_CONNECTION_TransmitHandle *th;
struct GNUNET_CONNECTION_Handle *csock;
- csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+ csock = GNUNET_CONNECTION_create_from_connect (cfg,
"localhost", PORT);
GNUNET_assert (csock != NULL);
th = GNUNET_CONNECTION_notify_transmit_ready (csock,
file_hasher (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_assert (NULL !=
- GNUNET_CRYPTO_hash_file (tc->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
FILENAME, 1024,
&finished_task, cls));
}
static void
iter_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_DISK_directory_iterator_start (tc->sched,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ GNUNET_DISK_directory_iterator_start (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
"test", &iter_callback, cls);
}
{
GNUNET_break (0);
ok = 1;
- GNUNET_SCHEDULER_cancel(tc->sched, die_task);
- GNUNET_SCHEDULER_add_now(tc->sched, &end_task, NULL);
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_task, NULL);
return;
}
#endif
if (ok == 0)
{
- GNUNET_SCHEDULER_cancel(tc->sched, die_task);
- GNUNET_SCHEDULER_add_now(tc->sched, &end_task, NULL);
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_task, NULL);
return;
}
- GNUNET_SCHEDULER_add_read_file (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
stdout_read_handle, &read_call, stdout_read_handle);
}
stdout_read_handle = GNUNET_DISK_pipe_handle(hello_pipe_stdout, GNUNET_DISK_PIPE_END_READ);
- die_task = GNUNET_SCHEDULER_add_delayed(tc->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 1), &end_task, NULL);
+ die_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 1), &end_task, NULL);
- GNUNET_SCHEDULER_add_read_file (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
stdout_read_handle, &read_call, (void *)stdout_read_handle);
}
static void
runner (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
int *ok = cls;
GNUNET_assert (setme1 == 1);
- GNUNET_assert (sched != NULL);
GNUNET_assert (0 == strcmp (args[0], "extra"));
GNUNET_assert (args[1] == NULL);
GNUNET_assert (0 == strcmp (cfgfile, "test_program_data.conf"));
}
static void
-run(void *cls, struct GNUNET_SCHEDULER_Handle *sched, char * const *args,
+run(void *cls, char * const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
int *ok = cls;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- GNUNET_RESOLVER_ip_get(sched, cfg, "localhost", AF_INET, timeout, &check_127,
+ GNUNET_RESOLVER_ip_get(cfg, "localhost", AF_INET, timeout, &check_127,
cls);
- GNUNET_RESOLVER_hostname_get(sched, cfg, (const struct sockaddr *) &sa,
+ GNUNET_RESOLVER_hostname_get(cfg, (const struct sockaddr *) &sa,
sizeof(struct sockaddr), GNUNET_YES, timeout, &check_localhost, cls);
- GNUNET_RESOLVER_hostname_get(sched, cfg, (const struct sockaddr *) &sa,
+ GNUNET_RESOLVER_hostname_get(cfg, (const struct sockaddr *) &sa,
sizeof(struct sockaddr), GNUNET_NO, timeout, &check_localhost_num, cls);
- GNUNET_RESOLVER_hostname_resolve(sched, cfg, AF_UNSPEC, timeout,
+ GNUNET_RESOLVER_hostname_resolve(cfg, AF_UNSPEC, timeout,
&check_hostname, cls);
#endif
/* Resolve the same using GNUNET */
- GNUNET_RESOLVER_ip_get(sched, cfg, ROOTSERVER_NAME, AF_INET, timeout,
+ GNUNET_RESOLVER_ip_get(cfg, ROOTSERVER_NAME, AF_INET, timeout,
&check_rootserver_ip, cls);
/*
#else
sa.sin_addr.S_un.S_addr = inet_addr(ROOTSERVER_IP);
#endif
- GNUNET_RESOLVER_hostname_get(sched, cfg, (const struct sockaddr *) &sa,
+ GNUNET_RESOLVER_hostname_get(cfg, (const struct sockaddr *) &sa,
sizeof(struct sockaddr), GNUNET_YES, timeout, &check_rootserver_name, cls);
}
{
int *ok = cls;
/* t4 should be ready (albeit with lower priority) */
- GNUNET_assert (1 == GNUNET_SCHEDULER_get_load (tc->sched,
- GNUNET_SCHEDULER_PRIORITY_COUNT));
+ GNUNET_assert (1 == GNUNET_SCHEDULER_get_load (GNUNET_SCHEDULER_PRIORITY_COUNT));
GNUNET_assert (3 == *ok);
(*ok) = 4;
}
GNUNET_assert (2 == *ok);
(*ok) = 3;
/* t3 will go before t4: higher priority */
- GNUNET_SCHEDULER_add_with_priority (tc->sched,
- GNUNET_SCHEDULER_PRIORITY_UI,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
&task3, cls);
}
GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, fds[0]));
GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1));
(*ok) = 8;
- GNUNET_SCHEDULER_add_with_priority (tc->sched,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&taskLast, cls);
- GNUNET_SCHEDULER_shutdown (tc->sched);
+ GNUNET_SCHEDULER_shutdown ();
}
GNUNET_assert (NULL != p);
fds[0] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_READ);
fds[1] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_WRITE);
- GNUNET_SCHEDULER_add_read_file (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
fds[0], &taskRd, cls);
- GNUNET_SCHEDULER_add_write_file (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
fds[1], &taskWrt, cls);
}
GNUNET_assert (1 == *ok);
(*ok) = 2;
/* t2 will go first -- prereq for all */
- t2 = GNUNET_SCHEDULER_add_after (tc->sched,
- GNUNET_SCHEDULER_NO_TASK, &task2, cls);
+ t2 = GNUNET_SCHEDULER_add_after (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 (t2, &task4, cls);
/* t5 will go last (after p4) */
- GNUNET_SCHEDULER_add_after (tc->sched, t4, &task5, cls);
+ GNUNET_SCHEDULER_add_after (t4, &task5, cls);
}
int *ok = cls;
GNUNET_assert (1 == *ok);
*ok = 8;
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
- GNUNET_SCHEDULER_shutdown (tc->sched);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
+ GNUNET_SCHEDULER_shutdown ();
}
int *ok = cls;
GNUNET_assert (1 == *ok);
*ok = 8;
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM));
}
GNUNET_assert (1 == *ok);
*ok = 0;
- GNUNET_SCHEDULER_cancel (tc->sched,
- GNUNET_SCHEDULER_add_after (tc->sched,
- GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
&taskNeverRun, NULL));
}
fprintf (stderr, "\n");
return;
}
- GNUNET_SCHEDULER_add_delayed (tc->sched,
- GNUNET_TIME_relative_multiply
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, i),
&test_task, NULL);
i += INCR;
static struct GNUNET_CONFIGURATION_Handle *cfg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
GNUNET_assert (ok == 5);
ok = 6;
GNUNET_SERVER_receive_done (client, GNUNET_OK);
- GNUNET_SCHEDULER_add_now (sched,
- &finish_up,
+ GNUNET_SCHEDULER_add_now (&finish_up,
NULL);
}
slens[0] = sizeof (sa);
sap[1] = NULL;
slens[1] = 0;
- sched = tc->sched;
memset (&sa, 0, sizeof (sa));
#if HAVE_SOCKADDR_IN_SIN_LEN
sa.sin_len = sizeof (sa);
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
- server = GNUNET_SERVER_create (tc->sched,
- NULL,
+ server = GNUNET_SERVER_create (NULL,
NULL,
sap,
slens,
GNUNET_CONFIGURATION_set_value_number (cfg, "test-server", "PORT", PORT);
GNUNET_CONFIGURATION_set_value_string (cfg, "test-server", "HOSTNAME", "localhost");
GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost");
- cc = GNUNET_CLIENT_connect (tc->sched,
- "test-server",
+ cc = GNUNET_CLIENT_connect ("test-server",
cfg);
GNUNET_assert (cc != NULL);
GNUNET_assert (NULL !=
static struct GNUNET_CONFIGURATION_Handle *cfg;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static int ok;
return;
GNUNET_assert (ok == 4);
ok = 5;
- GNUNET_SCHEDULER_add_now (sched,
- &finish_up,
+ GNUNET_SCHEDULER_add_now (&finish_up,
NULL);
}
GNUNET_assert (ok == 2);
ok = 3;
GNUNET_SERVER_client_keep (client);
- GNUNET_SCHEDULER_add_now (sched,
- &server_disconnect, client);
+ GNUNET_SCHEDULER_add_now (&server_disconnect, client);
GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
ntohs (message->size));
GNUNET_assert (MY_TYPE == ntohs (message->type));
slens[0] = sizeof (sa);
sap[1] = NULL;
slens[1] = 0;
- sched = tc->sched;
memset (&sa, 0, sizeof (sa));
#if HAVE_SOCKADDR_IN_SIN_LEN
sa.sin_len = sizeof (sa);
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
- server = GNUNET_SERVER_create (tc->sched,
- NULL,
+ server = GNUNET_SERVER_create (NULL,
NULL,
sap,
slens,
GNUNET_CONFIGURATION_set_value_number (cfg, "test-server", "PORT", PORT);
GNUNET_CONFIGURATION_set_value_string (cfg, "test-server", "HOSTNAME", "localhost");
GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost");
- cc = GNUNET_CLIENT_connect (tc->sched,
- "test-server",
+ cc = GNUNET_CLIENT_connect ("test-server",
cfg);
GNUNET_assert (cc != NULL);
GNUNET_assert (NULL !=
static struct GNUNET_CLIENT_Connection *client;
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_CONFIGURATION_Handle *cfg;
static int ok;
{
case 2:
ok++;
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_relative_multiply
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 50),
&send_done, argclient);
break;
return;
GNUNET_assert (ok == 5);
ok = 0;
- GNUNET_SCHEDULER_add_now (sched,
- &clean_up, NULL);
+ GNUNET_SCHEDULER_add_now (&clean_up, NULL);
}
slens[0] = sizeof (sa);
sap[1] = NULL;
slens[1] = 0;
- sched = tc->sched;
memset (&sa, 0, sizeof (sa));
#if HAVE_SOCKADDR_IN_SIN_LEN
sa.sin_len = sizeof (sa);
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
- server = GNUNET_SERVER_create (tc->sched,
- NULL,
+ server = GNUNET_SERVER_create (NULL,
NULL,
sap,
slens,
"localhost");
GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
"localhost");
- client = GNUNET_CLIENT_connect (tc->sched, "test", cfg);
+ client = GNUNET_CLIENT_connect ("test", cfg);
GNUNET_assert (client != NULL);
GNUNET_CLIENT_notify_transmit_ready (client,
256,
#define MY_TYPE 256
-static struct GNUNET_SCHEDULER_Handle *sched;
-
static struct GNUNET_SERVICE_Context *sctx;
static int ok = 1;
GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service confirmed running\n");
- sched = tc->sched;
- client = GNUNET_CLIENT_connect (tc->sched, "test_service", cfg);
+ client = GNUNET_CLIENT_connect ("test_service", cfg);
GNUNET_assert (client != NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Client connecting, waiting to transmit\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");
GNUNET_SERVER_receive_done (client, GNUNET_OK);
if (sctx != NULL)
- GNUNET_SCHEDULER_add_now (sched, &do_stop, NULL);
+ GNUNET_SCHEDULER_add_now (&do_stop, NULL);
else
- GNUNET_SCHEDULER_shutdown (sched);
+ GNUNET_SCHEDULER_shutdown ();
ok = 0;
}
static void
runner (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service initializing\n");
GNUNET_SERVER_add_handlers (server, myhandlers);
- GNUNET_CLIENT_service_test (sched,
- "test_service",
+ GNUNET_CLIENT_service_test ("test_service",
cfg, GNUNET_TIME_UNIT_SECONDS, &ready,
(void *) cfg);
}
struct GNUNET_CLIENT_Connection *client;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 ready\n");
- sched = tc->sched;
GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
- client = GNUNET_CLIENT_connect (tc->sched, "test_service6", cfg);
+ client = GNUNET_CLIENT_connect ("test_service6", cfg);
GNUNET_assert (client != NULL);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
GNUNET_CLIENT_notify_transmit_ready (client,
static void
runner6 (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
GNUNET_SERVER_add_handlers (server, myhandlers);
- GNUNET_CLIENT_service_test (sched,
- "test_service6",
+ GNUNET_CLIENT_service_test ("test_service6",
cfg, GNUNET_TIME_UNIT_SECONDS, &ready6,
(void *) cfg);
}
static void
start_stop_main (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
int *ret = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting service using start method\n");
- sctx = GNUNET_SERVICE_start ("test_service", sched, cfg);
+ sctx = GNUNET_SERVICE_start ("test_service", cfg);
GNUNET_assert (NULL != sctx);
- runner (cls, sched, GNUNET_SERVICE_get_server (sctx), cfg);
+ runner (cls, GNUNET_SERVICE_get_server (sctx), cfg);
*ret = 0;
}
/**
* @file vpn/gnunet-daemon-vpn.c
* @brief
- * @author Philipp Tรถlke
+ * @author Philipp Toelke
*/
#include "platform.h"
#include "gnunet_getopt_lib.h"
*/
static int ret;
-/**
- * The scheduler to use throughout the daemon
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* The configuration to use
*/
restart_hijack = 1;
GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
- GNUNET_SCHEDULER_add_read_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, fh_from_helper, &helper_read, NULL);
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, fh_from_helper, &helper_read, NULL);
}
/**
GNUNET_DISK_pipe_close(helper_out);
/* Restart the helper */
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_UNIT_SECONDS, start_helper_and_schedule, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, start_helper_and_schedule, NULL);
}
/**
/* On read-error, restart the helper */
if (t<=0) {
GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Read error for header from vpn-helper: %m\n");
- GNUNET_SCHEDULER_add_now(sched, restart_helper, cls);
+ GNUNET_SCHEDULER_add_now(restart_helper, cls);
return;
}
/* FIXME */ GNUNET_SERVER_mst_receive(mst, NULL, buf, t, 0, 0);
- GNUNET_SCHEDULER_add_read_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, fh_from_helper, &helper_read, NULL);
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, fh_from_helper, &helper_read, NULL);
}
/**
/* if more packets are available, reschedule */
if (answer_proc_head != NULL)
- GNUNET_SCHEDULER_add_write_file (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
fh_to_helper,
&helper_write,
NULL);
memcpy(pkt6_icmp, pkt6, ntohs(pkt6->shdr.size));
/* If this packet is an icmp-echo-request and a mapping exists, answer */
if (pkt6_icmp->icmp_hdr.type == 0x80 && address_mapping_exists(pkt6->ip6_hdr.sadr))
- GNUNET_SCHEDULER_add_now(sched, &send_icmp_response, pkt6_icmp);
+ GNUNET_SCHEDULER_add_now(&send_icmp_response, pkt6_icmp);
break;
}
}
return;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
GNUNET_assert (dns_connection == NULL);
- dns_connection = GNUNET_CLIENT_connect (sched, "dns", cfg);
+ dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
/* If a packet is already in the list, schedule to send it */
GNUNET_CONTAINER_DLL_insert_after(answer_proc_head, answer_proc_tail, answer_proc_tail, list);
- GNUNET_SCHEDULER_add_write_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, fh_to_helper, &helper_write, NULL);
+ GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL, fh_to_helper, &helper_write, NULL);
return;
}
{
GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
dns_connection = NULL;
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_SECONDS,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&connect_to_service_dns,
NULL);
return;
GNUNET_break (0);
GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
dns_connection = NULL;
- GNUNET_SCHEDULER_add_now (sched,
- &connect_to_service_dns,
+ GNUNET_SCHEDULER_add_now (&connect_to_service_dns,
NULL);
return;
}
memcpy(pkt, msg, ntohs(msg->size));
- GNUNET_SCHEDULER_add_now(sched, process_answer, pkt);
+ GNUNET_SCHEDULER_add_now(process_answer, pkt);
GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
}
* Main function that will be run by the scheduler.
*
* @param cls closure
- * @param sched the scheduler to use
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched_,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg_) {
- sched = sched_;
mst = GNUNET_SERVER_mst_create(&message_token, NULL);
cfg = cfg_;
restart_hijack = 0;
- GNUNET_SCHEDULER_add_now (sched, connect_to_service_dns, NULL);
- GNUNET_SCHEDULER_add_now (sched, start_helper_and_schedule, NULL);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_UNIT_FOREVER_REL, &cleanup, cls);
+ GNUNET_SCHEDULER_add_now (connect_to_service_dns, NULL);
+ GNUNET_SCHEDULER_add_now (start_helper_and_schedule, NULL);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_FOREVER_REL, &cleanup, cls);
}
/**
#include "gnunet_crypto_lib.h"
#include "gnunet_signatures.h"
-/**
- * The scheduler to use throughout the service
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* The UDP-Socket through which DNS-Resolves will be sent if they are not to be
* Hijack all outgoing DNS-Traffic but for traffic leaving "our" port.
*/
static void
-hijack(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tc) {
+hijack(unsigned short port) {
char port_s[6];
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Hijacking, port is %d\n", dnsoutport);
- snprintf(port_s, 6, "%d", dnsoutport);
- GNUNET_OS_process_close (GNUNET_OS_start_process(NULL,
- NULL,
- "gnunet-helper-hijack-dns",
- "gnunet-hijack-dns",
- port_s,
- NULL));
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Hijacking, port is %d\n", port);
+ snprintf(port_s, 6, "%d", port);
+ GNUNET_OS_start_process(NULL,
+ NULL,
+ "gnunet-helper-hijack-dns",
+ "gnunet-hijack-dns",
+ port_s,
+ NULL);
}
/**
return len;
}
-static void
-send_rev_query(void * cls, const struct GNUNET_SCHEDULER_TaskContext *tc) {
- struct dns_pkt_parsed* pdns = (struct dns_pkt_parsed*) cls;
-
- unsigned short id = pdns->s.id;
-
- if (query_states[id].valid != GNUNET_YES) return;
- query_states[id].valid = GNUNET_NO;
-
- GNUNET_assert(query_states[id].namelen == 74);
-
- size_t len = sizeof(struct answer_packet) - 1 \
- + sizeof(struct dns_static) \
- + 74 /* this is the length of a reverse ipv6-lookup */ \
- + sizeof(struct dns_query_line) \
- + 2 /* To hold the pointer (as defined in RFC1035) to the name */ \
- + sizeof(struct dns_record_line) - 1 \
- - 2 /* We do not know the lenght of the answer yet*/ \
- - 2 /* No idea why... */ ;
-
- struct answer_packet_list* answer = GNUNET_malloc(len + 2*sizeof(struct answer_packet_list*));
- memset(answer, 0, len + 2*sizeof(struct answer_packet_list*));
-
- answer->pkt.hdr.type = htons(GNUNET_MESSAGE_TYPE_LOCAL_RESPONSE_DNS);
- answer->pkt.hdr.size = htons(len);
- answer->pkt.subtype = GNUNET_DNS_ANSWER_TYPE_REV;
-
- answer->pkt.from = query_states[id].remote_ip;
-
- answer->pkt.to = query_states[id].local_ip;
- answer->pkt.dst_port = query_states[id].local_port;
-
- struct dns_pkt *dpkt = (struct dns_pkt*)answer->pkt.data;
-
- dpkt->s.id = id;
- dpkt->s.aa = 1;
- dpkt->s.qr = 1;
- dpkt->s.ra = 1;
- dpkt->s.qdcount = htons(1);
- dpkt->s.ancount = htons(1);
-
- memcpy(dpkt->data, query_states[id].name, query_states[id].namelen);
- GNUNET_free(query_states[id].name);
-
- struct dns_query_line* dque = (struct dns_query_line*)(dpkt->data+(query_states[id].namelen));
- dque->type = htons(12); /* PTR */
- dque->class = htons(1); /* IN */
-
- char* anname = (char*)(dpkt->data+(query_states[id].namelen)+sizeof(struct dns_query_line));
- memcpy(anname, (char[]){0xc0, 0x0c}, 2);
-
- struct dns_record_line *drec_data = (struct dns_record_line*)(dpkt->data+(query_states[id].namelen)+sizeof(struct dns_query_line)+2);
- drec_data->type = htons(12); /* AAAA */
- drec_data->class = htons(1); /* IN */
- drec_data->ttl = htonl(3600); /* FIXME: read from block */
-
- /* Calculate at which offset in the packet the length of the name and the
- * name, it is filled in by the daemon-vpn */
- answer->pkt.addroffset = htons((unsigned short)((unsigned long)(&drec_data->data_len)-(unsigned long)(&answer->pkt)));
-
- GNUNET_CONTAINER_DLL_insert_after(head, tail, tail, answer);
-
- GNUNET_SERVER_notify_transmit_ready(query_states[id].client,
- len,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &send_answer,
- query_states[id].client);
-
- /*
- * build
- * complete dns-packet with empty name in the answer
- * provide offsett of the name
- */
-}
-
/**
* Receive a block from the dht.
*/
memcpy(dpkt->data, query_states[id].name, query_states[id].namelen);
GNUNET_free(query_states[id].name);
+
struct dns_query_line* dque = (struct dns_query_line*)(dpkt->data+(query_states[id].namelen));
dque->type = htons(28); /* AAAA */
dque->class = htons(1); /* IN */
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message) {
unhijack(dnsoutport);
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_UNIT_SECONDS, hijack, NULL);
-
- GNUNET_SERVER_receive_done(client, GNUNET_OK);
+ hijack(dnsoutport);
}
/**
query_states[dns->s.id].name = GNUNET_malloc(query_states[dns->s.id].namelen);
memcpy(query_states[dns->s.id].name, dns->data, query_states[dns->s.id].namelen);
- /* The query is for a .gnunet-address */
if (pdns->queries[0]->namelen > 9 &&
0 == strncmp(pdns->queries[0]->name+(pdns->queries[0]->namelen - 9), ".gnunet.", 9))
{
receive_dht,
cls);
- goto outfree;
- }
-
- /* The query is for a PTR of a previosly resolved virtual IP */
- if (htons(pdns->queries[0]->qtype) == 12 &&
- pdns->queries[0]->namelen > 19 &&
- 0 == strncmp(pdns->queries[0]->name+(pdns->queries[0]->namelen - 19), ".4.3.2.1.ip6.arpa.", 19))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Reverse-Query for .gnunet!\n");
-
- GNUNET_SCHEDULER_add_now(sched, send_rev_query, pdns);
-
goto out;
}
(struct sockaddr*) &dest,
sizeof dest);
-outfree:
+out:
free_parsed_dns_packet(pdns);
pdns = NULL;
-out:
GNUNET_SERVER_receive_done(client, GNUNET_OK);
}
query_states[dns->s.id].client);
}
- GNUNET_SCHEDULER_add_read_net(sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
dnsout,
&read_response,
NULL);
NULL,
NULL);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_HOURS,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_HOURS,
publish_name,
NULL);
}
/**
* @param cls closure
- * @param sched scheduler to use
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *sched_,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg_)
{
};
cfg = cfg_;
- sched = sched_;
unsigned int i;
for (i = 0; i < 65536; i++) {
query_states[i].valid = GNUNET_NO;
}
- dht = GNUNET_DHT_connect(sched, cfg, 1024);
+ dht = GNUNET_DHT_connect(cfg, 1024);
struct sockaddr_in addr;
dnsoutport = htons(addr.sin_port);
- GNUNET_SCHEDULER_add_now (sched, publish_name, NULL);
+ hijack(htons(addr.sin_port));
+
+ GNUNET_SCHEDULER_add_now (publish_name, NULL);
- GNUNET_SCHEDULER_add_read_net(sched, GNUNET_TIME_UNIT_FOREVER_REL, dnsout, &read_response, NULL);
+ GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, dnsout, &read_response, NULL);
GNUNET_SERVER_add_handlers (server, handlers);
- GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&cleanup_task,
cls);
}
projects / oweals / gnunet.git / commitdiff