X-Git-Url: http://git.silcnet.org/gitweb/?p=crypto.git;a=blobdiff_plain;f=lib%2Fsilcutil%2Fsilcschedule.c;h=5550181a7da686d070e2103a6a1d8ac33140e9dd;hp=2e546ee8576a6ee919bf97e9902268c3431a14d9;hb=60180da59ffdbbd12058dded66e3c8a547cd0852;hpb=f7b43bc4069a1e411da37f5bf2c0819cd87987d7 diff --git a/lib/silcutil/silcschedule.c b/lib/silcutil/silcschedule.c index 2e546ee8..5550181a 100644 --- a/lib/silcutil/silcschedule.c +++ b/lib/silcutil/silcschedule.c @@ -4,7 +4,7 @@ Author: Pekka Riikonen - Copyright (C) 1998 - 2006 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 @@ -22,6 +22,14 @@ /************************** Types and definitions ***************************/ +/* Connected event context */ +typedef struct SilcScheduleEventConnectionStruct { + SilcSchedule schedule; + SilcTaskEventCallback callback; + void *context; + struct SilcScheduleEventConnectionStruct *next; +} *SilcScheduleEventConnection; + /* Platform specific implementation */ extern const SilcScheduleOps schedule_ops; @@ -29,7 +37,7 @@ 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); /************************ Static utility functions **************************/ @@ -106,7 +114,7 @@ static void silc_schedule_dispatch_timeout(SilcSchedule schedule, } /* Execute the task if the timeout has expired */ - if (!silc_compare_timeval(&task->timeout, &curtime) && !dispatch_all) + if (silc_compare_timeval(&task->timeout, &curtime) > 0 && !dispatch_all) break; t->valid = FALSE; @@ -155,7 +163,7 @@ static void silc_schedule_select_timeout(SilcSchedule schedule) /* 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) && dispatch) { + if (silc_compare_timeval(&task->timeout, &curtime) <= 0 && dispatch) { silc_schedule_dispatch_timeout(schedule, FALSE); if (silc_unlikely(!schedule->valid)) return; @@ -196,17 +204,18 @@ static void silc_schedule_select_timeout(SilcSchedule schedule) static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task) { - SilcTaskFd ftask; + SilcSchedule parent; if (silc_unlikely(task == SILC_ALL_TASKS)) { SilcTask task; + SilcEventTask etask; SilcHashTableList htl; - SilcUInt32 fd; + void *fd; /* Delete from fd queue */ silc_hash_table_list(schedule->fd_queue, &htl); - while (silc_hash_table_get(&htl, (void **)&fd, (void **)&task)) - silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(fd)); + 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 */ @@ -216,19 +225,59 @@ static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask 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; } - if (silc_likely(task->type == 1)) { - /* Delete from timeout queue */ - silc_list_del(schedule->timeout_queue, task); + 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; - /* Put to free list */ - silc_list_add(schedule->free_tasks, task); - } else { - /* Delete from fd queue */ - ftask = (SilcTaskFd)task; - silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd)); + 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; } } @@ -290,14 +339,14 @@ void silc_schedule_stats(SilcSchedule schedule) { SilcTaskFd ftask; fprintf(stdout, "Schedule %p statistics:\n\n", schedule); - fprintf(stdout, "Num FD tasks : %lu (%lu bytes allocated)\n", + 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 (%d bytes allocated)\n", + 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 (%d bytes allocated)\n", + 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)); @@ -312,34 +361,58 @@ void silc_schedule_stats(SilcSchedule schedule) scheduler can handle. The `app_context' is application specific context that is delivered to task callbacks. */ -SilcSchedule silc_schedule_init(int max_tasks, void *app_context) +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; + SILC_LOG_DEBUG(("Initializing scheduler %p", schedule)); + + /* Allocate Fd task hash table dynamically */ schedule->fd_queue = - silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL, + silc_hash_table_alloc(NULL, 0, silc_hash_uint, NULL, NULL, NULL, silc_schedule_fd_destructor, NULL, TRUE); - if (!schedule->fd_queue) + if (!schedule->fd_queue) { + silc_stack_free(stack); return 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 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, @@ -357,7 +430,9 @@ SilcBool silc_schedule_uninit(SilcSchedule schedule) { SilcTask task; - SILC_LOG_DEBUG(("Uninitializing scheduler")); + SILC_VERIFY(schedule); + + SILC_LOG_DEBUG(("Uninitializing scheduler %p", schedule)); if (schedule->valid == TRUE) return FALSE; @@ -389,7 +464,7 @@ SilcBool silc_schedule_uninit(SilcSchedule schedule) schedule_ops.uninit(schedule, schedule->internal); silc_mutex_free(schedule->lock); - silc_free(schedule); + silc_stack_free(schedule->stack); return TRUE; } @@ -401,6 +476,7 @@ SilcBool silc_schedule_uninit(SilcSchedule schedule) void silc_schedule_stop(SilcSchedule schedule) { SILC_LOG_DEBUG(("Stopping scheduler")); + SILC_VERIFY(schedule); SILC_SCHEDULE_LOCK(schedule); schedule->valid = FALSE; SILC_SCHEDULE_UNLOCK(schedule); @@ -465,12 +541,20 @@ static SilcBool silc_schedule_iterate(SilcSchedule schedule, int timeout_usecs) /* There is some data available now */ SILC_LOG_DEBUG(("Running fd tasks")); silc_schedule_dispatch_fd(schedule); + + /* 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 */ - if (silc_likely(errno == EINTR)) + /* Error or special case handling */ + if (errno == EINTR) continue; + if (ret == -2) + break; + SILC_LOG_ERROR(("Error in select()/poll(): %s", strerror(errno))); continue; } @@ -493,6 +577,7 @@ SilcBool silc_schedule_one(SilcSchedule schedule, int timeout_usecs) /* Runs the scheduler and blocks here. When this returns the scheduler has ended. */ +#ifndef SILC_SYMBIAN void silc_schedule(SilcSchedule schedule) { SILC_LOG_DEBUG(("Running scheduler")); @@ -502,6 +587,7 @@ void silc_schedule(SilcSchedule schedule) silc_schedule_iterate(schedule, -1); SILC_SCHEDULE_UNLOCK(schedule); } +#endif /* !SILC_SYMBIAN */ /* Wakes up the scheduler. This is used only in multi-threaded environments where threads may add new tasks or remove old tasks @@ -520,6 +606,13 @@ void silc_schedule_wakeup(SilcSchedule schedule) #endif } +/* Returns parent scheduler */ + +SilcSchedule silc_schedule_get_parent(SilcSchedule schedule) +{ + return schedule->parent ? schedule->parent : schedule; +} + /* 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 @@ -530,6 +623,55 @@ void *silc_schedule_get_context(SilcSchedule schedule) return schedule->app_context; } +/* Return the stack of the scheduler */ + +SilcStack silc_schedule_get_stack(SilcSchedule schedule) +{ + return schedule->stack; +} + +/* Set notify callback */ + +void silc_schedule_set_notify(SilcSchedule schedule, + SilcTaskNotifyCb notify, void *context) +{ + schedule->notify = notify; + schedule->notify_context = context; +} + +/* Set global scheduler */ + +void silc_schedule_set_global(SilcSchedule schedule) +{ + SilcTls tls = silc_thread_get_tls(); + + if (!tls) { + /* Try to initialize Tls */ + tls = silc_thread_tls_init(); + SILC_VERIFY(tls); + if (!tls) + return; + } + + SILC_LOG_DEBUG(("Setting global scheduler %p", schedule)); + + tls->schedule = schedule; +} + +/* Return global scheduler */ + +SilcSchedule silc_schedule_get_global(void) +{ + SilcTls tls = silc_thread_get_tls(); + + if (!tls) + return NULL; + + SILC_LOG_DEBUG(("Return global scheduler %p", tls->schedule)); + + return tls->schedule; +} + /* Add new task to the scheduler */ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, @@ -539,8 +681,19 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, { SilcTask task = NULL; - if (silc_unlikely(!schedule->valid)) + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return NULL; + } + } + + if (silc_unlikely(!schedule->valid)) { + silc_set_errno(SILC_ERR_NOT_VALID); return NULL; + } SILC_SCHEDULE_LOCK(schedule); @@ -554,8 +707,8 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, ttask = silc_calloc(1, sizeof(*ttask)); if (silc_unlikely(!ttask)) goto out; - } - silc_list_del(schedule->free_tasks, ttask); + } else + silc_list_del(schedule->free_tasks, ttask); ttask->header.type = 1; ttask->header.callback = callback; @@ -583,7 +736,7 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, 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)) { + if (silc_compare_timeval(&ttask->timeout, &tmp->timeout) < 0) { silc_list_insert(schedule->timeout_queue, prev, ttask); break; } @@ -594,24 +747,40 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, task = (SilcTask)ttask; + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, TRUE, task, FALSE, 0, 0, seconds, useconds, + schedule->notify_context); + } else if (silc_likely(type == SILC_TASK_FD)) { + SilcTaskFd ftask; + /* Check if fd is already added */ if (silc_unlikely(silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), - NULL, (void **)&task))) - goto out; + 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); + } /* 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; } - SilcTaskFd ftask = silc_calloc(1, sizeof(*ftask)); - if (silc_unlikely(!ftask)) + ftask = silc_calloc(1, sizeof(*ftask)); + if (silc_unlikely(!ftask)) { + task = NULL; goto out; + } SILC_LOG_DEBUG(("New fd task %p fd=%d", ftask, fd)); @@ -622,11 +791,26 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, ftask->events = SILC_TASK_READ; ftask->fd = fd; - /* Add task */ - silc_hash_table_add(schedule->fd_queue, SILC_32_TO_PTR(fd), ftask); + /* 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, @@ -636,13 +820,33 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, out: SILC_SCHEDULE_UNLOCK(schedule); + +#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 task; } /* Invalidates task */ -void silc_schedule_task_del(SilcSchedule schedule, SilcTask task) +SilcBool silc_schedule_task_del(SilcSchedule schedule, SilcTask task) { + SilcSchedule parent; + + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } + if (silc_unlikely(task == SILC_ALL_TASKS)) { SilcHashTableList htl; @@ -652,67 +856,143 @@ void silc_schedule_task_del(SilcSchedule schedule, SilcTask task) /* Delete from fd queue */ silc_hash_table_list(schedule->fd_queue, &htl); - while (silc_hash_table_get(&htl, NULL, (void **)&task)) + 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); /* Delete from timeout queue */ silc_list_start(schedule->timeout_queue); - while ((task = (SilcTask)silc_list_get(schedule->timeout_queue)) - != SILC_LIST_END) + while ((task = (SilcTask)silc_list_get(schedule->timeout_queue))) { + task->valid = FALSE; + + /* Call notify callback */ + if (schedule->notify) + schedule->notify(schedule, FALSE, task, FALSE, 0, 0, 0, 0, + schedule->notify_context); + } + + /* 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); SILC_SCHEDULE_UNLOCK(schedule); - return; + return TRUE; } - SILC_LOG_DEBUG(("Unregistering task %p", task)); + 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; } /* Invalidate task by fd */ -void silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 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)); + 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))) + (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)) + 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; } /* 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")); + 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) + 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); @@ -720,30 +1000,61 @@ void silc_schedule_task_del_by_callback(SilcSchedule schedule, list = schedule->timeout_queue; silc_list_start(list); while ((task = (SilcTask)silc_list_get(list))) { - if (task->callback == callback) + 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; } /* 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")); + 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->context == context) + 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); @@ -751,26 +1062,49 @@ void silc_schedule_task_del_by_context(SilcSchedule schedule, void *context) list = schedule->timeout_queue; silc_list_start(list); while ((task = (SilcTask)silc_list_get(list))) { - if (task->context == context) + 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; + } } SILC_SCHEDULE_UNLOCK(schedule); + + if (ret == FALSE) + silc_set_errno(SILC_ERR_NOT_FOUND); + + return ret; } /* Invalidate task by all */ -void silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, - SilcTaskCallback callback, void *context) +SilcBool silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, + SilcTaskCallback callback, + void *context) { SilcTask task; SilcList list; + SilcBool ret = FALSE; SILC_LOG_DEBUG(("Unregister task by fd, callback and context")); /* For fd task, callback and context is irrelevant as fd is unique */ if (fd) - silc_schedule_task_del_by_fd(schedule, fd); + return silc_schedule_task_del_by_fd(schedule, 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); @@ -778,41 +1112,75 @@ void silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, list = schedule->timeout_queue; silc_list_start(list); while ((task = (SilcTask)silc_list_get(list))) { - if (task->callback == callback && task->context == context) + if (task->callback == callback && 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; + } } SILC_SCHEDULE_UNLOCK(schedule); + + if (ret == FALSE) + silc_set_errno(SILC_ERR_NOT_FOUND); + + return TRUE; } /* 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. */ -void silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, - SilcTaskEvent mask, SilcBool send_events) +SilcBool silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskEvent mask, SilcBool send_events) { SilcTaskFd task; - if (silc_unlikely(!schedule->valid)) - return; + 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; + } SILC_SCHEDULE_LOCK(schedule); if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), - NULL, (void **)&task)) { + NULL, (void *)&task)) { + if (!schedule_ops.schedule_fd(schedule, schedule->internal, task, mask)) { + SILC_SCHEDULE_UNLOCK(schedule); + return FALSE; + } task->events = mask; - schedule_ops.schedule_fd(schedule, schedule->internal, task, 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); } SILC_SCHEDULE_UNLOCK(schedule); + + return TRUE; } -/* Returns the file descriptors current requested event mask. */ +/* Returns the file descriptor's current requested event mask. */ SilcTaskEvent silc_schedule_get_fd_events(SilcSchedule schedule, SilcUInt32 fd) @@ -820,12 +1188,23 @@ SilcTaskEvent silc_schedule_get_fd_events(SilcSchedule schedule, SilcTaskFd task; SilcTaskEvent event = 0; - if (silc_unlikely(!schedule->valid)) + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return 0; + } + } + + 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)) + NULL, (void *)&task)) event = task->events; SILC_SCHEDULE_UNLOCK(schedule); @@ -838,3 +1217,365 @@ void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd) { silc_schedule_set_listen_fd(schedule, fd, 0, FALSE); } + +/*************************** Asynchronous Events ****************************/ + +/* Add event */ + +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); + + SILC_LOG_DEBUG(("Adding event '%s' to scheduler %p", event, parent)); + + 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; + } + } + + /* 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; +} + +/* Connect to event task */ + +SilcBool silc_schedule_event_connect(SilcSchedule schedule, + const char *event, SilcTask task, + SilcTaskEventCallback callback, + void *context) +{ + 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 (!event && !task) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + + if (task && task->type != SILC_TASK_EVENT) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); + + SILC_SCHEDULE_LOCK(parent); + + 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; + + /* 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)); + + /* 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; + } + } + + 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; +} + +/* Disconnect from event */ + +SilcBool silc_schedule_event_disconnect(SilcSchedule schedule, + const char *event, SilcTask task, + SilcTaskEventCallback callback, + void *context) +{ + 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 (!event && !task) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + + if (task && task->type != SILC_TASK_EVENT) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); + + SILC_SCHEDULE_LOCK(parent); + + 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; + + /* 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(("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; + } + } + + 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; + } + } + + if (silc_unlikely(!event && !task)) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + + if (silc_unlikely(task && task->type != SILC_TASK_EVENT)) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); + + SILC_SCHEDULE_LOCK(parent); + + 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; + + /* 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(("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); + + SILC_SCHEDULE_LOCK(parent); + + /* Stop signal if wanted or if the task was deleted */ + if (!stop || !task->valid) + break; + } + + va_end(ap); + + SILC_SCHEDULE_UNLOCK(parent); + + return TRUE; +} + +/* Delete event */ + +SilcBool silc_schedule_task_del_event(SilcSchedule schedule, const char *event) +{ + SilcSchedule parent; + SilcTask task; + + if (!schedule) { + schedule = silc_schedule_get_global(); + SILC_VERIFY(schedule); + if (!schedule) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + } + + if (!event) { + silc_set_errno(SILC_ERR_INVALID_ARGUMENT); + return FALSE; + } + + /* Get parent scheduler */ + parent = silc_schedule_get_parent(schedule); + + 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; + } + + /* See if already deleted */ + if (task->valid == FALSE) + return TRUE; + + SILC_LOG_DEBUG(("Delete event '%s'", ((SilcEventTask)task)->event)); + + SILC_SCHEDULE_UNLOCK(parent); + + silc_schedule_task_del(parent, task); + + return TRUE; +} + +/* Timeout to remove deleted event task */ + +SILC_TASK_CALLBACK(silc_schedule_event_del_timeout) +{ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_task_remove(schedule, context); + SILC_SCHEDULE_UNLOCK(schedule); +}