X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fsilcschedule.h;h=0e1a6e83ffba0115ebc417e310785751ba3bdd60;hb=40f8443d8d3a6577336ee66d18e04d9ac4d956bb;hp=19c384684e35f8c52b0f53f210b9a33794e98a5f;hpb=318d79b391bf6288e3e28c840217a7097f3d0392;p=silc.git diff --git a/lib/silcutil/silcschedule.h b/lib/silcutil/silcschedule.h index 19c38468..0e1a6e83 100644 --- a/lib/silcutil/silcschedule.h +++ b/lib/silcutil/silcschedule.h @@ -2,15 +2,14 @@ silcschedule.h - Author: Pekka Riikonen + Author: Pekka Riikonen - Copyright (C) 1998 - 2000 Pekka Riikonen + Copyright (C) 1998 - 2005 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 @@ -18,106 +17,643 @@ */ +/****h* silcutil/SILC Schedule Interface + * + * DESCRIPTION + * + * The SILC Scheduler is the heart of any application. The scheduler provides + * the application's main loop that can handle incoming data, outgoing data, + * timeouts and dispatch different kind of tasks. + * + * The SILC Scheduler supports file descriptor based tasks and timeout tasks. + * File descriptor tasks are tasks that perform some operation over the + * specified file descriptor. These include network connections, for example. + * The timeout tasks are timeouts that are executed after the specified + * timeout has elapsed. + * + * The SILC Scheduler is designed to be the sole main loop of the application + * so that the application does not need any other main loop. However, + * SILC Scheduler does support running the scheduler only once, so that the + * scheduler does not block, and thus providing a possiblity that some + * external main loop is run over the SILC Scheduler. + * + * Typical application first initializes the scheduler and then registers + * the very first tasks to the scheduler and then run the scheduler. After + * the scheduler's run function returns the application is considered to be + * ended. + * + * On WIN32 systems the SILC Scheduler is too designed to work as the main + * loop of the GUI application. It can handle all Windows messages and + * it dispatches them from the scheduler, and thus makes it possible to + * create GUI applications. The scheduler can also handle all kinds of + * WIN32 handles, this includes sockets created by the SILC Net API routines, + * WSAEVENT handle objects created by Winsock2 routines and arbitrary + * WIN32 HANDLE objects. + * + * The SILC Scheduler supports multi-threads as well. The actual scheduler + * must be run in single-thread but other threads may register new tasks + * and unregister old tasks. However, it is enforced that the actual + * task is always run in the main thread. The scheduler is context based + * which makes it possible to allocate several schedulers for one application. + * Since the scheduler must be run in single-thread, a multi-threaded + * application could be created by allocating own scheduler for each of the + * worker threads. + * + ***/ + #ifndef SILCSCHEDULE_H #define SILCSCHEDULE_H -/* Structure holding list of file descriptors, scheduler is supposed to - be listenning. The max_fd field is the maximum number of possible file - descriptors in the list. This value is set at the initialization - of the scheduler and it usually is the maximum number of connections - allowed. */ -typedef struct { - int *fd; - unsigned int last_fd; - unsigned int max_fd; -} SilcScheduleFdList; +/****s* silcutil/SilcScheduleAPI/SilcSchedule + * + * NAME + * + * typedef struct SilcScheduleStruct *SilcSchedule; + * + * DESCRIPTION + * + * This context is the actual Scheduler and is allocated by + * the silc_schedule_init funtion. The context is given as argument + * to all silc_schedule_* functions. It must be freed by the + * silc_schedule_uninit function. + * + ***/ +typedef struct SilcScheduleStruct *SilcSchedule; + +/****s* silcutil/SilcScheduleAPI/SilcTask + * + * NAME + * + * typedef struct SilcTaskStruct *SilcTask; + * + * DESCRIPTION + * + * This object represents one task in the scheduler. It is allocated + * by the silc_schedule_task_add function and freed by one of the + * silc_schedule_task_del* functions. + * + ***/ +typedef struct SilcTaskStruct *SilcTask; -/* - Silc Schedule object. +/****d* silcutil/SilcScheduleAPI/SilcTaskType + * + * NAME + * + * typedef enum { ... } SilcTaskType; + * + * DESCRIPTION + * + * SILC has two types of tasks, non-timeout tasks (tasks that perform + * over file descriptors), and timeout tasks. This type is sent as + * argument for the task registering function, silc_schedule_task_add. + * + * SOURCE + */ +typedef enum { + /* File descriptor task that performs some event over file descriptors. + These tasks are for example network connections. */ + SILC_TASK_FD = 0, - 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. + /* Timeout tasks are tasks that are executed after the specified + time has elapsed. After the task is executed the task is removed + automatically from the scheduler. It is safe to re-register the + task in task callback. It is also safe to unregister a task in + the task callback. */ + SILC_TASK_TIMEOUT, +} SilcTaskType; +/***/ - Following short description of the fields: +/****d* silcutil/SilcScheduleAPI/SilcTaskEvent + * + * NAME + * + * typedef enum { ... } SilcTaskEvent; + * + * DESCRIPTION + * + * SILC Task event types. The event type indicates the occurred + * event of the task. This type will be given as argument to the + * SilcTaskCallback function to indicate the event for the caller. + * The SILC_TASK_READ and SILC_TASK_WRITE may be set by the caller + * of the silc_schedule_set_listen_fd, if the caller needs to control + * the events for the task. The SILC_TASK_EXPIRE is set always only + * by the scheduler when timeout expires for timeout task. The + * SILC_TASK_INTERRUPT is set for signal callback. + * + * SOURCE + */ +typedef enum { + SILC_TASK_READ = 0x0001, /* Reading */ + SILC_TASK_WRITE = 0x0002, /* Writing */ + SILC_TASK_EXPIRE = 0x0004, /* Timeout */ + SILC_TASK_INTERRUPT = 0x0008, /* Signal */ +} SilcTaskEvent; +/***/ - SilcTaskQueue fd_queue +/****f* silcutil/SilcScheduleAPI/SilcTaskCallback + * + * SYNOPSIS + * + * typedef void (*SilcTaskCallback)(SilcSchedule schedule, + * void *app_context, + * SilcTaskEvent type, SilcUInt32 fd, + * void *context); + * + * DESCRIPTION + * + * The task callback function. This function will be called by the + * scheduler when some event of the task is performed. For example, + * when data is available from the connection this will be called. + * + * The `schedule' is the scheduler context, the `type' is the indicated + * event, the `fd' is the file descriptor of the task and the `context' + * is a caller specified context. If multiple events occurred this + * callback is called separately for all events. The `app_context' + * is application specific context that was given as argument to the + * silc_schedule_init function. If the task is timeout task then `fd' + * is zero (0). + * + * To specify task callback function in the application using the + * SILC_TASK_CALLBACK macro is recommended. + * + ***/ +typedef void (*SilcTaskCallback)(SilcSchedule schedule, void *app_context, + SilcTaskEvent type, SilcUInt32 fd, + void *context); - 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. +/* Macros */ - SilcTaskQueue timeout_queue +/****d* silcutil/SilcScheduleAPI/SILC_ALL_TASKS + * + * NAME + * + * #define SILC_ALL_TASKS ... + * + * DESCRIPTION + * + * Marks for all tasks in the scheduler. This can be passed to + * silc_schedule_task_del function to delete all tasks at once. + * + * SOURCE + */ +#define SILC_ALL_TASKS ((SilcTask)1) +/***/ - 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. +/****d* silcutil/SilcScheduleAPI/SILC_TASK_CALLBACK + * + * NAME + * + * #define SILC_TASK_CALLBACK ... + * + * DESCRIPTION + * + * Generic macro to define task callback functions. This defines a + * static function with name `func' as a task callback function. + * + * SOURCE + */ +#define SILC_TASK_CALLBACK(func) \ +void func(SilcSchedule schedule, void *app_context, SilcTaskEvent type, \ + SilcUInt32 fd, void *context) +/***/ - SilcTaskQueue generic_queue +/* Prototypes */ - 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. +/****f* silcutil/SilcScheduleAPI/silc_schedule_init + * + * SYNOPSIS + * + * SilcSchedule silc_schedule_init(int max_tasks, void *app_context); + * + * DESCRIPTION + * + * Initializes the scheduler. This returns the scheduler context that + * is given as argument usually to all silc_schedule_* functions. + * The `app_context' is application specific context that is delivered + * to all task callbacks. The caller must free that context. The + * 'app_context' can be for example the application itself. + * + * The `max_tasks' is the maximum number of SILC_TASK_FD tasks in the + * scheduler. Set value to 0 to use default. Operating system will + * enforce the final limit. On some operating systems the limit can + * be significantly increased when this function is called in priviliged + * mode (as super user). + * + ***/ +SilcSchedule silc_schedule_init(int max_tasks, void *app_context); - SilcScheduleFdList fd_list +/****f* silcutil/SilcScheduleAPI/silc_schedule_uninit + * + * SYNOPSIS + * + * SilcBool silc_schedule_uninit(SilcSchedule schedule); + * + * DESCRIPTION + * + * Uninitializes the scheduler. This is called when the program is ready + * to end. This removes all tasks from the scheduler. Returns FALSE if the + * scheduler could not be uninitialized. This happens when the scheduler + * is still valid and silc_schedule_stop has not been called. + * + ***/ +SilcBool silc_schedule_uninit(SilcSchedule schedule); - List of file descriptors the scheduler is supposed to be listenning. - This is updated internally. +/****f* silcutil/SilcScheduleAPI/silc_schedule_stop + * + * SYNOPSIS + * + * void silc_schedule_stop(SilcSchedule schedule); + * + * DESCRIPTION + * + * Stops the scheduler even if it is not supposed to be stopped yet. + * After calling this, one must call silc_schedule_uninit (after the + * silc_schedule has returned). After this is called it is guaranteed + * that next time the scheduler enters the main loop it will be stopped. + * However, untill it enters the main loop it will not detect that + * it is stopped for example if this is called from another thread. + * + ***/ +void silc_schedule_stop(SilcSchedule schedule); - struct timeval *timeout; +/****f* silcutil/SilcScheduleAPI/silc_schedule + * + * SYNOPSIS + * + * void silc_schedule(SilcSchedule schedule); + * + * DESCRIPTION + * + * The SILC scheduler. The program will run inside this function. + * When this returns the program is to be ended. Before this function can + * be called, one must call silc_schedule_init function. + * + ***/ +void silc_schedule(SilcSchedule schedule); - Pointer to the schedules next timeout. Value of this timeout is - automatically updated in the silc_schedule function. +/****f* silcutil/SilcScheduleAPI/silc_schedule_one + * + * SYNOPSIS + * + * SilcBool silc_schedule_one(SilcSchedule schedule, int block); + * + * DESCRIPTION + * + * Same as the silc_schedule but runs the scheduler only one round + * and then returns. This function is handy when the SILC scheduler + * is used inside some other external scheduler, for example. If + * the `timeout_usecs' is non-negative a timeout will be added to the + * scheduler. The function will not return in this timeout unless + * some other event occurs. + * + ***/ +SilcBool silc_schedule_one(SilcSchedule schedule, int timeout_usecs); - int valid +/****f* silcutil/SilcScheduleAPI/silc_schedule_wakeup + * + * SYNOPSIS + * + * void silc_schedule_wakeup(SilcSchedule schedule); + * + * DESCRIPTION + * + * Wakes up the scheduler. This is used only in multi-threaded + * environments where threads may add new tasks or remove old tasks + * from the scheduler. This is called to wake up the scheduler in the + * main thread so that it detects the changes in the scheduler. + * If threads support is not compiled in this function has no effect. + * Implementation of this function may be platform specific. + * + ***/ +void silc_schedule_wakeup(SilcSchedule schedule); - 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. +/****f* silcutil/SilcScheduleAPI/silc_schedule_get_context + * + * SYNOPSIS + * + * void *silc_schedule_get_context(SilcSchedule schedule); + * + * DESCRIPTION + * + * 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. + * + ***/ +void *silc_schedule_get_context(SilcSchedule schedule); - fd_set in - fd_set out +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_add + * + * SYNOPSIS + * + * SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, + * SilcTaskCallback callback, + * void *context, + * long seconds, long useconds, + * SilcTaskType type); + * + * DESCRIPTION + * + * Registers a new task to the scheduler. This same function is used + * to register all types of tasks. The `type' argument tells what type + * of the task is. Note that when registering non-timeout (fd) tasks one + * should also pass 0 as timeout, as the timeout will be ignored anyway. + * Also, note, that one cannot register timeout task with 0 timeout. + * There cannot be zero timeouts, passing zero means no timeout is used + * for the task and SILC_TASK_FD is used as default task type in + * this case. + * + * The `schedule' is the scheduler context. The `fd' is the file + * descriptor of the task. On WIN32 systems the `fd' is not actual + * file descriptor but some WIN32 event handle. On WIN32 system the `fd' + * may be a socket created by the SILC Net API routines, WSAEVENT object + * created by Winsock2 network routines or arbitrary WIN32 HANDLE object. + * On Unix systems the `fd' is always the real file descriptor. The + * same `fd' can be added only once. + * + * The `callback' is the task callback that will be called when some + * event occurs for this task. The `context' is sent as argument to + * the task `callback' function. For timeout tasks the callback is + * called after the specified timeout has elapsed. + * + * If the `type' is SILC_TASK_TIMEOUT then `seconds' and `useconds' + * may be non-zero. Otherwise they should be zero. + * + * It is always safe to call this function in any place. New tasks + * may be added also in task callbacks, and in multi-threaded environment + * in other threads as well. + * + ***/ +SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskCallback callback, void *context, + long seconds, long useconds, + SilcTaskType type); - File descriptor sets for select(). These are automatically managed - by the scheduler and should not be touched otherwise. +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_add_fd + * + * SYNOPSIS + * + * SilcTask + * silc_schedule_task_add_fd(SilcSchedule schedule, SilcUInt32 fd, + * SilcTaskCallback callback, void *context); + * + * DESCRIPTION + * + * A convenience function to add fd task. You may use this if you + * don't want to use the silc_schedule_task_add function to add fd task. + * + ***/ +#define silc_schedule_task_add_fd(schedule, fd, callback, context) \ + silc_schedule_task_add(schedule, fd, callback, context, 0, 0, SILC_TASK_FD) - int max_fd +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_add_timeout + * + * SYNOPSIS + * + * SilcTask + * silc_schedule_task_add_timeout(SilcSchedule schedule, + * SilcTaskCallback callback, void *context, + * long seconds, long useconds); + * + * DESCRIPTION + * + * A convenience function to add timeout task. You may use this if + * you don't want to use the silc_schedule_task_add function to add + * timeout task. + * + ***/ +#define silc_schedule_task_add_timeout(schedule, callback, context, s, u) \ + silc_schedule_task_add(schedule, 0, callback, context, s, u, \ + SILC_TASK_TIMEOUT) - Number of maximum file descriptors for select(). This, as well, is - managed automatically by the scheduler and should be considered to - be read-only field otherwise. +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_del + * + * SYNOPSIS + * + * void silc_schedule_task_del(SilcSchedule schedule, SilcTask task); + * + * DESCRIPTION + * + * Deletes the `task' from the scheduler indicated by the `schedule'. + * After deleting the task it is guaranteed that the task callback + * will not be called. If the `task' is SILC_ALL_TASKS then all + * tasks is removed from the scheduler. + * + * It is safe to call this function in any place. Tasks may be removed + * in task callbacks (including in the task's own task callback) and + * in multi-threaded environment in other threads as well. + * + ***/ +void silc_schedule_task_del(SilcSchedule schedule, SilcTask task); -*/ +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_del_by_fd + * + * SYNOPSIS + * + * void silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd); + * + * DESCRIPTION + * + * Deletes a task from the scheduler by the specified `fd'. + * + * It is safe to call this function in any place. Tasks may be removed + * in task callbacks (including in the task's own task callback) and + * in multi-threaded environment in other threads as well. + * + ***/ +void silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd); -typedef struct { - SilcTaskQueue fd_queue; - SilcTaskQueue timeout_queue; - SilcTaskQueue generic_queue; - SilcScheduleFdList fd_list; - struct timeval *timeout; - int valid; - fd_set in; - fd_set out; - int max_fd; -} SilcScheduleObject; +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_del_by_callback + * + * SYNOPSIS + * + * void silc_schedule_task_del_by_callback(SilcSchedule schedule, + * SilcTaskCallback callback); + * + * DESCRIPTION + * + * Deletes a task from the scheduler by the specified `callback' task + * callback function. + * + * It is safe to call this function in any place. Tasks may be removed + * in task callbacks (including in the task's own task callback) and + * in multi-threaded environment in other threads as well. + * + ***/ +void silc_schedule_task_del_by_callback(SilcSchedule schedule, + SilcTaskCallback callback); -typedef SilcScheduleObject SilcSchedule; +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_del_by_context + * + * SYNOPSIS + * + * void silc_schedule_task_del_by_context(SilcSchedule schedule, + * void *context); + * + * DESCRIPTION + * + * Deletes a task from the scheduler by the specified `context'. + * + * It is safe to call this function in any place. Tasks may be removed + * in task callbacks (including in the task's own task callback) and + * in multi-threaded environment in other threads as well. + * + ***/ +void silc_schedule_task_del_by_context(SilcSchedule schedule, void *context); -/* Prototypes */ -void silc_schedule_init(SilcTaskQueue *fd_queue, - SilcTaskQueue *timeout_queue, - SilcTaskQueue *generic_queue, - int max_fd); -int silc_schedule_uninit(); -void silc_schedule_stop(); -void silc_schedule_set_listen_fd(int fd, unsigned int iomask); -void silc_schedule_unset_listen_fd(int fd); -void silc_schedule(); +/****f* silcutil/SilcScheduleAPI/silc_schedule_task_del_by_all + * + * SYNOPSIS + * + * void silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, + * SilcTaskCallback callback, + * void *context); + * + * DESCRIPTION + * + * Deletes a task from the scheduler by the specified `fd', `callback' + * and `context'. + * + * It is safe to call this function in any place. Tasks may be removed + * in task callbacks (including in the task's own task callback) and + * in multi-threaded environment in other threads as well. + * + ***/ +void silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, + SilcTaskCallback callback, void *context); + +/****f* silcutil/SilcScheduleAPI/silc_schedule_set_listen_fd + * + * SYNOPSIS + * + * void silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, + * SilcTaskEvent mask, SilcBool send_events); + * + * DESCRIPTION + * + * Sets a file descriptor `fd' to be listened by the scheduler for + * `mask' events. To tell scheduler not to listen anymore for this + * file descriptor call the silc_schedule_unset_listen_fd function. + * When new task is created with silc_schedule_task_add the event + * for the task's fd is initially set to SILC_TASK_READ. If you need + * to control the task's fd's events you must call this function + * whenever you need to change the events. This can be called multiple + * times to change the events. + * + * If the `send_events' is TRUE then this function sends the events + * in `mask' to the application. If FALSE then they are sent only + * after the event occurs in reality. In normal cases the `send_events' + * is set to FALSE. + * + ***/ +void silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskEvent mask, SilcBool send_events); + +/****f* silcutil/SilcScheduleAPI/silc_schedule_unset_listen_fd + * + * SYNOPSIS + * + * void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd); + * + * DESCRIPTION + * + * Tells the scheduler not to listen anymore for the specified + * file descriptor `fd'. No events will be detected for the `fd' + * after calling this function. + * + ***/ +void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd); + +/****f* silcutil/SilcScheduleAPI/silc_schedule_signal_register + * + * SYNOPSIS + * + * void silc_schedule_signal_register(SilcSchedule schedule, + * SilcUInt32 signal, + * SilcTaskCallback callback, + * void *context); + * + * DESCRIPTION + * + * Register signal indicated by `signal' to the scheduler. Application + * should register all signals it is going to use to the scheduler. + * The `callback' with `context' will be called after the application + * has called silc_schedule_signal_call function in the real signal + * callback. Application is responsible of calling that, and the + * signal system will not work without calling silc_schedule_signal_call + * function. The specified `signal' value will be also delivered to + * the `callback' as the fd-argument. The event type in the callback + * will be SILC_TASK_INTERRUPT. It is safe to use any SILC routines + * in the `callback' since it is actually called after the signal really + * happened. + * + * On platform that does not support signals calling this function has + * no effect. + * + * EXAMPLE + * + * Typical signal usage case on Unix systems: + * + * struct sigaction sa; + * sa.sa_handler = signal_handler; + * sigaction(SIGHUP, &sa, NULL); + * sigaction(SIGINT, &sa, NULL); + * silc_schedule_signal_register(schedule, SIGHUP, hup_signal, context); + * silc_schedule_signal_register(schedule, SIGINT, int_signal, context); + * + * static void signal_handler(int sig) + * { + * silc_schedule_signal_call(schedule, sig); + * } + * + * The `signal_handler' can be used as generic signal callback in the + * application that merely calls silc_schedule_signal_call, which then + * eventually will deliver for example the `hup_signal' callback. The + * same `signal_handler' can be used with all signals. + * + ***/ +void silc_schedule_signal_register(SilcSchedule schedule, SilcUInt32 signal, + SilcTaskCallback callback, void *context); + +/****f* silcutil/SilcScheduleAPI/silc_schedule_signal_unregister + * + * SYNOPSIS + * + * void silc_schedule_signal_unregister(SilcSchedule schedule, + * SilcUInt32 signal, + * SilcTaskCallback callback, + * void *context); + * + * DESCRIPTION + * + * Unregister a signal indicated by `signal' from the scheduler. On + * platform that does not support signals calling this function has no + * effect. + * + ***/ +void silc_schedule_signal_unregister(SilcSchedule schedule, SilcUInt32 signal, + SilcTaskCallback callback, void *context); + +/****f* silcutil/SilcScheduleAPI/silc_schedule_signal_call + * + * SYNOPSIS + * + * void silc_schedule_signal_call(SilcSchedule schedule, + * SilcUInt32 signal); + * + * DESCRIPTION + * + * Mark the `signal' to be called later. Every signal that has been + * registered by silc_schedule_signal_register is delivered by calling + * this function. When signal really occurs, the application is + * responsible of calling this function in the signal handler. After + * signal is over the scheduler will then safely deliver the callback + * that was given to silc_schedule_signal_register function. + * + ***/ +void silc_schedule_signal_call(SilcSchedule schedule, SilcUInt32 signal); + +#include "silcschedule_i.h" #endif