su 1.12.11devel
/tmp/buildd/sofia-sip-1.12.11+20110422/libsofia-sip-ua/su/su_port.h
00001 /*
00002  * This file is part of the Sofia-SIP package
00003  *
00004  * Copyright (C) 2005 Nokia Corporation.
00005  *
00006  * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
00007  *
00008  * This library is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public License
00010  * as published by the Free Software Foundation; either version 2.1 of
00011  * the License, or (at your option) any later version.
00012  *
00013  * This library is distributed in the hope that it will be useful, but
00014  * WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with this library; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
00021  * 02110-1301 USA
00022  *
00023  */
00024 
00025 #ifndef SU_PORT_H
00026 
00027 #define SU_PORT_H
00028 
00040 #ifndef SU_MSG_ARG_T
00041 #define SU_MSG_ARG_T union { char anoymous[4]; }
00042 #endif
00043 
00044 #ifndef SU_WAIT_H
00045 #include "sofia-sip/su_wait.h"
00046 #endif
00047 
00048 #ifndef SU_MODULE_DEBUG_H
00049 #include "su_module_debug.h"
00050 #endif
00051 
00052 #ifndef SU_ALLOC_H
00053 #include <sofia-sip/su_alloc.h>
00054 #endif
00055 
00056 #include <assert.h>
00057 
00058 #define SU_WAIT_MIN    (16)
00059 
00060 SOFIA_BEGIN_DECLS
00061 
00063 struct su_msg_s {
00064   size_t         sum_size;
00065   su_msg_t      *sum_next;
00066   su_task_r      sum_to;
00067   su_task_r      sum_from;
00068   su_msg_f       sum_func;
00069   su_msg_f       sum_report;
00070   su_msg_deinit_function *sum_deinit;
00071   su_msg_arg_t   sum_data[1];           /* minimum size, may be extended */
00072 };
00073 
00074 struct _GSource;
00075 
00077 struct su_root_s {
00078   int              sur_size;
00079   su_root_magic_t *sur_magic;
00080   su_root_deinit_f sur_deinit;
00081   su_task_r        sur_task;
00082   su_task_r        sur_parent;
00083   unsigned         sur_threading : 1;
00084   unsigned         sur_deiniting : 1;
00085 };
00086 
00087 #define SU_ROOT_MAGIC(r) ((r) ? (r)->sur_magic : NULL)
00088 
00089 enum su_port_thread_op {
00090   su_port_thread_op_is_obtained,
00091   su_port_thread_op_release,
00092   su_port_thread_op_obtain
00093 };
00094 
00096 typedef struct su_port_vtable {
00097   unsigned su_vtable_size;
00098   void (*su_port_lock)(su_port_t *port, char const *who);
00099   void (*su_port_unlock)(su_port_t *port, char const *who);
00100   void (*su_port_incref)(su_port_t *port, char const *who);
00101   void (*su_port_decref)(su_port_t *port, int block, char const *who);
00102   struct _GSource *(*su_port_gsource)(su_port_t *port);
00103   int (*su_port_send)(su_port_t *self, su_msg_r rmsg);
00104   int (*su_port_register)(su_port_t *self,
00105                           su_root_t *root,
00106                           su_wait_t *wait,
00107                           su_wakeup_f callback,
00108                           su_wakeup_arg_t *arg,
00109                           int priority);
00110   int (*su_port_unregister)(su_port_t *port,
00111                             su_root_t *root,
00112                             su_wait_t *wait,
00113                             su_wakeup_f callback,
00114                             su_wakeup_arg_t *arg);
00115   int (*su_port_deregister)(su_port_t *self, int i);
00116   int (*su_port_unregister_all)(su_port_t *self,
00117                              su_root_t *root);
00118   int (*su_port_eventmask)(su_port_t *self, int index, int socket, int events);
00119   void (*su_port_run)(su_port_t *self);
00120   void (*su_port_break)(su_port_t *self);
00121   su_duration_t (*su_port_step)(su_port_t *self, su_duration_t tout);
00122 
00123   /* Reused slot */
00124   int (*su_port_thread)(su_port_t *port, enum su_port_thread_op op);
00125 
00126   int (*su_port_add_prepoll)(su_port_t *port,
00127                              su_root_t *root,
00128                              su_prepoll_f *,
00129                              su_prepoll_magic_t *);
00130 
00131   int (*su_port_remove_prepoll)(su_port_t *port,
00132                                 su_root_t *root);
00133 
00134   su_timer_queue_t *(*su_port_timers)(su_port_t *port);
00135 
00136   int (*su_port_multishot)(su_port_t *port, int multishot);
00137 
00138   /* Extension from >= 1.12.4 */
00139   int (*su_port_wait_events)(su_port_t *port, su_duration_t timeout);
00140   int (*su_port_getmsgs)(su_port_t *port);
00141   /* Extension from >= 1.12.5 */
00142   int (*su_port_getmsgs_from)(su_port_t *port, su_port_t *cloneport);
00143   char const *(*su_port_name)(su_port_t const *port);
00144   int (*su_port_start_shared)(su_root_t *root,
00145                               su_clone_r return_clone,
00146                               su_root_magic_t *magic,
00147                               su_root_init_f init,
00148                               su_root_deinit_f deinit);
00149   void (*su_port_wait)(su_clone_r rclone);
00150   int (*su_port_execute)(su_task_r const task,
00151                          int (*function)(void *), void *arg,
00152                          int *return_value);
00153 
00154   /* >= 1.12.11 */
00155   su_timer_queue_t *(*su_port_deferrable)(su_port_t *port);
00156   int (*su_port_max_defer)(su_port_t *port,
00157                            su_duration_t *return_duration,
00158                            su_duration_t *set_duration);
00159   int (*su_port_wakeup)(su_port_t *port);
00160   int (*su_port_is_running)(su_port_t const *port);
00161 
00162   /* >= 1.12.12 */
00163   su_time64_t (*su_port_stamp64)(su_port_t *);
00164   su_dur64_t (*su_port_stamp64_offset)(su_port_t *);
00165 } su_port_vtable_t;
00166 
00167 SOFIAPUBFUN su_port_t *su_port_create(void)
00168      __attribute__((__malloc__));
00169 
00170 /* Extension from >= 1.12.5 */
00171 
00172 SOFIAPUBFUN void su_msg_delivery_report(su_msg_r msg);
00173 SOFIAPUBFUN su_duration_t su_timer_next_expires(su_timer_queue_t const *timers,
00174                                                 su_time_t now);
00175 SOFIAPUBFUN su_root_t *su_root_create_with_port(su_root_magic_t *magic,
00176                                                 su_port_t *port)
00177   __attribute__((__malloc__));
00178 
00179 /* Extension from >= 1.12.6 */
00180 
00181 SOFIAPUBFUN char const *su_port_name(su_port_t const *port);
00182 
00183 SOFIAPUBFUN int su_timer_reset_all(su_timer_queue_t *, su_task_r );
00184 
00185 /* ---------------------------------------------------------------------- */
00186 
00187 /* React to multiple events per one poll() to make sure
00188  * that high-priority events can never completely mask other events.
00189  * Enabled by default on all platforms except WIN32 */
00190 #if !defined(WIN32)
00191 #define SU_ENABLE_MULTISHOT_POLL 1
00192 #else
00193 #define SU_ENABLE_MULTISHOT_POLL 0
00194 #endif
00195 
00196 /* ---------------------------------------------------------------------- */
00197 /* Virtual functions */
00198 
00199 typedef struct su_virtual_port_s {
00200   su_home_t        sup_home[1];
00201   su_port_vtable_t const *sup_vtable;
00202 } su_virtual_port_t;
00203 
00204 su_inline
00205 su_home_t *su_port_home(su_port_t const *self)
00206 {
00207   return (su_home_t *)self;
00208 }
00209 
00210 su_inline
00211 void su_port_lock(su_port_t *self, char const *who)
00212 {
00213   su_virtual_port_t *base = (su_virtual_port_t *)self;
00214   base->sup_vtable->su_port_lock(self, who);
00215 }
00216 
00217 su_inline
00218 void su_port_unlock(su_port_t *self, char const *who)
00219 {
00220   su_virtual_port_t *base = (su_virtual_port_t *)self;
00221   base->sup_vtable->su_port_unlock(self, who);
00222 }
00223 
00224 su_inline
00225 void su_port_incref(su_port_t *self, char const *who)
00226 {
00227   su_virtual_port_t *base = (su_virtual_port_t *)self;
00228   base->sup_vtable->su_port_incref(self, who);
00229 }
00230 
00231 su_inline
00232 void su_port_decref(su_port_t *self, char const *who)
00233 {
00234   su_virtual_port_t *base = (su_virtual_port_t *)self;
00235   base->sup_vtable->su_port_decref(self, 0, who);
00236 }
00237 
00238 su_inline
00239 void su_port_zapref(su_port_t *self, char const *who)
00240 {
00241   su_virtual_port_t *base = (su_virtual_port_t *)self;
00242   base->sup_vtable->su_port_decref(self, 1, who);
00243 }
00244 
00245 su_inline
00246 struct _GSource *su_port_gsource(su_port_t *self)
00247 {
00248   su_virtual_port_t *base = (su_virtual_port_t *)self;
00249   return base->sup_vtable->su_port_gsource(self);
00250 }
00251 
00252 su_inline
00253 int su_port_send(su_port_t *self, su_msg_r rmsg)
00254 {
00255   su_virtual_port_t *base = (su_virtual_port_t *)self;
00256   return base->sup_vtable->su_port_send(self, rmsg);
00257 }
00258 
00259 su_inline
00260 int su_port_wakeup(su_port_t *self)
00261 {
00262   su_virtual_port_t *base = (su_virtual_port_t *)self;
00263   return base->sup_vtable->su_port_wakeup(self);
00264 }
00265 
00266 su_inline
00267 int su_port_register(su_port_t *self,
00268                      su_root_t *root,
00269                      su_wait_t *wait,
00270                      su_wakeup_f callback,
00271                      su_wakeup_arg_t *arg,
00272                      int priority)
00273 {
00274   su_virtual_port_t *base = (su_virtual_port_t *)self;
00275   return base->sup_vtable->
00276     su_port_register(self, root, wait, callback, arg, priority);
00277 }
00278 
00279 su_inline
00280 int su_port_unregister(su_port_t *self,
00281                        su_root_t *root,
00282                        su_wait_t *wait,
00283                        su_wakeup_f callback,
00284                        su_wakeup_arg_t *arg)
00285 {
00286   su_virtual_port_t *base = (su_virtual_port_t *)self;
00287   return base->sup_vtable->
00288     su_port_unregister(self, root, wait, callback, arg);
00289 }
00290 
00291 su_inline
00292 int su_port_deregister(su_port_t *self, int i)
00293 {
00294   su_virtual_port_t *base = (su_virtual_port_t *)self;
00295   return base->sup_vtable->
00296     su_port_deregister(self, i);
00297 }
00298 
00299 su_inline
00300 int su_port_unregister_all(su_port_t *self,
00301                            su_root_t *root)
00302 {
00303   su_virtual_port_t *base = (su_virtual_port_t *)self;
00304   return base->sup_vtable->
00305     su_port_unregister_all(self, root);
00306 }
00307 
00308 su_inline
00309 int su_port_eventmask(su_port_t *self, int index, int socket, int events)
00310 {
00311   su_virtual_port_t *base = (su_virtual_port_t *)self;
00312   return base->sup_vtable->
00313     su_port_eventmask(self, index, socket, events);
00314 }
00315 
00316 su_inline
00317 int su_port_wait_events(su_port_t *self, su_duration_t timeout)
00318 {
00319   su_virtual_port_t *base = (su_virtual_port_t *)self;
00320   if (base->sup_vtable->su_port_wait_events == NULL)
00321     return errno = ENOSYS, -1;
00322   return base->sup_vtable->
00323     su_port_wait_events(self, timeout);
00324 }
00325 
00326 su_inline
00327 void su_port_run(su_port_t *self)
00328 {
00329   su_virtual_port_t *base = (su_virtual_port_t *)self;
00330   base->sup_vtable->su_port_run(self);
00331 }
00332 
00333 su_inline
00334 void su_port_break(su_port_t *self)
00335 {
00336   su_virtual_port_t *base = (su_virtual_port_t *)self;
00337   base->sup_vtable->su_port_break(self);
00338 }
00339 
00340 su_inline
00341 su_duration_t su_port_step(su_port_t *self, su_duration_t tout)
00342 {
00343   su_virtual_port_t *base = (su_virtual_port_t *)self;
00344   return base->sup_vtable->su_port_step(self, tout);
00345 }
00346 
00347 
00348 su_inline
00349 int su_port_own_thread(su_port_t const *self)
00350 {
00351   su_virtual_port_t const *base = (su_virtual_port_t *)self;
00352   return base->sup_vtable->
00353     su_port_thread((su_port_t *)self, su_port_thread_op_is_obtained) == 2;
00354 }
00355 
00356 su_inline int su_port_has_thread(su_port_t *self)
00357 {
00358   su_virtual_port_t *base = (su_virtual_port_t *)self;
00359   return base->sup_vtable->su_port_thread(self, su_port_thread_op_is_obtained);
00360 }
00361 
00362 su_inline int su_port_release(su_port_t *self)
00363 {
00364   su_virtual_port_t *base = (su_virtual_port_t *)self;
00365   return base->sup_vtable->su_port_thread(self, su_port_thread_op_release);
00366 }
00367 
00368 su_inline int su_port_obtain(su_port_t *self)
00369 {
00370   su_virtual_port_t *base = (su_virtual_port_t *)self;
00371   return base->sup_vtable->su_port_thread(self, su_port_thread_op_obtain);
00372 }
00373 
00374 su_inline
00375 int su_port_add_prepoll(su_port_t *self,
00376                         su_root_t *root,
00377                         su_prepoll_f *prepoll,
00378                         su_prepoll_magic_t *magic)
00379 {
00380   su_virtual_port_t *base = (su_virtual_port_t *)self;
00381   return base->sup_vtable->su_port_add_prepoll(self, root, prepoll, magic);
00382 }
00383 
00384 su_inline
00385 int su_port_remove_prepoll(su_port_t *self,
00386                            su_root_t *root)
00387 {
00388   su_virtual_port_t *base = (su_virtual_port_t *)self;
00389   return base->sup_vtable->su_port_remove_prepoll(self, root);
00390 }
00391 
00392 su_inline
00393 su_timer_queue_t *su_port_timers(su_port_t *self)
00394 {
00395   su_virtual_port_t *base = (su_virtual_port_t *)self;
00396   return base->sup_vtable->su_port_timers(self);
00397 }
00398 
00399 su_inline
00400 int su_port_multishot(su_port_t *self, int multishot)
00401 {
00402   su_virtual_port_t *base = (su_virtual_port_t *)self;
00403   return base->sup_vtable->su_port_multishot(self, multishot);
00404 }
00405 
00406 su_inline
00407 int su_port_getmsgs(su_port_t *self)
00408 {
00409   su_virtual_port_t *base = (su_virtual_port_t *)self;
00410   return base->sup_vtable->su_port_getmsgs(self);
00411 }
00412 
00413 su_inline
00414 int su_port_getmsgs_from(su_port_t *self, su_port_t *cloneport)
00415 {
00416   su_virtual_port_t *base = (su_virtual_port_t *)self;
00417   return base->sup_vtable->su_port_getmsgs_from(self, cloneport);
00418 }
00419 
00422 su_inline
00423 su_timer_queue_t *su_port_deferrable(su_port_t *self)
00424 {
00425   su_virtual_port_t *base = (su_virtual_port_t *)self;
00426 
00427   if (base == NULL) {
00428     errno = EFAULT;
00429     return NULL;
00430   }
00431 
00432   return base->sup_vtable->su_port_deferrable(self);
00433 }
00434 
00435 su_inline
00436 int su_port_max_defer(su_port_t *self,
00437                       su_duration_t *return_duration,
00438                       su_duration_t *set_duration)
00439 {
00440   su_virtual_port_t *base = (su_virtual_port_t *)self;
00441 
00442   if (base == NULL)
00443     return (errno = EFAULT), -1;
00444 
00445   return base->sup_vtable->su_port_max_defer(self,
00446                                              return_duration,
00447                                              set_duration);
00448 }
00449 
00450 su_inline
00451 int su_port_is_running(su_port_t const *self)
00452 {
00453   su_virtual_port_t *base = (su_virtual_port_t *)self;
00454   return base && base->sup_vtable->su_port_is_running(self);
00455 }
00456 
00457 su_inline su_time64_t
00458 su_port_stamp64(su_port_t *self)
00459 {
00460   su_virtual_port_t *base = (su_virtual_port_t *)self;
00461 
00462   if (base)
00463     return base->sup_vtable->su_port_stamp64(self);
00464   else
00465     return su_stamp64();
00466 }
00467 
00468 su_inline su_dur64_t su_port_stamp64_offset(su_port_t *self)
00469 {
00470   su_virtual_port_t *base = (su_virtual_port_t *)self;
00471 
00472   if (base)
00473     return base->sup_vtable->su_port_stamp64_offset(self);
00474 
00475   return su_now64() - su_stamp64();
00476 }
00477 
00478 SOFIAPUBFUN void su_port_wait(su_clone_r rclone);
00479 
00480 SOFIAPUBFUN int su_port_execute(su_task_r const task,
00481                                 int (*function)(void *), void *arg,
00482                                 int *return_value);
00483 
00484 /* ---------------------------------------------------------------------- */
00485 
00491 typedef struct su_base_port_s {
00492   su_home_t        sup_home[1];
00493   su_port_vtable_t const *sup_vtable;
00494 
00495   /* Implementation may vary stuff below, too. */
00496 
00497   /* Cached timestamps */
00498   su_time64_t      sup_stamp64;
00499 
00500   struct {
00501     su_time64_t    sampled;
00502     su_dur64_t     value;
00503   } sup_offset;
00504 
00505   /* Pre-poll callback */
00506   su_prepoll_f    *sup_prepoll;
00507   su_prepoll_magic_t *sup_pp_magic;
00508   su_root_t       *sup_pp_root;
00509 
00510   /* Message list - this is protected by su_port_lock()/su_port_unlock() */
00511   su_msg_t        *sup_head, **sup_tail;
00512 
00513   /* Timer list */
00514   su_timer_queue_t sup_timers, sup_deferrable;
00515 
00516   su_duration_t    sup_max_defer; 
00518   unsigned         sup_running;   
00519 } su_base_port_t;
00520 
00521 /* Base methods */
00522 
00523 SOFIAPUBFUN int su_base_port_init(su_port_t *, su_port_vtable_t const *);
00524 SOFIAPUBFUN void su_base_port_deinit(su_port_t *self);
00525 
00526 SOFIAPUBFUN void su_base_port_lock(su_port_t *self, char const *who);
00527 SOFIAPUBFUN void su_base_port_unlock(su_port_t *self, char const *who);
00528 
00529 SOFIAPUBFUN int su_base_port_thread(su_port_t const *self,
00530                                     enum su_port_thread_op op);
00531 
00532 SOFIAPUBFUN void su_base_port_incref(su_port_t *self, char const *who);
00533 SOFIAPUBFUN int su_base_port_decref(su_port_t *self,
00534                                     int blocking,
00535                                     char const *who);
00536 
00537 SOFIAPUBFUN struct _GSource *su_base_port_gsource(su_port_t *self);
00538 
00539 SOFIAPUBFUN su_socket_t su_base_port_mbox(su_port_t *self);
00540 SOFIAPUBFUN int su_base_port_send(su_port_t *self, su_msg_r rmsg);
00541 SOFIAPUBFUN int su_base_port_getmsgs(su_port_t *self);
00542 SOFIAPUBFUN int su_base_port_getmsgs_from(su_port_t *self,
00543                                            su_port_t *from);
00544 
00545 SOFIAPUBFUN void su_base_port_run(su_port_t *self);
00546 SOFIAPUBFUN void su_base_port_break(su_port_t *self);
00547 SOFIAPUBFUN su_duration_t su_base_port_step(su_port_t *self,
00548                                             su_duration_t tout);
00549 
00550 SOFIAPUBFUN int su_base_port_add_prepoll(su_port_t *self,
00551                                          su_root_t *root,
00552                                          su_prepoll_f *,
00553                                          su_prepoll_magic_t *);
00554 
00555 SOFIAPUBFUN int su_base_port_remove_prepoll(su_port_t *self, su_root_t *root);
00556 
00557 SOFIAPUBFUN su_timer_queue_t *su_base_port_timers(su_port_t *self);
00558 
00559 SOFIAPUBFUN int su_base_port_multishot(su_port_t *self, int multishot);
00560 
00561 SOFIAPUBFUN int su_base_port_start_shared(su_root_t *parent,
00562                                           su_clone_r return_clone,
00563                                           su_root_magic_t *magic,
00564                                           su_root_init_f init,
00565                                           su_root_deinit_f deinit);
00566 SOFIAPUBFUN void su_base_port_wait(su_clone_r rclone);
00567 
00568 SOFIAPUBFUN su_timer_queue_t *su_base_port_deferrable(su_port_t *self);
00569 
00570 SOFIAPUBFUN int su_base_port_max_defer(su_port_t *self,
00571                                        su_duration_t *return_duration,
00572                                        su_duration_t *set_duration);
00573 
00574 SOFIAPUBFUN int su_base_port_is_running(su_port_t const *self);
00575 
00576 SOFIAPUBFUN su_time64_t su_base_port_stamp64(su_port_t *);
00577 
00578 SOFIAPUBFUN su_dur64_t su_base_port_stamp64_offset(su_port_t *);
00579 
00580 SOFIAPUBFUN void su_base_port_waiting(su_port_t *);
00581 
00582 /* ---------------------------------------------------------------------- */
00583 
00584 #if SU_HAVE_PTHREADS
00585 
00586 #include <pthread.h>
00587 
00589 typedef struct su_pthread_port_s {
00590   su_base_port_t   sup_base[1];
00591   struct su_pthread_port_waiting_parent
00592                   *sup_waiting_parent;
00593   pthread_t        sup_tid;
00594   pthread_mutex_t  sup_obtained[1];
00595 
00596 #if 0                           /* Pausing and resuming are not used */
00597   pthread_mutex_t  sup_runlock[1];
00598   pthread_cond_t   sup_resume[1];
00599   short            sup_paused;  
00600 #endif
00601   short            sup_thread;  
00602 } su_pthread_port_t;
00603 
00604 /* Pthread methods */
00605 
00606 SOFIAPUBFUN int su_pthread_port_init(su_port_t *, su_port_vtable_t const *);
00607 SOFIAPUBFUN void su_pthread_port_deinit(su_port_t *self);
00608 
00609 SOFIAPUBFUN void su_pthread_port_lock(su_port_t *self, char const *who);
00610 SOFIAPUBFUN void su_pthread_port_unlock(su_port_t *self, char const *who);
00611 
00612 SOFIAPUBFUN int su_pthread_port_thread(su_port_t *self,
00613                                        enum su_port_thread_op op);
00614 
00615 #if 0                           /* not yet  */
00616 SOFIAPUBFUN int su_pthread_port_send(su_port_t *self, su_msg_r rmsg);
00617 
00618 SOFIAPUBFUN su_port_t *su_pthread_port_create(void);
00619 SOFIAPUBFUN su_port_t *su_pthread_port_start(su_root_t *parent,
00620                                              su_clone_r return_clone,
00621                                              su_root_magic_t *magic,
00622                                              su_root_init_f init,
00623                                              su_root_deinit_f deinit);
00624 #endif
00625 
00626 SOFIAPUBFUN int su_pthreaded_port_start(su_port_create_f *create,
00627                                         su_root_t *parent,
00628                                         su_clone_r return_clone,
00629                                         su_root_magic_t *magic,
00630                                         su_root_init_f init,
00631                                         su_root_deinit_f deinit);
00632 
00633 SOFIAPUBFUN void su_pthread_port_wait(su_clone_r rclone);
00634 SOFIAPUBFUN int su_pthread_port_execute(su_task_r const task,
00635                                         int (*function)(void *), void *arg,
00636                                         int *return_value);
00637 
00638 #if 0
00639 SOFIAPUBFUN int su_pthread_port_pause(su_port_t *self);
00640 SOFIAPUBFUN int su_pthread_port_resume(su_port_t *self);
00641 #endif
00642 
00643 #else
00644 
00645 typedef su_base_port_t su_pthread_port_t;
00646 
00647 #define su_pthread_port_init   su_base_port_init
00648 #define su_pthread_port_deinit su_base_port_deinit
00649 #define su_pthread_port_lock   su_base_port_lock
00650 #define su_pthread_port_unlock su_base_port_unlock
00651 #define su_pthread_port_thread su_base_port_thread
00652 #define su_pthread_port_wait   su_base_port_wait
00653 #define su_pthread_port_execute  su_base_port_execute
00654 
00655 #endif
00656 
00657 /* ====================================================================== */
00658 /* Mailbox port using sockets */
00659 
00660 #define SU_MBOX_SIZE 2
00661 
00662 typedef struct su_socket_port_s {
00663   su_pthread_port_t sup_base[1];
00664   int               sup_mbox_index;
00665   su_socket_t       sup_mbox[SU_MBOX_SIZE];
00666 } su_socket_port_t;
00667 
00668 SOFIAPUBFUN int su_socket_port_init(su_socket_port_t *,
00669                                     su_port_vtable_t const *);
00670 SOFIAPUBFUN void su_socket_port_deinit(su_socket_port_t *self);
00671 SOFIAPUBFUN int su_socket_port_wakeup(su_port_t *self);
00672 
00673 SOFIA_END_DECLS
00674 
00675 #endif /* SU_PORT_H */
 All Data Structures Files Functions Variables Typedefs Enumerator Defines

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