#include "sofia-sip/su_time.h"
#include <sys/poll.h>
#include "sofia-sip/su.h"
Include dependency graph for su_wait.h:
Go to the source code of this file.
Defines | |
#define | SU_WAIT_CMP(x, y) |
Compare wait object. | |
#define | SU_WAIT_IN |
Incoming data is available on socket. | |
#define | SU_WAIT_OUT |
Data can be sent on socket. | |
#define | SU_WAIT_CONNECT |
Socket is connected. | |
#define | SU_WAIT_ERR |
An error occurred on socket. | |
#define | SU_WAIT_HUP |
The socket connection was closed. | |
#define | SU_WAIT_ACCEPT |
A listening socket accepted a new connection. | |
#define | SU_WAIT_FOREVER |
No timeout for su_wait(). | |
#define | SU_WAIT_TIMEOUT |
The return value of su_wait() if timeout occurred. | |
#define | SU_WAIT_INIT |
Initializer for a wait object. | |
#define | SU_ROOT_MAGIC_T |
Default type of application context for su_root_t. | |
#define | SU_WAKEUP_ARG_T |
Default type of wakeup function argument type . | |
#define | SU_PREPOLL_MAGIC_T |
Default type of application context for prepoll function. | |
#define | SU_TIMER_ARG_T |
Default type of timer expiration callback function argument type. | |
#define | SU_TASK_R_INIT |
Initializer for a task reference. | |
#define | SU_MSG_ARG_T |
Default type of su_msg_t message data. | |
#define | SU_MSG_R_INIT |
Initializer for a message reference. | |
#define | SU_CLONE_R_INIT |
Clone reference initializer. | |
Typedefs | |
typedef os_specific | su_wait_t |
Wait object. | |
typedef su_root_t | su_root_t |
Root object type. | |
typedef SU_ROOT_MAGIC_T | su_root_magic_t |
Root context pointer type. | |
typedef SU_WAKEUP_ARG_T | su_wakeup_arg_t |
Wakeup callback argument type. | |
typedef int(*) | su_wakeup_f (su_root_magic_t *, su_wait_t *, su_wakeup_arg_t *arg) |
Wakeup callback function prototype. | |
typedef SU_PREPOLL_MAGIC_T | su_prepoll_magic_t |
Root context pointer type. | |
typedef void | su_prepoll_f (su_prepoll_magic_t *, su_root_t *) |
Pre-poll callback function prototype. | |
typedef su_timer_s | su_timer_t |
Timer object type. | |
typedef SU_TIMER_ARG_T | su_timer_arg_t |
Timer callback argument type. | |
typedef void(*) | su_timer_f (su_root_magic_t *magic, su_timer_t *t, su_timer_arg_t *arg) |
Timeout function type. | |
typedef su_port_s | su_port_t |
Port type. | |
typedef _su_task_t | su_task_r [1] |
Task reference type. | |
typedef SU_MSG_ARG_T | su_msg_arg_t |
Message argument type. | |
typedef su_msg_s | su_msg_t |
Message type. | |
typedef su_msg_t * | su_msg_r [1] |
Message reference type. | |
typedef su_msg_t *const | su_msg_cr [1] |
Contstant reference to su_msg. | |
typedef void(*) | su_msg_f (su_root_magic_t *magic, su_msg_r msg, su_msg_arg_t *arg) |
Message delivery function type. | |
typedef SU_CLONE_T * | su_clone_r [1] |
Clone reference. | |
typedef int(*) | su_root_init_f (su_root_t *, su_root_magic_t *) |
Clone initialization function type. | |
typedef void(*) | su_root_deinit_f (su_root_t *, su_root_magic_t *) |
Clone finalization function type. | |
Enumerations | |
enum | { su_pri_normal, su_pri_first, su_pri_realtime } |
Functions | |
SOFIAPUBFUN void | su_wait_init (su_wait_t dst[1]) |
Initialize a wait object. | |
SOFIAPUBFUN int | su_wait_create (su_wait_t *dst, su_socket_t s, int events) |
Create a wait object. | |
SOFIAPUBFUN int | su_wait_destroy (su_wait_t *dst) |
Destroy a wait object. | |
SOFIAPUBFUN int | su_wait (su_wait_t waits[], unsigned n, su_duration_t timeout) |
Wait for multiple events. | |
SOFIAPUBFUN int | su_wait_events (su_wait_t *wait, su_socket_t s) |
Get events. | |
SOFIAPUBFUN int | su_wait_mask (su_wait_t *dst, su_socket_t s, int events) |
Set event mask. | |
SOFIAPUBFUN su_root_t * | su_root_create (su_root_magic_t *magic)) |
Create a reactor object. | |
SOFIAPUBFUN void | su_root_destroy (su_root_t *) |
Destroy a synchronization object. | |
SOFIAPUBFUN int | su_root_set_magic (su_root_t *self, su_root_magic_t *magic) |
Set the context pointer. | |
SOFIAPUBFUN su_root_magic_t * | su_root_magic (su_root_t *root) |
Get context pointer. | |
SOFIAPUBFUN int | su_root_register (su_root_t *, su_wait_t *, su_wakeup_f, su_wakeup_arg_t *, int priority) |
Register a su_wait_t object. | |
SOFIAPUBFUN int | su_root_unregister (su_root_t *, su_wait_t *, su_wakeup_f, su_wakeup_arg_t *) |
Unregister a su_wait_t object. | |
SOFIAPUBFUN int | su_root_deregister (su_root_t *, int) |
Remove a su_wait_t registration. | |
SOFIAPUBFUN int | su_root_eventmask (su_root_t *, int index, int socket, int events) |
Set mask for a registered event. | |
SOFIAPUBFUN su_duration_t | su_root_step (su_root_t *root, su_duration_t timeout) |
Process events, timers and messages. | |
SOFIAPUBFUN su_duration_t | su_root_sleep (su_root_t *root, su_duration_t) |
Run event and message loop for given duration. | |
SOFIAPUBFUN int | su_root_multishot (su_root_t *root, int multishot) |
Set multishot mode. | |
SOFIAPUBFUN void | su_root_run (su_root_t *root) |
Run event and message loop. | |
SOFIAPUBFUN void | su_root_break (su_root_t *root) |
Terminate event loop. | |
SOFIAPUBFUN su_task_r | su_root_task (su_root_t const *root) |
Get task reference. | |
SOFIAPUBFUN su_task_r | su_root_parent (su_root_t const *root) |
Get parent task reference. | |
SOFIAPUBFUN int | su_root_add_prepoll (su_root_t *root, su_prepoll_f *, su_prepoll_magic_t *) |
Add a pre-poll callback. | |
SOFIAPUBFUN int | su_root_remove_prepoll (su_root_t *root) |
Remove a pre-poll callback. | |
SOFIAPUBFUN struct _GSource * | su_root_gsource (su_root_t *self) |
Get a GSource. | |
SOFIAPUBFUN int | su_root_yield (su_root_t *root) |
Check wait events in callbacks that take lots of time. | |
SOFIAPUBFUN su_timer_t * | su_timer_create (su_task_r const, su_duration_t msec)) |
Create a timer. | |
SOFIAPUBFUN void | su_timer_destroy (su_timer_t *) |
Destroy a timer. | |
SOFIAPUBFUN int | su_timer_set (su_timer_t *, su_timer_f, su_timer_arg_t *) |
Set the timer for the default interval. | |
SOFIAPUBFUN int | su_timer_set_interval (su_timer_t *t, su_timer_f, su_timer_arg_t *, su_duration_t) |
Set the timer for the given interval. | |
SOFIAPUBFUN int | su_timer_run (su_timer_t *, su_timer_f, su_timer_arg_t *) |
Set the timer for regular intervals. | |
SOFIAPUBFUN int | su_timer_set_for_ever (su_timer_t *, su_timer_f, su_timer_arg_t *) |
Set the timer for regular intervals. | |
SOFIAPUBFUN int | su_timer_reset (su_timer_t *) |
Reset the timer. | |
SOFIAPUBFUN su_root_t * | su_timer_root (su_timer_t const *) |
Get the root object owning the timer. | |
SOFIAPUBFUN su_task_r | su_task_init (su_task_r task) |
Initialize a task handle with su_task_null. | |
SOFIAPUBFUN void | su_task_deinit (su_task_r task) |
Destroy a task handle. | |
SOFIAPUBFUN void | su_task_copy (su_task_r dst, su_task_r const src) |
Duplicates a task handle. | |
SOFIAPUBFUN void | su_task_move (su_task_r dst, su_task_r src) |
Moves a task handle. | |
SOFIAPUBFUN int | su_task_cmp (su_task_r const, su_task_r const) |
Compare two tasks with each other. | |
SOFIAPUBFUN int | su_task_is_running (su_task_r const) |
Tests if a task is running. | |
SOFIAPUBFUN su_root_t * | su_task_root (su_task_r const self) |
Get root pointer attached to a task handle. | |
SOFIAPUBFUN su_timer_t ** | su_task_timers (su_task_r const self) |
Return the timer list associated with given task. | |
SOFIAPUBFUN int | su_task_execute (su_task_r const task, int(*function)(void *), void *arg, int *return_value) |
Execute by task thread. | |
SOFIAPUBFUN int | su_msg_create (su_msg_r msg, su_task_r const to, su_task_r const from, su_msg_f wakeup, int size) |
Allocates a message of given size. | |
SOFIAPUBFUN int | su_msg_report (su_msg_r msg, su_msg_f report) |
Add a report function to a message. | |
SOFIAPUBFUN int | su_msg_reply (su_msg_r reply, su_msg_r const msg, su_msg_f wakeup, int size) |
Allocates a reply message of given size. | |
SOFIAPUBFUN void | su_msg_destroy (su_msg_r msg) |
Destroys an unsent message. | |
SOFIAPUBFUN void | su_msg_save (su_msg_r msg, su_msg_r msg0) |
Save a message. | |
SOFIAPUBFUN su_msg_arg_t * | su_msg_data (su_msg_cr msg) |
Gets a pointer to the message data area. | |
SOFIAPUBFUN int | su_msg_size (su_msg_cr msg) |
Get size of message data area. | |
SOFIAPUBFUN int | su_msg_send (su_msg_r msg) |
Send a message. | |
SOFIAPUBFUN int | su_root_threading (su_root_t *self, int enable) |
Set threading option. | |
SOFIAPUBFUN int | su_clone_start (su_root_t *root, su_clone_r, su_root_magic_t *magic, su_root_init_f, su_root_deinit_f) |
Start a clone task. | |
SOFIAPUBFUN su_task_r | su_clone_task (su_clone_r) |
Get reference to clone task. | |
SOFIAPUBFUN void | su_clone_forget (su_clone_r) |
Forget the clone. | |
SOFIAPUBFUN void | su_clone_stop (su_clone_r) |
Stop the clone. | |
SOFIAPUBFUN void | su_clone_wait (su_root_t *root, su_clone_r clone) |
Stop a clone and wait until it is has completed. | |
SOFIAPUBFUN int | su_clone_pause (su_clone_r) |
Pause a clone. | |
SOFIAPUBFUN int | su_clone_resume (su_clone_r) |
Resume a clone. | |
Variables | |
SOFIAPUBVAR int | su_root_size_hint |
Hint for number of registered fds in su_root. | |
SOFIAPUBVAR su_task_r const | su_task_null |
NULL task. |
#define SU_MSG_ARG_T |
Default type of su_msg_t message data.
Application may define this to appropriate type before including <su_wait.h>.
#define SU_PREPOLL_MAGIC_T |
Default type of application context for prepoll function.
Application may define the typedef su_prepoll_magic_t to appropriate type by defining macro SU_PREPOLL_MAGIC_T before including <su_wait.h>, for example,
#define SU_PREPOLL_MAGIC_T struct context #include <su_wait.h>
#define SU_ROOT_MAGIC_T |
Default type of application context for su_root_t.
Application may define the typedef su_root_magic_t to appropriate type by defining macro SU_ROOT_MAGIC_T before including <su_wait.h>, for example,
#define SU_ROOT_MAGIC_T struct context #include <su_wait.h>
#define SU_TIMER_ARG_T |
Default type of timer expiration callback function argument type.
Application may define this to appropriate type before including <su_wait.h>.
#define SU_WAKEUP_ARG_T |
Default type of wakeup function argument type .
The application can define the typedef su_wakeup_arg_t by defining the SU_WAKEUP_ARG_T before including <su_wait.h>, for example,
#define SU_WAKEUP_ARG_T struct transport #include <su_wait.h>
typedef SU_PREPOLL_MAGIC_T su_prepoll_magic_t |
Root context pointer type.
Application may define the typedef su_prepoll_magic_t to appropriate type by defining macro SU_PREPOLL_MAGIC_T before including <su_wait.h>, for example,
#define SU_PREPOLL_MAGIC_T struct context #include <su_wait.h>
typedef SU_ROOT_MAGIC_T su_root_magic_t |
Root context pointer type.
Application may define the typedef su_root_magic_t to appropriate type by defining macro SU_ROOT_MAGIC_T before including <su_wait.h>, for example,
#define SU_ROOT_MAGIC_T struct context #include <su_wait.h>
typedef SU_WAKEUP_ARG_T su_wakeup_arg_t |
Wakeup callback argument type.
The application can define the typedef su_wakeup_arg_t by defining the SU_WAKEUP_ARG_T before including <su_wait.h>, for example,
#define SU_WAKEUP_ARG_T struct transport #include <su_wait.h>
typedef int(*) su_wakeup_f(su_root_magic_t *, su_wait_t *, su_wakeup_arg_t *arg) |
Wakeup callback function prototype.
Whenever a registered wait object receives an event, the callback function is invoked.
anonymous enum |
SOFIAPUBFUN void su_clone_forget | ( | su_clone_r | rclone | ) |
Forget the clone.
Normally, the clone task executes until it is stopped. If the parent task does not need to stop the task, it can "forget" the clone. The clone exits independently of the parent task.
rclone | Reference to the clone. |
SOFIAPUBFUN int su_clone_pause | ( | su_clone_r | rclone | ) |
Pause a clone.
Obtain a exclusive lock on clone's private data.
0 | if successful (and clone is paused) | |
-1 | upon an error |
SOFIAPUBFUN int su_clone_resume | ( | su_clone_r | rclone | ) |
Resume a clone.
Give up a exclusive lock on clone's private data.
0 | if successful (and clone is resumed) | |
-1 | upon an error |
SOFIAPUBFUN int su_clone_start | ( | su_root_t * | parent, | |
su_clone_r | return_clone, | |||
su_root_magic_t * | magic, | |||
su_root_init_f | init, | |||
su_root_deinit_f | deinit | |||
) |
Start a clone task.
The function su_clone_start() allocates and initializes a sub-task. Depending on the settings, a separate thread may be created to execute the sub-task. The sub-task is represented by clone handle to the rest of the application. The function su_clone_start() returns the clone handle in return_clone. The clone handle is used to communicate with the newly created clone task using messages.
A new su_root_t object is created for the sub-task with the magic as the root context pointer. Because the sub-task may or may not have its own thread, all its activity must be scheduled via this root object. In other words, the sub-task can be schedule
Messages can also be used to pass information between tasks or threads.
In multi-threaded implementation, su_clone_start() launches a new thread, and the initialization routine is executed by this newly created thread. The calling thread blocks until the initialization routine completes. If the initialization routine returns su_success (0), the sub-task is considered to be created successfully. After the successful initialization, the sub-task continues to execeute the function su_root_run().
In single-threaded implementations, just a new root object is created. The initialization routine is called directly from su_clone_start().
If the initalization function init fails, the sub-task (either the newly created thread or the current thread executing the su_clone_start() function) calls the deinitialization function, and su_clone_start() returns NULL.
parent | root to be cloned (may be NULL if multi-threaded) | |
return_clone | reference to a clone [OUT] | |
magic | pointer to user data | |
init | initialization function | |
deinit | deinitialization function |
SOFIAPUBFUN void su_clone_stop | ( | su_clone_r | rclone | ) |
SOFIAPUBFUN su_task_r su_clone_task | ( | su_clone_r | clone | ) |
Get reference to clone task.
clone | Clone pointer |
SOFIAPUBFUN void su_clone_wait | ( | su_root_t * | root, | |
su_clone_r | rclone | |||
) |
Stop a clone and wait until it is has completed.
The function su_clone_wait() is used to stop the clone task and wait until it has cleaned up. The clone task is destroyed asynchronously. The parent sends a message to clone, clone deinitializes itself and then replies. After the reply message is received by the parent, it will send a third message back to clone.
The parent destroy all messages to or from clone task before calling su_clone_wait(). The parent task may not send any messages to the clone after calling su_clone_wait(). The su_clone_wait() function blocks until the cloned task is destroyed. During that time, the parent task must be prepared to process all the messages sent by clone task. This includes all the messages sent by clone before destroy message reached the clone.
SOFIAPUBFUN int su_msg_create | ( | su_msg_r | rmsg, | |
su_task_r const | to, | |||
su_task_r const | from, | |||
su_msg_f | wakeup, | |||
int | size | |||
) |
Allocates a message of given size.
The function su_msg_create()
allocates a message with given data size. If successful, it moves the new message handle to the rmsg
.
rmsg | handle to the new message (may be uninitialized prior calling) | |
to | the recipient task | |
from | the sender task | |
wakeup | function that is called when message is delivered | |
size | size of the message data |
0 | if successful, | |
-1 | if message allocation fails. |
SOFIAPUBFUN su_msg_arg_t* su_msg_data | ( | su_msg_cr | rmsg | ) |
Gets a pointer to the message data area.
The function su_msg_data()
returns a pointer to the message data area. If rmsg
contains a NULL
handle, or message size is 0, NULL
pointer is returned.
rmsg | message handle |
SOFIAPUBFUN void su_msg_destroy | ( | su_msg_r | rmsg | ) |
Destroys an unsent message.
rmsg | message handle. |
Allocates a reply message of given size.
reply | handle to the new message (may be uninitialized prior calling) | |
msg | the incoming message | |
wakeup | function that is called when message is delivered | |
size | size of the message data |
0 | if successful, | |
-1 | otherwise. |
SOFIAPUBFUN int su_msg_send | ( | su_msg_r | rmsg | ) |
Send a message.
The function su_msg_send()
sends the message. The message is added to the recipients message queue, and recipient is waken up. The caller may not alter the message or the data associated with it after the message has been sent.
rmsg | message handle |
0 | if signal was sent successfully or handle was NULL , | |
-1 | otherwise. |
SOFIAPUBFUN void su_root_break | ( | su_root_t * | self | ) |
Terminate event loop.
The function su_root_break() is used to terminate execution of su_root_run(). It can be called from a callback function.
self | pointer to root object |
SOFIAPUBFUN su_root_t* su_root_create | ( | su_root_magic_t * | magic | ) |
SOFIAPUBFUN int su_root_deregister | ( | su_root_t * | self, | |
int | i | |||
) |
Remove a su_wait_t registration.
The function su_root_deregister() deregisters a su_wait_t object. The wait object, a callback function and a argument are removed from the root object. The wait object is destroyed.
self | pointer to root object | |
i | registration index |
SOFIAPUBFUN void su_root_destroy | ( | su_root_t * | self | ) |
Destroy a synchronization object.
Stop and free an instance of su_root_t
self | pointer to a root object. |
SOFIAPUBFUN int su_root_eventmask | ( | su_root_t * | self, | |
int | index, | |||
int | socket, | |||
int | events | |||
) |
Set mask for a registered event.
The function su_root_eventmask() sets the mask describing events that can signal the registered callback.
self | pointer to root object | |
index | registration index | |
socket | socket | |
events | new event mask |
0 | when successful, | |
-1 | upon an error. |
SOFIAPUBFUN su_root_magic_t* su_root_magic | ( | su_root_t * | self | ) |
Get context pointer.
The function su_root_magic() returns the user context pointer that was given input to su_root_create() or su_root_set_magic().
self | pointer to a root object |
SOFIAPUBFUN int su_root_multishot | ( | su_root_t * | self, | |
int | multishot | |||
) |
Set multishot mode.
The function su_root_multishot() enables, disables or queries the multishot mode for the root. The multishot mode determines how the events are scheduled by root. If multishot mode is enabled, root serves all the sockets that have received network events. If it is disables, only first socket event is served.
self | pointer to root object | |
multishot | multishot mode (0 => disables, 1 => enables, -1 => query) |
0 | multishot mode is disabled | |
1 | multishot mode is enabled | |
-1 | an error occurred |
SOFIAPUBFUN su_task_r su_root_parent | ( | su_root_t const * | self | ) |
Get parent task reference.
The function su_root_parent() is used to retrieve the task reference (PId) of the parent task.
self | a pointer to a root object |
SOFIAPUBFUN int su_root_register | ( | su_root_t * | self, | |
su_wait_t * | wait, | |||
su_wakeup_f | callback, | |||
su_wakeup_arg_t * | arg, | |||
int | priority | |||
) |
Register a su_wait_t object.
The function su_root_register() registers a su_wait_t object. The wait object, a callback function and a argument are stored to the root object. The callback function is called, when the wait object is signaled.
Please note if identical wait objects are inserted, only first one is ever signalled.
self | pointer to root object | |
wait | pointer to wait object | |
callback | callback function pointer | |
arg | argument given to callback function when it is invoked | |
priority | relative priority of the wait object (0 is normal, 1 important, 2 realtime) |
SOFIAPUBFUN void su_root_run | ( | su_root_t * | self | ) |
Run event and message loop.
The function su_root_run() runs the root main loop. The root loop waits for wait objects and the timers associated with the root object. When any wait object is signaled or timer is expired, it invokes the callbacks, and returns waiting.
This function returns when su_root_break() is called from a callback.
self | pointer to root object |
SOFIAPUBFUN int su_root_set_magic | ( | su_root_t * | self, | |
su_root_magic_t * | magic | |||
) |
Set the context pointer.
Set the context pointer (magic) of a root object.
self | pointer to a root object | |
magic | pointer to user data |
0 | when successful, | |
-1 | upon error. |
SOFIAPUBFUN su_duration_t su_root_sleep | ( | su_root_t * | self, | |
su_duration_t | duration | |||
) |
Run event and message loop for given duration.
The function su_root_sleep() runs event loop for duration milliseconds. The event loop waits for wait objects and the timers associated with the root object. When any wait object is signaled, timer is expired, or message is received, it invokes the callbacks and returns waiting.
self | pointer to root object | |
duration | milliseconds to run event loop |
SOFIAPUBFUN su_duration_t su_root_step | ( | su_root_t * | self, | |
su_duration_t | tout | |||
) |
Process events, timers and messages.
The function su_root_step() waits for wait objects and the timers associated with the root object. When any wait object is signaled or timer is expired, it invokes the callbacks.
This function returns when a callback has been invoked or tout milliseconds is elapsed.
self | pointer to root object | |
tout | timeout in milliseconds |
SOFIAPUBFUN su_task_r su_root_task | ( | su_root_t const * | self | ) |
Get task reference.
The function su_root_task() is used to retrieve the task reference (PId) related with the root object.
self | a pointer to a root object |
SOFIAPUBFUN int su_root_threading | ( | su_root_t * | self, | |
int | enable | |||
) |
Set threading option.
Controls whether su_clone_start() creates a new thread.
self | pointer to a root object | |
enable | if true, enable threading, if false, disable threading |
SOFIAPUBFUN int su_root_unregister | ( | su_root_t * | self, | |
su_wait_t * | wait, | |||
su_wakeup_f | callback, | |||
su_wakeup_arg_t * | arg | |||
) |
Unregister a su_wait_t object.
The function su_root_unregister() unregisters a su_wait_t object. The wait object, a callback function and a argument are removed from the root object.
self | pointer to root object | |
wait | pointer to wait object | |
callback | callback function pointer (may be NULL) | |
arg | argument given to callback function when it is invoked (may be NULL) |
SOFIAPUBFUN int su_root_yield | ( | su_root_t * | self | ) |
Check wait events in callbacks that take lots of time.
This function does a 0 timeout poll() and runs wait objects
self | pointer to root object |
SOFIAPUBFUN int su_task_cmp | ( | su_task_r const | a, | |
su_task_r const | b | |||
) |
Compare two tasks with each other.
a | First task | |
b | Second task |
su_task_cmp()
returns negative number, if a < b, positive number, if a > b, and 0, if a == b. SOFIAPUBFUN void su_task_copy | ( | su_task_r | dst, | |
su_task_r const | src | |||
) |
Duplicates a task handle.
dst | destination task reference | |
src | source task reference |
SOFIAPUBFUN void su_task_deinit | ( | su_task_r | task | ) |
Destroy a task handle.
task | task handle |
SOFIAPUBFUN int su_task_execute | ( | su_task_r const | task, | |
int(*)(void *) | function, | |||
void * | arg, | |||
int * | return_value | |||
) |
Execute by task thread.
0 | if successful | |
-1 | upon an error |
SOFIAPUBFUN su_task_r su_task_init | ( | su_task_r | task | ) |
Initialize a task handle with su_task_null.
task | task handle |
SOFIAPUBFUN int su_task_is_running | ( | su_task_r const | task | ) |
Tests if a task is running.
task | task handle |
true | (nonzero) if task is not stopped, | |
zero | if it is null or stopped. |
SOFIAPUBFUN void su_task_move | ( | su_task_r | dst, | |
su_task_r | src | |||
) |
Moves a task handle.
dst | destination task reference | |
src | source task reference |
SOFIAPUBFUN su_root_t* su_task_root | ( | su_task_r const | self | ) |
Get root pointer attached to a task handle.
self | task handle |
su_task_root()
returns a pointer to root object attached to the task handle, or NULL if no root object has been attached. SOFIAPUBFUN su_timer_t** su_task_timers | ( | su_task_r const | task | ) |
Return the timer list associated with given task.
task | task handle |
su_task_timers()
returns a timer list of the task. If there are no timers, it returns NULL. SOFIAPUBFUN su_timer_t* su_timer_create | ( | su_task_r const | task, | |
su_duration_t | msec | |||
) |
Create a timer.
Allocate and initialize an instance of su_timer_t.
task | a task for root object with which the timer will be associated | |
msec | the default duration of the timer |
SOFIAPUBFUN void su_timer_destroy | ( | su_timer_t * | t | ) |
Destroy a timer.
Deinitialize and free an instance of su_timer_t.
t | pointer to the timer object |
SOFIAPUBFUN int su_timer_reset | ( | su_timer_t * | t | ) |
Reset the timer.
Resets (stops) the given timer.
t | pointer to the timer object |
SOFIAPUBFUN su_root_t* su_timer_root | ( | su_timer_t const * | t | ) |
Get the root object owning the timer.
The function su_timer_root() return pointer to the root object owning the timer.
t | pointer to the timer |
SOFIAPUBFUN int su_timer_run | ( | su_timer_t * | t, | |
su_timer_f | wakeup, | |||
su_timer_arg_t * | arg | |||
) |
Set the timer for regular intervals.
Run the given timer continuously, call wakeup function repeately in the default interval. If a wakeup call is missed, try to make it up (in other words, this kind of timer fails miserably if time is adjusted and it should really use /proc/uptime instead of gettimeofday()).
While a continously running timer is active it must not be set using su_timer_set() or su_timer_set_at().
The timer must have an non-zero default interval.
t | pointer to the timer object | |
wakeup | pointer to the wakeup function | |
arg | argument given to the wakeup function |
SOFIAPUBFUN int su_timer_set | ( | su_timer_t * | t, | |
su_timer_f | wakeup, | |||
su_timer_arg_t * | arg | |||
) |
Set the timer for the default interval.
Sets (starts) the given timer to expire after the default duration.
The timer must have an default duration.
t | pointer to the timer object | |
wakeup | pointer to the wakeup function | |
arg | argument given to the wakeup function |
SOFIAPUBFUN int su_timer_set_for_ever | ( | su_timer_t * | t, | |
su_timer_f | wakeup, | |||
su_timer_arg_t * | arg | |||
) |
Set the timer for regular intervals.
Run the given timer continuously, call wakeup function repeately in the default interval. While a continously running timer is active it must not be set using su_timer_set() or su_timer_set_at(). Unlike su_timer_run(), set for ever timer does not try to catchup missed callbacks.
The timer must have an non-zero default interval.
t | pointer to the timer object | |
wakeup | pointer to the wakeup function | |
arg | argument given to the wakeup function |
SOFIAPUBFUN int su_timer_set_interval | ( | su_timer_t * | t, | |
su_timer_f | wakeup, | |||
su_timer_arg_t * | arg, | |||
su_duration_t | interval | |||
) |
Set the timer for the given interval.
Sets (starts) the given timer to expire after the specified duration.
t | pointer to the timer object | |
wakeup | pointer to the wakeup function | |
arg | argument given to the wakeup function | |
interval | duration in milliseconds before timer wakeup is called |
SOFIAPUBFUN int su_wait | ( | su_wait_t | waits[], | |
unsigned | n, | |||
su_duration_t | timeout | |||
) |
Wait for multiple events.
The function su_wait() blocks until a event specified by wait objects in wait array. If timeout is not SU_WAIT_FOREVER, a timeout occurs after timeout milliseconds.
In Unix, this is poll()
or select()
.
In Windows, this is WSAWaitForMultipleEvents()
.
waits | array of wait objects | |
n | number of wait objects in array waits | |
timeout | timeout in milliseconds |
Index | of the signaled wait object, if any, | |
SU_WAIT_TIMEOUT | if timeout occurred, or | |
-1 | upon an error. |
SOFIAPUBFUN int su_wait_create | ( | su_wait_t * | newwait, | |
su_socket_t | socket, | |||
int | events | |||
) |
Create a wait object.
The function su_wait_create() creates a new su_wait_t object for an socket, with given events. The new wait object is assigned to the newwait parameter.
newwait | the newly created wait object (output) | |
socket | socket | |
events | mask for events that can signal this wait object |
0 | if the call was successful, | |
-1 | upon an error. |
SOFIAPUBFUN int su_wait_destroy | ( | su_wait_t * | waitobj | ) |
Destroy a wait object.
The function su_wait_destroy() destroys a su_wait_t object.
waitobj | pointer to wait object |
0 | when successful, | |
-1 | upon an error. |
SOFIAPUBFUN int su_wait_events | ( | su_wait_t * | waitobj, | |
su_socket_t | s | |||
) |
Get events.
The function su_wait_events() returns an mask describing events occurred.
waitobj | pointer to wait object | |
s | socket |
SOFIAPUBFUN void su_wait_init | ( | su_wait_t | dst[1] | ) |
Initialize a wait object.
The function su_wait_init initializes a memory area of a su_wait_t object.
SOFIAPUBFUN int su_wait_mask | ( | su_wait_t * | waitobj, | |
su_socket_t | s, | |||
int | events | |||
) |
Set event mask.
The function su_wait_mask() sets the mask describing events that can signal the wait object.
waitobj | pointer to wait object | |
s | socket | |
events | new event mask |
0 | when successful, | |
-1 | upon an error. |