globus_xio  6.3
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
globus_i_xio.h
1 
2 #ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
3 
4 #if !defined(GLOBUS_I_XIO_H)
5 #define GLOBUS_I_XIO_H 1
6 
7 #include "globus_xio.h"
8 #include "globus_xio_driver.h"
9 #include "globus_common.h"
10 #include "globus_xio_util.h"
11 #include "globus_xio_load.h"
12 
13 #define GLOBUS_XIO_ATTR_ARRAY_BASE_SIZE 16
14 #define GLOBUS_XIO_HANDLE_DEFAULT_OPERATION_COUNT 4
15 
16 /***************************************************************************
17  * internal macros
18  * ---------------
19  **************************************************************************/
20 
21 #define GlobusXIOCurrentBlockedThread(blocked_thread) \
22  if (globus_i_am_only_thread()) \
23  { \
24  blocked_thread.thread = globus_thread_self(); \
25  } \
26  else \
27  { \
28  blocked_thread.depth = globus_callback_space_get_depth( \
29  GLOBUS_CALLBACK_GLOBAL_SPACE); \
30  }
31 #define GlobusXIOBlockedThreadMatchesCurrentThread(a) \
32  (globus_i_am_only_thread() \
33  ? (a.depth == \
34  globus_callback_space_get_depth(GLOBUS_CALLBACK_GLOBAL_SPACE)) \
35  : globus_thread_equal(a.thread, globus_thread_self()))
36 
37 GlobusDebugDeclare(GLOBUS_XIO);
38 
39 #define GlobusXIODebugPrintf(level, message) \
40  GlobusDebugPrintf(GLOBUS_XIO, level, message)
41 
42 #define GlobusXIOOpInc(_in_op) \
43 do \
44 { \
45  (_in_op)->ref++; \
46  GlobusXIODebugPrintf( \
47  GLOBUS_XIO_DEBUG_STATE, \
48  ("[%s:%d] Op @ 0x%x ref increased to %d:\n", _xio_name, __LINE__, \
49  (_in_op), (_in_op)->ref)); \
50 } while(0)
51 
52 #define GlobusXIOOpDec(_in_op) \
53 do \
54 { \
55  (_in_op)->ref--; \
56  GlobusXIODebugPrintf( \
57  GLOBUS_XIO_DEBUG_STATE, \
58  ("[%s:%d] Op @ 0x%x ref decreased to %d:\n", _xio_name, __LINE__, \
59  (_in_op), (_in_op)->ref)); \
60 } while(0)
61 
62 #define GlobusXIOObjToResult(_in_obj) \
63  (_in_obj == NULL ? GLOBUS_SUCCESS : globus_error_put(_in_obj))
64 
65 #define GlobusXIOResultToObj(_in_res) \
66  (_in_res == GLOBUS_SUCCESS ? NULL : globus_error_get(_in_res))
67 
68 #define GlobusXIOHandleStateChange(_h, _new) \
69 do \
70 { \
71  globus_i_xio_handle_t * _l_h; \
72  \
73  _l_h = (_h); \
74  GlobusXIODebugPrintf( \
75  GLOBUS_XIO_DEBUG_STATE, \
76  ("[%s:%d] Handle @ 0x%x state change:\n" \
77  " From:%s\n" \
78  " to: %s\n", \
79  _xio_name, \
80  __LINE__, \
81  _l_h, \
82  globus_i_xio_handle_state_name_table[_l_h->state], \
83  globus_i_xio_handle_state_name_table[_new])); \
84  _l_h->state = _new; \
85 } while(0)
86 
87 #define GlobusXIOOpStateChange(_op, _new) \
88 do \
89 { \
90  globus_i_xio_op_t * _l_op; \
91  \
92  _l_op = (_op); \
93  GlobusXIODebugPrintf( \
94  GLOBUS_XIO_DEBUG_STATE, \
95  ("[%s:%d] Op @ 0x%x state change:\n" \
96  " From:%s\n" \
97  " to: %s\n", \
98  _xio_name, \
99  __LINE__, \
100  _l_op, \
101  globus_i_xio_op_state_name_table[_l_op->state], \
102  globus_i_xio_op_state_name_table[_new])); \
103  _l_op->state = _new; \
104 } while(0)
105 
106 #define GlobusXIOContextStateChange(_c, _new) \
107 do \
108 { \
109  globus_i_xio_context_entry_t * _l_context; \
110  \
111  _l_context = (_c); \
112  GlobusXIODebugPrintf( \
113  GLOBUS_XIO_DEBUG_STATE, \
114  ("[%s:%d] Context @ 0x%x state change:\n" \
115  " From:%s\n" \
116  " to: %s\n", \
117  _xio_name, \
118  __LINE__, \
119  _l_context, \
120  globus_i_xio_context_state_name_table[_l_context->state], \
121  globus_i_xio_context_state_name_table[_new])); \
122  _l_context->state = _new; \
123 } while(0)
124 
125 #define GlobusXIODebugEnter() \
126  GlobusXIODebugPrintf( \
127  GLOBUS_XIO_DEBUG_TRACE, \
128  ("[%s] Entering\n", _xio_name))
129 
130 #define GlobusXIODebugExit() \
131  GlobusXIODebugPrintf( \
132  GLOBUS_XIO_DEBUG_TRACE, \
133  ("[%s] Exiting\n", _xio_name))
134 
135 #define GlobusXIODebugExitWithError() \
136  GlobusXIODebugPrintf( \
137  GLOBUS_XIO_DEBUG_TRACE, \
138  ("[%s] Exiting with error\n", _xio_name))
139 
140 #define GlobusXIODebugInternalEnter() \
141  GlobusXIODebugPrintf( \
142  GLOBUS_XIO_DEBUG_INTERNAL_TRACE, \
143  ("[%s] I Entering\n", _xio_name))
144 
145 #define GlobusXIODebugInternalExit() \
146  GlobusXIODebugPrintf( \
147  GLOBUS_XIO_DEBUG_INTERNAL_TRACE, \
148  ("[%s] I Exiting\n", _xio_name))
149 
150 #define GlobusXIODebugInternalExitWithError() \
151  GlobusXIODebugPrintf( \
152  GLOBUS_XIO_DEBUG_INTERNAL_TRACE, \
153  ("[%s] I Exiting with error\n", _xio_name))
154 
155 #define GlobusXIODebugInregisterOneShot() \
156  GlobusXIODebugPrintf( \
157  GLOBUS_XIO_DEBUG_INFO, \
158  ("[%s] Registering one shot due to in_register.\n", _xio_name))
159 
160 #define GlobusXIODebugDelayedFinish() \
161  GlobusXIODebugPrintf( \
162  GLOBUS_XIO_DEBUG_INFO, \
163  ("[%s] Delaying finish due to in_register and blocking op.\n", \
164  _xio_name))
165 
166 #define GlobusXIOOperationCreate(_out_op, _in_c) \
167 do \
168 { \
169  globus_i_xio_op_t * _X_op; \
170  globus_i_xio_context_t * _X_c; \
171  \
172  _X_c = (_in_c); \
173  _X_op = (globus_i_xio_op_t * ) \
174  globus_memory_pop_node(&_X_c->op_memory); \
175  if(_X_op != NULL) \
176  { \
177  /* sets deliver_op to NONE */ \
178  memset(_X_op, '\0', sizeof(globus_i_xio_op_t) + \
179  (sizeof(globus_i_xio_op_entry_t) * (_X_c->stack_size - 1))); \
180  _X_op->_op_context = _X_c; \
181  _X_op->stack_size = _X_c->stack_size; \
182  _X_op->progress = GLOBUS_TRUE; \
183  _X_op->_op_ent_offset = -1; \
184  } \
185  _out_op = _X_op; \
186 } while(0)
187 
188 
189 /* if index == the level at which a cancel was requested then we reset the
190  * canceled flag for the operation.
191  */
192 #define GlobusIXIOClearCancel(op) \
193 do \
194 { \
195  globus_i_xio_op_t * _op = (op); \
196  /* op->ndx is source_ndx + 1, canceled is source_ndx + 2 */ \
197  /* so, source_ndx == op->ndx + 1 */ \
198  /* see globus_i_xio_operation_cancel */ \
199  if(_op->canceled) \
200  { \
201  globus_mutex_lock(&_op->_op_context->cancel_mutex); \
202  if(_op->canceled == _op->ndx + 1) \
203  { \
204  _op->canceled = 0; \
205  } \
206  globus_mutex_unlock(&_op->_op_context->cancel_mutex); \
207  } \
208 } while(0)
209 
210 /***************************************************************************
211  * state and type enumerations
212  * ---------------------------
213  **************************************************************************/
214 
215 /* forward declare for setting cred */
216 typedef struct gss_cred_id_desc_struct * gss_cred_id_t;
217 
218 extern char * globus_i_xio_context_state_name_table[];
219 
220 typedef enum globus_i_xio_context_state_e
221 {
222  GLOBUS_XIO_CONTEXT_STATE_NONE,
223  GLOBUS_XIO_CONTEXT_STATE_OPENING,
224  GLOBUS_XIO_CONTEXT_STATE_OPEN,
225  GLOBUS_XIO_CONTEXT_STATE_OPEN_FAILED,
226  GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED,
227  GLOBUS_XIO_CONTEXT_STATE_EOF_DELIVERED,
228  GLOBUS_XIO_CONTEXT_STATE_EOF_RECEIVED_AND_CLOSING,
229  GLOBUS_XIO_CONTEXT_STATE_EOF_DELIVERED_AND_CLOSING,
230  GLOBUS_XIO_CONTEXT_STATE_CLOSING,
231  GLOBUS_XIO_CONTEXT_STATE_OPENING_AND_CLOSING,
232  GLOBUS_XIO_CONTEXT_STATE_CLOSED
233 } globus_i_xio_context_state_t;
234 
235 extern char * globus_i_xio_handle_state_name_table[];
236 
237 typedef enum globus_i_xio_handle_state_e
238 {
239  GLOBUS_XIO_HANDLE_STATE_NONE,
240  GLOBUS_XIO_HANDLE_STATE_CLIENT,
241  GLOBUS_XIO_HANDLE_STATE_ACCEPTED,
242  GLOBUS_XIO_HANDLE_STATE_OPENING,
243  GLOBUS_XIO_HANDLE_STATE_OPENING_FAILED,
244  GLOBUS_XIO_HANDLE_STATE_OPENING_AND_CLOSING,
245  GLOBUS_XIO_HANDLE_STATE_OPEN,
246  GLOBUS_XIO_HANDLE_STATE_OPEN_FAILED,
247  GLOBUS_XIO_HANDLE_STATE_CLOSING,
248  GLOBUS_XIO_HANDLE_STATE_CLOSED
249 } globus_i_xio_handle_state_t;
250 
251 extern char * globus_i_xio_op_state_name_table[];
252 
253 typedef enum globus_i_xio_op_state_e
254 {
255  GLOBUS_XIO_OP_STATE_NONE,
256  GLOBUS_XIO_OP_STATE_OPERATING,
257  GLOBUS_XIO_OP_STATE_TIMEOUT_PENDING,
258  GLOBUS_XIO_OP_STATE_FINISH_WAITING,
259  GLOBUS_XIO_OP_STATE_FINISHED
260 } globus_i_xio_op_state_t;
261 
262 typedef enum globus_xio_server_state_e
263 {
264  GLOBUS_XIO_SERVER_STATE_NONE,
265  GLOBUS_XIO_SERVER_STATE_OPEN,
266  GLOBUS_XIO_SERVER_STATE_ACCEPTING,
267  GLOBUS_XIO_SERVER_STATE_COMPLETING,
268  GLOBUS_XIO_SERVER_STATE_CLOSE_PENDING,
269  GLOBUS_XIO_SERVER_STATE_CLOSING,
270  GLOBUS_XIO_SERVER_STATE_CLOSED
271 } globus_xio_server_state_t;
272 
273 /***************************************************************************
274  * Internally exposed data structures
275  * ----------------------------------
276  **************************************************************************/
277 
278 
279 struct globus_i_xio_context_s;
280 struct globus_i_xio_op_s;
281 
282 typedef struct globus_i_xio_monitor_s
283 {
284  int count;
285 } globus_i_xio_monitor_t;
286 
287 void
288 globus_i_xio_monitor_init(
289  globus_i_xio_monitor_t * monitor);
290 
291 void
292 globus_i_xio_monitor_destroy(
293  globus_i_xio_monitor_t * monitor);
294 
295 typedef struct globus_i_xio_attr_ent_s
296 {
297  globus_xio_driver_t driver;
298  void * driver_data;
299 } globus_i_xio_attr_ent_t;
300 
301 typedef struct globus_i_xio_attr_s
302 {
303  globus_bool_t unloaded;
304 
305  globus_xio_timeout_callback_t open_timeout_cb;
306  globus_reltime_t open_timeout_period;
307  globus_xio_timeout_callback_t read_timeout_cb;
308  globus_reltime_t read_timeout_period;
309  globus_xio_timeout_callback_t write_timeout_cb;
310  globus_reltime_t write_timeout_period;
311  globus_xio_timeout_callback_t close_timeout_cb;
312  globus_reltime_t close_timeout_period;
313 
314  globus_xio_timeout_server_callback_t accept_timeout_cb;
315  globus_reltime_t accept_timeout_period;
316 
317  globus_bool_t cancel_open;
318  globus_bool_t cancel_close;
319  globus_bool_t cancel_read;
320  globus_bool_t cancel_write;
321 
322  globus_bool_t no_cancel;
323  void * timeout_arg;
324 
325  gss_cred_id_t user_open_cred;
326  char * user_open_sbj;
327  char * user_open_username;
328  char * user_open_pw;
329 
330  globus_callback_space_t space;
331 
332  int max;
333  int ndx;
334  globus_i_xio_attr_ent_t * entry;
335 } globus_i_xio_attr_t;
336 
337 typedef struct globus_i_xio_stack_s
338 {
339  int size;
340  globus_list_t * driver_stack;
341  globus_xio_driver_t pushing_driver;
342 } globus_i_xio_stack_t;
343 
344 
345 typedef struct globus_i_xio_server_entry_s
346 {
347  globus_xio_driver_t driver;
348  void * server_handle;
349 } globus_i_xio_server_entry_t;
350 /*
351  *
352  */
353 typedef struct globus_i_xio_server_s
354 {
355  globus_i_xio_monitor_t * sd_monitor;
356 
357  globus_xio_server_state_t state;
358 
359  globus_xio_timeout_server_callback_t accept_timeout;
360  globus_reltime_t accept_timeout_period;
361  struct globus_i_xio_op_s * op;
362 
364  void * user_arg;
365 
366  int outstanding_operations;
367 
368  int ref;
369  globus_mutex_t mutex;
370  globus_callback_space_t space;
371 
372  globus_bool_t blocking;
373  char * contact_string;
374 
375  int stack_size;
376  globus_i_xio_server_entry_t entry[1];
377 } globus_i_xio_server_t;
378 
379 typedef struct globus_i_xio_handle_s
380 {
381  globus_i_xio_monitor_t * sd_monitor;
382 
383  globus_list_t * cb_list;
384  int ref;
385  struct globus_i_xio_context_s * context;
386 
387  globus_i_xio_handle_state_t state;
388 
389  /* since only 1 open or close can be outstanding at a time we don't
390  need a list */
391  globus_list_t * write_op_list;
392  globus_list_t * read_op_list;
393  struct globus_i_xio_op_s * open_op;
394  struct globus_i_xio_op_s * close_op;
395 
396  void * timeout_arg;
397 
398  globus_callback_space_t space;
399  globus_xio_timeout_callback_t open_timeout_cb;
400  globus_reltime_t open_timeout_period;
401  globus_xio_timeout_callback_t read_timeout_cb;
402  globus_reltime_t read_timeout_period;
403  globus_xio_timeout_callback_t write_timeout_cb;
404  globus_reltime_t write_timeout_period;
405  globus_xio_timeout_callback_t close_timeout_cb;
406  globus_reltime_t close_timeout_period;
407 } globus_i_xio_handle_t;
408 
409 /*
410  * represents an entry in the array of open handles.
411  *
412  * each entry is mapped to a driver in the stack
413  */
414 typedef struct globus_i_xio_context_entry_s
415 {
416  globus_xio_driver_t driver;
417  void * driver_handle;
418 
419  /* each level must implement the entire state machine */
420  globus_i_xio_context_state_t state;
421  int outstanding_operations;
422  int read_operations;
423  int eof_operations;
424  int pending_reads;
425 
426  /* is this hacky? */
427  globus_bool_t close_started;
428 
429  struct globus_i_xio_op_s * open_op;
430  struct globus_i_xio_op_s * close_op;
431  globus_list_t * eof_op_list;
432  globus_fifo_t pending_read_queue;
433  struct globus_i_xio_context_s * whos_my_daddy;
434 } globus_i_xio_context_entry_t;
435 
436 /*
437  * a stretchy array
438  */
439 typedef struct globus_i_xio_context_s
440 {
441  /* handle has a reference and every entry has a reference */
442  int ref;
443  int stack_size;
444 
445  globus_memory_t op_memory;
446  globus_mutex_t mutex;
447  globus_mutex_t cancel_mutex;
448  globus_i_xio_context_entry_t entry[1];
449 } globus_i_xio_context_t;
450 
451 /* MACROS for accessing the op_entry structure unin elements */
452 #define _op_ent_data_cb type_u.handle_s.data_cb
453 #define _op_ent_wait_for type_u.handle_s.wait_for_bytes
454 #define _op_ent_offset type_u.handle_s.offset
455 #define _op_ent_nbytes type_u.handle_s.nbytes
456 #define _op_ent_iovec type_u.handle_s.iovec
457 #define _op_ent_iovec_count type_u.handle_s.iovec_count
458 #define _op_ent_fake_iovec type_u.handle_s.fake_iovec
459 
460 /*
461  * represents a entry in an array of operations. Each entry
462  * is mapped to a driver at the same index.
463  */
464 typedef struct globus_i_xio_op_entry_s
465 {
466  /* callback info arrays */
469  void * user_arg;
470 
471  union
472  {
473  /* handle op entries */
474  struct
475  {
477  globus_size_t wait_for_bytes;
478  globus_size_t nbytes;
479  globus_xio_iovec_t * iovec;
480  int iovec_count;
481  globus_xio_iovec_t * fake_iovec;
482  } handle_s;
483  } type_u;
484  globus_bool_t in_register;
485  globus_bool_t is_limited;
486 
487  void * dd;
488  void * link;
489  void * open_attr;
490  void * close_attr;
491  int prev_ndx;
492  int next_ndx;
493 
494  globus_xio_operation_type_t * deliver_type;
495 } globus_i_xio_op_entry_t;
496 
497 
498 #define _op_data_cb data_cb
499 #define _op_iovec_cb iovec_cb
500 #define _op_cb callback_u.cb
501 #define _op_accept_cb callback_u.accept_cb
502 
503 #define _op_handle type_u.handle_s.handle
504 #define _op_iovec type_u.handle_s.iovec
505 #define _op_iovec_count type_u.handle_s.iovec_count
506 #define _op_mem_iovec type_u.handle_s.mem_iovec
507 #define _op_context type_u.handle_s.context
508 #define _op_nbytes type_u.handle_s.nbytes
509 #define _op_wait_for type_u.handle_s.wait_for
510 #define _op_handle_timeout_cb type_u.handle_s.timeout_cb
511 
512 #define _op_server type_u.server_s.server
513 #define _op_server_timeout_cb type_u.server_s.timeout_cb
514 
521 typedef union
522 {
523  globus_thread_t thread;
524  int depth;
525 }
526 globus_i_xio_blocked_thread_t;
527 /*
528  * represents a requested io operation (open close read or write).
529  */
530 typedef struct globus_i_xio_op_s
531 {
532  /* operation type */
534  globus_i_xio_op_state_t state;
535 
536  globus_bool_t is_user_dd;
537 
538  /*
539  * user callbacks. only 1 will be used per operation
540  */
541  union
542  {
545  }callback_u;
546 
549  void * user_arg;
550 
551  /*
552  * Union operation members that will not overlap together
553  */
554  union
555  {
556  /* handle op stuff */
557  struct
558  {
559  globus_i_xio_handle_t * handle;
560 
561  globus_xio_iovec_t * iovec;
562  int iovec_count;
563  globus_xio_iovec_t mem_iovec;
564 
565  globus_size_t nbytes;
566 
567  /* convenience pointer, really owned by handle */
568  globus_i_xio_context_t * context;
569  /* data descriptor */
570  globus_size_t wait_for;
571  globus_off_t offset;
573  } handle_s;
574  /* server op stuff */
575  struct
576  {
577  globus_i_xio_server_t * server;
578  globus_xio_timeout_server_callback_t timeout_cb;
579  } server_s;
580  } type_u;
581 
582  /* flag to determine if timeout should happen */
583  globus_bool_t progress;
584 
585  /* reference count for destruction */
586  int ref;
587 
588  /* members for cancellation */
589  globus_xio_driver_cancel_callback_t cancel_cb;
590  void * cancel_arg;
591  int canceled;
592  globus_bool_t block_timeout;
593 
594  globus_bool_t restarted;
595  globus_bool_t blocking;
596  globus_i_xio_blocked_thread_t blocked_thread;
597  globus_bool_t finished_delayed;
598 
599  /* just stash away the cred to open so that the driver can interrogate
600  it. */
601  gss_cred_id_t user_open_cred;
602  char * user_open_sbj;
603  char * user_open_username;
604  char * user_open_pw;
605 
606  /* result code saved in op for kickouts */
607  globus_object_t * cached_obj;
608 
609  /* size of the arrays */
610  int stack_size;
611  /* current index in the driver stack */
612  int ndx;
613  /* entry for each thing driver in the stack */
614  globus_i_xio_op_entry_t entry[1];
615 } globus_i_xio_op_t;
616 
617 typedef struct globus_i_xio_driver_s
618 {
619  char * name;
620  void * user_data;
621  void * wrap_data;
622  /* these are filled in by the driver loader */
623  globus_xio_driver_hook_t * hook;
624  globus_extension_handle_t extension_handle;
625  globus_bool_t extension_activated;
626 
627  globus_xio_string_cntl_table_t * string_table;
628  globus_xio_string_cntl_table_t * handle_string_table;
629 
630  /*
631  * main io interface functions
632  */
633  globus_xio_driver_transform_open_t transform_open_func;
634  globus_xio_driver_transport_open_t transport_open_func;
635  globus_xio_driver_close_t close_func;
636  globus_xio_driver_read_t read_func;
637  globus_xio_driver_write_t write_func;
638  globus_xio_driver_handle_cntl_t handle_cntl_func;
639 
640  globus_xio_driver_push_driver_t push_driver_func;
641 
642  /*
643  * server
644  */
645  globus_xio_driver_server_init_t server_pre_init_func;
646  globus_xio_driver_server_init_t server_init_func;
647  globus_xio_driver_server_accept_t server_accept_func;
648  globus_xio_driver_server_destroy_t server_destroy_func;
649  globus_xio_driver_server_cntl_t server_cntl_func;
650  globus_xio_driver_link_cntl_t link_cntl_func;
651  globus_xio_driver_link_destroy_t link_destroy_func;
652 
653  /*
654  * driver attr functions. All or none may be NULL
655  *
656  * data descriptor is done with attr
657  */
658  globus_xio_driver_attr_init_t attr_init_func;
659  globus_xio_driver_attr_copy_t attr_copy_func;
660  globus_xio_driver_attr_cntl_t attr_cntl_func;
661  globus_xio_driver_attr_destroy_t attr_destroy_func;
662 } globus_i_xio_driver_t;
663 
664 
665 /*
666  * wrapper struct
667  */
668 typedef struct globus_i_xio_blocking_s
669 {
670  globus_mutex_t mutex;
671  globus_cond_t cond;
672  globus_bool_t done;
673  globus_size_t nbytes;
674  globus_i_xio_op_t * op;
675  globus_xio_handle_t accepted_handle;
676  globus_xio_data_descriptor_t data_desc;
677  globus_object_t * error_obj;
678 } globus_i_xio_blocking_t;
679 
680 typedef struct globus_i_xio_restart_s
681 {
682  globus_i_xio_op_t * op;
683  globus_bool_t restarted;
684 } globus_i_xio_restart_t;
685 
686 globus_i_xio_blocking_t *
687 globus_i_xio_blocking_alloc();
688 
689 void
690 globus_i_xio_blocking_destroy(
691  globus_i_xio_blocking_t * info);
692 
693 /*************************************************************************
694  * internal function signatures
695  ************************************************************************/
696 globus_result_t
697 globus_i_xio_server_close(
698  globus_xio_server_t xio_server,
700  void * user_arg);
701 
702 void
703 globus_l_xio_driver_purge_read_eof(
704  globus_i_xio_context_entry_t * my_context);
705 
706 void
707 globus_l_xio_driver_op_write_kickout(
708  void * user_arg);
709 
710 void
711 globus_l_xio_driver_op_read_kickout(
712  void * user_arg);
713 
714 globus_result_t
715 globus_i_xio_driver_start_close(
716  globus_i_xio_op_t * op,
717  globus_bool_t can_fail);
718 
719 void
720 globus_l_xio_driver_op_close_kickout(
721  void * user_arg);
722 
723 void
724 globus_l_xio_driver_op_accept_kickout(
725  void * user_arg);
726 
727 void
728 globus_l_xio_driver_open_op_kickout(
729  void * user_arg);
730 
731 void
732 globus_i_xio_driver_resume_op(
733  globus_i_xio_op_t * op);
734 
735 /*
736  * time stuff
737  */
738 typedef globus_bool_t
739 (*globus_i_xio_timer_cb_t)(
740  void * datum);
741 
742 typedef struct globus_i_xio_op_timer_s
743 {
744  globus_reltime_t minimal_delay;
745  globus_mutex_t mutex;
746  globus_cond_t cond;
747  globus_list_t * op_list;
748  globus_bool_t running;
749  globus_callback_handle_t periodic_handle;
750 } globus_i_xio_timer_t;
751 
752 void
753 globus_i_xio_timer_init(
754  globus_i_xio_timer_t * timer);
755 
756 void
757 globus_i_xio_timer_destroy(
758  globus_i_xio_timer_t * timer);
759 
760 void
761 globus_i_xio_timer_register_timeout(
762  globus_i_xio_timer_t * timer,
763  void * datum,
764  globus_bool_t * progress_ptr,
765  globus_i_xio_timer_cb_t timeout_cb,
766  globus_reltime_t * timeout);
767 
768 globus_bool_t
769 globus_i_xio_timer_unregister_timeout(
770  globus_i_xio_timer_t * timer,
771  void * datum);
772 
773 globus_i_xio_context_t *
774 globus_i_xio_context_create(
775  int stack_size);
776 
777 void
778 globus_i_xio_context_destroy(
779  globus_i_xio_context_t * xio_context);
780 
781 void
782 globus_i_xio_will_block_cb(
783  int space,
784  globus_thread_callback_index_t ndx,
785  void * user_args);
786 
787 void
788 globus_i_xio_pass_failed(
789  globus_i_xio_op_t * op,
790  globus_i_xio_context_entry_t * my_context,
791  globus_bool_t * close,
792  globus_bool_t * destroy_handle);
793 
794 void
795 globus_i_xio_handle_destroy(
796  globus_i_xio_handle_t * handle);
797 
798 void
799 globus_i_xio_handle_dec(
800  globus_i_xio_handle_t * handle,
801  globus_bool_t * destroy_handle);
802 
803 void
804 globus_i_xio_op_destroy(
805  globus_i_xio_op_t * op,
806  globus_bool_t * destroy_handle);
807 
808 globus_result_t
809 globus_i_xio_repass_write(
810  globus_i_xio_op_t * op);
811 
812 globus_result_t
813 globus_i_xio_repass_read(
814  globus_i_xio_op_t * op);
815 
816 void
817 globus_i_xio_register_oneshot(
818  globus_i_xio_handle_t * handle,
819  globus_callback_func_t cb,
820  void * user_arg,
821  globus_callback_space_t space);
822 
823 
824 typedef struct globus_i_xio_space_info_s
825 {
826  globus_bool_t unregister;
827  globus_i_xio_handle_t * handle;
828  globus_callback_handle_t ch;
829  globus_callback_func_t func;
830  void * user_arg;
831 } globus_i_xio_space_info_t;
832 
833 void
834 globus_i_xio_close_handles(
835  globus_xio_driver_t driver);
836 
837 globus_result_t
838 globus_i_xio_operation_cancel(
839  globus_i_xio_op_t * op,
840  int source_ndx);
841 
842 void
843 globus_i_xio_driver_deliver_op(
844  globus_i_xio_op_t * op,
845  int ndx,
846  globus_xio_operation_type_t deliver_type);
847 
848 void
849 globus_xio_driver_open_delivered(
850  globus_xio_operation_t in_op,
851  int in_ndx,
852  globus_xio_operation_type_t * deliver_type);
853 
854 void
855 globus_xio_driver_write_delivered(
856  globus_xio_operation_t in_op,
857  int in_ndx,
858  globus_xio_operation_type_t * deliver_type);
859 
860 void
861 globus_xio_driver_read_delivered(
862  globus_xio_operation_t op,
863  int in_ndx,
864  globus_xio_operation_type_t * deliver_type);
865 
866 globus_result_t
867 globus_i_xio_driver_dd_cntl(
868  globus_i_xio_op_t * op,
869  globus_xio_driver_t driver,
871  int cmd,
872  va_list ap);
873 
874 globus_result_t
875 globus_i_xio_driver_handle_cntl(
876  globus_i_xio_context_t * context,
877  int start_ndx,
878  globus_xio_driver_t driver,
879  int cmd,
880  va_list ap);
881 
882 globus_result_t
883 globus_i_xio_driver_attr_cntl(
884  globus_i_xio_attr_t * attr,
885  globus_xio_driver_t driver,
886  int cmd,
887  va_list ap);
888 
889 globus_result_t
890 globus_i_xio_string_cntl_parser(
891  const char * env_str,
892  globus_xio_string_cntl_table_t * table,
893  void * attr,
895 
896 
897 extern globus_i_xio_timer_t globus_i_xio_timeout_timer;
898 extern globus_list_t * globus_i_xio_outstanding_handles_list;
899 extern globus_list_t * globus_i_xio_outstanding_servers_list;
900 extern globus_list_t * globus_i_xio_outstanding_attrs_list;
901 extern globus_list_t * globus_i_xio_outstanding_dds_list;
902 extern globus_mutex_t globus_i_xio_mutex;
903 extern globus_cond_t globus_i_xio_cond;
904 
905 #endif /* GLOBUS_I_XIO_H */
906 
907 #endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
void(* globus_xio_driver_data_callback_t)(globus_xio_operation_t op, globus_result_t result, globus_size_t nbytes, void *user_arg)
Definition: globus_xio_driver.h:285
void(* globus_xio_accept_callback_t)(globus_xio_server_t server, globus_xio_handle_t handle, globus_result_t result, void *user_arg)
Definition: globus_xio.h:342
globus_result_t(* globus_xio_driver_attr_copy_t)(void **dst, void *src)
Definition: globus_xio_driver.h:353
globus_result_t(* globus_xio_driver_read_t)(void *driver_specific_handle, const globus_xio_iovec_t *iovec, int iovec_count, globus_xio_operation_t op)
Definition: globus_xio_driver.h:868
globus_result_t(* globus_xio_driver_write_t)(void *driver_specific_handle, const globus_xio_iovec_t *iovec, int iovec_count, globus_xio_operation_t op)
Definition: globus_xio_driver.h:1018
globus_result_t(* globus_xio_driver_server_destroy_t)(void *driver_server)
Definition: globus_xio_driver.h:470
globus_result_t(* globus_xio_driver_attr_cntl_t)(void *attr, int cmd, va_list ap)
Definition: globus_xio_driver.h:388
void(* globus_xio_data_callback_t)(globus_xio_handle_t handle, globus_result_t result, globus_byte_t *buffer, globus_size_t len, globus_size_t nbytes, globus_xio_data_descriptor_t data_desc, void *user_arg)
Definition: globus_xio.h:585
globus_result_t(* globus_xio_driver_close_t)(void *driver_handle, void *driver_attr, globus_xio_operation_t op)
Close a handle.
Definition: globus_xio_driver.h:794
globus_bool_t(* globus_xio_timeout_callback_t)(globus_xio_handle_t handle, globus_xio_operation_type_t type, void *user_arg)
Definition: globus_xio.h:506
enum globus_i_xio_op_type_e globus_xio_operation_type_t
void(* globus_xio_callback_t)(globus_xio_handle_t handle, globus_result_t result, void *user_arg)
Definition: globus_xio.h:571
globus_result_t(* globus_xio_driver_transport_open_t)(const globus_xio_contact_t *contact_info, void *driver_link, void *driver_attr, globus_xio_operation_t op)
Open a handle.
Definition: globus_xio_driver.h:629
globus_result_t(* globus_xio_driver_attr_destroy_t)(void *driver_attr)
Definition: globus_xio_driver.h:365
void(* globus_xio_driver_callback_t)(globus_xio_operation_t op, globus_result_t result, void *user_arg)
Open and Close Callback Signature.
Definition: globus_xio_driver.h:257
globus_result_t(* globus_xio_driver_handle_cntl_t)(void *handle, int cmd, va_list ap)
Definition: globus_xio_driver.h:760
globus_result_t(* globus_xio_driver_server_init_t)(void *driver_attr, const globus_xio_contact_t *contact_info, globus_xio_operation_t op)
Definition: globus_xio_driver.h:419
globus_result_t(* globus_xio_driver_transform_open_t)(const globus_xio_contact_t *contact_info, void *driver_link, void *driver_attr, globus_xio_operation_t op)
Open a handle.
Definition: globus_xio_driver.h:618
globus_result_t(* globus_xio_driver_link_destroy_t)(void *driver_link)
Definition: globus_xio_driver.h:582
globus_result_t(* globus_xio_driver_server_cntl_t)(void *driver_server, int cmd, va_list ap)
Definition: globus_xio_driver.h:556
globus_result_t(* globus_xio_driver_server_accept_t)(void *driver_server, globus_xio_operation_t op)
Definition: globus_xio_driver.h:494
void(* globus_xio_server_callback_t)(globus_xio_server_t server, void *user_arg)
Definition: globus_xio.h:356
void(* globus_xio_iovec_callback_t)(globus_xio_handle_t handle, globus_result_t result, globus_xio_iovec_t *iovec, int count, globus_size_t nbytes, globus_xio_data_descriptor_t data_desc, void *user_arg)
Definition: globus_xio.h:603
globus_result_t(* globus_xio_driver_attr_init_t)(void **out_driver_attr)
Definition: globus_xio_driver.h:342