su  1.12.11devel
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
26 
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 
60 SOFIA_BEGIN_DECLS
61 
63 struct 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 
74 struct _GSource;
75 
77 struct 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 
89 enum 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 
96 typedef 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 
167 SOFIAPUBFUN su_port_t *su_port_create(void)
168  __attribute__((__malloc__));
169 
170 /* Extension from >= 1.12.5 */
171 
172 SOFIAPUBFUN void su_msg_delivery_report(su_msg_r msg);
173 SOFIAPUBFUN su_duration_t su_timer_next_expires(su_timer_queue_t const *timers,
174  su_time_t now);
175 SOFIAPUBFUN 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 
181 SOFIAPUBFUN char const *su_port_name(su_port_t const *port);
182 
183 SOFIAPUBFUN 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 
199 typedef 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 
204 su_inline
205 su_home_t *su_port_home(su_port_t const *self)
206 {
207  return (su_home_t *)self;
208 }
209 
210 su_inline
211 void 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 
217 su_inline
218 void 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 
224 su_inline
225 void 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 
231 su_inline
232 void 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 
238 su_inline
239 void 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 
245 su_inline
246 struct _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 
252 su_inline
253 int 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 
259 su_inline
260 int 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 
266 su_inline
267 int 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 
279 su_inline
280 int 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 
291 su_inline
292 int 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 
299 su_inline
300 int 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 
308 su_inline
309 int 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 
316 su_inline
317 int 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 
326 su_inline
327 void 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 
333 su_inline
334 void 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 
340 su_inline
341 su_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 
348 su_inline
349 int 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 
356 su_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 
362 su_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 
368 su_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 
374 su_inline
375 int 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 
384 su_inline
385 int 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 
392 su_inline
393 su_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 
399 su_inline
400 int 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 
406 su_inline
407 int 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 
413 su_inline
414 int 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 
422 su_inline
423 su_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 
435 su_inline
436 int 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 
450 su_inline
451 int 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 
458 su_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 
468 su_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 
478 SOFIAPUBFUN void su_port_wait(su_clone_r rclone);
479 
480 SOFIAPUBFUN int su_port_execute(su_task_r const task,
481  int (*function)(void *), void *arg,
482  int *return_value);
483 
484 /* ---------------------------------------------------------------------- */
485 
491 typedef 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 
523 SOFIAPUBFUN int su_base_port_init(su_port_t *, su_port_vtable_t const *);
524 SOFIAPUBFUN void su_base_port_deinit(su_port_t *self);
525 
526 SOFIAPUBFUN void su_base_port_lock(su_port_t *self, char const *who);
527 SOFIAPUBFUN void su_base_port_unlock(su_port_t *self, char const *who);
528 
529 SOFIAPUBFUN int su_base_port_thread(su_port_t const *self,
530  enum su_port_thread_op op);
531 
532 SOFIAPUBFUN void su_base_port_incref(su_port_t *self, char const *who);
533 SOFIAPUBFUN int su_base_port_decref(su_port_t *self,
534  int blocking,
535  char const *who);
536 
537 SOFIAPUBFUN struct _GSource *su_base_port_gsource(su_port_t *self);
538 
539 SOFIAPUBFUN su_socket_t su_base_port_mbox(su_port_t *self);
540 SOFIAPUBFUN int su_base_port_send(su_port_t *self, su_msg_r rmsg);
541 SOFIAPUBFUN int su_base_port_getmsgs(su_port_t *self);
542 SOFIAPUBFUN int su_base_port_getmsgs_from(su_port_t *self,
543  su_port_t *from);
544 
545 SOFIAPUBFUN void su_base_port_run(su_port_t *self);
546 SOFIAPUBFUN void su_base_port_break(su_port_t *self);
547 SOFIAPUBFUN su_duration_t su_base_port_step(su_port_t *self,
548  su_duration_t tout);
549 
550 SOFIAPUBFUN int su_base_port_add_prepoll(su_port_t *self,
551  su_root_t *root,
552  su_prepoll_f *,
554 
555 SOFIAPUBFUN int su_base_port_remove_prepoll(su_port_t *self, su_root_t *root);
556 
557 SOFIAPUBFUN su_timer_queue_t *su_base_port_timers(su_port_t *self);
558 
559 SOFIAPUBFUN int su_base_port_multishot(su_port_t *self, int multishot);
560 
561 SOFIAPUBFUN 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);
566 SOFIAPUBFUN void su_base_port_wait(su_clone_r rclone);
567 
568 SOFIAPUBFUN su_timer_queue_t *su_base_port_deferrable(su_port_t *self);
569 
570 SOFIAPUBFUN int su_base_port_max_defer(su_port_t *self,
571  su_duration_t *return_duration,
572  su_duration_t *set_duration);
573 
574 SOFIAPUBFUN int su_base_port_is_running(su_port_t const *self);
575 
576 SOFIAPUBFUN su_time64_t su_base_port_stamp64(su_port_t *);
577 
578 SOFIAPUBFUN su_dur64_t su_base_port_stamp64_offset(su_port_t *);
579 
580 SOFIAPUBFUN void su_base_port_waiting(su_port_t *);
581 
582 /* ---------------------------------------------------------------------- */
583 
584 #if SU_HAVE_PTHREADS
585 
586 #include <pthread.h>
587 
589 typedef 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 
606 SOFIAPUBFUN int su_pthread_port_init(su_port_t *, su_port_vtable_t const *);
607 SOFIAPUBFUN void su_pthread_port_deinit(su_port_t *self);
608 
609 SOFIAPUBFUN void su_pthread_port_lock(su_port_t *self, char const *who);
610 SOFIAPUBFUN void su_pthread_port_unlock(su_port_t *self, char const *who);
611 
612 SOFIAPUBFUN int su_pthread_port_thread(su_port_t *self,
613  enum su_port_thread_op op);
614 
615 #if 0 /* not yet */
616 SOFIAPUBFUN int su_pthread_port_send(su_port_t *self, su_msg_r rmsg);
617 
618 SOFIAPUBFUN su_port_t *su_pthread_port_create(void);
619 SOFIAPUBFUN 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 
626 SOFIAPUBFUN 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 
633 SOFIAPUBFUN void su_pthread_port_wait(su_clone_r rclone);
634 SOFIAPUBFUN int su_pthread_port_execute(su_task_r const task,
635  int (*function)(void *), void *arg,
636  int *return_value);
637 
638 #if 0
639 SOFIAPUBFUN int su_pthread_port_pause(su_port_t *self);
640 SOFIAPUBFUN int su_pthread_port_resume(su_port_t *self);
641 #endif
642 
643 #else
644 
645 typedef 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 
662 typedef 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 
668 SOFIAPUBFUN int su_socket_port_init(su_socket_port_t *,
669  su_port_vtable_t const *);
670 SOFIAPUBFUN void su_socket_port_deinit(su_socket_port_t *self);
671 SOFIAPUBFUN int su_socket_port_wakeup(su_port_t *self);
672 
673 SOFIA_END_DECLS
674 
675 #endif /* SU_PORT_H */
su_wait.h
su_home_t
SU_HOME_T su_home_t
Memory home type.
Definition: su_alloc.h:50
su_port_t
struct su_port_s su_port_t
Port type.
Definition: su_wait.h:355
su_now64
su_time64_t su_now64(void)
Get current time as nanoseconds since epoch.
Definition: su_time0.c:194
su_msg_r
su_msg_t * su_msg_r[1]
Message reference type.
Definition: su_wait.h:385
su_alloc.h
su_time_s
Time in seconds and microsecondcs.
Definition: su_time.h:57
su_wait_t
struct pollfd su_wait_t
Wait object.
Definition: su_wait.h:184
su_socket_t
int su_socket_t
Socket descriptor type.
Definition: su.h:128
su_inline
#define su_inline
Define as suitable declarator static inline functions.
Definition: su_configure.h:90
su_wakeup_arg_t
SU_WAKEUP_ARG_T su_wakeup_arg_t
Wakeup callback argument type.
Definition: su_wait.h:261
su_msg_f
su_msg_function * su_msg_f
Message delivery function pointer type.
Definition: su_wait.h:405
su_msg_arg_t
SU_MSG_ARG_T su_msg_arg_t
Message argument type.
Definition: su_wait.h:379
su_msg_t
struct su_msg_s su_msg_t
Message type.
Definition: su_wait.h:382
su_clone_r
SU_CLONE_T * su_clone_r[1]
Clone reference.
Definition: su_wait.h:416
su_stamp64
su_time64_t su_stamp64(void)
Get current monotonic timestamp as nanoseconds.
Definition: su_time0.c:271
su_msg_deinit_function
void su_msg_deinit_function(su_msg_arg_t *arg)
Message deinitializer function type.
Definition: su_wait.h:402
su_prepoll_magic_t
SU_PREPOLL_MAGIC_T su_prepoll_magic_t
Root context pointer type.
Definition: su_wait.h:310
su_root_init_f
int(* su_root_init_f)(su_root_t *, su_root_magic_t *)
Clone initialization function type.
Definition: su_wait.h:422
su_dur64_t
int64_t su_dur64_t
Time offset (duration) in nanoseconds.
Definition: su_time.h:50
su_root_t
struct su_root_t su_root_t
Root object type.
Definition: su_wait.h:210
su_duration_t
long su_duration_t
Time difference in microseconds.
Definition: su_time.h:70
su_prepoll_f
void su_prepoll_f(su_prepoll_magic_t *, su_root_t *)
Pre-poll callback function prototype.
Definition: su_wait.h:317
SOFIAPUBFUN
#define SOFIAPUBFUN
SOFIAPUBFUN declares an exported function.
Definition: su_config.h:66
su_time64_t
uint64_t su_time64_t
Time in nanoseconds.
Definition: su_time.h:44
su_wakeup_f
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 su_root_magic_t
Root context pointer type.
Definition: su_wait.h:236
su_root_deinit_f
void(* su_root_deinit_f)(su_root_t *, su_root_magic_t *)
Clone finalization function type.
Definition: su_wait.h:425
su_task_r
_su_task_t su_task_r[1]
Task reference type.
Definition: su_wait.h:360

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