* Argument to be passed from the driver to
* #GNUNET_SCHEDULER_run_from_driver(). Contains the
* scheduler's internal state.
- */
+ */
struct GNUNET_SCHEDULER_Handle
{
/**
* Driver we used for the event loop.
*/
const struct GNUNET_SCHEDULER_Driver *driver;
-
+
};
* Handle to the scheduler's state.
*/
const struct GNUNET_SCHEDULER_Handle *sh;
-
+
/**
* Set of file descriptors this task is waiting
* for for reading. Once ready, this is updated
* Size of the @e fds array.
*/
unsigned int fds_len;
-
+
/**
* Why is the task ready? Set after task is added to ready queue.
* Initially set to zero. All reasons that have already been
};
+/**
+ * The driver used for the event loop. Will be handed over to
+ * the scheduler in #GNUNET_SCHEDULER_run_from_driver(), peristed
+ * there in this variable for later use in functions like
+ * #GNUNET_SCHEDULER_add_select(), #add_without_sets() and
+ * #GNUNET_SCHEDULER_cancel().
+ */
+GNUNET_SCHEDULER_Driver *scheduler_driver;
/**
* Head of list of tasks waiting for an event.
* @param ws write-set, set to all FDs we would like to write (updated)
* @param timeout next timeout (updated)
*/
-static void
-update_sets (struct GNUNET_NETWORK_FDSet *rs,
- struct GNUNET_NETWORK_FDSet *ws,
- struct GNUNET_TIME_Relative *timeout)
+void getNextPendingTimeout(struct GNUNET_TIME_Relative *timeout)
{
+
struct GNUNET_SCHEDULER_Task *pos;
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Relative to;
if (0 != pos->reason)
*timeout = GNUNET_TIME_UNIT_ZERO;
}
+}
+
+static void
+update_sets (struct GNUNET_NETWORK_FDSet *rs,
+ struct GNUNET_NETWORK_FDSet *ws,
+ struct GNUNET_TIME_Relative *timeout)
+{
+ struct GNUNET_SCHEDULER_Task *pos;
+ struct GNUNET_TIME_Absolute now;
+ struct GNUNET_TIME_Relative to;
+
+ now = GNUNET_TIME_absolute_get ();
+
+ getNextPendingTimeout(timeout);
for (pos = pending_head; NULL != pos; pos = pos->next)
{
if (pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
for (i = 0; i < t->num_backtrace_strings; i++)
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %p trace %u: %s\n",
- t,
- i,
- t->backtrace_strings[i]);
+ "Task %p trace %u: %s\n",
+ t,
+ i,
+ t->backtrace_strings[i]);
#endif
}
DELAY_THRESHOLD.rel_value_us)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %p took %s to be scheduled\n",
+ "Task %p took %s to be scheduled\n",
pos,
GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
GNUNET_YES));
(!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
GNUNET_assert (0); // added to ready in previous select loop!
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Running task: %p\n",
+ "Running task: %p\n",
pos);
pos->callback (pos->callback_cls);
dump_backtrace (pos);
}
-/**
- * Initialize and run scheduler. This function will return when all
- * tasks have completed. On systems with signals, receiving a SIGTERM
- * (and other similar signals) will cause #GNUNET_SCHEDULER_shutdown()
- * to be run after the active task is complete. As a result, SIGTERM
- * causes all active tasks to be scheduled with reason
- * #GNUNET_SCHEDULER_REASON_SHUTDOWN. (However, tasks added
- * afterwards will execute normally!). Note that any particular signal
- * will only shut down one scheduler; applications should always only
- * create a single scheduler.
- *
- * @param task task to run immediately
- * @param task_cls closure of @a task
- */
-void
-GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+
+void while_live(struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
{
- struct GNUNET_NETWORK_FDSet *rs;
- struct GNUNET_NETWORK_FDSet *ws;
- struct GNUNET_TIME_Relative timeout;
int ret;
- struct GNUNET_SIGNAL_Context *shc_int;
- struct GNUNET_SIGNAL_Context *shc_term;
-#if (SIGTERM != GNUNET_TERM_SIG)
- struct GNUNET_SIGNAL_Context *shc_gterm;
-#endif
-
-#ifndef MINGW
- struct GNUNET_SIGNAL_Context *shc_quit;
- struct GNUNET_SIGNAL_Context *shc_hup;
- struct GNUNET_SIGNAL_Context *shc_pipe;
-#endif
- unsigned long long last_tr;
unsigned int busy_wait_warning;
+ unsigned long long last_tr;
const struct GNUNET_DISK_FileHandle *pr;
char c;
+ struct GNUNET_TIME_Relative timeout;
- GNUNET_assert (NULL == active_task);
- rs = GNUNET_NETWORK_fdset_create ();
- ws = GNUNET_NETWORK_fdset_create ();
- GNUNET_assert (NULL == shutdown_pipe_handle);
- shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
- GNUNET_NO,
- GNUNET_NO,
- GNUNET_NO);
- GNUNET_assert (NULL != shutdown_pipe_handle);
+ busy_wait_warning = 0;
pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
GNUNET_DISK_PIPE_END_READ);
GNUNET_assert (NULL != pr);
- my_pid = getpid ();
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Registering signal handlers\n");
- shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
- &sighandler_shutdown);
- shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
- &sighandler_shutdown);
-#if (SIGTERM != GNUNET_TERM_SIG)
- shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
- &sighandler_shutdown);
-#endif
-#ifndef MINGW
- shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
- &sighandler_pipe);
- shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
- &sighandler_shutdown);
- shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
- &sighandler_shutdown);
-#endif
- current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
- current_lifeness = GNUNET_YES;
- GNUNET_SCHEDULER_add_with_reason_and_priority (task,
- task_cls,
- GNUNET_SCHEDULER_REASON_STARTUP,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT);
- active_task = (void *) (long) -1; /* force passing of sanity check */
- GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
- &GNUNET_OS_install_parent_control_handler,
- NULL);
- active_task = NULL;
last_tr = 0;
- busy_wait_warning = 0;
+
while (GNUNET_OK == check_lifeness ())
{
GNUNET_NETWORK_fdset_zero (rs);
LOG (GNUNET_ERROR_TYPE_ERROR,
"Got invalid file descriptor %d!\n",
t->read_fd);
- dump_backtrace (t);
+ dump_backtrace (t);
}
}
if (-1 != t->write_fd)
LOG (GNUNET_ERROR_TYPE_ERROR,
"Got invalid file descriptor %d!\n",
t->write_fd);
- dump_backtrace (t);
+ dump_backtrace (t);
}
}
}
busy_wait_warning = 0;
}
}
+}
+
+/**
+ * Initialize and run scheduler. This function will return when all
+ * tasks have completed. On systems with signals, receiving a SIGTERM
+ * (and other similar signals) will cause #GNUNET_SCHEDULER_shutdown()
+ * to be run after the active task is complete. As a result, SIGTERM
+ * causes all active tasks to be scheduled with reason
+ * #GNUNET_SCHEDULER_REASON_SHUTDOWN. (However, tasks added
+ * afterwards will execute normally!). Note that any particular signal
+ * will only shut down one scheduler; applications should always only
+ * create a single scheduler.
+ *
+ * @param task task to run immediately
+ * @param task_cls closure of @a task
+ */
+void
+GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
+ void *task_cls)
+{
+ struct GNUNET_NETWORK_FDSet *rs;
+ struct GNUNET_NETWORK_FDSet *ws;
+
+
+ struct GNUNET_SIGNAL_Context *shc_int;
+ struct GNUNET_SIGNAL_Context *shc_term;
+#if (SIGTERM != GNUNET_TERM_SIG)
+ struct GNUNET_SIGNAL_Context *shc_gterm;
+#endif
+
+#ifndef MINGW
+ struct GNUNET_SIGNAL_Context *shc_quit;
+ struct GNUNET_SIGNAL_Context *shc_hup;
+ struct GNUNET_SIGNAL_Context *shc_pipe;
+#endif
+
+ unsigned int busy_wait_warning;
+
+
+
+ GNUNET_assert (NULL == active_task);
+ rs = GNUNET_NETWORK_fdset_create ();
+ ws = GNUNET_NETWORK_fdset_create ();
+ GNUNET_assert (NULL == shutdown_pipe_handle);
+ shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
+ GNUNET_NO,
+ GNUNET_NO,
+ GNUNET_NO);
+ GNUNET_assert (NULL != shutdown_pipe_handle);
+
+ my_pid = getpid ();
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Registering signal handlers\n");
+ shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
+ &sighandler_shutdown);
+ shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
+ &sighandler_shutdown);
+#if (SIGTERM != GNUNET_TERM_SIG)
+ shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
+ &sighandler_shutdown);
+#endif
+#ifndef MINGW
+ shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
+ &sighandler_pipe);
+ shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
+ &sighandler_shutdown);
+ shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
+ &sighandler_shutdown);
+#endif
+ current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
+ current_lifeness = GNUNET_YES;
+ GNUNET_SCHEDULER_add_with_reason_and_priority (task,
+ task_cls,
+ GNUNET_SCHEDULER_REASON_STARTUP,
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+ active_task = (void *) (long) -1; /* force passing of sanity check */
+ GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
+ &GNUNET_OS_install_parent_control_handler,
+ NULL);
+ active_task = NULL;
+
+
+ while_live(rs, ws);
GNUNET_SIGNAL_handler_uninstall (shc_int);
GNUNET_SIGNAL_handler_uninstall (shc_term);
#if (SIGTERM != GNUNET_TERM_SIG)
* @param task id of the task to cancel
* @return original closure of the task
*/
+void initFdINfo(GNUNET_SCHEDULER_FdInfo *fdi, struct GNUNET_SCHEDULER_Task *task)
+{
+ if (-1 != task->read_fd)
+ {
+ fdi->sock=task->read_fd;
+ }else if (-1 != task->write_fd){
+ fdi->sock=task->write_fd;
+ } else if (NULL != task->read_set){
+ fdi->fd=task->read_set;
+ }else if (NULL != task->write_set){
+ fdi->fd=task->write_set;
+ }
+}
+
void *
GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
{
enum GNUNET_SCHEDULER_Priority p;
void *ret;
+ GNUNET_SCHEDULER_FdInfo *fdi;
GNUNET_assert ( (NULL != active_task) ||
- (GNUNET_NO == task->lifeness) );
+ (GNUNET_NO == task->lifeness) );
if (! task->in_ready_list)
{
if ( (-1 == task->read_fd) &&
(NULL == task->write_set) )
{
if (GNUNET_YES == task->on_shutdown)
- GNUNET_CONTAINER_DLL_remove (shutdown_head,
- shutdown_tail,
- task);
+ GNUNET_CONTAINER_DLL_remove (shutdown_head,
+ shutdown_tail,
+ task);
else
- GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
- pending_timeout_tail,
- task);
+ GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
+ pending_timeout_tail,
+ task);
if (task == pending_timeout_last)
pending_timeout_last = NULL;
}
else
{
- GNUNET_CONTAINER_DLL_remove (pending_head,
+ /*GNUNET_CONTAINER_DLL_remove (pending_head,
pending_tail,
- task);
+ task);*/
+ fdi = GNUNET_new (struct GNUNET_SCHEDULER_FdInfo);
+ initFdINfo(fdi, task);
+ scheduler_driver->del(scheduler_driver->cls, task, fdi);
}
}
else
= backtrace (backtrace_array, MAX_TRACE_DEPTH);
t->backtrace_strings =
backtrace_symbols (backtrace_array,
- t->num_backtrace_strings);
+ t->num_backtrace_strings);
dump_backtrace (t);
#endif
}
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- GNUNET_SCHEDULER_TaskCallback task,
+ enum GNUNET_SCHEDULER_Priority priority,
+ GNUNET_SCHEDULER_TaskCallback task,
void *task_cls)
{
return GNUNET_SCHEDULER_add_at_with_priority (GNUNET_TIME_relative_to_absolute (delay),
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+ void *task_cls)
{
return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- task,
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ task,
task_cls);
}
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+ void *task_cls)
{
return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO,
- task,
- task_cls);
+ task,
+ task_cls);
}
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+ void *task_cls)
{
struct GNUNET_SCHEDULER_Task *t;
t->on_shutdown = GNUNET_YES;
t->lifeness = GNUNET_YES;
GNUNET_CONTAINER_DLL_insert (shutdown_head,
- shutdown_tail,
- t);
+ shutdown_tail,
+ t);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding task: %p\n",
t);
#ifndef MINGW
static struct GNUNET_SCHEDULER_Task *
add_without_sets (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- int rfd,
+ enum GNUNET_SCHEDULER_Priority priority,
+ int rfd,
int wfd,
GNUNET_SCHEDULER_TaskCallback task,
void *task_cls)
t->timeout = GNUNET_TIME_relative_to_absolute (delay);
t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority);
t->lifeness = current_lifeness;
- GNUNET_CONTAINER_DLL_insert (pending_head,
+ /*GNUNET_CONTAINER_DLL_insert (pending_head,
pending_tail,
- t);
+ t);*/
+ fdi = GNUNET_new (struct GNUNET_SCHEDULER_FdInfo);
+ initFdINfo(fdi, task);
+ scheduler_driver->add(scheduler_driver, t , fdi);
max_priority_added = GNUNET_MAX (max_priority_added,
t->priority);
LOG (GNUNET_ERROR_TYPE_DEBUG,
void *task_cls)
{
return GNUNET_SCHEDULER_add_read_net_with_priority (delay,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- rfd, task, task_cls);
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ rfd, task, task_cls);
}
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- struct GNUNET_NETWORK_Handle *rfd,
- GNUNET_SCHEDULER_TaskCallback task,
+ enum GNUNET_SCHEDULER_Priority priority,
+ struct GNUNET_NETWORK_Handle *rfd,
+ GNUNET_SCHEDULER_TaskCallback task,
void *task_cls)
{
return GNUNET_SCHEDULER_add_net_with_priority (delay, priority,
GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
prio);
t->lifeness = current_lifeness;
- GNUNET_CONTAINER_DLL_insert (pending_head,
+ /*GNUNET_CONTAINER_DLL_insert (pending_head,
pending_tail,
- t);
+ t);*/
+ fdi = GNUNET_new (struct GNUNET_SCHEDULER_FdInfo);
+ initFdINfo(fdi, task);
+ scheduler_driver->add(scheduler_driver, t , fdi);
max_priority_added = GNUNET_MAX (max_priority_added,
- t->priority);
+ t->priority);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding task %p\n",
t);
*/
void
GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
- enum GNUNET_SCHEDULER_EventType et)
+ enum GNUNET_SCHEDULER_EventType et)
{
enum GNUNET_SCHEDULER_Reason reason;
struct GNUNET_TIME_Absolute now;
*
* @param sh scheduler handle that was given to the `loop`
* @return #GNUNET_OK if there are more tasks that are ready,
- * and thus we would like to run more (yield to avoid
+ * and thus we would like to run more (yield to avoid
* blocking other activities for too long)
* #GNUNET_NO if we are done running tasks (yield to block)
* #GNUNET_SYSERR on error
pending_timeout_last = NULL;
queue_ready_task (pos);
}
-
+
if (0 == ready_count)
return GNUNET_NO;
- /* find out which task priority level we are going to
+ /* find out which task priority level we are going to
process this time */
max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
while (NULL != (pos = ready_head[p]))
{
GNUNET_CONTAINER_DLL_remove (ready_head[p],
- ready_tail[p],
- pos);
+ ready_tail[p],
+ pos);
ready_count--;
current_priority = pos->priority;
current_lifeness = pos->lifeness;
active_task = pos;
#if PROFILE_DELAYS
if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
- DELAY_THRESHOLD.rel_value_us)
+ DELAY_THRESHOLD.rel_value_us)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %p took %s to be scheduled\n",
- pos,
- GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
- GNUNET_YES));
+ "Task %p took %s to be scheduled\n",
+ pos,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
+ GNUNET_YES));
}
#endif
tc.reason = pos->reason;
tc.fds = pos->fds;
tc.read_ready = (NULL == pos->read_set) ? sh->rs : pos->read_set;
if ( (-1 != pos->read_fd) &&
- (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)) )
+ (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)) )
GNUNET_NETWORK_fdset_set_native (sh->rs,
- pos->read_fd);
+ pos->read_fd);
tc.write_ready = (NULL == pos->write_set) ? sh->ws : pos->write_set;
if ((-1 != pos->write_fd) &&
- (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
+ (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
GNUNET_NETWORK_fdset_set_native (sh->ws,
- pos->write_fd);
+ pos->write_fd);
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Running task: %p\n",
- pos);
+ "Running task: %p\n",
+ pos);
pos->callback (pos->callback_cls);
active_task = NULL;
dump_backtrace (pos);
*/
int
GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
- GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+ GNUNET_SCHEDULER_TaskCallback task,
+ void *task_cls)
{
int ret;
struct GNUNET_SIGNAL_Context *shc_int;
#endif
struct GNUNET_SCHEDULER_Task tsk;
const struct GNUNET_DISK_FileHandle *pr;
- struct GNUNET_SCHEDULER_Handle sh;
+ scheduler_driver = driver;
/* general set-up */
GNUNET_assert (NULL == active_task);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Registering signal handlers\n");
shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
- &sighandler_shutdown);
+ &sighandler_shutdown);
shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
- &sighandler_shutdown);
+ &sighandler_shutdown);
#if (SIGTERM != GNUNET_TERM_SIG)
shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
- &sighandler_shutdown);
+ &sighandler_shutdown);
#endif
#ifndef MINGW
shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
- &sighandler_pipe);
+ &sighandler_pipe);
shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
- &sighandler_shutdown);
+ &sighandler_shutdown);
shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
- &sighandler_shutdown);
+ &sighandler_shutdown);
#endif
/* Setup initial tasks */
current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
current_lifeness = GNUNET_YES;
memset (&tsk,
- 0,
- sizeof (tsk));
+ 0,
+ sizeof (tsk));
active_task = &tsk;
tsk.sh = &sh;
GNUNET_SCHEDULER_add_with_reason_and_priority (task,
NULL);
active_task = NULL;
driver->set_wakeup (driver->cls,
- GNUNET_TIME_absolute_get ());
+ GNUNET_TIME_absolute_get ());
/* begin main event loop */
sh.rs = GNUNET_NETWORK_fdset_create ();
sh.ws = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_handle_set (rs, pr);
sh.driver = driver;
ret = driver->loop (driver->cls,
- &sh);
+ &sh);
GNUNET_NETWORK_fdset_destroy (sh.rs);
GNUNET_NETWORK_fdset_destroy (sh.ws);
return ret;
}
+int
+select_add(void *cls,
+ struct GNUNET_SCHEDULER_Task *task,
+ struct GNUNET_SCHEDULER_FdInfo *fdi){
+
+ GNUNET_CONTAINER_DLL_insert (pending_head,
+ pending_tail,
+ task);
+
+}
+
+int
+select_del(void *cls,
+ struct GNUNET_SCHEDULER_Task *task,
+ struct GNUNET_SCHEDULER_FdInfo *fdi){
+
+ GNUNET_CONTAINER_DLL_remove (pending_head,
+ pending_tail,
+ task);
+
+}
+
+
+int
+select_loop(void *cls,
+ struct GNUNET_SCHEDULER_Handle *sh){
+
+ while_live(sh-rs, sh->ws);
+
+}
+
+void
+select_set_wakeup(void *cls,
+ struct GNUNET_TIME_Absolute dt){
+
+
+
+}
+
/**
* Obtain the driver for using select() as the event loop.
const struct GNUNET_SCHEDULER_Driver *
GNUNET_SCHEDULER_driver_select ()
{
- GNUNET_break (0); // not implemented
- return NULL;
+
+ GNUNET_SCHEDULER_Driver *select_driver;
+
+ select_driver = GNUNET_new (struct GNUNET_SCHEDULER_Driver);
+
+ select_driver->loop = &select_loop;
+ select_driver->add = &select_add;
+ select_driver->del = &select_del;
+ select_driver->set_wakeup = &select_set_wakeup;
+
+
+ return select_driver;
}
projects / oweals / gnunet.git / commitdiff