X-Git-Url: http://git.silcnet.org/gitweb/?p=crypto.git;a=blobdiff_plain;f=lib%2Fsilcutil%2Fsilcschedule.c;h=5550181a7da686d070e2103a6a1d8ac33140e9dd;hp=8a8e581cc5a22c4c28808c775838b1bd20cc69f4;hb=60180da59ffdbbd12058dded66e3c8a547cd0852;hpb=2dc218143c7859f7529396dc121ae08e2fd78da0 diff --git a/lib/silcutil/silcschedule.c b/lib/silcutil/silcschedule.c index 8a8e581c..5550181a 100644 --- a/lib/silcutil/silcschedule.c +++ b/lib/silcutil/silcschedule.c @@ -4,13 +4,12 @@ Author: Pekka Riikonen - Copyright (C) 1998 - 2001 Pekka Riikonen + Copyright (C) 1998 - 2007 Pekka Riikonen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - + the Free Software Foundation; version 2 of the License. + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the @@ -19,201 +18,405 @@ */ /* $Id$ */ -#include "silcincludes.h" -#include "silcschedule_i.h" - -/* Forward declarations */ -typedef struct SilcTaskQueueStruct *SilcTaskQueue; - -/* System specific routines. Implemented under unix/ and win32/. */ - -/* System specific select(). Returns same values as normal select(). */ -int silc_select(SilcScheduleFd fds, uint32 fds_count, struct timeval *timeout); - -/* Initializes the wakeup of the scheduler. In multi-threaded environment - the scheduler needs to be wakenup when tasks are added or removed from - the task queues. This will initialize the wakeup for the scheduler. - Any tasks that needs to be registered must be registered to the `queue'. - It is guaranteed that the scheduler will automatically free any - registered tasks in this queue. This is system specific routine. */ -void *silc_schedule_wakeup_init(SilcSchedule schedule); - -/* Uninitializes the system specific wakeup. */ -void silc_schedule_wakeup_uninit(void *context); - -/* Wakes up the scheduler. This is platform specific routine */ -void silc_schedule_wakeup_internal(void *context); - - -/* Internal task management routines. */ - -static void silc_task_queue_alloc(SilcTaskQueue *queue); -static void silc_task_queue_free(SilcTaskQueue queue); -static SilcTask silc_task_find(SilcTaskQueue queue, uint32 fd); -static SilcTask silc_task_add(SilcTaskQueue queue, SilcTask newtask, - SilcTaskPriority priority); -static SilcTask silc_task_get_first(SilcTaskQueue queue, SilcTask first); -static SilcTask silc_task_add_timeout(SilcTaskQueue queue, SilcTask newtask, - SilcTaskPriority priority); -static int silc_schedule_task_remove(SilcTaskQueue queue, SilcTask task); -static int silc_schedule_task_timeout_compare(struct timeval *smaller, - struct timeval *bigger); -static void silc_task_del_by_context(SilcTaskQueue queue, void *context); -static void silc_task_del_by_callback(SilcTaskQueue queue, - SilcTaskCallback callback); -static void silc_task_del_by_fd(SilcTaskQueue queue, uint32 fd); - -/* Returns the task queue by task type */ -#define SILC_SCHEDULE_GET_QUEUE(type) \ - (type == SILC_TASK_FD ? schedule->fd_queue : \ - type == SILC_TASK_TIMEOUT ? schedule->timeout_queue : \ - schedule->generic_queue) - -/* SILC Task object. Represents one task in the scheduler. */ -struct SilcTaskStruct { - uint32 fd; - struct timeval timeout; - SilcTaskCallback callback; +#include "silc.h" + +/************************** Types and definitions ***************************/ + +/* Connected event context */ +typedef struct SilcScheduleEventConnectionStruct { + SilcSchedule schedule; + SilcTaskEventCallback callback; void *context; - bool valid; - SilcTaskPriority priority; - SilcTaskType type; + struct SilcScheduleEventConnectionStruct *next; +} *SilcScheduleEventConnection; - /* Pointers forming doubly linked circular list */ - struct SilcTaskStruct *next; - struct SilcTaskStruct *prev; -}; +/* Platform specific implementation */ +extern const SilcScheduleOps schedule_ops; -/* SILC Task Queue object. The queue holds all the tasks in the scheduler. - There are always three task queues in the scheduler. One for non-timeout - tasks (fd tasks performing tasks over specified file descriptor), - one for timeout tasks and one for generic tasks. */ -struct SilcTaskQueueStruct { - SilcTask task; /* Pointer to all tasks */ - struct timeval timeout; /* Current timeout */ - SILC_MUTEX_DEFINE(lock); /* Queue's lock */ -}; +static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task); +static void silc_schedule_dispatch_fd(SilcSchedule schedule); +static void silc_schedule_dispatch_timeout(SilcSchedule schedule, + SilcBool dispatch_all); +SILC_TASK_CALLBACK(silc_schedule_event_del_timeout); -/* - SILC Scheduler structure. +/************************ Static utility functions **************************/ - This is the actual schedule object in SILC. Both SILC client and server - uses this same scheduler. Actually, this scheduler could be used by any - program needing scheduling. +/* Fd task hash table destructor */ - Following short description of the fields: +static void silc_schedule_fd_destructor(void *key, void *context, + void *user_context) +{ + silc_free(context); +} - SilcTaskQueue fd_queue +/* Executes file descriptor tasks. Invalid tasks are removed here. */ - Task queue hook for non-timeout tasks. Usually this means that these - tasks perform different kind of I/O on file descriptors. File - descriptors are usually network sockets but they actually can be - any file descriptors. This hook is initialized in silc_schedule_init - function. Timeout tasks should not be added to this queue because - they will never expire. +static void silc_schedule_dispatch_fd(SilcSchedule schedule) +{ + SilcTaskFd task; + SilcTask t; + + /* The dispatch list includes only valid tasks, and tasks that have + something to dispatch. Dispatching is atomic; no matter if another + thread invalidates a task when we unlock, we dispatch to completion. */ + SILC_SCHEDULE_UNLOCK(schedule); + silc_list_start(schedule->fd_dispatch); + while ((task = silc_list_get(schedule->fd_dispatch))) { + t = (SilcTask)task; + + /* Is the task ready for reading */ + if (task->revents & SILC_TASK_READ) + t->callback(schedule, schedule->app_context, SILC_TASK_READ, + task->fd, t->context); + + /* Is the task ready for writing */ + if (t->valid && task->revents & SILC_TASK_WRITE) + t->callback(schedule, schedule->app_context, SILC_TASK_WRITE, + task->fd, t->context); + } + SILC_SCHEDULE_LOCK(schedule); - SilcTaskQueue timeout_queue + /* Remove invalidated tasks */ + silc_list_start(schedule->fd_dispatch); + while ((task = silc_list_get(schedule->fd_dispatch))) + if (silc_unlikely(!task->header.valid)) + silc_schedule_task_remove(schedule, (SilcTask)task); +} - Task queue hook for timeout tasks. This hook is reserved specificly - for tasks with timeout. Non-timeout tasks should not be added to this - queue because they will never get scheduled. This hook is also - initialized in silc_schedule_init function. +/* Executes all tasks whose timeout has expired. The task is removed from + the task queue after the callback function has returned. Also, invalid + tasks are removed here. */ - SilcTaskQueue generic_queue +static void silc_schedule_dispatch_timeout(SilcSchedule schedule, + SilcBool dispatch_all) +{ + SilcTask t; + SilcTaskTimeout task; + struct timeval curtime; + int count = 0; - Task queue hook for generic tasks. This hook is reserved specificly - for generic tasks, tasks that apply to all file descriptors, except - to those that have specificly registered a non-timeout task. This hook - is also initialized in silc_schedule_init function. + SILC_LOG_DEBUG(("Running timeout tasks")); - SilcScheduleFd fd_list + silc_gettimeofday(&curtime); - List of file descriptors the scheduler is supposed to be listenning. - This is updated internally. + /* First task in the task queue has always the earliest timeout. */ + silc_list_start(schedule->timeout_queue); + task = silc_list_get(schedule->timeout_queue); + if (silc_unlikely(!task)) + return; + do { + t = (SilcTask)task; - uint32 max_fd - uint32 last_fd + /* Remove invalid task */ + if (silc_unlikely(!t->valid)) { + silc_schedule_task_remove(schedule, t); + continue; + } - Size of the fd_list list. There can be `max_fd' many tasks in - the scheduler at once. The `last_fd' is the last valid entry - in the fd_list. + /* Execute the task if the timeout has expired */ + if (silc_compare_timeval(&task->timeout, &curtime) > 0 && !dispatch_all) + break; - struct timeval *timeout; + t->valid = FALSE; + SILC_SCHEDULE_UNLOCK(schedule); + t->callback(schedule, schedule->app_context, SILC_TASK_EXPIRE, 0, + t->context); + SILC_SCHEDULE_LOCK(schedule); - Pointer to the schedules next timeout. Value of this timeout is - automatically updated in the silc_schedule function. + /* Remove the expired task */ + silc_schedule_task_remove(schedule, t); - bool valid + /* Balance when we have lots of small timeouts */ + if (silc_unlikely((++count) > 40)) + break; + } while (silc_likely((task = silc_list_get(schedule->timeout_queue)))); +} - Marks validity of the scheduler. This is a boolean value. When this - is false the scheduler is terminated and the program will end. This - set to true when the scheduler is initialized with silc_schedule_init - function. +/* Calculates next timeout. This is the timeout value when at earliest some + of the timeout tasks expire. If this is in the past, they will be + dispatched now. */ - fd_set in - fd_set out +static void silc_schedule_select_timeout(SilcSchedule schedule) +{ + SilcTask t; + SilcTaskTimeout task; + struct timeval curtime; + SilcBool dispatch = TRUE; - File descriptor sets for select(). These are automatically managed - by the scheduler and should not be touched otherwise. + /* Get the current time */ + silc_gettimeofday(&curtime); + schedule->has_timeout = FALSE; - void *wakeup + /* First task in the task queue has always the earliest timeout. */ + silc_list_start(schedule->timeout_queue); + task = silc_list_get(schedule->timeout_queue); + if (silc_unlikely(!task)) + return; + do { + t = (SilcTask)task; - System specific wakeup context. On multi-threaded environments the - scheduler needs to be wakenup (in the thread) when tasks are added - or removed. This is initialized by silc_schedule_wakeup_init. + /* Remove invalid task */ + if (silc_unlikely(!t->valid)) { + silc_schedule_task_remove(schedule, t); + continue; + } - SILC_MUTEX_DEFINE(lock) - - Scheduler lock. + /* If the timeout is in past, we will run the task and all other + timeout tasks from the past. */ + if (silc_compare_timeval(&task->timeout, &curtime) <= 0 && dispatch) { + silc_schedule_dispatch_timeout(schedule, FALSE); + if (silc_unlikely(!schedule->valid)) + return; -*/ -struct SilcScheduleStruct { - SilcTaskQueue fd_queue; - SilcTaskQueue timeout_queue; - SilcTaskQueue generic_queue; - SilcScheduleFd fd_list; - uint32 max_fd; - uint32 last_fd; - struct timeval *timeout; - bool valid; - void *wakeup; - SILC_MUTEX_DEFINE(lock); - bool is_locked; -}; + /* Start selecting new timeout again after dispatch */ + silc_list_start(schedule->timeout_queue); + dispatch = FALSE; + continue; + } + + /* Calculate the next timeout */ + curtime.tv_sec = task->timeout.tv_sec - curtime.tv_sec; + curtime.tv_usec = task->timeout.tv_usec - curtime.tv_usec; + if (curtime.tv_sec < 0) + curtime.tv_sec = 0; + + /* We wouldn't want to go under zero, check for it. */ + if (curtime.tv_usec < 0) { + curtime.tv_sec -= 1; + if (curtime.tv_sec < 0) + curtime.tv_sec = 0; + curtime.tv_usec += 1000000L; + } + break; + } while ((task = silc_list_get(schedule->timeout_queue))); + + /* Save the timeout */ + if (task) { + schedule->timeout = curtime; + schedule->has_timeout = TRUE; + SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout.tv_sec, + schedule->timeout.tv_usec)); + } +} + +/* Removes task from the scheduler. This must be called with scheduler + locked. */ + +static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task) +{ + SilcSchedule parent; + + if (silc_unlikely(task == SILC_ALL_TASKS)) { + SilcTask task; + SilcEventTask etask; + SilcHashTableList htl; + void *fd; + + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, &fd, (void *)&task)) + silc_hash_table_del(schedule->fd_queue, fd); + silc_hash_table_list_reset(&htl); + + /* Delete from timeout queue */ + silc_list_start(schedule->timeout_queue); + while ((task = silc_list_get(schedule->timeout_queue))) { + silc_list_del(schedule->timeout_queue, task); + silc_free(task); + } + + /* Delete even tasks */ + parent = silc_schedule_get_parent(schedule); + silc_hash_table_list(parent->events, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&etask)) { + silc_hash_table_del_by_context(parent->events, etask->event, etask); + silc_free(etask->event); + silc_free(etask); + } + silc_hash_table_list_reset(&htl); + return; + } + + switch (task->type) { + case SILC_TASK_FD: + { + /* Delete from fd queue */ + SilcTaskFd ftask = (SilcTaskFd)task; + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd)); + } + break; + + case SILC_TASK_TIMEOUT: + { + /* Delete from timeout queue */ + silc_list_del(schedule->timeout_queue, task); + + /* Put to free list */ + silc_list_add(schedule->free_tasks, task); + } + break; + + case SILC_TASK_EVENT: + { + SilcEventTask etask = (SilcEventTask)task; + SilcScheduleEventConnection conn; + + parent = silc_schedule_get_parent(schedule); + + /* Delete event */ + silc_hash_table_del_by_context(parent->events, etask->event, etask); + + /* Remove all connections */ + silc_list_start(etask->connections); + while ((conn = silc_list_get(etask->connections))) + silc_free(conn); + + silc_free(etask->event); + silc_free(etask); + } + break; + + default: + break; + } +} + +/* Timeout freelist garbage collection */ + +SILC_TASK_CALLBACK(silc_schedule_timeout_gc) +{ + SilcTaskTimeout t; + int c; + + if (!schedule->valid) + return; + + SILC_LOG_DEBUG(("Timeout freelist garbage collection")); + + SILC_SCHEDULE_LOCK(schedule); + + if (silc_list_count(schedule->free_tasks) <= 10) { + SILC_SCHEDULE_UNLOCK(schedule); + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); + return; + } + if (silc_list_count(schedule->timeout_queue) > + silc_list_count(schedule->free_tasks)) { + SILC_SCHEDULE_UNLOCK(schedule); + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); + return; + } + + c = silc_list_count(schedule->free_tasks) / 2; + if (c > silc_list_count(schedule->timeout_queue)) + c = (silc_list_count(schedule->free_tasks) - + silc_list_count(schedule->timeout_queue)); + if (silc_list_count(schedule->free_tasks) - c < 10) + c -= (10 - (silc_list_count(schedule->free_tasks) - c)); + + SILC_LOG_DEBUG(("Freeing %d unused tasks, leaving %d", c, + silc_list_count(schedule->free_tasks) - c)); + + silc_list_start(schedule->free_tasks); + while ((t = silc_list_get(schedule->free_tasks)) && c-- > 0) { + silc_list_del(schedule->free_tasks, t); + silc_free(t); + } + silc_list_start(schedule->free_tasks); + + SILC_SCHEDULE_UNLOCK(schedule); + + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); +} + +#ifdef SILC_DIST_INPLACE +/* Print schedule statistics to stdout */ + +void silc_schedule_stats(SilcSchedule schedule) +{ + SilcTaskFd ftask; + fprintf(stdout, "Schedule %p statistics:\n\n", schedule); + fprintf(stdout, "Num FD tasks : %d (%lu bytes allocated)\n", + silc_hash_table_count(schedule->fd_queue), + sizeof(*ftask) * silc_hash_table_count(schedule->fd_queue)); + fprintf(stdout, "Num Timeout tasks : %d (%lu bytes allocated)\n", + silc_list_count(schedule->timeout_queue), + sizeof(struct SilcTaskTimeoutStruct) * + silc_list_count(schedule->timeout_queue)); + fprintf(stdout, "Num Timeout freelist : %d (%lu bytes allocated)\n", + silc_list_count(schedule->free_tasks), + sizeof(struct SilcTaskTimeoutStruct) * + silc_list_count(schedule->free_tasks)); +} +#endif /* SILC_DIST_INPLACE */ + +/****************************** Public API **********************************/ /* Initializes the scheduler. This returns the scheduler context that is given as arugment usually to all silc_schedule_* functions. The `max_tasks' indicates the number of maximum tasks that the - scheduler can handle. */ + scheduler can handle. The `app_context' is application specific + context that is delivered to task callbacks. */ -SilcSchedule silc_schedule_init(int max_tasks) +SilcSchedule silc_schedule_init(int max_tasks, void *app_context, + SilcStack stack, SilcSchedule parent) { SilcSchedule schedule; - SILC_LOG_DEBUG(("Initializing scheduler")); + /* Initialize Tls, in case it hasn't been done yet */ + silc_thread_tls_init(); + + stack = silc_stack_alloc(0, stack); + if (!stack) + return NULL; - schedule = silc_calloc(1, sizeof(*schedule)); + /* Allocate scheduler from the stack */ + schedule = silc_scalloc(stack, 1, sizeof(*schedule)); + if (!schedule) + return NULL; - /* Allocate three task queues, one for file descriptor based tasks, - one for timeout tasks and one for generic tasks. */ - silc_task_queue_alloc(&schedule->fd_queue); - silc_task_queue_alloc(&schedule->timeout_queue); - silc_task_queue_alloc(&schedule->generic_queue); + SILC_LOG_DEBUG(("Initializing scheduler %p", schedule)); - if (!max_tasks) - max_tasks = 200; + /* Allocate Fd task hash table dynamically */ + schedule->fd_queue = + silc_hash_table_alloc(NULL, 0, silc_hash_uint, NULL, NULL, NULL, + silc_schedule_fd_destructor, NULL, TRUE); + if (!schedule->fd_queue) { + silc_stack_free(stack); + return NULL; + } - /* Initialize the scheduler */ - schedule->fd_list = silc_calloc(max_tasks, sizeof(*schedule->fd_list)); - schedule->max_fd = max_tasks; - schedule->timeout = NULL; + silc_list_init(schedule->timeout_queue, struct SilcTaskStruct, next); + silc_list_init(schedule->free_tasks, struct SilcTaskStruct, next); + + /* Get the parent */ + if (parent && parent->parent) + parent = parent->parent; + + schedule->stack = stack; + schedule->app_context = app_context; schedule->valid = TRUE; + schedule->max_tasks = max_tasks; + schedule->parent = parent; /* Allocate scheduler lock */ silc_mutex_alloc(&schedule->lock); - /* Initialize the wakeup, for multi-threads support */ - schedule->wakeup = silc_schedule_wakeup_init(schedule); + /* Initialize the platform specific scheduler. */ + schedule->internal = schedule_ops.init(schedule, app_context); + if (!schedule->internal) { + silc_hash_table_free(schedule->fd_queue); + silc_mutex_free(schedule->lock); + silc_stack_free(stack); + return NULL; + } + + /* Timeout freelist garbage collection */ + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); return schedule; } @@ -223,987 +426,1156 @@ SilcSchedule silc_schedule_init(int max_tasks) scheduler could not be uninitialized. This happens when the scheduler is still valid and silc_schedule_stop has not been called. */ -bool silc_schedule_uninit(SilcSchedule schedule) +SilcBool silc_schedule_uninit(SilcSchedule schedule) { - SILC_LOG_DEBUG(("Uninitializing scheduler")); + SilcTask task; + + SILC_VERIFY(schedule); + + SILC_LOG_DEBUG(("Uninitializing scheduler %p", schedule)); if (schedule->valid == TRUE) return FALSE; + /* Dispatch all timeouts before going away */ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_dispatch_timeout(schedule, TRUE); + SILC_SCHEDULE_UNLOCK(schedule); + + /* Deliver signals before going away */ + if (schedule->signal_tasks) { + schedule_ops.signals_call(schedule, schedule->internal); + schedule->signal_tasks = FALSE; + } + /* Unregister all tasks */ - silc_schedule_task_remove(schedule->fd_queue, SILC_ALL_TASKS); - silc_schedule_task_remove(schedule->timeout_queue, SILC_ALL_TASKS); - silc_schedule_task_remove(schedule->generic_queue, SILC_ALL_TASKS); + silc_schedule_task_del(schedule, SILC_ALL_TASKS); + silc_schedule_task_remove(schedule, SILC_ALL_TASKS); - /* Unregister all task queues */ - silc_task_queue_free(schedule->fd_queue); - silc_task_queue_free(schedule->timeout_queue); - silc_task_queue_free(schedule->generic_queue); + /* Delete timeout task freelist */ + silc_list_start(schedule->free_tasks); + while ((task = silc_list_get(schedule->free_tasks))) + silc_free(task); - silc_free(schedule->fd_list); + /* Unregister all task queues */ + silc_hash_table_free(schedule->fd_queue); - /* Uninit the wakeup */ - silc_schedule_wakeup_uninit(schedule->wakeup); + /* Uninit the platform specific scheduler. */ + schedule_ops.uninit(schedule, schedule->internal); silc_mutex_free(schedule->lock); + silc_stack_free(schedule->stack); return TRUE; } -/* Stops the schedule even if it is not supposed to be stopped yet. - After calling this, one should call silc_schedule_uninit (after the +/* Stops the schedule even if it is not supposed to be stopped yet. + After calling this, one should call silc_schedule_uninit (after the silc_schedule has returned). */ void silc_schedule_stop(SilcSchedule schedule) { SILC_LOG_DEBUG(("Stopping scheduler")); - silc_mutex_lock(schedule->lock); + SILC_VERIFY(schedule); + SILC_SCHEDULE_LOCK(schedule); schedule->valid = FALSE; - silc_mutex_unlock(schedule->lock); + SILC_SCHEDULE_UNLOCK(schedule); } -/* Executes nontimeout tasks. It then checks whether any of ther fd tasks - was signaled by the silc_select. If some task was not signaled then - all generic tasks are executed for that task. The generic tasks are - never executed for task that has explicit fd task set. */ -/* This holds the schedule->lock and the queue locks. */ +/* Runs the scheduler once and then returns. Must be called locked. */ -static void silc_schedule_dispatch_nontimeout(SilcSchedule schedule) +static SilcBool silc_schedule_iterate(SilcSchedule schedule, int timeout_usecs) { - SilcTask task; - int i, last_fd = schedule->last_fd; - uint32 fd; + struct timeval timeout; + int ret; - for (i = 0; i <= last_fd; i++) { - if (schedule->fd_list[i].events == 0) - continue; + do { + SILC_LOG_DEBUG(("In scheduler loop")); - fd = schedule->fd_list[i].fd; - - /* First check whether this fd has task in the fd queue */ - silc_mutex_lock(schedule->fd_queue->lock); - task = silc_task_find(schedule->fd_queue, fd); - - /* If the task was found then execute its callbacks. If not then - execute all generic tasks for that fd. */ - if (task) { - /* Validity of the task is checked always before and after - execution beacuse the task might have been unregistered - in the callback function, ie. it is not valid anymore. */ - - /* Is the task ready for reading */ - if (task->valid && schedule->fd_list[i].revents & SILC_TASK_READ) { - silc_mutex_unlock(schedule->fd_queue->lock); - silc_mutex_unlock(schedule->lock); - task->callback(schedule, SILC_TASK_READ, task->fd, task->context); - silc_mutex_lock(schedule->lock); - silc_mutex_lock(schedule->fd_queue->lock); - } + /* Deliver signals if any has been set to be called */ + if (silc_unlikely(schedule->signal_tasks)) { + SILC_SCHEDULE_UNLOCK(schedule); + schedule_ops.signals_call(schedule, schedule->internal); + schedule->signal_tasks = FALSE; + SILC_SCHEDULE_LOCK(schedule); + } - /* Is the task ready for writing */ - if (task->valid && schedule->fd_list[i].revents & SILC_TASK_WRITE) { - silc_mutex_unlock(schedule->fd_queue->lock); - silc_mutex_unlock(schedule->lock); - task->callback(schedule, SILC_TASK_WRITE, task->fd, task->context); - silc_mutex_lock(schedule->lock); - silc_mutex_lock(schedule->fd_queue->lock); - } + /* Check if scheduler is valid */ + if (silc_unlikely(schedule->valid == FALSE)) { + SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); + return FALSE; + } - if (!task->valid) - silc_schedule_task_remove(schedule->fd_queue, task); + /* Calculate next timeout for silc_select(). This is the timeout value + when at earliest some of the timeout tasks expire. This may dispatch + already expired timeouts. */ + silc_schedule_select_timeout(schedule); - silc_mutex_unlock(schedule->fd_queue->lock); - } else { - /* Run generic tasks for this fd. */ + /* Check if scheduler is valid */ + if (silc_unlikely(schedule->valid == FALSE)) { + SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); + return FALSE; + } - silc_mutex_unlock(schedule->fd_queue->lock); + if (timeout_usecs >= 0) { + timeout.tv_sec = 0; + timeout.tv_usec = timeout_usecs; + schedule->timeout = timeout; + schedule->has_timeout = TRUE; + } + + /* This is the main silc_select(). The program blocks here until some + of the selected file descriptors change status or the selected + timeout expires. */ + SILC_LOG_DEBUG(("Select")); + ret = schedule_ops.schedule(schedule, schedule->internal); + + if (silc_likely(ret == 0)) { + /* Timeout */ + SILC_LOG_DEBUG(("Running timeout tasks")); + if (silc_likely(silc_list_count(schedule->timeout_queue))) + silc_schedule_dispatch_timeout(schedule, FALSE); + continue; + + } else if (silc_likely(ret > 0)) { + /* There is some data available now */ + SILC_LOG_DEBUG(("Running fd tasks")); + silc_schedule_dispatch_fd(schedule); - silc_mutex_lock(schedule->generic_queue->lock); - if (!schedule->generic_queue->task) { - silc_mutex_unlock(schedule->generic_queue->lock); + /* If timeout was very short, dispatch also timeout tasks */ + if (schedule->has_timeout && schedule->timeout.tv_sec == 0 && + schedule->timeout.tv_usec < 50000) + silc_schedule_dispatch_timeout(schedule, FALSE); + continue; + + } else { + /* Error or special case handling */ + if (errno == EINTR) continue; - } + if (ret == -2) + break; - task = schedule->generic_queue->task; - while(1) { - /* Validity of the task is checked always before and after - execution beacuse the task might have been unregistered - in the callback function, ie. it is not valid anymore. */ - - /* Is the task ready for reading */ - if (task->valid && schedule->fd_list[i].revents & SILC_TASK_READ) { - silc_mutex_unlock(schedule->generic_queue->lock); - silc_mutex_unlock(schedule->lock); - task->callback(schedule, SILC_TASK_READ, fd, task->context); - silc_mutex_lock(schedule->lock); - silc_mutex_lock(schedule->generic_queue->lock); - } - - /* Is the task ready for writing */ - if (task->valid && schedule->fd_list[i].revents & SILC_TASK_WRITE) { - silc_mutex_unlock(schedule->generic_queue->lock); - silc_mutex_unlock(schedule->lock); - task->callback(schedule, SILC_TASK_WRITE, fd, task->context); - silc_mutex_lock(schedule->lock); - silc_mutex_lock(schedule->generic_queue->lock); - } - - if (!task->valid) { - /* Invalid (unregistered) tasks are removed from the - task queue. */ - if (schedule->generic_queue->task == task->next) { - silc_schedule_task_remove(schedule->generic_queue, task); - silc_mutex_unlock(schedule->generic_queue->lock); - break; - } - - task = task->next; - silc_schedule_task_remove(schedule->generic_queue, task); - continue; - } - - /* Break if there isn't more tasks in the queue */ - if (schedule->generic_queue->task == task->next) - break; - - task = task->next; - } - - silc_mutex_unlock(schedule->generic_queue->lock); + SILC_LOG_ERROR(("Error in select()/poll(): %s", strerror(errno))); + continue; } - } + } while (timeout_usecs == -1); + + return TRUE; } -/* Executes all tasks whose timeout has expired. The task is removed from - the task queue after the callback function has returned. Also, invalid - tasks are removed here. We don't have to care about priorities because - tasks are already sorted in their priority order at the registration - phase. */ -/* This holds the schedule->lock and the schedule->timeout_queue->lock */ +/* Runs the scheduler once and then returns. */ -static void silc_schedule_dispatch_timeout(SilcSchedule schedule) +SilcBool silc_schedule_one(SilcSchedule schedule, int timeout_usecs) { - SilcTaskQueue queue = schedule->timeout_queue; - SilcTask task; - struct timeval curtime; + SilcBool ret; + SILC_SCHEDULE_LOCK(schedule); + ret = silc_schedule_iterate(schedule, timeout_usecs); + SILC_SCHEDULE_UNLOCK(schedule); + return ret; +} - SILC_LOG_DEBUG(("Running timeout tasks")); +/* Runs the scheduler and blocks here. When this returns the scheduler + has ended. */ - silc_gettimeofday(&curtime); +#ifndef SILC_SYMBIAN +void silc_schedule(SilcSchedule schedule) +{ + SILC_LOG_DEBUG(("Running scheduler")); - queue = schedule->timeout_queue; - if (queue && queue->task) { - task = queue->task; - - /* Walk thorugh all tasks in the particular task queue and run all - the expired tasks. */ - while(1) { - /* Execute the task if the timeout has expired */ - if (silc_schedule_task_timeout_compare(&task->timeout, &curtime)) { - if (task->valid) { - silc_mutex_unlock(queue->lock); - silc_mutex_unlock(schedule->lock); - task->callback(schedule, SILC_TASK_EXPIRE, task->fd, task->context); - silc_mutex_lock(schedule->lock); - silc_mutex_lock(queue->lock); - } - - /* Break if there isn't more tasks in the queue */ - if (queue->task == task->next) { - silc_schedule_task_remove(queue, task); - break; - } - - task = task->next; - - /* Remove the task from queue */ - silc_schedule_task_remove(queue, task->prev); - } else { - /* The timeout hasn't expired, check for next one */ - - /* Break if there isn't more tasks in the queue */ - if (queue->task == task->next) - break; - - task = task->next; - } - } - } + /* Start the scheduler loop */ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_iterate(schedule, -1); + SILC_SCHEDULE_UNLOCK(schedule); } +#endif /* !SILC_SYMBIAN */ -/* Calculates next timeout for select(). This is the timeout value - when at earliest some of the timeout tasks expire. If this is in the - past, they will be run now. */ -/* This holds the schedule->lock and the schedule->timeout_queue->lock */ +/* Wakes up the scheduler. This is used only in multi-threaded + environments where threads may add new tasks or remove old tasks + from task queues. This is called to wake up the scheduler in the + main thread so that it detects the changes in the task queues. + If threads support is not compiled in this function has no effect. + Implementation of this function is platform specific. */ -static void silc_schedule_select_timeout(SilcSchedule schedule) +void silc_schedule_wakeup(SilcSchedule schedule) { - SilcTaskQueue queue = schedule->timeout_queue; - SilcTask task; - struct timeval curtime; +#ifdef SILC_THREADS + SILC_LOG_DEBUG(("Wakeup scheduler")); + SILC_SCHEDULE_LOCK(schedule); + schedule_ops.wakeup(schedule, schedule->internal); + SILC_SCHEDULE_UNLOCK(schedule); +#endif +} - /* Get the current time */ - silc_gettimeofday(&curtime); - schedule->timeout = NULL; - - /* First task in the task queue has always the smallest timeout. */ - task = queue->task; - while(1) { - if (task && task->valid == TRUE) { - /* If the timeout is in past, we will run the task and all other - timeout tasks from the past. */ - if (silc_schedule_task_timeout_compare(&task->timeout, &curtime)) { - silc_schedule_dispatch_timeout(schedule); - - /* The task(s) has expired and doesn't exist on the task queue - anymore. We continue with new timeout. */ - queue = schedule->timeout_queue; - task = queue->task; - if (task == NULL || task->valid == FALSE) - break; - } +/* Returns parent scheduler */ - /* Calculate the next timeout for select() */ - queue->timeout.tv_sec = task->timeout.tv_sec - curtime.tv_sec; - queue->timeout.tv_usec = task->timeout.tv_usec - curtime.tv_usec; - if (queue->timeout.tv_sec < 0) - queue->timeout.tv_sec = 0; - - /* We wouldn't want to go under zero, check for it. */ - if (queue->timeout.tv_usec < 0) { - queue->timeout.tv_sec -= 1; - if (queue->timeout.tv_sec < 0) - queue->timeout.tv_sec = 0; - queue->timeout.tv_usec += 1000000L; - } +SilcSchedule silc_schedule_get_parent(SilcSchedule schedule) +{ + return schedule->parent ? schedule->parent : schedule; +} - /* We've got the timeout value */ - break; - } else { - /* Task is not valid, remove it and try next one. */ - silc_schedule_task_remove(queue, task); - task = queue->task; - if (queue->task == NULL) - break; - } - } +/* Returns the application specific context that was saved into the + scheduler in silc_schedule_init function. The context is also + returned to application in task callback functions, but this function + may be used to get it as well if needed. */ - /* Save the timeout */ - if (task) { - schedule->timeout = &queue->timeout; - SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout->tv_sec, - schedule->timeout->tv_usec)); - } +void *silc_schedule_get_context(SilcSchedule schedule) +{ + return schedule->app_context; } -/* Runs the scheduler once and then returns. */ +/* Return the stack of the scheduler */ -bool silc_schedule_one(SilcSchedule schedule, int timeout_usecs) +SilcStack silc_schedule_get_stack(SilcSchedule schedule) { - struct timeval timeout; - int ret; + return schedule->stack; +} - SILC_LOG_DEBUG(("In scheduler loop")); +/* Set notify callback */ - if (!schedule->is_locked) - silc_mutex_lock(schedule->lock); +void silc_schedule_set_notify(SilcSchedule schedule, + SilcTaskNotifyCb notify, void *context) +{ + schedule->notify = notify; + schedule->notify_context = context; +} - /* If the task queues aren't initialized or we aren't valid anymore - we will return */ - if ((!schedule->fd_queue && !schedule->timeout_queue - && !schedule->generic_queue) || schedule->valid == FALSE) { - SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); - if (!schedule->is_locked) - silc_mutex_unlock(schedule->lock); - return FALSE; - } +/* Set global scheduler */ - /* Calculate next timeout for silc_select(). This is the timeout value - when at earliest some of the timeout tasks expire. */ - silc_mutex_lock(schedule->timeout_queue->lock); - silc_schedule_select_timeout(schedule); - silc_mutex_unlock(schedule->timeout_queue->lock); +void silc_schedule_set_global(SilcSchedule schedule) +{ + SilcTls tls = silc_thread_get_tls(); - if (timeout_usecs >= 0) { - timeout.tv_sec = 0; - timeout.tv_usec = timeout_usecs; - schedule->timeout = &timeout; + if (!tls) { + /* Try to initialize Tls */ + tls = silc_thread_tls_init(); + SILC_VERIFY(tls); + if (!tls) + return; } - silc_mutex_unlock(schedule->lock); + SILC_LOG_DEBUG(("Setting global scheduler %p", schedule)); - /* This is the main select(). The program blocks here until some - of the selected file descriptors change status or the selected - timeout expires. */ - SILC_LOG_DEBUG(("Select")); - ret = silc_select(schedule->fd_list, schedule->last_fd + 1, - schedule->timeout); + tls->schedule = schedule; +} - silc_mutex_lock(schedule->lock); +/* Return global scheduler */ - switch (ret) { - case -1: - /* Error */ - if (errno == EINTR) - break; - SILC_LOG_ERROR(("Error in select(): %s", strerror(errno))); - break; - case 0: - /* Timeout */ - silc_mutex_lock(schedule->timeout_queue->lock); - silc_schedule_dispatch_timeout(schedule); - silc_mutex_unlock(schedule->timeout_queue->lock); - break; - default: - /* There is some data available now */ - SILC_LOG_DEBUG(("Running non-timeout tasks")); - silc_schedule_dispatch_nontimeout(schedule); - break; - } +SilcSchedule silc_schedule_get_global(void) +{ + SilcTls tls = silc_thread_get_tls(); - if (!schedule->is_locked) - silc_mutex_unlock(schedule->lock); + if (!tls) + return NULL; - return TRUE; + SILC_LOG_DEBUG(("Return global scheduler %p", tls->schedule)); + + return tls->schedule; } -/* The SILC scheduler. This is actually the main routine in SILC programs. - When this returns the program is to be ended. Before this function can - be called, one must call silc_schedule_init function. */ +/* Add new task to the scheduler */ -void silc_schedule(SilcSchedule schedule) +SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskCallback callback, void *context, + long seconds, long useconds, + SilcTaskType type) { - SILC_LOG_DEBUG(("Running scheduler")); + SilcTask task = NULL; - if (schedule->valid == FALSE) { - SILC_LOG_ERROR(("Scheduler is not valid, stopping")); - return; + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return NULL; + } } - silc_mutex_lock(schedule->lock); - schedule->is_locked = TRUE; + if (silc_unlikely(!schedule->valid)) { + silc_set_errno(SILC_ERR_NOT_VALID); + return NULL; + } - /* Start the scheduler loop */ - while (silc_schedule_one(schedule, -1)) - ; + SILC_SCHEDULE_LOCK(schedule); + + if (silc_likely(type == SILC_TASK_TIMEOUT)) { + SilcTaskTimeout tmp, prev, ttask; + SilcList list; + + silc_list_start(schedule->free_tasks); + ttask = silc_list_get(schedule->free_tasks); + if (silc_unlikely(!ttask)) { + ttask = silc_calloc(1, sizeof(*ttask)); + if (silc_unlikely(!ttask)) + goto out; + } else + silc_list_del(schedule->free_tasks, ttask); + + ttask->header.type = 1; + ttask->header.callback = callback; + ttask->header.context = context; + ttask->header.valid = TRUE; + + /* Add timeout */ + silc_gettimeofday(&ttask->timeout); + if ((seconds + useconds) > 0) { + ttask->timeout.tv_sec += seconds + (useconds / 1000000L); + ttask->timeout.tv_usec += (useconds % 1000000L); + if (ttask->timeout.tv_usec >= 1000000L) { + ttask->timeout.tv_sec += 1; + ttask->timeout.tv_usec -= 1000000L; + } + } - silc_mutex_unlock(schedule->lock); -} + SILC_LOG_DEBUG(("New timeout task %p: sec=%d, usec=%d", ttask, + seconds, useconds)); + + /* Add task to correct spot so that the first task in the list has + the earliest timeout. */ + list = schedule->timeout_queue; + silc_list_start(list); + prev = NULL; + while ((tmp = silc_list_get(list)) != SILC_LIST_END) { + /* If we have shorter timeout, we have found our spot */ + if (silc_compare_timeval(&ttask->timeout, &tmp->timeout) < 0) { + silc_list_insert(schedule->timeout_queue, prev, ttask); + break; + } + prev = tmp; + } + if (!tmp) + silc_list_add(schedule->timeout_queue, ttask); -/* Wakes up the scheduler. This is used only in multi-threaded - environments where threads may add new tasks or remove old tasks - from task queues. This is called to wake up the scheduler in the - main thread so that it detects the changes in the task queues. - If threads support is not compiled in this function has no effect. - Implementation of this function is platform specific. */ + task = (SilcTask)ttask; -void silc_schedule_wakeup(SilcSchedule schedule) -{ -#ifdef SILC_THREADS - SILC_LOG_DEBUG(("Wakeup scheduler")); - silc_mutex_lock(schedule->lock); - silc_schedule_wakeup_internal(schedule->wakeup); - silc_mutex_unlock(schedule->lock); -#endif -} + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, TRUE, task, FALSE, 0, 0, seconds, useconds, + schedule->notify_context); -/* Add new task to the scheduler */ + } else if (silc_likely(type == SILC_TASK_FD)) { + SilcTaskFd ftask; -SilcTask silc_schedule_task_add(SilcSchedule schedule, uint32 fd, - SilcTaskCallback callback, void *context, - long seconds, long useconds, - SilcTaskType type, - SilcTaskPriority priority) -{ - SilcTask newtask; - SilcTaskQueue queue; - int timeout = FALSE; - - SILC_LOG_DEBUG(("Registering new task, fd=%d type=%d priority=%d", fd, - type, priority)); - - queue = SILC_SCHEDULE_GET_QUEUE(type); - - /* If the task is generic task, we check whether this task has already - been registered. Generic tasks are registered only once and after that - the same task applies to all file descriptors to be registered. */ - if (type == SILC_TASK_GENERIC) { - silc_mutex_lock(queue->lock); - - if (queue->task) { - SilcTask task = queue->task; - while(1) { - if ((task->callback == callback) && (task->context == context)) { - SILC_LOG_DEBUG(("Found matching generic task, using the match")); - - silc_mutex_unlock(queue->lock); - - /* Add the fd to be listened, the task found now applies to this - fd as well. */ - silc_schedule_set_listen_fd(schedule, fd, SILC_TASK_READ); - return task; - } - - if (queue->task == task->next) - break; - - task = task->next; - } + /* Check if fd is already added */ + if (silc_unlikely(silc_hash_table_find(schedule->fd_queue, + SILC_32_TO_PTR(fd), + NULL, (void *)&task))) { + if (task->valid) + goto out; + + /* Remove invalid task. We must have unique fd key to hash table. */ + silc_schedule_task_remove(schedule, task); } - silc_mutex_unlock(queue->lock); - } + /* Check max tasks */ + if (silc_unlikely(schedule->max_tasks > 0 && + silc_hash_table_count(schedule->fd_queue) >= + schedule->max_tasks)) { + SILC_LOG_WARNING(("Scheduler task limit reached: cannot add new task")); + task = NULL; + silc_set_errno(SILC_ERR_LIMIT); + goto out; + } - newtask = silc_calloc(1, sizeof(*newtask)); - newtask->fd = fd; - newtask->context = context; - newtask->callback = callback; - newtask->valid = TRUE; - newtask->priority = priority; - newtask->type = type; - newtask->next = newtask; - newtask->prev = newtask; - - /* Create timeout if marked to be timeout task */ - if (((seconds + useconds) > 0) && (type == SILC_TASK_TIMEOUT)) { - silc_gettimeofday(&newtask->timeout); - newtask->timeout.tv_sec += seconds + (useconds / 1000000L); - newtask->timeout.tv_usec += (useconds % 1000000L); - if (newtask->timeout.tv_usec > 999999L) { - newtask->timeout.tv_sec += 1; - newtask->timeout.tv_usec -= 1000000L; + ftask = silc_calloc(1, sizeof(*ftask)); + if (silc_unlikely(!ftask)) { + task = NULL; + goto out; } - timeout = TRUE; - } - /* If the task is non-timeout task we have to tell the scheduler that we - would like to have these tasks scheduled at some odd distant future. */ - if (type != SILC_TASK_TIMEOUT) - silc_schedule_set_listen_fd(schedule, fd, SILC_TASK_READ); + SILC_LOG_DEBUG(("New fd task %p fd=%d", ftask, fd)); - silc_mutex_lock(queue->lock); + ftask->header.type = 0; + ftask->header.callback = callback; + ftask->header.context = context; + ftask->header.valid = TRUE; + ftask->events = SILC_TASK_READ; + ftask->fd = fd; - /* Is this first task of the queue? */ - if (queue->task == NULL) { - queue->task = newtask; - silc_mutex_unlock(queue->lock); - return newtask; + /* Add task and schedule it */ + if (!silc_hash_table_add(schedule->fd_queue, SILC_32_TO_PTR(fd), ftask)) { + silc_free(ftask); + task = NULL; + goto out; + } + if (!schedule_ops.schedule_fd(schedule, schedule->internal, + ftask, ftask->events)) { + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(fd)); + task = NULL; + goto out; + } + + task = (SilcTask)ftask; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, TRUE, task, TRUE, ftask->fd, + SILC_TASK_READ, 0, 0, schedule->notify_context); + + } else if (silc_unlikely(type == SILC_TASK_SIGNAL)) { + SILC_SCHEDULE_UNLOCK(schedule); + schedule_ops.signal_register(schedule, schedule->internal, fd, + callback, context); + return NULL; } - if (timeout) - newtask = silc_task_add_timeout(queue, newtask, priority); - else - newtask = silc_task_add(queue, newtask, priority); + out: + SILC_SCHEDULE_UNLOCK(schedule); - silc_mutex_unlock(queue->lock); +#ifdef SILC_SYMBIAN + /* On symbian we wakeup scheduler immediately after adding timeout task + in case the task is added outside the scheduler loop (in some active + object). */ + if (task && task->type == 1) + silc_schedule_wakeup(schedule); +#endif /* SILC_SYMBIAN */ - return newtask; + return task; } -/* Removes a task from the scheduler */ +/* Invalidates task */ -void silc_schedule_task_del(SilcSchedule schedule, SilcTask task) +SilcBool silc_schedule_task_del(SilcSchedule schedule, SilcTask task) { - SilcTaskQueue queue = SILC_SCHEDULE_GET_QUEUE(task->type); + SilcSchedule parent; - /* Unregister all tasks */ - if (task == SILC_ALL_TASKS) { - SilcTask next; - SILC_LOG_DEBUG(("Unregistering all tasks at once")); + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } - silc_mutex_lock(queue->lock); + if (silc_unlikely(task == SILC_ALL_TASKS)) { + SilcHashTableList htl; - if (!queue->task) { - silc_mutex_unlock(queue->lock); - return; - } + SILC_LOG_DEBUG(("Unregister all tasks")); - next = queue->task; - - while(1) { - if (next->valid) - next->valid = FALSE; - if (queue->task == next->next) - break; - next = next->next; + SILC_SCHEDULE_LOCK(schedule); + + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, + ((SilcTaskFd)task)->fd, 0, 0, 0, + schedule->notify_context); } + silc_hash_table_list_reset(&htl); - silc_mutex_unlock(queue->lock); - return; - } + /* Delete from timeout queue */ + silc_list_start(schedule->timeout_queue); + while ((task = (SilcTask)silc_list_get(schedule->timeout_queue))) { + task->valid = FALSE; - SILC_LOG_DEBUG(("Unregistering task")); + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + } - silc_mutex_lock(queue->lock); + /* Delete even tasks */ + parent = silc_schedule_get_parent(schedule); + silc_hash_table_list(parent->events, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&task)) + task->valid = FALSE; + silc_hash_table_list_reset(&htl); - /* Unregister the specific task */ - if (task->valid) - task->valid = FALSE; + SILC_SCHEDULE_UNLOCK(schedule); + return TRUE; + } - silc_mutex_unlock(queue->lock); + SILC_LOG_DEBUG(("Unregistering task %p, type %d", task, task->type)); + SILC_SCHEDULE_LOCK(schedule); + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify && task->type != SILC_TASK_EVENT) + schedule->notify(schedule, FALSE, task, task->type == SILC_TASK_FD, + 0, 0, 0, 0, schedule->notify_context); + SILC_SCHEDULE_UNLOCK(schedule); + + if (task->type == SILC_TASK_EVENT) { + /* Schedule removal of deleted event task */ + parent = silc_schedule_get_parent(schedule); + silc_schedule_task_add_timeout(parent, silc_schedule_event_del_timeout, + task, 0, 1); + } + + return TRUE; } -/* Remove task by fd */ +/* Invalidate task by fd */ -void silc_schedule_task_del_by_fd(SilcSchedule schedule, uint32 fd) +SilcBool silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd) { + SilcTask task = NULL; + SilcBool ret = FALSE; + SILC_LOG_DEBUG(("Unregister task by fd %d", fd)); - silc_task_del_by_fd(schedule->timeout_queue, fd); - silc_task_del_by_fd(schedule->fd_queue, fd); + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } + + SILC_SCHEDULE_LOCK(schedule); + + /* fd is unique, so there is only one task with this fd in the table */ + if (silc_likely(silc_hash_table_find(schedule->fd_queue, + SILC_32_TO_PTR(fd), NULL, + (void *)&task))) { + SILC_LOG_DEBUG(("Deleting task %p", task)); + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, fd, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } + + SILC_SCHEDULE_UNLOCK(schedule); + + /* If it is signal, remove it */ + if (silc_unlikely(!task)) { + schedule_ops.signal_unregister(schedule, schedule->internal, fd); + ret = TRUE; + } + + if (ret == FALSE) + silc_set_errno(SILC_ERR_NOT_FOUND); + + return ret; } -/* Remove task by task callback. */ +/* Invalidate task by task callback. */ -void silc_schedule_task_del_by_callback(SilcSchedule schedule, - SilcTaskCallback callback) +SilcBool silc_schedule_task_del_by_callback(SilcSchedule schedule, + SilcTaskCallback callback) { + SilcTask task; + SilcHashTableList htl; + SilcList list; + SilcBool ret = FALSE; + SILC_LOG_DEBUG(("Unregister task by callback")); - silc_task_del_by_callback(schedule->timeout_queue, callback); - silc_task_del_by_callback(schedule->fd_queue, callback); - silc_task_del_by_callback(schedule->generic_queue, callback); + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } + + SILC_SCHEDULE_LOCK(schedule); + + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { + if (task->callback == callback) { + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, + ((SilcTaskFd)task)->fd, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } + } + silc_hash_table_list_reset(&htl); + + /* Delete from timeout queue */ + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->callback == callback) { + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } + } + + SILC_SCHEDULE_UNLOCK(schedule); + + if (ret == FALSE) + silc_set_errno(SILC_ERR_NOT_FOUND); + + return ret; } -/* Remove task by context. */ +/* Invalidate task by context. */ -void silc_schedule_task_del_by_context(SilcSchedule schedule, void *context) +SilcBool silc_schedule_task_del_by_context(SilcSchedule schedule, + void *context) { + SilcTask task; + SilcHashTableList htl; + SilcList list; + SilcBool ret = FALSE; + SILC_LOG_DEBUG(("Unregister task by context")); - silc_task_del_by_context(schedule->timeout_queue, context); - silc_task_del_by_context(schedule->fd_queue, context); - silc_task_del_by_context(schedule->generic_queue, context); -} + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } -/* Sets a file descriptor to be listened by select() in scheduler. One can - call this directly if wanted. This can be called multiple times for - one file descriptor to set different iomasks. */ + SILC_SCHEDULE_LOCK(schedule); -void silc_schedule_set_listen_fd(SilcSchedule schedule, - uint32 fd, SilcTaskEvent iomask) -{ - int i; - bool found = FALSE; - - silc_mutex_lock(schedule->lock); - - for (i = 0; i < schedule->max_fd; i++) - if (schedule->fd_list[i].fd == fd) { - schedule->fd_list[i].fd = fd; - schedule->fd_list[i].events = iomask; - if (i > schedule->last_fd) - schedule->last_fd = i; - found = TRUE; - break; + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { + if (task->context == context) { + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, TRUE, + ((SilcTaskFd)task)->fd, 0, 0, 0, + schedule->notify_context); + ret = TRUE; } + } + silc_hash_table_list_reset(&htl); + + /* Delete from timeout queue */ + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->context == context) { + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } + } - if (!found) - for (i = 0; i < schedule->max_fd; i++) - if (schedule->fd_list[i].events == 0) { - schedule->fd_list[i].fd = fd; - schedule->fd_list[i].events = iomask; - if (i > schedule->last_fd) - schedule->last_fd = i; - break; - } + SILC_SCHEDULE_UNLOCK(schedule); - silc_mutex_unlock(schedule->lock); + if (ret == FALSE) + silc_set_errno(SILC_ERR_NOT_FOUND); + + return ret; } -/* Removes a file descriptor from listen list. */ +/* Invalidate task by all */ -void silc_schedule_unset_listen_fd(SilcSchedule schedule, uint32 fd) +SilcBool silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, + SilcTaskCallback callback, + void *context) { - int i; + SilcTask task; + SilcList list; + SilcBool ret = FALSE; - silc_mutex_lock(schedule->lock); + SILC_LOG_DEBUG(("Unregister task by fd, callback and context")); - SILC_LOG_DEBUG(("Unset listen fd %d", fd)); + /* For fd task, callback and context is irrelevant as fd is unique */ + if (fd) + return silc_schedule_task_del_by_fd(schedule, fd); - for (i = 0; i < schedule->max_fd; i++) - if (schedule->fd_list[i].fd == fd) { - schedule->fd_list[i].fd = 0; - schedule->fd_list[i].events = 0; - if (schedule->last_fd == i) - schedule->last_fd = schedule->max_fd - 1; - break; + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; } + } - silc_mutex_unlock(schedule->lock); -} + SILC_SCHEDULE_LOCK(schedule); -/* Allocates a newtask task queue into the scheduler */ + /* Delete from timeout queue */ + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->callback == callback && task->context == context) { + task->valid = FALSE; -static void silc_task_queue_alloc(SilcTaskQueue *queue) -{ - *queue = silc_calloc(1, sizeof(**queue)); - silc_mutex_alloc(&(*queue)->lock); -} + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + ret = TRUE; + } + } -/* Free's a task queue. */ + SILC_SCHEDULE_UNLOCK(schedule); -static void silc_task_queue_free(SilcTaskQueue queue) -{ - silc_mutex_free(queue->lock); - silc_free(queue); + if (ret == FALSE) + silc_set_errno(SILC_ERR_NOT_FOUND); + + return TRUE; } -/* Return task by its fd. */ +/* Sets a file descriptor to be listened by scheduler. One can call this + directly if wanted. This can be called multiple times for one file + descriptor to set different iomasks. */ -static SilcTask silc_task_find(SilcTaskQueue queue, uint32 fd) +SilcBool silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskEvent mask, SilcBool send_events) { - SilcTask next; + SilcTaskFd task; - if (!queue->task) - return NULL; + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } + + if (silc_unlikely(!schedule->valid)) { + silc_set_errno(SILC_ERR_NOT_VALID); + return FALSE; + } - next = queue->task; + SILC_SCHEDULE_LOCK(schedule); - while (1) { - if (next->fd == fd) - return next; - if (queue->task == next->next) - return NULL; - next = next->next; + if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), + NULL, (void *)&task)) { + if (!schedule_ops.schedule_fd(schedule, schedule->internal, task, mask)) { + SILC_SCHEDULE_UNLOCK(schedule); + return FALSE; + } + task->events = mask; + if (silc_unlikely(send_events) && mask) { + task->revents = mask; + silc_schedule_dispatch_fd(schedule); + } + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, TRUE, (SilcTask)task, + TRUE, task->fd, mask, 0, 0, + schedule->notify_context); } - return NULL; + SILC_SCHEDULE_UNLOCK(schedule); + + return TRUE; } -/* Adds a non-timeout task into the task queue. This function is used - by silc_task_register function. Returns a pointer to the registered - task. */ +/* Returns the file descriptor's current requested event mask. */ -static SilcTask silc_task_add(SilcTaskQueue queue, SilcTask newtask, - SilcTaskPriority priority) +SilcTaskEvent silc_schedule_get_fd_events(SilcSchedule schedule, + SilcUInt32 fd) { - SilcTask task, next, prev; - - /* Take the first task in the queue */ - task = queue->task; - - switch(priority) { - case SILC_TASK_PRI_LOW: - /* Lowest priority. The task is added at the end of the list. */ - prev = task->prev; - newtask->prev = prev; - newtask->next = task; - prev->next = newtask; - task->prev = newtask; - break; - case SILC_TASK_PRI_NORMAL: - /* Normal priority. The task is added before lower priority tasks - but after tasks with higher priority. */ - prev = task->prev; - while(prev != task) { - if (prev->priority > SILC_TASK_PRI_LOW) - break; - prev = prev->prev; + SilcTaskFd task; + SilcTaskEvent event = 0; + + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return 0; } - if (prev == task) { - /* There are only lower priorities in the list, we will - sit before them and become the first task in the queue. */ - prev = task->prev; - newtask->prev = prev; - newtask->next = task; - task->prev = newtask; - prev->next = newtask; - - /* We are now the first task in queue */ - queue->task = newtask; - } else { - /* Found a spot from the list, add the task to the list. */ - next = prev->next; - newtask->prev = prev; - newtask->next = next; - prev->next = newtask; - next->prev = newtask; - } - break; - default: - silc_free(newtask); - return NULL; } - return newtask; + if (silc_unlikely(!schedule->valid)) { + silc_set_errno(SILC_ERR_NOT_VALID); + return 0; + } + + SILC_SCHEDULE_LOCK(schedule); + if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), + NULL, (void *)&task)) + event = task->events; + SILC_SCHEDULE_UNLOCK(schedule); + + return event; } -/* Return the timeout task with smallest timeout. */ +/* Removes a file descriptor from listen list. */ -static SilcTask silc_task_get_first(SilcTaskQueue queue, SilcTask first) +void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd) { - SilcTask prev, task; + silc_schedule_set_listen_fd(schedule, fd, 0, FALSE); +} - prev = first->prev; +/*************************** Asynchronous Events ****************************/ - if (first == prev) - return first; +/* Add event */ - task = first; - while (1) { - if (first == prev) - break; +SilcTask silc_schedule_task_add_event(SilcSchedule schedule, + const char *event, ...) +{ + SilcEventTask task; + SilcSchedule parent; + + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return NULL; + } + } + + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); - if (silc_schedule_task_timeout_compare(&prev->timeout, &task->timeout)) - task = prev; + SILC_LOG_DEBUG(("Adding event '%s' to scheduler %p", event, parent)); - prev = prev->prev; + SILC_SCHEDULE_LOCK(parent); + + /* Create events hash table if not already done */ + if (!parent->events) { + parent->events = silc_hash_table_alloc(NULL, 3, + silc_hash_string, NULL, + silc_hash_string_compare, NULL, + NULL, NULL, FALSE); + if (!parent->events) { + SILC_SCHEDULE_UNLOCK(parent); + return NULL; + } } - return task; + /* Check if this event is added already */ + if (silc_hash_table_find(parent->events, (void *)event, NULL, NULL)) { + SILC_SCHEDULE_UNLOCK(parent); + return NULL; + } + + /* Add new event */ + task = silc_calloc(1, sizeof(*task)); + if (!task) { + SILC_SCHEDULE_UNLOCK(parent); + return NULL; + } + + task->header.type = SILC_TASK_EVENT; + task->header.valid = TRUE; + task->event = silc_strdup(event); + if (!task->event) { + SILC_SCHEDULE_UNLOCK(parent); + silc_free(task); + return NULL; + } + silc_list_init(task->connections, struct SilcScheduleEventConnectionStruct, + next); + + if (!silc_hash_table_add(parent->events, task->event, task)) { + SILC_SCHEDULE_UNLOCK(parent); + silc_free(task->event); + silc_free(task); + return NULL; + } + + SILC_SCHEDULE_UNLOCK(parent); + + return (SilcTask)task; } -/* Adds a timeout task into the task queue. This function is used by - silc_task_register function. Returns a pointer to the registered - task. Timeout tasks are sorted by their timeout value in ascending - order. The priority matters if there are more than one task with - same timeout. */ +/* Connect to event task */ -static SilcTask silc_task_add_timeout(SilcTaskQueue queue, SilcTask newtask, - SilcTaskPriority priority) +SilcBool silc_schedule_event_connect(SilcSchedule schedule, + const char *event, SilcTask task, + SilcTaskEventCallback callback, + void *context) { - SilcTask task, prev, next; - - /* Take the first task in the queue */ - task = queue->task; - - /* Take last task from the list */ - prev = task->prev; - - switch(priority) { - case SILC_TASK_PRI_LOW: - /* Lowest priority. The task is added at the end of the list. */ - while(prev != task) { - - /* If we have longer timeout than with the task head of us - we have found our spot. */ - if (silc_schedule_task_timeout_compare(&prev->timeout, - &newtask->timeout)) - break; + SilcSchedule parent; + SilcScheduleEventConnection conn; + SilcEventTask etask; + + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } - /* If we are equal size of timeout we will be after it. */ - if (!silc_schedule_task_timeout_compare(&newtask->timeout, - &prev->timeout)) - break; + if (!event && !task) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } - /* We have shorter timeout, compare to next one. */ - prev = prev->prev; - } - /* Found a spot from the list, add the task to the list. */ - next = prev->next; - newtask->prev = prev; - newtask->next = next; - prev->next = newtask; - next->prev = newtask; - - if (prev == task) { - /* Check if we are going to be the first task in the queue */ - if (silc_schedule_task_timeout_compare(&prev->timeout, - &newtask->timeout)) - break; - if (!silc_schedule_task_timeout_compare(&newtask->timeout, - &prev->timeout)) - break; + if (task && task->type != SILC_TASK_EVENT) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } - /* We are now the first task in queue */ - queue->task = newtask; - } - break; - case SILC_TASK_PRI_NORMAL: - /* Normal priority. The task is added before lower priority tasks - but after tasks with higher priority. */ - while(prev != task) { - - /* If we have longer timeout than with the task head of us - we have found our spot. */ - if (silc_schedule_task_timeout_compare(&prev->timeout, - &newtask->timeout)) - break; + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); - /* If we are equal size of timeout, priority kicks in place. */ - if (!silc_schedule_task_timeout_compare(&newtask->timeout, - &prev->timeout)) - if (prev->priority >= SILC_TASK_PRI_NORMAL) - break; + SILC_SCHEDULE_LOCK(parent); - /* We have shorter timeout or higher priority, compare to next one. */ - prev = prev->prev; + if (!task) { + /* Get the event task */ + if (!silc_hash_table_find(parent->events, (void *)event, NULL, + (void *)&task)) { + SILC_SCHEDULE_UNLOCK(parent); + return FALSE; } - /* Found a spot from the list, add the task to the list. */ - next = prev->next; - newtask->prev = prev; - newtask->next = next; - prev->next = newtask; - next->prev = newtask; - - if (prev == task) { - /* Check if we are going to be the first task in the queue */ - if (silc_schedule_task_timeout_compare(&prev->timeout, - &newtask->timeout)) - break; - if (!silc_schedule_task_timeout_compare(&newtask->timeout, - &prev->timeout)) - if (prev->priority >= SILC_TASK_PRI_NORMAL) - break; + } + etask = (SilcEventTask)task; + + /* See if task is deleted */ + if (task->valid == FALSE) { + SILC_SCHEDULE_UNLOCK(parent); + silc_set_errno(SILC_ERR_NOT_VALID); + return FALSE; + } + + SILC_LOG_DEBUG(("Connect callback %p with context %p to event '%s'", + callback, context, etask->event)); - /* We are now the first task in queue */ - queue->task = newtask; + /* See if already connected */ + silc_list_start(etask->connections); + while ((conn = silc_list_get(etask->connections))) { + if (conn->callback == callback && conn->context == context) { + SILC_SCHEDULE_UNLOCK(parent); + silc_set_errno(SILC_ERR_ALREADY_EXISTS); + return FALSE; } - break; - default: - silc_free(newtask); - return NULL; } - return newtask; + conn = silc_calloc(1, sizeof(*conn)); + if (!conn) { + SILC_SCHEDULE_UNLOCK(parent); + return FALSE; + } + + /* Connect to the event */ + conn->schedule = schedule; + conn->callback = callback; + conn->context = context; + silc_list_add(etask->connections, conn); + + SILC_SCHEDULE_UNLOCK(parent); + + return TRUE; } -/* Removes (unregisters) a task from particular task queue. This function - is used internally by scheduler. This must be called holding the - queue->lock. */ +/* Disconnect from event */ -static int silc_schedule_task_remove(SilcTaskQueue queue, SilcTask task) +SilcBool silc_schedule_event_disconnect(SilcSchedule schedule, + const char *event, SilcTask task, + SilcTaskEventCallback callback, + void *context) { - SilcTask first, old, next; + SilcSchedule parent; + SilcScheduleEventConnection conn; + SilcEventTask etask; + + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } - if (!queue || !task) + if (!event && !task) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); return FALSE; + } - if (!queue->task) { + if (task && task->type != SILC_TASK_EVENT) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); return FALSE; } - first = queue->task; + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); - /* Unregister all tasks in queue */ - if (task == SILC_ALL_TASKS) { - SILC_LOG_DEBUG(("Removing all tasks at once")); - next = first; + SILC_SCHEDULE_LOCK(parent); - while(1) { - next = next->next; - silc_free(next->prev); - if (next == first) - break; + if (!task) { + /* Get the event task */ + if (!silc_hash_table_find(parent->events, (void *)event, NULL, + (void *)&task)) { + SILC_SCHEDULE_UNLOCK(parent); + return FALSE; } + } + etask = (SilcEventTask)task; - queue->task = NULL; - return TRUE; + /* See if task is deleted */ + if (task->valid == FALSE) { + SILC_SCHEDULE_UNLOCK(parent); + silc_set_errno(SILC_ERR_NOT_VALID); + return FALSE; } - SILC_LOG_DEBUG(("Removing task")); - - /* Unregister the task */ - old = first; - while(1) { - if (old == task) { - SilcTask prev, next; - - prev = old->prev; - next = old->next; - prev->next = next; - next->prev = prev; - - if (prev == old && next == old) - queue->task = NULL; - if (queue->task == old) - queue->task = silc_task_get_first(queue, next); - - silc_free(old); + SILC_LOG_DEBUG(("Disconnect callback %p with context %p from event '%s'", + callback, context, etask->event)); + + /* Disconnect */ + silc_list_start(etask->connections); + while ((conn = silc_list_get(etask->connections))) { + if (conn->callback == callback && conn->context == context) { + silc_list_del(etask->connections, conn); + silc_free(conn); + SILC_SCHEDULE_UNLOCK(parent); return TRUE; } - old = old->prev; + } - if (old == first) { + SILC_SCHEDULE_UNLOCK(parent); + silc_set_errno(SILC_ERR_NOT_FOUND); + return FALSE; +} + +/* Signal event */ + +SilcBool silc_schedule_event_signal(SilcSchedule schedule, const char *event, + SilcTask task, ...) +{ + SilcSchedule parent; + SilcScheduleEventConnection conn; + SilcEventTask etask; + SilcBool stop; + va_list ap, cp; + + if (silc_unlikely(!schedule)) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); return FALSE; } } -} -/* Compare two time values. If the first argument is smaller than the - second this function returns TRUE. */ + if (silc_unlikely(!event && !task)) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } -static int silc_schedule_task_timeout_compare(struct timeval *smaller, - struct timeval *bigger) -{ - if ((smaller->tv_sec < bigger->tv_sec) || - ((smaller->tv_sec == bigger->tv_sec) && - (smaller->tv_usec < bigger->tv_usec))) - return TRUE; + if (silc_unlikely(task && task->type != SILC_TASK_EVENT)) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } - return FALSE; -} + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); -static void silc_task_del_by_fd(SilcTaskQueue queue, uint32 fd) -{ - SilcTask next; + SILC_SCHEDULE_LOCK(parent); - silc_mutex_lock(queue->lock); + if (!task) { + /* Get the event task */ + if (!silc_hash_table_find(parent->events, (void *)event, NULL, + (void *)&task)) { + SILC_SCHEDULE_UNLOCK(parent); + return FALSE; + } + } + etask = (SilcEventTask)task; - if (!queue->task) { - silc_mutex_unlock(queue->lock); - return; + /* See if task is deleted */ + if (task->valid == FALSE) { + SILC_SCHEDULE_UNLOCK(parent); + silc_set_errno(SILC_ERR_NOT_VALID); + return FALSE; } - next = queue->task; + SILC_LOG_DEBUG(("Signal event '%s'", etask->event)); + + va_start(ap, task); + + /* Deliver the signal */ + silc_list_start(etask->connections); + while ((conn = silc_list_get(etask->connections))) { + SILC_SCHEDULE_UNLOCK(parent); + + silc_va_copy(cp, ap); + stop = conn->callback(conn->schedule, conn->schedule->app_context, + task, conn->context, cp); + va_end(cp); - while(1) { - if (next->fd == fd) - next->valid = FALSE; - if (queue->task == next->next) + SILC_SCHEDULE_LOCK(parent); + + /* Stop signal if wanted or if the task was deleted */ + if (!stop || !task->valid) break; - next = next->next; } - silc_mutex_unlock(queue->lock); + va_end(ap); + + SILC_SCHEDULE_UNLOCK(parent); + + return TRUE; } -static void silc_task_del_by_callback(SilcTaskQueue queue, - SilcTaskCallback callback) +/* Delete event */ + +SilcBool silc_schedule_task_del_event(SilcSchedule schedule, const char *event) { - SilcTask next; + SilcSchedule parent; + SilcTask task; - silc_mutex_lock(queue->lock); + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } - if (!queue->task) { - silc_mutex_unlock(queue->lock); - return; + if (!event) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; } - next = queue->task; + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); - while(1) { - if (next->callback == callback) - next->valid = FALSE; - if (queue->task == next->next) - break; - next = next->next; + SILC_SCHEDULE_LOCK(parent); + + /* Get the event task */ + if (!silc_hash_table_find(parent->events, (void *)event, NULL, + (void *)&task)) { + SILC_SCHEDULE_UNLOCK(parent); + return FALSE; } - silc_mutex_unlock(queue->lock); -} + /* See if already deleted */ + if (task->valid == FALSE) + return TRUE; -static void silc_task_del_by_context(SilcTaskQueue queue, void *context) -{ - SilcTask next; + SILC_LOG_DEBUG(("Delete event '%s'", ((SilcEventTask)task)->event)); - silc_mutex_lock(queue->lock); + SILC_SCHEDULE_UNLOCK(parent); - if (!queue->task) { - silc_mutex_unlock(queue->lock); - return; - } + silc_schedule_task_del(parent, task); - next = queue->task; + return TRUE; +} - while(1) { - if (next->context == context) - next->valid = FALSE; - if (queue->task == next->next) - break; - next = next->next; - } +/* Timeout to remove deleted event task */ - silc_mutex_unlock(queue->lock); +SILC_TASK_CALLBACK(silc_schedule_event_del_timeout) +{ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_task_remove(schedule, context); + SILC_SCHEDULE_UNLOCK(schedule); }