su 1.12.11devel
|
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 */