su 1.12.11devel
Loading...
Searching...
No Matches
su_port.h
1/*
2 * This file is part of the Sofia-SIP package
3 *
4 * Copyright (C) 2005 Nokia Corporation.
5 *
6 * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 2.1 of
11 * the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 *
23 */
24
25#ifndef SU_PORT_H
27#define SU_PORT_H
28
40#ifndef SU_MSG_ARG_T
41#define SU_MSG_ARG_T union { char anoymous[4]; }
42#endif
43
44#ifndef SU_WAIT_H
45#include "sofia-sip/su_wait.h"
46#endif
47
48#ifndef SU_MODULE_DEBUG_H
49#include "su_module_debug.h"
50#endif
51
52#ifndef SU_ALLOC_H
53#include <sofia-sip/su_alloc.h>
54#endif
55
56#include <assert.h>
57
58#define SU_WAIT_MIN (16)
59
60SOFIA_BEGIN_DECLS
61
63struct su_msg_s {
64 size_t sum_size;
65 su_msg_t *sum_next;
66 su_task_r sum_to;
67 su_task_r sum_from;
68 su_msg_f sum_func;
69 su_msg_f sum_report;
70 su_msg_deinit_function *sum_deinit;
71 su_msg_arg_t sum_data[1]; /* minimum size, may be extended */
72};
73
74struct _GSource;
75
77struct su_root_s {
78 int sur_size;
79 su_root_magic_t *sur_magic;
80 su_root_deinit_f sur_deinit;
81 su_task_r sur_task;
82 su_task_r sur_parent;
83 unsigned sur_threading : 1;
84 unsigned sur_deiniting : 1;
85};
86
87#define SU_ROOT_MAGIC(r) ((r) ? (r)->sur_magic : NULL)
88
89enum su_port_thread_op {
90 su_port_thread_op_is_obtained,
91 su_port_thread_op_release,
92 su_port_thread_op_obtain
93};
94
96typedef struct su_port_vtable {
97 unsigned su_vtable_size;
98 void (*su_port_lock)(su_port_t *port, char const *who);
99 void (*su_port_unlock)(su_port_t *port, char const *who);
100 void (*su_port_incref)(su_port_t *port, char const *who);
101 void (*su_port_decref)(su_port_t *port, int block, char const *who);
102 struct _GSource *(*su_port_gsource)(su_port_t *port);
103 int (*su_port_send)(su_port_t *self, su_msg_r rmsg);
104 int (*su_port_register)(su_port_t *self,
105 su_root_t *root,
106 su_wait_t *wait,
107 su_wakeup_f callback,
108 su_wakeup_arg_t *arg,
109 int priority);
110 int (*su_port_unregister)(su_port_t *port,
111 su_root_t *root,
112 su_wait_t *wait,
113 su_wakeup_f callback,
114 su_wakeup_arg_t *arg);
115 int (*su_port_deregister)(su_port_t *self, int i);
116 int (*su_port_unregister_all)(su_port_t *self,
117 su_root_t *root);
118 int (*su_port_eventmask)(su_port_t *self, int index, int socket, int events);
119 void (*su_port_run)(su_port_t *self);
120 void (*su_port_break)(su_port_t *self);
121 su_duration_t (*su_port_step)(su_port_t *self, su_duration_t tout);
122
123 /* Reused slot */
124 int (*su_port_thread)(su_port_t *port, enum su_port_thread_op op);
125
126 int (*su_port_add_prepoll)(su_port_t *port,
127 su_root_t *root,
128 su_prepoll_f *,
130
131 int (*su_port_remove_prepoll)(su_port_t *port,
132 su_root_t *root);
133
134 su_timer_queue_t *(*su_port_timers)(su_port_t *port);
135
136 int (*su_port_multishot)(su_port_t *port, int multishot);
137
138 /* Extension from >= 1.12.4 */
139 int (*su_port_wait_events)(su_port_t *port, su_duration_t timeout);
140 int (*su_port_getmsgs)(su_port_t *port);
141 /* Extension from >= 1.12.5 */
142 int (*su_port_getmsgs_from)(su_port_t *port, su_port_t *cloneport);
143 char const *(*su_port_name)(su_port_t const *port);
144 int (*su_port_start_shared)(su_root_t *root,
145 su_clone_r return_clone,
146 su_root_magic_t *magic,
147 su_root_init_f init,
148 su_root_deinit_f deinit);
149 void (*su_port_wait)(su_clone_r rclone);
150 int (*su_port_execute)(su_task_r const task,
151 int (*function)(void *), void *arg,
152 int *return_value);
153
154 /* >= 1.12.11 */
155 su_timer_queue_t *(*su_port_deferrable)(su_port_t *port);
156 int (*su_port_max_defer)(su_port_t *port,
157 su_duration_t *return_duration,
158 su_duration_t *set_duration);
159 int (*su_port_wakeup)(su_port_t *port);
160 int (*su_port_is_running)(su_port_t const *port);
161
162 /* >= 1.12.12 */
163 su_time64_t (*su_port_stamp64)(su_port_t *);
164 su_dur64_t (*su_port_stamp64_offset)(su_port_t *);
165} su_port_vtable_t;
166
167SOFIAPUBFUN su_port_t *su_port_create(void)
168 __attribute__((__malloc__));
169
170/* Extension from >= 1.12.5 */
171
172SOFIAPUBFUN void su_msg_delivery_report(su_msg_r msg);
173SOFIAPUBFUN su_duration_t su_timer_next_expires(su_timer_queue_t const *timers,
174 su_time_t now);
175SOFIAPUBFUN su_root_t *su_root_create_with_port(su_root_magic_t *magic,
176 su_port_t *port)
177 __attribute__((__malloc__));
178
179/* Extension from >= 1.12.6 */
180
181SOFIAPUBFUN char const *su_port_name(su_port_t const *port);
182
183SOFIAPUBFUN int su_timer_reset_all(su_timer_queue_t *, su_task_r );
184
185/* ---------------------------------------------------------------------- */
186
187/* React to multiple events per one poll() to make sure
188 * that high-priority events can never completely mask other events.
189 * Enabled by default on all platforms except WIN32 */
190#if !defined(WIN32)
191#define SU_ENABLE_MULTISHOT_POLL 1
192#else
193#define SU_ENABLE_MULTISHOT_POLL 0
194#endif
195
196/* ---------------------------------------------------------------------- */
197/* Virtual functions */
198
199typedef struct su_virtual_port_s {
200 su_home_t sup_home[1];
201 su_port_vtable_t const *sup_vtable;
202} su_virtual_port_t;
203
205su_home_t *su_port_home(su_port_t const *self)
206{
207 return (su_home_t *)self;
208}
209
211void su_port_lock(su_port_t *self, char const *who)
212{
213 su_virtual_port_t *base = (su_virtual_port_t *)self;
214 base->sup_vtable->su_port_lock(self, who);
215}
216
218void su_port_unlock(su_port_t *self, char const *who)
219{
220 su_virtual_port_t *base = (su_virtual_port_t *)self;
221 base->sup_vtable->su_port_unlock(self, who);
222}
223
225void su_port_incref(su_port_t *self, char const *who)
226{
227 su_virtual_port_t *base = (su_virtual_port_t *)self;
228 base->sup_vtable->su_port_incref(self, who);
229}
230
232void su_port_decref(su_port_t *self, char const *who)
233{
234 su_virtual_port_t *base = (su_virtual_port_t *)self;
235 base->sup_vtable->su_port_decref(self, 0, who);
236}
237
239void su_port_zapref(su_port_t *self, char const *who)
240{
241 su_virtual_port_t *base = (su_virtual_port_t *)self;
242 base->sup_vtable->su_port_decref(self, 1, who);
243}
244
246struct _GSource *su_port_gsource(su_port_t *self)
247{
248 su_virtual_port_t *base = (su_virtual_port_t *)self;
249 return base->sup_vtable->su_port_gsource(self);
250}
251
253int su_port_send(su_port_t *self, su_msg_r rmsg)
254{
255 su_virtual_port_t *base = (su_virtual_port_t *)self;
256 return base->sup_vtable->su_port_send(self, rmsg);
257}
258
260int su_port_wakeup(su_port_t *self)
261{
262 su_virtual_port_t *base = (su_virtual_port_t *)self;
263 return base->sup_vtable->su_port_wakeup(self);
264}
265
267int su_port_register(su_port_t *self,
268 su_root_t *root,
269 su_wait_t *wait,
270 su_wakeup_f callback,
271 su_wakeup_arg_t *arg,
272 int priority)
273{
274 su_virtual_port_t *base = (su_virtual_port_t *)self;
275 return base->sup_vtable->
276 su_port_register(self, root, wait, callback, arg, priority);
277}
278
280int su_port_unregister(su_port_t *self,
281 su_root_t *root,
282 su_wait_t *wait,
283 su_wakeup_f callback,
284 su_wakeup_arg_t *arg)
285{
286 su_virtual_port_t *base = (su_virtual_port_t *)self;
287 return base->sup_vtable->
288 su_port_unregister(self, root, wait, callback, arg);
289}
290
292int su_port_deregister(su_port_t *self, int i)
293{
294 su_virtual_port_t *base = (su_virtual_port_t *)self;
295 return base->sup_vtable->
296 su_port_deregister(self, i);
297}
298
300int su_port_unregister_all(su_port_t *self,
301 su_root_t *root)
302{
303 su_virtual_port_t *base = (su_virtual_port_t *)self;
304 return base->sup_vtable->
305 su_port_unregister_all(self, root);
306}
307
309int su_port_eventmask(su_port_t *self, int index, int socket, int events)
310{
311 su_virtual_port_t *base = (su_virtual_port_t *)self;
312 return base->sup_vtable->
313 su_port_eventmask(self, index, socket, events);
314}
315
317int su_port_wait_events(su_port_t *self, su_duration_t timeout)
318{
319 su_virtual_port_t *base = (su_virtual_port_t *)self;
320 if (base->sup_vtable->su_port_wait_events == NULL)
321 return errno = ENOSYS, -1;
322 return base->sup_vtable->
323 su_port_wait_events(self, timeout);
324}
325
327void su_port_run(su_port_t *self)
328{
329 su_virtual_port_t *base = (su_virtual_port_t *)self;
330 base->sup_vtable->su_port_run(self);
331}
332
334void su_port_break(su_port_t *self)
335{
336 su_virtual_port_t *base = (su_virtual_port_t *)self;
337 base->sup_vtable->su_port_break(self);
338}
339
341su_duration_t su_port_step(su_port_t *self, su_duration_t tout)
342{
343 su_virtual_port_t *base = (su_virtual_port_t *)self;
344 return base->sup_vtable->su_port_step(self, tout);
345}
346
347
349int su_port_own_thread(su_port_t const *self)
350{
351 su_virtual_port_t const *base = (su_virtual_port_t *)self;
352 return base->sup_vtable->
353 su_port_thread((su_port_t *)self, su_port_thread_op_is_obtained) == 2;
354}
355
356su_inline int su_port_has_thread(su_port_t *self)
357{
358 su_virtual_port_t *base = (su_virtual_port_t *)self;
359 return base->sup_vtable->su_port_thread(self, su_port_thread_op_is_obtained);
360}
361
362su_inline int su_port_release(su_port_t *self)
363{
364 su_virtual_port_t *base = (su_virtual_port_t *)self;
365 return base->sup_vtable->su_port_thread(self, su_port_thread_op_release);
366}
367
368su_inline int su_port_obtain(su_port_t *self)
369{
370 su_virtual_port_t *base = (su_virtual_port_t *)self;
371 return base->sup_vtable->su_port_thread(self, su_port_thread_op_obtain);
372}
373
375int su_port_add_prepoll(su_port_t *self,
376 su_root_t *root,
377 su_prepoll_f *prepoll,
378 su_prepoll_magic_t *magic)
379{
380 su_virtual_port_t *base = (su_virtual_port_t *)self;
381 return base->sup_vtable->su_port_add_prepoll(self, root, prepoll, magic);
382}
383
385int su_port_remove_prepoll(su_port_t *self,
386 su_root_t *root)
387{
388 su_virtual_port_t *base = (su_virtual_port_t *)self;
389 return base->sup_vtable->su_port_remove_prepoll(self, root);
390}
391
393su_timer_queue_t *su_port_timers(su_port_t *self)
394{
395 su_virtual_port_t *base = (su_virtual_port_t *)self;
396 return base->sup_vtable->su_port_timers(self);
397}
398
400int su_port_multishot(su_port_t *self, int multishot)
401{
402 su_virtual_port_t *base = (su_virtual_port_t *)self;
403 return base->sup_vtable->su_port_multishot(self, multishot);
404}
405
407int su_port_getmsgs(su_port_t *self)
408{
409 su_virtual_port_t *base = (su_virtual_port_t *)self;
410 return base->sup_vtable->su_port_getmsgs(self);
411}
412
414int su_port_getmsgs_from(su_port_t *self, su_port_t *cloneport)
415{
416 su_virtual_port_t *base = (su_virtual_port_t *)self;
417 return base->sup_vtable->su_port_getmsgs_from(self, cloneport);
418}
419
423su_timer_queue_t *su_port_deferrable(su_port_t *self)
424{
425 su_virtual_port_t *base = (su_virtual_port_t *)self;
426
427 if (base == NULL) {
428 errno = EFAULT;
429 return NULL;
430 }
431
432 return base->sup_vtable->su_port_deferrable(self);
433}
434
436int su_port_max_defer(su_port_t *self,
437 su_duration_t *return_duration,
438 su_duration_t *set_duration)
439{
440 su_virtual_port_t *base = (su_virtual_port_t *)self;
441
442 if (base == NULL)
443 return (errno = EFAULT), -1;
444
445 return base->sup_vtable->su_port_max_defer(self,
446 return_duration,
447 set_duration);
448}
449
451int su_port_is_running(su_port_t const *self)
452{
453 su_virtual_port_t *base = (su_virtual_port_t *)self;
454 return base && base->sup_vtable->su_port_is_running(self);
455}
456
458su_port_stamp64(su_port_t *self)
459{
460 su_virtual_port_t *base = (su_virtual_port_t *)self;
461
462 if (base)
463 return base->sup_vtable->su_port_stamp64(self);
464 else
465 return su_stamp64();
466}
467
468su_inline su_dur64_t su_port_stamp64_offset(su_port_t *self)
469{
470 su_virtual_port_t *base = (su_virtual_port_t *)self;
471
472 if (base)
473 return base->sup_vtable->su_port_stamp64_offset(self);
474
475 return su_now64() - su_stamp64();
476}
477
478SOFIAPUBFUN void su_port_wait(su_clone_r rclone);
479
480SOFIAPUBFUN int su_port_execute(su_task_r const task,
481 int (*function)(void *), void *arg,
482 int *return_value);
483
484/* ---------------------------------------------------------------------- */
485
491typedef struct su_base_port_s {
492 su_home_t sup_home[1];
493 su_port_vtable_t const *sup_vtable;
494
495 /* Implementation may vary stuff below, too. */
496
497 /* Cached timestamps */
498 su_time64_t sup_stamp64;
499
500 struct {
501 su_time64_t sampled;
502 su_dur64_t value;
503 } sup_offset;
504
505 /* Pre-poll callback */
506 su_prepoll_f *sup_prepoll;
507 su_prepoll_magic_t *sup_pp_magic;
508 su_root_t *sup_pp_root;
509
510 /* Message list - this is protected by su_port_lock()/su_port_unlock() */
511 su_msg_t *sup_head, **sup_tail;
512
513 /* Timer list */
514 su_timer_queue_t sup_timers, sup_deferrable;
515
516 su_duration_t sup_max_defer;
518 unsigned sup_running;
519} su_base_port_t;
520
521/* Base methods */
522
523SOFIAPUBFUN int su_base_port_init(su_port_t *, su_port_vtable_t const *);
524SOFIAPUBFUN void su_base_port_deinit(su_port_t *self);
525
526SOFIAPUBFUN void su_base_port_lock(su_port_t *self, char const *who);
527SOFIAPUBFUN void su_base_port_unlock(su_port_t *self, char const *who);
528
529SOFIAPUBFUN int su_base_port_thread(su_port_t const *self,
530 enum su_port_thread_op op);
531
532SOFIAPUBFUN void su_base_port_incref(su_port_t *self, char const *who);
533SOFIAPUBFUN int su_base_port_decref(su_port_t *self,
534 int blocking,
535 char const *who);
536
537SOFIAPUBFUN struct _GSource *su_base_port_gsource(su_port_t *self);
538
539SOFIAPUBFUN su_socket_t su_base_port_mbox(su_port_t *self);
540SOFIAPUBFUN int su_base_port_send(su_port_t *self, su_msg_r rmsg);
541SOFIAPUBFUN int su_base_port_getmsgs(su_port_t *self);
542SOFIAPUBFUN int su_base_port_getmsgs_from(su_port_t *self,
543 su_port_t *from);
544
545SOFIAPUBFUN void su_base_port_run(su_port_t *self);
546SOFIAPUBFUN void su_base_port_break(su_port_t *self);
547SOFIAPUBFUN su_duration_t su_base_port_step(su_port_t *self,
548 su_duration_t tout);
549
550SOFIAPUBFUN int su_base_port_add_prepoll(su_port_t *self,
551 su_root_t *root,
552 su_prepoll_f *,
554
555SOFIAPUBFUN int su_base_port_remove_prepoll(su_port_t *self, su_root_t *root);
556
557SOFIAPUBFUN su_timer_queue_t *su_base_port_timers(su_port_t *self);
558
559SOFIAPUBFUN int su_base_port_multishot(su_port_t *self, int multishot);
560
561SOFIAPUBFUN int su_base_port_start_shared(su_root_t *parent,
562 su_clone_r return_clone,
563 su_root_magic_t *magic,
564 su_root_init_f init,
565 su_root_deinit_f deinit);
566SOFIAPUBFUN void su_base_port_wait(su_clone_r rclone);
567
568SOFIAPUBFUN su_timer_queue_t *su_base_port_deferrable(su_port_t *self);
569
570SOFIAPUBFUN int su_base_port_max_defer(su_port_t *self,
571 su_duration_t *return_duration,
572 su_duration_t *set_duration);
573
574SOFIAPUBFUN int su_base_port_is_running(su_port_t const *self);
575
576SOFIAPUBFUN su_time64_t su_base_port_stamp64(su_port_t *);
577
578SOFIAPUBFUN su_dur64_t su_base_port_stamp64_offset(su_port_t *);
579
580SOFIAPUBFUN void su_base_port_waiting(su_port_t *);
581
582/* ---------------------------------------------------------------------- */
583
584#if SU_HAVE_PTHREADS
585
586#include <pthread.h>
587
589typedef struct su_pthread_port_s {
590 su_base_port_t sup_base[1];
591 struct su_pthread_port_waiting_parent
592 *sup_waiting_parent;
593 pthread_t sup_tid;
594 pthread_mutex_t sup_obtained[1];
595
596#if 0 /* Pausing and resuming are not used */
597 pthread_mutex_t sup_runlock[1];
598 pthread_cond_t sup_resume[1];
599 short sup_paused;
600#endif
601 short sup_thread;
602} su_pthread_port_t;
603
604/* Pthread methods */
605
606SOFIAPUBFUN int su_pthread_port_init(su_port_t *, su_port_vtable_t const *);
607SOFIAPUBFUN void su_pthread_port_deinit(su_port_t *self);
608
609SOFIAPUBFUN void su_pthread_port_lock(su_port_t *self, char const *who);
610SOFIAPUBFUN void su_pthread_port_unlock(su_port_t *self, char const *who);
611
612SOFIAPUBFUN int su_pthread_port_thread(su_port_t *self,
613 enum su_port_thread_op op);
614
615#if 0 /* not yet */
616SOFIAPUBFUN int su_pthread_port_send(su_port_t *self, su_msg_r rmsg);
617
618SOFIAPUBFUN su_port_t *su_pthread_port_create(void);
619SOFIAPUBFUN su_port_t *su_pthread_port_start(su_root_t *parent,
620 su_clone_r return_clone,
621 su_root_magic_t *magic,
622 su_root_init_f init,
623 su_root_deinit_f deinit);
624#endif
625
626SOFIAPUBFUN int su_pthreaded_port_start(su_port_create_f *create,
627 su_root_t *parent,
628 su_clone_r return_clone,
629 su_root_magic_t *magic,
630 su_root_init_f init,
631 su_root_deinit_f deinit);
632
633SOFIAPUBFUN void su_pthread_port_wait(su_clone_r rclone);
634SOFIAPUBFUN int su_pthread_port_execute(su_task_r const task,
635 int (*function)(void *), void *arg,
636 int *return_value);
637
638#if 0
639SOFIAPUBFUN int su_pthread_port_pause(su_port_t *self);
640SOFIAPUBFUN int su_pthread_port_resume(su_port_t *self);
641#endif
642
643#else
644
645typedef su_base_port_t su_pthread_port_t;
646
647#define su_pthread_port_init su_base_port_init
648#define su_pthread_port_deinit su_base_port_deinit
649#define su_pthread_port_lock su_base_port_lock
650#define su_pthread_port_unlock su_base_port_unlock
651#define su_pthread_port_thread su_base_port_thread
652#define su_pthread_port_wait su_base_port_wait
653#define su_pthread_port_execute su_base_port_execute
654
655#endif
656
657/* ====================================================================== */
658/* Mailbox port using sockets */
659
660#define SU_MBOX_SIZE 2
661
662typedef struct su_socket_port_s {
663 su_pthread_port_t sup_base[1];
664 int sup_mbox_index;
665 su_socket_t sup_mbox[SU_MBOX_SIZE];
666} su_socket_port_t;
667
668SOFIAPUBFUN int su_socket_port_init(su_socket_port_t *,
669 su_port_vtable_t const *);
670SOFIAPUBFUN void su_socket_port_deinit(su_socket_port_t *self);
671SOFIAPUBFUN int su_socket_port_send(su_port_t *self, su_msg_r rmsg);
672SOFIAPUBFUN int su_socket_port_wakeup(su_port_t *self);
673
674SOFIA_END_DECLS
675
676#endif /* SU_PORT_H */
Time in seconds and microsecondcs.
Definition su_time.h:57
int su_socket_t
Socket descriptor type.
Definition su.h:128
Home-based memory management interface.
SU_HOME_T su_home_t
Memory home type.
Definition su_alloc.h:50
#define SOFIAPUBFUN
SOFIAPUBFUN declares an exported function.
Definition su_config.h:66
#define su_inline
Define as suitable declarator static inline functions.
Definition su_configure.h:90
su_time64_t su_now64(void)
Get current time as nanoseconds since epoch.
Definition su_time0.c:194
int64_t su_dur64_t
Time offset (duration) in nanoseconds.
Definition su_time.h:50
long su_duration_t
Time difference in microseconds.
Definition su_time.h:70
su_time64_t su_stamp64(void)
Get current monotonic timestamp as nanoseconds.
Definition su_time0.c:271
uint64_t su_time64_t
Time in nanoseconds.
Definition su_time.h:44
Syncronization and threading interface.
struct su_root_t su_root_t
Root object type.
Definition su_wait.h:210
SU_WAKEUP_ARG_T su_wakeup_arg_t
Wakeup callback argument type.
Definition su_wait.h:261
void(* su_root_deinit_f)(su_root_t *, su_root_magic_t *)
Clone finalization function type.
Definition su_wait.h:425
int(* su_wakeup_f)(su_root_magic_t *, su_wait_t *, su_wakeup_arg_t *arg)
Wakeup callback function pointer type.
Definition su_wait.h:268
SU_ROOT_MAGIC_T su_root_magic_t
Root context pointer type.
Definition su_wait.h:236
struct pollfd su_wait_t
Wait object.
Definition su_wait.h:184
int(* su_root_init_f)(su_root_t *, su_root_magic_t *)
Clone initialization function type.
Definition su_wait.h:422
_su_task_t su_task_r[1]
Task reference type.
Definition su_wait.h:360
SU_PREPOLL_MAGIC_T su_prepoll_magic_t
Root context pointer type.
Definition su_wait.h:310
struct su_msg_s su_msg_t
Message type.
Definition su_wait.h:382
su_msg_function * su_msg_f
Message delivery function pointer type.
Definition su_wait.h:405
SU_CLONE_T * su_clone_r[1]
Clone reference.
Definition su_wait.h:416
struct su_port_s su_port_t
Port type.
Definition su_wait.h:355
SU_MSG_ARG_T su_msg_arg_t
Message argument type.
Definition su_wait.h:379
void su_prepoll_f(su_prepoll_magic_t *, su_root_t *)
Pre-poll callback function prototype.
Definition su_wait.h:317
void su_msg_deinit_function(su_msg_arg_t *arg)
Message deinitializer function type.
Definition su_wait.h:402
su_msg_t * su_msg_r[1]
Message reference type.
Definition su_wait.h:385

Sofia-SIP 1.12.11devel - Copyright (C) 2006 Nokia Corporation. All rights reserved. Licensed under the terms of the GNU Lesser General Public License.