1 /*
2 * Portions of this file Copyright 1999-2005 University of Chicago
3 * Portions of this file Copyright 1999-2005 The University of Southern California.
4 *
5 * This file or a portion of this file is licensed under the
6 * terms of the Globus Toolkit Public License, found at
7 * http://www.globus.org/toolkit/download/license.html.
8 * If you redistribute this file, with or without
9 * modifications, you must include this notice in the file.
10 */
11
12
13 #include "globus_i_service_engine.h"
14 #include "globus_service_registry.h"
15 #include "globus_soap_message.h"
16 #include "globus_soap_message_attrs.h"
17 #include "globus_soap_message_fault.h"
18 #include "globus_xio_tcp_driver.h"
19 #include "globus_xio_http.h"
20 #include "globus_xio_buffer.h"
21 #include "version.h"
22 #include "globus_flavor.h"
23 #include "libxml/uri.h"
24 #include "globus_ws_addressing.h"
25 #include "globus_soap_message_markers.h"
26 #include "globus_i_soap_message.h"
27 #include "globus_usage.h"
28
29 #define SOAP_ACTION_HEADER "SOAPAction"
30 #define CONTENT_TYPE_HEADER "Content-Type"
31
32 #define GLOBUS_I_SERVICE_DESCRIPTOR_KEY "GLOBUS_SERVICE_DESCRIPTOR"
33 #define GLOBUS_I_SERVICE_EXTENSION_HANDLE_KEY "GLOBUS_SERVICE_EXTENSION_HANDLE"
34 #define GLOBUS_I_SESSION_HANDLE_KEY "GLOBUS_ENGINE_CALLBACK_HANDLE"
35 #define GLOBUS_I_SERVICE_OPERATION_QNAME_KEY "GLOBUS_SERVICE_OPERATION_QNAME"
36
37 static globus_list_t * globus_l_service_engine_extensions = NULL;
38 static globus_mutex_t globus_l_service_engine_extensions_mutex;
39
40 globus_extension_registry_t globus_service_registry =
41 {
42 NULL,
43 GLOBUS_FALSE,
44 GLOBUS_FALSE
45 };
46
47 static int
48 globus_l_service_engine_activate();
49
50 static int
51 globus_l_service_engine_deactivate();
52
53 globus_module_descriptor_t globus_l_service_engine_module =
54 {
55 "globus_service_engine_module",
56 globus_l_service_engine_activate,
57 globus_l_service_engine_deactivate,
58 NULL,
59 NULL,
60 &local_version
61 };
62
63 0 GlobusDebugDefine(GLOBUS_SERVICE_ENGINE);
64
65 typedef enum
66 {
67 GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_MESSAGE,
68 GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_SERVICE_HANDLERS,
69 GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_HANDLERS,
70 GLOBUS_L_SERVICE_ENGINE_START_DESERIALIZE,
71 GLOBUS_L_SERVICE_ENGINE_TRIGGER_INVOKE_HANDLERS,
72 GLOBUS_L_SERVICE_ENGINE_REQUEST_HEADER_FAILED,
73 GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_HANDLERS,
74 GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_SERVICE_HANDLERS,
75 GLOBUS_L_SERVICE_ENGINE_REQUEST_DESERIALIZE,
76 GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_SERVICE_HANDLERS,
77 GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_HANDLERS,
78 GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_OPERATION,
79 GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_ANOTHER_MESSAGE,
80 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_SERVICE_HANDLERS,
81 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_HANDLERS,
82 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_SERVICE_HANDLERS,
83 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_HANDLERS,
84 GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_SERVICE_HANDLERS,
85 GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_HANDLERS,
86 GLOBUS_L_SERVICE_ENGINE_RESPONSE_SEND,
87 GLOBUS_L_SERVICE_ENGINE_RESPONSE_CLOSE,
88 GLOBUS_L_SERVICE_ENGINE_RESPONSE_DONE
89 } globus_l_service_session_state_t;
90
91 static char * globus_l_service_engine_state_strings[22] =
92 {
93 "GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_MESSAGE",
94 "GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_SERVICE_HANDLERS",
95 "GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_HANDLERS",
96 "GLOBUS_L_SERVICE_ENGINE_START_DESERIALIZE",
97 "GLOBUS_L_SERVICE_ENGINE_TRIGGER_INVOKE_HANDLERS",
98 "GLOBUS_L_SERVICE_ENGINE_REQUEST_HEADER_FAILED",
99 "GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_HANDLERS",
100 "GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_SERVICE_HANDLERS",
101 "GLOBUS_L_SERVICE_ENGINE_REQUEST_DESERIALIZE",
102 "GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_SERVICE_HANDLERS",
103 "GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_HANDLERS",
104 "GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_OPERATION",
105 "GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_ANOTHER_MESSAGE",
106 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_SERVICE_HANDLERS",
107 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_HANDLERS",
108 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_SERVICE_HANDLERS",
109 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_HANDLERS",
110 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_SERVICE_HANDLERS",
111 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_HANDLERS",
112 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_SEND",
113 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_CLOSE",
114 "GLOBUS_L_SERVICE_ENGINE_RESPONSE_DONE"
115 };
116
117 typedef struct globus_l_session_callback_handle_s
118 {
119 globus_service_engine_t engine;
120 globus_soap_message_handle_t message;
121 globus_service_session_callback_func_t callback;
122 void * args;
123 globus_l_service_session_state_t state;
124 globus_result_t result;
125 globus_result_t callback_result;
126 globus_service_response_t response;
127
128 globus_service_session_callback_func_t process_callback;
129 void * process_args;
130 globus_bool_t faulting;
131 } globus_l_session_callback_handle_t;
132
133 typedef struct
134 {
135 globus_service_engine_t engine;
136 globus_service_engine_callback_func_t callback;
137 void * args;
138 globus_result_t result;
139 } globus_l_service_engine_callback_handle_t;
140
141 static
142 void
143 globus_l_service_session_callback(
144 void * args);
145
146 static
147 void
148 globus_l_service_session_callback_handle_destroy(
149 globus_l_session_callback_handle_t * callback_handle);
150
151 static
152 void
153 globus_l_service_engine_open_callback(
154 globus_xio_handle_t handle,
155 globus_result_t result,
156 void * user_arg);
157
158 static
159 void
160 globus_l_service_engine_service_module_destroy(
161 void * ext);
162
163 static
164 void
165 globus_l_service_engine_request_ready_callback(
166 globus_xio_handle_t handle,
167 globus_result_t result,
168 globus_byte_t * buffer,
169 globus_size_t len,
170 globus_size_t nbytes,
171 globus_xio_data_descriptor_t data_desc,
172 void * user_arg);
173
174 static
175 void
176 globus_l_service_engine_accept_callback(
177 globus_xio_server_t server,
178 globus_xio_handle_t new_handle,
179 globus_result_t result,
180 void * user_args);
181
182 static
183 void
184 globus_l_service_session_result_callback(
185 globus_result_t result,
186 void * args);
187
188 static
189 void
190 globus_l_service_engine_send_client_fault(
191 void * args);
192
193 static
194 void
195 globus_l_service_engine_session_complete_callback(
196 globus_result_t result,
197 globus_service_engine_t engine,
198 globus_soap_message_handle_t session,
199 void * args);
200
201 static
202 void
203 globus_l_service_engine_session_started_callback(
204 globus_result_t result,
205 globus_service_engine_t engine,
206 globus_soap_message_handle_t session,
207 void * args);
208
209 static globus_usage_stats_handle_t globus_l_service_engine_usage;
210
211 static int
212 globus_l_service_engine_activate()
213 32 {
214 32 int rc = 0;
215 GlobusFuncName(globus_l_service_engine_activate);
216
217 32 rc = globus_module_activate(GLOBUS_COMMON_MODULE);
218 32 if(rc != GLOBUS_SUCCESS)
219 {
220 0 return rc;
221 }
222
223 32 GlobusDebugInit(GLOBUS_SERVICE_ENGINE, DEBUG INFO TRACE WARN ERROR);
224 32 GlobusServiceEngineDebugEnter();
225
226 32 rc = globus_module_activate(GLOBUS_SOAP_MESSAGE_MODULE);
227 32 if(rc != GLOBUS_SUCCESS)
228 {
229 0 globus_module_deactivate(GLOBUS_COMMON_MODULE);
230 0 goto error_exit;
231 }
232
233 32 rc = globus_module_activate(GLOBUS_OPERATION_PROVIDER_MODULE);
234 32 if(rc != GLOBUS_SUCCESS)
235 {
236 0 globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
237 0 globus_module_deactivate(GLOBUS_COMMON_MODULE);
238 0 goto error_exit;
239 }
240
241 32 rc = globus_module_activate(GLOBUS_USAGE_MODULE);
242 32 if(rc != GLOBUS_SUCCESS)
243 {
244 0 globus_module_deactivate(GLOBUS_OPERATION_PROVIDER_MODULE);
245 0 globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
246 0 globus_module_deactivate(GLOBUS_COMMON_MODULE);
247 0 goto error_exit;
248 }
249
250 32 rc = globus_usage_stats_handle_init(
251 &globus_l_service_engine_usage,
252 4, 1, NULL);
253 32 if(rc == GLOBUS_SUCCESS)
254 {
255 32 globus_usage_stats_send(globus_l_service_engine_usage, 0);
256 }
257 else
258 {
259 0 globus_object_free(globus_error_get(rc));
260 0 rc = GLOBUS_SUCCESS;
261 }
262
263 32 globus_mutex_init(&globus_l_service_engine_extensions_mutex, NULL);
264
265 32 goto exit;
266
267 0 error_exit:
268
269 0 GlobusServiceEngineDebugExit();
270 0 GlobusDebugDestroy(GLOBUS_SERVICE_ENGINE);
271 0 return rc;
272
273 32 exit:
274
275 32 GlobusServiceEngineDebugExit();
276 32 return rc;
277 }
278
279 static
280 void
281 globus_l_service_engine_extension_destroy(
282 void * sym)
283 57 {
284 57 char * symbol = (char *) sym;
285
286 57 globus_extension_deactivate(sym);
287 57 globus_free(symbol);
288 }
289
290 static int
291 globus_l_service_engine_deactivate()
292 31 {
293 31 int rc = 0;
294 GlobusFuncName(globus_l_service_engine_deactivate);
295 31 GlobusServiceEngineDebugEnter();
296
297 31 globus_usage_stats_handle_destroy(globus_l_service_engine_usage);
298
299 31 globus_mutex_lock(&globus_l_service_engine_extensions_mutex);
300 31 globus_list_destroy_all(globus_l_service_engine_extensions,
301 globus_l_service_engine_extension_destroy);
302 31 globus_mutex_unlock(&globus_l_service_engine_extensions_mutex);
303 31 globus_mutex_destroy(&globus_l_service_engine_extensions_mutex);
304
305 31 rc = globus_module_deactivate(GLOBUS_USAGE_MODULE);
306 31 if(rc != GLOBUS_SUCCESS)
307 {
308 31 goto exit;
309 }
310
311 31 rc = globus_module_deactivate(GLOBUS_OPERATION_PROVIDER_MODULE);
312 31 if(rc != GLOBUS_SUCCESS)
313 {
314 31 goto exit;
315 }
316
317 31 rc = globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
318 if(rc != GLOBUS_SUCCESS)
319 {
320 goto exit;
321 }
322
323 31 exit:
324
325 31 GlobusServiceEngineDebugExit();
326 31 GlobusDebugDestroy(GLOBUS_SERVICE_ENGINE);
327 31 globus_module_deactivate(GLOBUS_COMMON_MODULE);
328
329 31 return rc;
330 }
331
332 static
333 globus_bool_t
334 globus_l_service_engine_timeout_callback(
335 globus_xio_handle_t handle,
336 globus_xio_operation_type_t type,
337 void * user_arg)
338 0 {
339 0 return GLOBUS_TRUE;
340 }
341
342 globus_result_t
343 globus_service_engine_init(
344 globus_service_engine_t * new_engine,
345 globus_soap_message_attr_t attrs,
346 const char * port_contact,
347 globus_handler_chain_t handlers,
348 globus_bool_t enable_https)
349 30 {
350 30 globus_result_t result = GLOBUS_SUCCESS;
351 30 int port = 0;
352 30 globus_i_service_engine_t * engine = NULL;
353 30 globus_xio_attr_t server_attr = NULL;
354 30 char * contact = NULL;
355 30 void * timeout = NULL;
356 globus_soap_message_auth_method_t secattr;
357 GlobusFuncName(globus_service_engine_init);
358 30 GlobusServiceEngineDebugEnter();
359
360 30 engine = malloc(sizeof(globus_i_service_engine_t));
361 30 if(!engine)
362 {
363 0 result = GlobusServiceEngineErrorOutOfMemory;
364 0 goto exit;
365 }
366 30 memset(engine, 0, sizeof(globus_i_service_engine_t));
367
368 30 if(!attrs)
369 {
370 30 result = globus_soap_message_attr_init(&engine->attrs);
371 30 if(result != GLOBUS_SUCCESS)
372 {
373 0 result = GlobusServiceEngineErrorInitFailed(result);
374 0 goto exit;
375 }
376 }
377 else
378 {
379 0 result = globus_soap_message_attr_copy(
380 &engine->attrs, attrs);
381 0 if(result != GLOBUS_SUCCESS)
382 {
383 0 result = GlobusServiceEngineErrorInitFailed(result);
384 0 goto exit;
385 }
386 }
387
388 30 result = globus_xio_attr_init(&server_attr);
389 30 if(result != GLOBUS_SUCCESS)
390 {
391 0 result = GlobusServiceEngineErrorInitFailed(result);
392 0 goto error;
393 }
394
395 30 if(port_contact)
396 {
397 27 port = atoi(port_contact);
398 27 if(port < 0)
399 {
400 0 result = GlobusServiceEngineErrorInvalidContact(port_contact);
401 0 goto error;
402 }
403
404 27 result = globus_xio_attr_cntl(server_attr,
405 globus_i_soap_message_tcp_driver,
406 GLOBUS_XIO_TCP_SET_PORT, port);
407 27 if(result != GLOBUS_SUCCESS)
408 {
409 0 result = GlobusServiceEngineErrorInitFailed(result);
410 0 goto error;
411 }
412
413 27 result = globus_xio_attr_cntl(server_attr,
414 globus_i_soap_message_tcp_driver,
415 GLOBUS_XIO_TCP_SET_REUSEADDR,
416 GLOBUS_TRUE);
417 27 if(result != GLOBUS_SUCCESS)
418 {
419 0 result = GlobusServiceEngineErrorInitFailed(result);
420 0 goto error;
421 }
422 }
423 30 result = globus_xio_attr_cntl(server_attr,
424 globus_i_soap_message_tcp_driver,
425 GLOBUS_XIO_TCP_SET_NODELAY,
426 GLOBUS_TRUE);
427
428 30 if(result != GLOBUS_SUCCESS)
429 {
430 0 result = GlobusServiceEngineErrorInitFailed(result);
431 0 goto error;
432 }
433
434
435 30 timeout = globus_soap_message_attr_get(
436 engine->attrs, GLOBUS_SOAP_MESSAGE_TIMEOUT_KEY);
437 30 if(timeout)
438 {
439 0 result = globus_xio_attr_cntl(
440 server_attr,
441 GLOBUS_NULL,
442 GLOBUS_XIO_ATTR_SET_TIMEOUT_ALL,
443 globus_l_service_engine_timeout_callback,
444 timeout,
445 GLOBUS_NULL);
446 0 if(result != GLOBUS_SUCCESS)
447 {
448 0 result = GlobusSoapMessageErrorFailedTransport(
449 result, "Failed to set timeout for xio handle");
450 0 goto exit;
451 }
452 }
453
454 30 if(enable_https)
455 {
456 1 result = globus_i_soap_message_setup_transport_security(
457 engine->attrs,
458 server_attr);
459 1 if(result != GLOBUS_SUCCESS)
460 {
461 0 result = GlobusServiceEngineErrorInitFailed(result);
462 0 goto error;
463 }
464
465 1 result = globus_xio_server_create(
466 &engine->server,
467 server_attr,
468 globus_i_soap_message_xio_https_stack);
469 1 if(result != GLOBUS_SUCCESS)
470 {
471 0 result = GlobusServiceEngineErrorInitFailed(result);
472 0 goto error;
473 }
474 }
475 else
476 {
477 29 result = globus_xio_server_create(&engine->server,
478 server_attr,
479 globus_i_soap_message_xio_stack);
480 29 if(result != GLOBUS_SUCCESS)
481 {
482 0 result = GlobusServiceEngineErrorInitFailed(result);
483 0 goto error;
484 }
485 }
486
487 30 globus_mutex_init(&engine->mutex, NULL);
488
489 30 globus_xio_server_get_contact_string(engine->server, &contact);
490 30 engine->contact = globus_common_create_string(
491 "http%s://%s/",
492 (enable_https ? "s" : ""),
493 contact);
494 30 free(contact);
495
496 30 if(!handlers)
497 {
498 30 int res = 0;
499 30 res = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
500 30 if(res != 0)
501 {
502 0 globus_object_t * tmp = globus_error_get((globus_result_t) res);
503 0 result = GlobusServiceEngineErrorHandlerLoadFailed(
504 GLOBUS_HANDLER_WS_ADDRESSING_MODULE,
505 tmp);
506 0 goto error;
507 }
508
509 30 globus_mutex_lock(&globus_l_service_engine_extensions_mutex);
510 30 globus_list_insert(&globus_l_service_engine_extensions,
511 strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
512 30 globus_mutex_unlock(&globus_l_service_engine_extensions_mutex);
513
514 30 globus_handler_chain_init(&engine->handlers);
515
516 30 result = globus_handler_chain_push(
517 engine->handlers,
518 GLOBUS_HANDLER_TYPE_REQUEST_ALL,
519 GLOBUS_HANDLER_WS_ADDRESSING_SERVER);
520 30 if(result != GLOBUS_SUCCESS)
521 {
522 0 result = GlobusServiceEngineErrorInitFailed(result);
523 0 goto error;
524 }
525
526 30 result = globus_handler_chain_push(
527 engine->handlers,
528 GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
529 GLOBUS_HANDLER_WS_ADDRESSING_SERVER);
530 30 if(result != GLOBUS_SUCCESS)
531 {
532 0 result = GlobusServiceEngineErrorInitFailed(result);
533 0 goto error;
534 }
535
536 30 secattr = (globus_soap_message_auth_method_t)
537 globus_soap_message_attr_get(
538 engine->attrs,
539 GLOBUS_SOAP_MESSAGE_AUTHENTICATION_METHOD_KEY);
540
541 30 if ((!enable_https) &&
542 (secattr == GLOBUS_SOAP_MESSAGE_AUTH_SECURE ||
543 secattr == GLOBUS_SOAP_MESSAGE_AUTH_SECURE_MESSAGE))
544 {
545 0 res = globus_extension_activate("globus_handler_ws_secure_message");
546 0 if(res != 0)
547 {
548 0 globus_object_t * tmp = globus_error_get((globus_result_t) res);
549 0 result = GlobusServiceEngineErrorHandlerLoadFailed(
550 "globus_handler_ws_secure_message",
551 tmp);
552 0 goto error;
553 }
554
555 0 globus_mutex_lock(&globus_l_service_engine_extensions_mutex);
556 0 globus_list_insert(&globus_l_service_engine_extensions,
557 strdup("globus_handler_ws_secure_message"));
558 0 globus_mutex_unlock(&globus_l_service_engine_extensions_mutex);
559
560 0 result = globus_handler_chain_push(
561 engine->handlers,
562 GLOBUS_HANDLER_TYPE_REQUEST,
563 "globus_handler_ws_secure_message_server");
564 0 if(result != GLOBUS_SUCCESS)
565 {
566 0 result = GlobusServiceEngineErrorInitFailed(result);
567 0 goto error;
568 }
569
570 0 result = globus_handler_chain_push(
571 engine->handlers,
572 GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
573 "globus_handler_ws_secure_message_server");
574 0 if(result != GLOBUS_SUCCESS)
575 {
576 0 result = GlobusServiceEngineErrorInitFailed(result);
577 0 goto error;
578 }
579 }
580 }
581 else
582 {
583 0 globus_handler_chain_copy(&engine->handlers, handlers);
584 }
585
586 30 *new_engine = (globus_service_engine_t) engine;
587 30 goto exit;
588
589 0 error:
590
591 0 if(server_attr)
592 {
593 0 globus_xio_attr_destroy(server_attr);
594 }
595
596 0 if(engine)
597 {
598 0 if(engine->server)
599 {
600 0 globus_xio_server_close(engine->server);
601 }
602
603 0 free(engine);
604 }
605
606 30 exit:
607
608 30 GlobusServiceEngineDebugExit();
609 30 return result;
610 }
611
612 globus_result_t
613 globus_service_engine_get_contact(
614 globus_service_engine_t engine,
615 char ** contact)
616 75 {
617 75 *contact = globus_libc_strdup(engine->contact);
618 75 return GLOBUS_SUCCESS;
619 }
620
621 void
622 globus_service_engine_destroy(
623 globus_service_engine_t engine)
624 30 {
625 int res;
626 GlobusFuncName(globus_service_engine_destroy);
627 30 GlobusServiceEngineDebugEnter();
628
629 30 if(engine->handlers)
630 {
631 30 globus_handler_chain_destroy(engine->handlers);
632 }
633
634 30 if(engine->contact)
635 {
636 30 free(engine->contact);
637 }
638
639 30 if(engine->server)
640 {
641 30 globus_xio_server_close(engine->server);
642 }
643
644 30 res = globus_mutex_destroy(&engine->mutex);
645 30 globus_assert_string((res == 0), "Failed to destroy mutex");
646
647 30 if(engine->attrs)
648 {
649 30 globus_soap_message_attr_destroy(engine->attrs);
650 }
651
652 30 free(engine);
653 30 GlobusServiceEngineDebugExit();
654 }
655
656 static
657 void
658 globus_l_service_session_callback_handle_destroy(
659 globus_l_session_callback_handle_t * callback_handle)
660 1075 {
661 1075 if(callback_handle)
662 {
663 1075 if(callback_handle->result)
664 {
665 0 globus_object_free(globus_error_get(callback_handle->result));
666 }
667
668 1075 if(callback_handle->callback_result)
669 {
670 2 globus_object_free(
671 globus_error_get(callback_handle->callback_result));
672 }
673
674 1075 free(callback_handle);
675 }
676 }
677
678 static
679 void
680 globus_l_service_engine_open_callback(
681 globus_xio_handle_t handle,
682 globus_result_t result,
683 void * user_arg)
684 1075 {
685 1075 globus_l_session_callback_handle_t *callback_handle = NULL;
686 static globus_byte_t buffer[1];
687 GlobusFuncName(globus_l_service_engine_open_callback);
688 1075 GlobusServiceEngineDebugEnter();
689
690 1075 callback_handle = (globus_l_session_callback_handle_t *) user_arg;
691
692 1075 globus_mutex_lock(&callback_handle->engine->mutex);
693 1075 if(result == GLOBUS_SUCCESS)
694 {
695 1075 result = globus_xio_register_read(handle,
696 buffer,
697 0,
698 0,
699 NULL,
700 globus_l_service_engine_request_ready_callback,
701 callback_handle);
702 }
703
704 1075 if (result != GLOBUS_SUCCESS)
705 {
706 0 globus_soap_message_handle_destroy(callback_handle->message);
707 0 callback_handle->message = NULL;
708 0 callback_handle->callback(
709 result, callback_handle->engine,
710 callback_handle->message, callback_handle->args);
711 }
712 1075 globus_mutex_unlock(&callback_handle->engine->mutex);
713
714 1075 GlobusServiceEngineDebugExit();
715 }
716
717 static
718 globus_result_t
719 globus_l_service_engine_service_module_copy(
720 void ** ne,
721 void * e)
722 2131 {
723 2131 globus_extension_reference((globus_extension_handle_t)e);
724 2131 *ne = e;
725 2131 return GLOBUS_SUCCESS;
726 }
727
728 static
729 void
730 globus_l_service_engine_service_module_destroy(
731 void * e)
732 2131 {
733 2131 globus_extension_release((globus_extension_handle_t)e);
734 }
735
736 static
737 void
738 globus_l_service_engine_request_ready_callback(
739 globus_xio_handle_t handle,
740 globus_result_t result,
741 globus_byte_t * buffer,
742 globus_size_t len,
743 globus_size_t nbytes,
744 globus_xio_data_descriptor_t data_desc,
745 void * user_arg)
746 3206 {
747 3206 const char * uriref = NULL;
748 3206 char * service_path = NULL;
749 3206 globus_xio_http_header_t * soap_action = NULL;
750 3206 globus_xio_http_header_t * content_type = NULL;
751 3206 globus_xio_http_header_t * connection = NULL;
752 3206 char * method = NULL;
753 3206 char * uri = NULL;
754 globus_xio_http_version_t http_version;
755 globus_hashtable_t headers;
756
757 3206 globus_l_session_callback_handle_t * callback_handle = NULL;
758 GlobusFuncName(globus_l_service_engine_request_ready_callback);
759 3206 GlobusServiceEngineDebugEnter();
760
761 3206 callback_handle = (globus_l_session_callback_handle_t *) user_arg;
762
763 3206 if (result == GLOBUS_SUCCESS)
764 {
765 2142 result = globus_xio_data_descriptor_cntl(
766 data_desc,
767 globus_i_soap_message_http_driver,
768 GLOBUS_XIO_HTTP_GET_REQUEST,
769 &method,
770 &uri,
771 &http_version,
772 &headers);
773
774 }
775
776 3206 if (method == NULL || result != GLOBUS_SUCCESS)
777 {
778 /* No more requests */
779 1074 if (callback_handle->process_callback != NULL)
780 {
781 1074 callback_handle->state = GLOBUS_L_SERVICE_ENGINE_RESPONSE_CLOSE;
782 1074 globus_soap_message_handle_set_attr(
783 callback_handle->message,
784 GLOBUS_SOAP_MESSAGE_CONNECTION_KEY,
785 globus_soap_message_attr_copy_string,
786 globus_libc_free,
787 (void *) "close");
788 }
789 }
790 2132 else if(!strcmp(method, "POST"))
791 {
792 globus_extension_handle_t ext;
793 globus_service_descriptor_t * service_desc;
794
795 2132 soap_action = (globus_xio_http_header_t *)
796 globus_hashtable_lookup(&headers, (void *) SOAP_ACTION_HEADER);
797 2132 if(!soap_action)
798 {
799 0 GlobusServiceEngineDebugPrintf(
800 GLOBUS_L_SERVICE_ENGINE_DEBUG_DEBUG,
801 ("Service request: %s does not "
802 "have a SOAPAction header entry\n",
803 uri));
804 }
805
806 2132 content_type = (globus_xio_http_header_t *)
807 globus_hashtable_lookup(&headers, (void *) CONTENT_TYPE_HEADER);
808 2132 if(!content_type || !content_type->value ||
809 !strstr(content_type->value, "text/xml"))
810 {
811 0 result = GlobusServiceEngineErrorUnsupportedMediaType(
812 content_type->value);
813 0 goto exit;
814 }
815 2132 if (http_version != GLOBUS_XIO_HTTP_VERSION_1_0)
816 {
817 /*
818 * Assume persistent connection with HTTP/1.1 unless told
819 * otherwise
820 */
821 2132 connection = globus_hashtable_lookup(
822 &headers,
823 (void *) "Connection");
824 2132 if (connection && connection->value &&
825 strstr(connection->value, "close"))
826 {
827 0 result = globus_soap_message_handle_set_attr(
828 callback_handle->message,
829 GLOBUS_SOAP_MESSAGE_CONNECTION_KEY,
830 globus_soap_message_attr_copy_string,
831 globus_libc_free,
832 (void *) "close");
833 }
834 }
835 else
836 {
837 0 result = globus_soap_message_handle_set_attr(
838 callback_handle->message,
839 GLOBUS_SOAP_MESSAGE_CONNECTION_KEY,
840 globus_soap_message_attr_copy_string,
841 globus_libc_free,
842 (void *) "close");
843 }
844 2132 if (result != GLOBUS_SUCCESS)
845 {
846 2132 goto exit;
847 }
848
849 2132 uriref = uri;
850 6396 while (*uriref == '/')
851 {
852 2132 uriref++;
853 }
854
855 2132 service_path = globus_common_create_string(
856 GLOBUS_SERVICE_ENGINE_MODULE_PATH_PREFIX "/%s", uriref);
857 2132 service_desc = globus_extension_lookup(
858 &ext,
859 GLOBUS_SERVICE_REGISTRY,
860 service_path);
861 2132 if(!service_desc)
862 {
863 30 int res = 0;
864
865 30 res = globus_extension_activate(
866 service_path);
867 30 if(res != GLOBUS_SUCCESS)
868 {
869 1 globus_object_t * tmp_err = globus_error_get((globus_result_t) res);
870 1 if(GlobusServiceEngineDebug(
871 GLOBUS_L_SERVICE_ENGINE_DEBUG_DEBUG))
872 {
873 char * serror = globus_error_print_chain(
874 0 tmp_err);
875 0 GlobusServiceEngineDebugPrintf(
876 GLOBUS_L_SERVICE_ENGINE_DEBUG_DEBUG,
877 ("Module Activation Failed:\n\n%s\n",
878 serror));
879 0 globus_free(serror);
880 }
881
882 1 result = GlobusServiceEngineErrorServiceLoadFailed(uri, tmp_err);
883 1 goto exit;
884 }
885
886 29 globus_mutex_lock(&globus_l_service_engine_extensions_mutex);
887 29 globus_list_insert(&globus_l_service_engine_extensions,
888 strdup(service_path));
889 29 globus_mutex_unlock(&globus_l_service_engine_extensions_mutex);
890
891 29 service_desc = (globus_service_descriptor_t *)
892 globus_extension_lookup(&ext, GLOBUS_SERVICE_REGISTRY,
893 service_path);
894 29 if(!service_desc)
895 {
896 0 result = GlobusServiceEngineErrorServiceLoadFailed(uri, NULL);
897 0 goto exit;
898 }
899 }
900
901 2131 result = globus_soap_message_handle_set_attr(
902 callback_handle->message,
903 GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY,
904 globus_soap_message_attr_copy_string,
905 globus_libc_free,
906 (void *)uri);
907 2131 if(result != GLOBUS_SUCCESS)
908 {
909 0 result = GlobusServiceEngineErrorReadRequestFailed(result);
910 0 goto exit;
911 }
912
913 2131 result = globus_soap_message_handle_set_attr(
914 callback_handle->message,
915 GLOBUS_I_SERVICE_DESCRIPTOR_KEY,
916 globus_l_service_engine_service_module_copy,
917 globus_l_service_engine_service_module_destroy,
918 (void *)ext);
919 2131 if(result != GLOBUS_SUCCESS)
920 {
921 0 result = GlobusServiceEngineErrorReadRequestFailed(result);
922 0 goto exit;
923 }
924
925 2131 if(soap_action)
926 {
927 2131 result = globus_soap_message_handle_set_attr(
928 callback_handle->message,
929 GLOBUS_SOAP_MESSAGE_SOAP_ACTION_KEY,
930 globus_soap_message_attr_copy_string,
931 globus_libc_free,
932 (void *)soap_action->value);
933 2131 if(result != GLOBUS_SUCCESS)
934 {
935 0 result = GlobusServiceEngineErrorReadRequestFailed(result);
936 0 goto exit;
937 }
938 }
939 }
940 else
941 {
942 0 result = GlobusServiceEngineErrorMethodNotAllowed(method);
943 0 goto exit;
944 }
945
946 3205 if (callback_handle->state ==
947 GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_ANOTHER_MESSAGE ||
948 callback_handle->state ==
949 GLOBUS_L_SERVICE_ENGINE_RESPONSE_CLOSE)
950 {
951 2131 result = globus_callback_register_oneshot(
952 NULL,
953 &globus_i_reltime_zero,
954 globus_l_service_session_callback,
955 callback_handle);
956 2131 if(result == GLOBUS_SUCCESS)
957 {
958 0 goto no_callback_exit;
959 }
960 else
961 {
962 0 result = GlobusServiceEngineErrorFailedRequestProcess(
963 result, "Failed to register callback to invoke operation");
964 goto exit;
965 }
966 }
967 1075 exit:
968
969 1075 if(result != GLOBUS_SUCCESS)
970 {
971 1 callback_handle->result = result;
972 1 globus_soap_message_handle_set_attr(
973 callback_handle->message,
974 GLOBUS_SOAP_MESSAGE_CONNECTION_KEY,
975 globus_soap_message_attr_copy_string,
976 globus_libc_free,
977 (void *) "close");
978 }
979
980 1075 callback_handle->callback(
981 result, callback_handle->engine,
982 callback_handle->message, callback_handle->args);
983
984 3206 no_callback_exit:
985
986 3206 if(service_path)
987 {
988 2132 free(service_path);
989 }
990
991
992 3206 GlobusServiceEngineDebugExit();
993 }
994
995 static
996 void
997 globus_l_service_engine_accept_callback(
998 globus_xio_server_t server,
999 globus_xio_handle_t new_handle,
1000 globus_result_t result,
1001 void * user_args)
1002 1105 {
1003 1105 char * peer_contact = NULL;
1004 globus_xio_attr_t attr;
1005 1105 globus_soap_message_handle_t message = NULL;
1006 globus_l_session_callback_handle_t * callback_handle;
1007 GlobusFuncName(globus_l_service_engine_accept_callback);
1008 1105 GlobusServiceEngineDebugEnter();
1009
1010 1105 callback_handle = (globus_l_session_callback_handle_t *) user_args;
1011
1012 1105 if(result != GLOBUS_SUCCESS)
1013 {
1014 1075 goto exit;
1015 }
1016
1017 1075 result = globus_soap_message_handle_init(&message, new_handle);
1018 1075 if(result != GLOBUS_SUCCESS)
1019 {
1020 0 result = GlobusServiceEngineErrorFailedRequest(result);
1021 0 goto exit;
1022 }
1023 1075 globus_mutex_lock(&callback_handle->engine->mutex);
1024 1075 result = globus_soap_message_handle_set_attrs(
1025 message,
1026 callback_handle->engine->attrs);
1027 1075 if(result != GLOBUS_SUCCESS)
1028 {
1029 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1030 0 result = GlobusServiceEngineErrorFailedRequest(result);
1031 0 goto exit;
1032 }
1033 1075 result = globus_soap_message_handle_set_attr(
1034 message,
1035 GLOBUS_I_SESSION_HANDLE_KEY,
1036 NULL,
1037 NULL,
1038 callback_handle);
1039 1075 if(result != GLOBUS_SUCCESS)
1040 {
1041 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1042 0 result = GlobusServiceEngineErrorFailedRequest(result);
1043 0 goto exit;
1044 }
1045
1046 1075 globus_mutex_unlock(&callback_handle->engine->mutex);
1047
1048 1075 callback_handle->message = message;
1049
1050 1075 result = globus_xio_attr_init(&attr);
1051 1075 if(result != GLOBUS_SUCCESS)
1052 {
1053 0 result = GlobusServiceEngineErrorFailedRequest(result);
1054 0 goto exit;
1055 }
1056
1057 1075 result = globus_xio_handle_cntl(
1058 new_handle, globus_i_soap_message_tcp_driver,
1059 GLOBUS_XIO_TCP_GET_REMOTE_CONTACT,
1060 &peer_contact);
1061 1075 if(result != GLOBUS_SUCCESS)
1062 {
1063 0 result = globus_xio_handle_cntl(
1064 new_handle, globus_i_soap_message_tcp_driver,
1065 GLOBUS_XIO_TCP_GET_REMOTE_NUMERIC_CONTACT,
1066 &peer_contact);
1067
1068 0 if (result != GLOBUS_SUCCESS)
1069 {
1070 0 result = GlobusServiceEngineErrorFailedRequest(result);
1071 }
1072 goto exit;
1073 }
1074
1075 1075 result = globus_xio_register_open(
1076 new_handle, peer_contact, attr,
1077 globus_l_service_engine_open_callback, callback_handle);
1078 1075 if(result != GLOBUS_SUCCESS)
1079 {
1080 0 result = GlobusServiceEngineErrorFailedRequest(result);
1081 goto exit;
1082 }
1083
1084 1105 exit:
1085 1105 if (peer_contact != NULL)
1086 {
1087 1075 globus_libc_free(peer_contact);
1088 }
1089
1090 1105 if(result != GLOBUS_SUCCESS)
1091 {
1092 30 callback_handle->callback(result, callback_handle->engine,
1093 message, callback_handle->args);
1094 30 free(callback_handle);
1095 30 if(message)
1096 {
1097 0 globus_soap_message_handle_destroy(message);
1098 }
1099 }
1100
1101 1105 GlobusServiceEngineDebugExit();
1102 }
1103
1104 globus_result_t
1105 globus_service_engine_register_session(
1106 globus_service_engine_t engine,
1107 globus_service_session_callback_func_t callback,
1108 void * user_args)
1109 1105 {
1110 1105 globus_l_session_callback_handle_t * callback_handle = NULL;
1111 1105 globus_result_t result = GLOBUS_SUCCESS;
1112 GlobusFuncName(globus_service_engine_register_session);
1113 1105 GlobusServiceEngineDebugEnter();
1114
1115 1105 callback_handle = calloc(1, sizeof(globus_l_session_callback_handle_t));
1116 1105 if(!callback_handle)
1117 {
1118 0 result = GlobusServiceEngineErrorOutOfMemory;
1119 0 goto exit;
1120 }
1121
1122 1105 callback_handle->callback = callback;
1123 1105 callback_handle->args = user_args;
1124 1105 callback_handle->engine = engine;
1125 1105 callback_handle->faulting = GLOBUS_FALSE;
1126
1127 1105 result = globus_xio_server_register_accept(
1128 engine->server,
1129 globus_l_service_engine_accept_callback,
1130 callback_handle);
1131 1105 if(result != GLOBUS_SUCCESS)
1132 {
1133 0 result = GlobusServiceEngineErrorAcceptFailed(result);
1134 goto exit;
1135 }
1136
1137 1105 exit:
1138
1139 1105 GlobusServiceEngineDebugExit();
1140 1105 return result;
1141 }
1142
1143 static
1144 void
1145 globus_l_service_session_result_callback(
1146 globus_result_t result,
1147 void * args)
1148 32971 {
1149 globus_l_session_callback_handle_t * callback_handle;
1150 GlobusFuncName(globus_l_service_session_result_callback);
1151 32971 GlobusServiceEngineDebugEnter();
1152
1153 32971 callback_handle = (globus_l_session_callback_handle_t *) args;
1154 32971 callback_handle->result = result;
1155
1156 32971 globus_l_service_session_callback(callback_handle);
1157
1158 32971 GlobusServiceEngineDebugExit();
1159 }
1160
1161 static
1162 void
1163 globus_l_service_session_callback(
1164 void * args)
1165 38309 {
1166 38309 globus_result_t result = GLOBUS_SUCCESS;
1167 38309 globus_service_descriptor_t * service_desc = NULL;
1168 globus_extension_handle_t ext;
1169 globus_l_session_callback_handle_t * callback_handle;
1170 38309 globus_service_operation_descriptor_t * op_desc = NULL;
1171 38309 xsd_QName * operation_name = NULL;
1172 38309 xsd_QName * header_element = NULL;
1173 38309 xsd_int must = 0;
1174 char * connection;
1175 globus_xio_handle_t xio_handle;
1176 static globus_byte_t buffer[1];
1177 GlobusFuncName(globus_l_service_session_callback);
1178 38309 GlobusServiceEngineDebugEnter();
1179
1180 38309 callback_handle = (globus_l_session_callback_handle_t *) args;
1181
1182 38309 if(callback_handle->result != GLOBUS_SUCCESS)
1183 {
1184 1 if(!callback_handle->faulting)
1185 {
1186 0 result = callback_handle->result;
1187 0 goto error_send_fault;
1188 }
1189 else
1190 {
1191 char * errstr;
1192
1193 1 errstr = globus_error_print_friendly(
1194 globus_error_peek(
1195 callback_handle->result));
1196
1197 1 GlobusServiceEngineDebugPrintf(
1198 GLOBUS_L_SERVICE_ENGINE_DEBUG_DEBUG,
1199 ("error occurred while sending a fault: %s\n",
1200 errstr));
1201
1202 1 free(errstr);
1203
1204 1 callback_handle->result = GLOBUS_SUCCESS;
1205 }
1206 }
1207
1208 38309 GlobusServiceEngineDebugPrintf(
1209 GLOBUS_L_SERVICE_ENGINE_DEBUG_DEBUG,
1210 ("STATE: %s\n",
1211 globus_l_service_engine_state_strings[callback_handle->state]));
1212
1213 38309 switch(callback_handle->state)
1214 {
1215
1216 case GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_ANOTHER_MESSAGE:
1217 1057 result = globus_soap_message_get_transport_handle(
1218 callback_handle->message,
1219 &xio_handle);
1220 1057 if (result != GLOBUS_SUCCESS)
1221 {
1222 1057 goto error_send_fault;
1223 }
1224 1057 result = globus_xio_handle_cntl(
1225 xio_handle,
1226 globus_i_soap_message_buffer_driver,
1227 GLOBUS_XIO_BUFFER_ENABLE_READ_BUFFERING);
1228 1057 if (result != GLOBUS_SUCCESS)
1229 {
1230 1057 goto error_send_fault;
1231 }
1232 1057 result = globus_i_soap_message_reset_reader(callback_handle->message);
1233 1057 if (result != GLOBUS_SUCCESS)
1234 {
1235 2131 goto error_send_fault;
1236 }
1237 /* FALLSTHROUGH */
1238 case GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_MESSAGE:
1239
1240 2131 callback_handle->state =
1241 GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_SERVICE_HANDLERS;
1242
1243 2131 if(callback_handle->result != GLOBUS_SUCCESS)
1244 {
1245 0 result = callback_handle->result;
1246 0 goto error_send_fault;
1247 }
1248
1249 2131 result = globus_soap_message_register_read_request(
1250 callback_handle->message,
1251 globus_l_service_session_result_callback,
1252 callback_handle);
1253 2131 if(result != GLOBUS_SUCCESS)
1254 {
1255 goto error_send_fault;
1256 }
1257
1258 break;
1259
1260 case GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_SERVICE_HANDLERS:
1261
1262 2131 callback_handle->state =
1263 GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_HANDLERS;
1264
1265 2131 if(callback_handle->result != GLOBUS_SUCCESS)
1266 {
1267 0 result = callback_handle->result;
1268 0 goto error_send_fault;
1269 }
1270
1271 2131 ext =
1272 (globus_extension_handle_t)
1273 globus_soap_message_handle_get_attr(
1274 callback_handle->message,
1275 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1276 2131 globus_assert_string(
1277 ext, "No SERVICE DESCRIPTOR attribute found!");
1278
1279 2131 service_desc = (globus_service_descriptor_t *)
1280 globus_extension_reference(ext);
1281
1282 2131 globus_assert_string(
1283 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1284
1285 2131 globus_mutex_lock(&service_desc->mutex);
1286 2131 if(service_desc->handlers)
1287 {
1288 0 globus_handler_chain_register_invoke(
1289 service_desc->handlers,
1290 GLOBUS_HANDLER_TYPE_REQUEST_INIT,
1291 callback_handle->message,
1292 globus_l_service_session_result_callback,
1293 callback_handle);
1294
1295 0 globus_mutex_unlock(&service_desc->mutex);
1296 0 service_desc = NULL;
1297 0 globus_extension_release(ext);
1298 0 break;
1299 }
1300 2131 globus_mutex_unlock(&service_desc->mutex);
1301 2131 service_desc = NULL;
1302 2131 globus_extension_release(ext);
1303
1304 case GLOBUS_L_SERVICE_ENGINE_REQUEST_INIT_HANDLERS:
1305
1306 2131 callback_handle->state =
1307 GLOBUS_L_SERVICE_ENGINE_START_DESERIALIZE;
1308
1309 2131 if(callback_handle->result != GLOBUS_SUCCESS)
1310 {
1311 0 result = callback_handle->result;
1312 0 goto error_send_fault;
1313 }
1314
1315 2131 globus_mutex_lock(&callback_handle->engine->mutex);
1316 2131 if(callback_handle->engine->handlers)
1317 {
1318 2131 globus_handler_chain_register_invoke(
1319 callback_handle->engine->handlers,
1320 GLOBUS_HANDLER_TYPE_REQUEST_INIT,
1321 callback_handle->message,
1322 globus_l_service_session_result_callback,
1323 callback_handle);
1324 2131 globus_mutex_unlock(&callback_handle->engine->mutex);
1325 2131 break;
1326 }
1327 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1328
1329 case GLOBUS_L_SERVICE_ENGINE_START_DESERIALIZE:
1330
1331 2131 callback_handle->state =
1332 GLOBUS_L_SERVICE_ENGINE_TRIGGER_INVOKE_HANDLERS;
1333
1334 2131 if(callback_handle->result != GLOBUS_SUCCESS)
1335 {
1336 0 result = callback_handle->result;
1337 0 goto error_send_fault;
1338 }
1339
1340 2131 result = globus_soap_message_deserialize_envelope(
1341 callback_handle->message);
1342 2131 if(result != GLOBUS_SUCCESS)
1343 {
1344 2131 goto error_send_fault;
1345 }
1346
1347 2131 result = globus_soap_message_deserialize_element_begin_close(
1348 callback_handle->message);
1349 2131 if(result != GLOBUS_SUCCESS)
1350 {
1351 2131 goto error_send_fault;
1352 }
1353
1354 2131 result = globus_soap_message_deserialize_header(
1355 callback_handle->message);
1356 2131 if(result != GLOBUS_SUCCESS)
1357 {
1358 0 if(GlobusSoapMessageStatusElementNotFoundCheck(result))
1359 {
1360 0 globus_soap_message_deserialize_push_element(
1361 callback_handle->message);
1362 0 result = GLOBUS_SUCCESS;
1363 0 callback_handle->state =
1364 GLOBUS_L_SERVICE_ENGINE_REQUEST_HEADER_FAILED;
1365 0 callback_handle->result = result;
1366 0 globus_l_service_session_callback(
1367 callback_handle);
1368 0 break;
1369 }
1370
1371 goto error_send_fault;
1372 }
1373
1374 case GLOBUS_L_SERVICE_ENGINE_TRIGGER_INVOKE_HANDLERS:
1375
1376 12739 callback_handle->state =
1377 GLOBUS_L_SERVICE_ENGINE_TRIGGER_INVOKE_HANDLERS;
1378
1379 12739 if(callback_handle->result != GLOBUS_SUCCESS)
1380 {
1381 0 result = callback_handle->result;
1382 0 goto error_send_fault;
1383 }
1384
1385 12739 xsd_QName_init(&header_element);
1386
1387 12739 result = globus_soap_message_deserialize_element_unknown(
1388 callback_handle->message,
1389 header_element);
1390 12739 if(result != GLOBUS_SUCCESS)
1391 {
1392 2131 if(!GlobusSoapMessageStatusFailedElementCheck(result))
1393 {
1394 0 xsd_QName_destroy(header_element);
1395 0 goto error_send_fault;
1396 }
1397 else
1398 {
1399 2131 callback_handle->state =
1400 GLOBUS_L_SERVICE_ENGINE_REQUEST_DESERIALIZE;
1401 2131 globus_callback_register_oneshot(
1402 NULL,
1403 &globus_i_reltime_zero,
1404 globus_l_service_session_callback,
1405 (void *)callback_handle);
1406 2131 xsd_QName_destroy(header_element);
1407 2131 break;
1408 }
1409 }
1410
1411 10608 result = globus_soap_message_deserialize_int_attribute(
1412 callback_handle->message,
1413 &soap_mustUnderstand_qname,
1414 &must);
1415 10608 if(result == GLOBUS_SUCCESS && (must == 1))
1416 {
1417 0 globus_soap_message_add_required_header_element(
1418 callback_handle->message,
1419 header_element);
1420 }
1421 10608 else if(result != GLOBUS_SUCCESS &&
1422 !GlobusSoapMessageStatusAttributeNotFoundCheck(result))
1423 {
1424 0 xsd_QName_destroy(header_element);
1425 0 goto error_send_fault;
1426 }
1427
1428 10608 globus_soap_message_deserialize_push_element(callback_handle->message);
1429
1430 10608 ext =
1431 (globus_extension_handle_t)
1432 globus_soap_message_handle_get_attr(
1433 callback_handle->message,
1434 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1435 10608 globus_assert_string(
1436 ext, "No SERVICE DESCRIPTOR attribute found!");
1437
1438 10608 service_desc = (globus_service_descriptor_t *)
1439 globus_extension_reference(ext);
1440
1441 10608 globus_assert_string(
1442 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1443
1444 10608 globus_mutex_lock(&service_desc->mutex);
1445 10608 if(service_desc->handlers)
1446 {
1447 0 if(globus_handler_chain_has_trigger(
1448 service_desc->handlers, header_element))
1449 {
1450 0 result = globus_handler_chain_register_trigger(
1451 service_desc->handlers,
1452 callback_handle->message,
1453 header_element,
1454 globus_l_service_session_result_callback,
1455 callback_handle);
1456 0 if(result == GLOBUS_SUCCESS)
1457 {
1458 0 xsd_QName_destroy(header_element);
1459 0 globus_mutex_unlock(&service_desc->mutex);
1460 0 service_desc = NULL;
1461 0 globus_extension_release(ext);
1462 0 break;
1463 }
1464 0 else if(!GlobusHandlerStatusNotTriggeredCheck(result))
1465 {
1466 0 xsd_QName_destroy(header_element);
1467 0 globus_mutex_unlock(&service_desc->mutex);
1468 0 service_desc = NULL;
1469 0 globus_extension_release(ext);
1470 0 goto error_send_fault;
1471 }
1472 }
1473 }
1474 10608 globus_mutex_unlock(&service_desc->mutex);
1475 10608 service_desc = NULL;
1476 10608 globus_extension_release(ext);
1477
1478 10608 globus_mutex_lock(&callback_handle->engine->mutex);
1479 10608 if(callback_handle->engine->handlers)
1480 {
1481 10608 result = globus_handler_chain_register_trigger(
1482 callback_handle->engine->handlers,
1483 callback_handle->message,
1484 header_element,
1485 globus_l_service_session_result_callback,
1486 callback_handle);
1487 10608 if(result == GLOBUS_SUCCESS)
1488 {
1489 10608 xsd_QName_destroy(header_element);
1490 10608 globus_mutex_unlock(&callback_handle->engine->mutex);
1491 10608 break;
1492 }
1493 0 else if(!GlobusHandlerStatusNotTriggeredCheck(result))
1494 {
1495 0 xsd_QName_destroy(header_element);
1496 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1497 0 goto error_send_fault;
1498 }
1499 }
1500 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1501
1502 0 xsd_QName_destroy(header_element);
1503 0 result = globus_soap_message_deserialize_skip(
1504 callback_handle->message);
1505 0 if(result != GLOBUS_SUCCESS)
1506 {
1507 0 goto error_send_fault;
1508 }
1509
1510 0 globus_callback_register_oneshot(
1511 NULL,
1512 &globus_i_reltime_zero,
1513 globus_l_service_session_callback,
1514 (void *)callback_handle);
1515 0 break;
1516
1517 case GLOBUS_L_SERVICE_ENGINE_REQUEST_DESERIALIZE:
1518
1519 2131 if(callback_handle->result != GLOBUS_SUCCESS)
1520 {
1521 0 result = callback_handle->result;
1522 0 goto error_send_fault;
1523 }
1524
1525 2131 result = globus_soap_message_check_required_headers(
1526 callback_handle->message);
1527 2131 if(result != GLOBUS_SUCCESS)
1528 {
1529 2131 goto error_send_fault;
1530 }
1531
1532 2131 result = globus_soap_message_deserialize_header_end(
1533 callback_handle->message);
1534 2131 if(result != GLOBUS_SUCCESS)
1535 {
1536 2131 goto error_send_fault;
1537 }
1538
1539 case GLOBUS_L_SERVICE_ENGINE_REQUEST_HEADER_FAILED:
1540
1541 2131 callback_handle->state =
1542 GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_HANDLERS;
1543
1544 2131 if(callback_handle->result != GLOBUS_SUCCESS)
1545 {
1546 0 result = callback_handle->result;
1547 0 goto error_send_fault;
1548 }
1549
1550 2131 result = globus_soap_message_deserialize_body(
1551 callback_handle->message);
1552 2131 if(result != GLOBUS_SUCCESS)
1553 {
1554 2131 goto error_send_fault;
1555 }
1556
1557 2131 result = xsd_QName_init(&operation_name);
1558 2131 if(result != GLOBUS_SUCCESS)
1559 {
1560 2131 goto error_send_fault;
1561 }
1562
1563 2131 result = globus_soap_message_deserialize_element_unknown(
1564 callback_handle->message, operation_name);
1565 2131 if(result != GLOBUS_SUCCESS)
1566 {
1567 0 xsd_QName_destroy(operation_name);
1568 0 goto error_send_fault;
1569 }
1570
1571 2131 result = globus_soap_message_handle_set_attr(
1572 callback_handle->message,
1573 GLOBUS_I_SERVICE_OPERATION_QNAME_KEY,
1574 xsd_QName_copy_wrapper,
1575 xsd_QName_destroy_wrapper,
1576 operation_name);
1577 2131 if(result != GLOBUS_SUCCESS)
1578 {
1579 0 xsd_QName_destroy(operation_name);
1580 0 goto error_send_fault;
1581 }
1582
1583 2131 globus_soap_message_deserialize_push_element(
1584 callback_handle->message);
1585 2131 if(result != GLOBUS_SUCCESS)
1586 {
1587 2131 goto error_send_fault;
1588 }
1589
1590 2131 ext =
1591 (globus_extension_handle_t)
1592 globus_soap_message_handle_get_attr(
1593 callback_handle->message,
1594 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1595 2131 globus_assert_string(
1596 ext, "No SERVICE DESCRIPTOR attribute found!");
1597
1598 2131 service_desc = (globus_service_descriptor_t *)
1599 globus_extension_reference(ext);
1600
1601 2131 globus_assert_string(
1602 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1603
1604 /* we use qn to map to operation deserialize function */
1605 2131 globus_mutex_lock(&service_desc->mutex);
1606 2131 if(service_desc->op_mapper)
1607 {
1608 2131 op_desc = (globus_service_operation_descriptor_t *)
1609 globus_hashtable_lookup(
1610 &service_desc->op_mapper,
1611 (void *)operation_name);
1612 }
1613
1614 2131 if(!op_desc)
1615 {
1616 1 result = GlobusServiceEngineErrorOperationLookupFailed(
1617 service_desc->name, operation_name);
1618 1 globus_mutex_unlock(&service_desc->mutex);
1619 1 xsd_QName_destroy(operation_name);
1620 1 service_desc = NULL;
1621 1 globus_extension_release(ext);
1622 1 goto error_send_fault;
1623 }
1624
1625 2130 result = op_desc->deserialize(
1626 callback_handle->engine,
1627 callback_handle->message,
1628 globus_l_service_session_result_callback,
1629 callback_handle);
1630 2130 if(result != GLOBUS_SUCCESS)
1631 {
1632 0 result = GlobusServiceEngineErrorOpDeserializeFailed(
1633 result, operation_name);
1634 0 globus_mutex_unlock(&service_desc->mutex);
1635 0 xsd_QName_destroy(operation_name);
1636 0 goto error_send_fault;
1637 }
1638
1639 2130 globus_mutex_unlock(&service_desc->mutex);
1640 2130 service_desc = NULL;
1641 2130 globus_extension_release(ext);
1642 2130 xsd_QName_destroy(operation_name);
1643
1644 2130 break;
1645
1646 case GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_HANDLERS:
1647
1648 2130 callback_handle->state =
1649 GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_SERVICE_HANDLERS;
1650
1651 2130 if(callback_handle->result != GLOBUS_SUCCESS)
1652 {
1653 0 result = callback_handle->result;
1654 0 goto error_send_fault;
1655 }
1656
1657 2130 result = globus_soap_message_deserialize_body_end(
1658 callback_handle->message);
1659 2130 if(result != GLOBUS_SUCCESS)
1660 {
1661 2130 goto error_send_fault;
1662 }
1663
1664 2130 result = globus_soap_message_deserialize_envelope_end(
1665 callback_handle->message);
1666 2130 if(result != GLOBUS_SUCCESS)
1667 {
1668 2130 goto error_send_fault;
1669 }
1670
1671 2130 globus_mutex_lock(&callback_handle->engine->mutex);
1672 2130 if(callback_handle->engine->handlers)
1673 {
1674 2130 globus_handler_chain_register_invoke(
1675 callback_handle->engine->handlers,
1676 GLOBUS_HANDLER_TYPE_REQUEST,
1677 callback_handle->message,
1678 globus_l_service_session_result_callback,
1679 callback_handle);
1680 2130 globus_mutex_unlock(&callback_handle->engine->mutex);
1681 2130 break;
1682 }
1683 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1684
1685 case GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_SERVICE_HANDLERS:
1686
1687 2130 callback_handle->state =
1688 GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_HANDLERS;
1689
1690 2130 if(callback_handle->result != GLOBUS_SUCCESS)
1691 {
1692 0 result = callback_handle->result;
1693 0 goto error_send_fault;
1694 }
1695
1696 2130 ext =
1697 (globus_extension_handle_t)
1698 globus_soap_message_handle_get_attr(
1699 callback_handle->message,
1700 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1701 2130 globus_assert_string(
1702 ext, "No SERVICE DESCRIPTOR attribute found!");
1703
1704 2130 service_desc = (globus_service_descriptor_t *)
1705 globus_extension_reference(ext);
1706
1707 2130 globus_assert_string(
1708 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1709
1710 2130 globus_mutex_lock(&service_desc->mutex);
1711 2130 if(service_desc->handlers)
1712 {
1713 0 globus_handler_chain_register_invoke(
1714 service_desc->handlers,
1715 GLOBUS_HANDLER_TYPE_REQUEST,
1716 callback_handle->message,
1717 globus_l_service_session_result_callback,
1718 callback_handle);
1719 0 globus_mutex_unlock(&service_desc->mutex);
1720 0 service_desc = NULL;
1721 0 globus_extension_release(ext);
1722 0 break;
1723 }
1724 2130 globus_mutex_unlock(&service_desc->mutex);
1725 2130 service_desc = NULL;
1726 2130 globus_extension_release(ext);
1727
1728 case GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_HANDLERS:
1729
1730 2130 callback_handle->state =
1731 GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_SERVICE_HANDLERS;
1732
1733 2130 if(callback_handle->result != GLOBUS_SUCCESS)
1734 {
1735 0 result = callback_handle->result;
1736 0 goto error_send_fault;
1737 }
1738
1739 2130 globus_mutex_lock(&callback_handle->engine->mutex);
1740 2130 if(callback_handle->engine->handlers)
1741 {
1742 2130 globus_handler_chain_register_invoke(
1743 callback_handle->engine->handlers,
1744 GLOBUS_HANDLER_TYPE_REQUEST_DESTROY,
1745 callback_handle->message,
1746 globus_l_service_session_result_callback,
1747 callback_handle);
1748 2130 globus_mutex_unlock(&callback_handle->engine->mutex);
1749 2130 break;
1750 }
1751 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1752
1753 case GLOBUS_L_SERVICE_ENGINE_REQUEST_DESTROY_SERVICE_HANDLERS:
1754
1755 2130 callback_handle->state =
1756 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_SERVICE_HANDLERS;
1757
1758 2130 if(callback_handle->result != GLOBUS_SUCCESS)
1759 {
1760 0 result = callback_handle->result;
1761 0 goto error_send_fault;
1762 }
1763
1764 2130 ext =
1765 (globus_extension_handle_t)
1766 globus_soap_message_handle_get_attr(
1767 callback_handle->message,
1768 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1769 2130 globus_assert_string(
1770 ext, "No SERVICE DESCRIPTOR attribute found!");
1771
1772 2130 service_desc = (globus_service_descriptor_t *)
1773 globus_extension_reference(ext);
1774
1775 2130 globus_assert_string(
1776 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1777
1778 2130 globus_mutex_lock(&service_desc->mutex);
1779 2130 if(service_desc->handlers)
1780 {
1781 0 globus_handler_chain_register_invoke(
1782 service_desc->handlers,
1783 GLOBUS_HANDLER_TYPE_REQUEST_DESTROY,
1784 callback_handle->message,
1785 globus_l_service_session_result_callback,
1786 callback_handle);
1787
1788 0 globus_mutex_unlock(&service_desc->mutex);
1789 0 service_desc = NULL;
1790 0 globus_extension_release(ext);
1791 0 break;
1792 }
1793 2130 globus_mutex_unlock(&service_desc->mutex);
1794 2130 service_desc = NULL;
1795 2130 globus_extension_release(ext);
1796
1797 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_SERVICE_HANDLERS:
1798
1799 2130 if(callback_handle->result != GLOBUS_SUCCESS)
1800 {
1801 0 result = callback_handle->result;
1802 0 goto callback_exit;
1803 }
1804
1805 2130 callback_handle->state =
1806 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_HANDLERS;
1807
1808 2130 ext =
1809 (globus_extension_handle_t)
1810 globus_soap_message_handle_get_attr(
1811 callback_handle->message,
1812 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1813 2130 globus_assert_string(
1814 ext, "No SERVICE DESCRIPTOR attribute found!");
1815
1816 2130 service_desc =
1817 (globus_service_descriptor_t *)
1818 globus_extension_reference(ext);
1819
1820 2130 globus_assert_string(
1821 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1822
1823 2130 globus_mutex_unlock(&service_desc->mutex);
1824 2130 if(service_desc->handlers)
1825 {
1826 0 globus_handler_chain_register_invoke(
1827 service_desc->handlers,
1828 GLOBUS_HANDLER_TYPE_RESPONSE_INIT,
1829 callback_handle->message,
1830 globus_l_service_session_result_callback,
1831 callback_handle);
1832 0 globus_mutex_unlock(&service_desc->mutex);
1833 0 service_desc = NULL;
1834 0 globus_extension_release(ext);
1835 0 break;
1836 }
1837 2130 globus_mutex_unlock(&service_desc->mutex);
1838
1839 2130 service_desc = NULL;
1840 2130 globus_extension_release(ext);
1841
1842 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_INIT_HANDLERS:
1843
1844 2130 if(callback_handle->result != GLOBUS_SUCCESS)
1845 {
1846 0 result = callback_handle->result;
1847 0 goto callback_exit;
1848 }
1849
1850 2130 callback_handle->state =
1851 GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_OPERATION;
1852
1853 2130 globus_mutex_lock(&callback_handle->engine->mutex);
1854 2130 if(callback_handle->engine->handlers)
1855 {
1856 2130 globus_handler_chain_register_invoke(
1857 callback_handle->engine->handlers,
1858 GLOBUS_HANDLER_TYPE_RESPONSE_INIT,
1859 callback_handle->message,
1860 globus_l_service_session_result_callback,
1861 callback_handle);
1862 2130 globus_mutex_unlock(&callback_handle->engine->mutex);
1863 2130 break;
1864 }
1865 0 globus_mutex_unlock(&callback_handle->engine->mutex);
1866
1867
1868 case GLOBUS_L_SERVICE_ENGINE_REQUEST_INVOKE_OPERATION:
1869
1870 2130 if(callback_handle->result != GLOBUS_SUCCESS)
1871 {
1872 0 result = callback_handle->result;
1873 0 goto error_send_fault;
1874 }
1875
1876 2130 callback_handle->state =
1877 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_SERVICE_HANDLERS;
1878
1879 2130 operation_name = globus_soap_message_handle_get_attr(
1880 callback_handle->message,
1881 GLOBUS_I_SERVICE_OPERATION_QNAME_KEY);
1882 2130 globus_assert(operation_name);
1883
1884 2130 ext =
1885 (globus_extension_handle_t)
1886 globus_soap_message_handle_get_attr(
1887 callback_handle->message,
1888 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1889 2130 globus_assert_string(
1890 ext, "No SERVICE DESCRIPTOR attribute found!");
1891
1892 2130 service_desc = (globus_service_descriptor_t *)
1893 globus_extension_reference(ext);
1894
1895 2130 globus_assert_string(
1896 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1897
1898 /* we use qn to map to operation deserialize function */
1899 2130 globus_mutex_lock(&service_desc->mutex);
1900 2130 if(service_desc->op_mapper)
1901 {
1902 2130 op_desc = (globus_service_operation_descriptor_t *)
1903 globus_hashtable_lookup(
1904 &service_desc->op_mapper,
1905 (void *)operation_name);
1906 }
1907
1908 2130 if(!op_desc)
1909 {
1910 0 result = GlobusServiceEngineErrorOperationLookupFailed(
1911 service_desc->name, operation_name);
1912 0 globus_mutex_unlock(&service_desc->mutex);
1913 0 service_desc = NULL;
1914 0 globus_extension_release(ext);
1915 0 goto error_send_fault;
1916 }
1917
1918 2130 result = op_desc->invoke(
1919 callback_handle->engine,
1920 callback_handle->message,
1921 &callback_handle->response,
1922 globus_l_service_session_result_callback,
1923 callback_handle);
1924 2130 if(result != GLOBUS_SUCCESS)
1925 {
1926 0 result = GlobusServiceEngineErrorOpInvokeFailed(
1927 result,
1928 operation_name);
1929 0 globus_mutex_unlock(&service_desc->mutex);
1930 0 goto error_send_fault;
1931 }
1932
1933 2130 if(callback_handle->response == GLOBUS_SERVICE_NO_RESPONSE)
1934 {
1935 10 callback_handle->state = GLOBUS_L_SERVICE_ENGINE_RESPONSE_SEND;
1936 }
1937
1938 2130 globus_mutex_unlock(&service_desc->mutex);
1939 2130 service_desc = NULL;
1940 2130 globus_extension_release(ext);
1941
1942 2130 break;
1943
1944 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_SERVICE_HANDLERS:
1945
1946 2120 if(callback_handle->result != GLOBUS_SUCCESS)
1947 {
1948 0 result = callback_handle->result;
1949 0 goto callback_exit;
1950 }
1951
1952 2120 callback_handle->state =
1953 GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_HANDLERS;
1954
1955 2120 result = globus_soap_message_set_write_position_to_marker(
1956 callback_handle->message,
1957 GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
1958 2120 if(result != GLOBUS_SUCCESS)
1959 {
1960 2120 goto callback_exit;
1961 }
1962
1963 2120 ext =
1964 (globus_extension_handle_t)
1965 globus_soap_message_handle_get_attr(
1966 callback_handle->message,
1967 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
1968 2120 globus_assert_string(
1969 ext, "No SERVICE DESCRIPTOR attribute found!");
1970
1971 2120 service_desc =
1972 (globus_service_descriptor_t *)
1973 globus_extension_reference(ext);
1974
1975 2120 globus_assert_string(
1976 service_desc, "No SERVICE DESCRIPTOR attribute found!");
1977
1978 2120 globus_mutex_unlock(&service_desc->mutex);
1979 2120 if(service_desc->handlers)
1980 {
1981 0 globus_handler_chain_register_invoke(
1982 service_desc->handlers,
1983 GLOBUS_HANDLER_TYPE_RESPONSE,
1984 callback_handle->message,
1985 globus_l_service_session_result_callback,
1986 callback_handle);
1987 0 globus_mutex_unlock(&service_desc->mutex);
1988 0 service_desc = NULL;
1989 0 globus_extension_release(ext);
1990 0 break;
1991 }
1992 2120 globus_mutex_unlock(&service_desc->mutex);
1993
1994 2120 service_desc = NULL;
1995 2120 globus_extension_release(ext);
1996
1997 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_INVOKE_HANDLERS:
1998
1999 2122 callback_handle->state =
2000 GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_SERVICE_HANDLERS;
2001
2002 2122 if(callback_handle->result != GLOBUS_SUCCESS)
2003 {
2004 0 result = callback_handle->result;
2005 0 goto callback_exit;
2006 }
2007
2008 2122 globus_mutex_lock(&callback_handle->engine->mutex);
2009 2122 if(callback_handle->engine->handlers)
2010 {
2011 2122 globus_handler_chain_register_invoke(
2012 callback_handle->engine->handlers,
2013 GLOBUS_HANDLER_TYPE_RESPONSE,
2014 callback_handle->message,
2015 globus_l_service_session_result_callback,
2016 callback_handle);
2017 2122 globus_mutex_unlock(&callback_handle->engine->mutex);
2018 2122 break;
2019 }
2020 0 globus_mutex_unlock(&callback_handle->engine->mutex);
2021
2022 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_SERVICE_HANDLERS:
2023
2024 2122 if(callback_handle->result != GLOBUS_SUCCESS)
2025 {
2026 0 result = callback_handle->result;
2027 0 goto callback_exit;
2028 }
2029
2030 2122 callback_handle->state =
2031 GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_HANDLERS;
2032
2033 2122 if(callback_handle->response == GLOBUS_SERVICE_NO_RESPONSE)
2034 {
2035 0 result = globus_soap_message_setup_writer(
2036 callback_handle->message);
2037 0 if(result != GLOBUS_SUCCESS)
2038 {
2039 2122 goto callback_exit;
2040 }
2041 }
2042
2043 2122 ext =
2044 (globus_extension_handle_t)
2045 globus_soap_message_handle_get_attr(
2046 callback_handle->message,
2047 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
2048
2049 /* If the user passes in an invalid service name, the extension
2050 * handle will be NULL. We'll just skip service-specific handler
2051 * invocation in this case.
2052 */
2053 2122 if (ext != NULL)
2054 {
2055 2121 service_desc =
2056 (globus_service_descriptor_t *)
2057 globus_extension_reference(ext);
2058
2059 2121 globus_assert_string(
2060 service_desc, "No SERVICE DESCRIPTOR attribute found!");
2061
2062 2121 globus_mutex_unlock(&service_desc->mutex);
2063 2121 if(service_desc->handlers)
2064 {
2065 0 globus_handler_chain_register_invoke(
2066 service_desc->handlers,
2067 GLOBUS_HANDLER_TYPE_RESPONSE_DESTROY,
2068 callback_handle->message,
2069 globus_l_service_session_result_callback,
2070 callback_handle);
2071 0 globus_mutex_unlock(&service_desc->mutex);
2072 0 service_desc = NULL;
2073 0 globus_extension_release(ext);
2074 0 break;
2075 }
2076 2121 globus_mutex_unlock(&service_desc->mutex);
2077
2078 2121 service_desc = NULL;
2079 2121 globus_extension_release(ext);
2080 }
2081
2082 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_DESTROY_HANDLERS:
2083
2084 2122 if(callback_handle->result != GLOBUS_SUCCESS)
2085 {
2086 0 result = callback_handle->result;
2087 0 goto callback_exit;
2088 }
2089
2090 2122 callback_handle->state =
2091 GLOBUS_L_SERVICE_ENGINE_RESPONSE_SEND;
2092
2093 2122 globus_mutex_lock(&callback_handle->engine->mutex);
2094 2122 if(callback_handle->engine->handlers)
2095 {
2096 2122 globus_handler_chain_register_invoke(
2097 callback_handle->engine->handlers,
2098 GLOBUS_HANDLER_TYPE_RESPONSE_DESTROY,
2099 callback_handle->message,
2100 globus_l_service_session_result_callback,
2101 callback_handle);
2102 2122 globus_mutex_unlock(&callback_handle->engine->mutex);
2103 2122 break;
2104 }
2105 0 globus_mutex_unlock(&callback_handle->engine->mutex);
2106
2107 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_SEND:
2108
2109 2132 callback_handle->state =
2110 GLOBUS_L_SERVICE_ENGINE_RESPONSE_CLOSE;
2111
2112 /* If there's no response, we setup the writer to clear the
2113 * buffer state so that we don't send the request back as
2114 * the unwanted response
2115 */
2116 2132 if(callback_handle->response == GLOBUS_SERVICE_NO_RESPONSE)
2117 {
2118 10 result = globus_soap_message_setup_writer(
2119 callback_handle->message);
2120 10 if(result != GLOBUS_SUCCESS)
2121 {
2122 2132 goto callback_exit;
2123 }
2124 }
2125 2132 result = globus_soap_message_register_write_response(
2126 callback_handle->message,
2127 globus_l_service_session_result_callback,
2128 callback_handle);
2129 2132 if(result != GLOBUS_SUCCESS)
2130 {
2131 goto callback_exit;
2132 }
2133
2134 break;
2135
2136 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_CLOSE:
2137 3206 connection = globus_soap_message_handle_get_attr(
2138 callback_handle->message,
2139 GLOBUS_SOAP_MESSAGE_CONNECTION_KEY);
2140
2141 3206 if (callback_handle->result == GLOBUS_SUCCESS
2142 && ((!connection) || (strcmp(connection, "close"))))
2143 {
2144 2131 callback_handle->state =
2145 GLOBUS_L_SERVICE_ENGINE_REQUEST_READ_ANOTHER_MESSAGE;
2146
2147 2131 result = globus_soap_message_handle_reset(
2148 callback_handle->message);
2149
2150 2131 if (result != GLOBUS_SUCCESS)
2151 {
2152 2131 goto close_it;
2153 }
2154 /* Register a new metadata read */
2155 2131 result = globus_soap_message_get_transport_handle(
2156 callback_handle->message,
2157 &xio_handle);
2158
2159 2131 if (result != GLOBUS_SUCCESS)
2160 {
2161 2131 goto close_it;
2162 }
2163 2131 result = globus_xio_handle_cntl(
2164 xio_handle,
2165 globus_i_soap_message_buffer_driver,
2166 GLOBUS_XIO_BUFFER_CLEAR);
2167 2131 if (result != GLOBUS_SUCCESS)
2168 {
2169 2131 goto close_it;
2170 }
2171 2131 result = globus_xio_handle_cntl(
2172 xio_handle,
2173 globus_i_soap_message_buffer_driver,
2174 GLOBUS_XIO_BUFFER_DISABLE_BUFFERING);
2175 2131 if (result != GLOBUS_SUCCESS)
2176 {
2177 2131 goto close_it;
2178 }
2179
2180 2131 result = globus_xio_register_read(
2181 xio_handle,
2182 buffer,
2183 0,
2184 0,
2185 NULL,
2186 globus_l_service_engine_request_ready_callback,
2187 callback_handle);
2188 2131 if (result == GLOBUS_SUCCESS)
2189 {
2190 1075 break;
2191 }
2192 }
2193 1075 close_it:
2194 1075 callback_handle->state =
2195 GLOBUS_L_SERVICE_ENGINE_RESPONSE_DONE;
2196
2197 1075 if(callback_handle->result != GLOBUS_SUCCESS)
2198 {
2199 0 result = callback_handle->result;
2200 0 goto exit;
2201 }
2202
2203 1075 result = globus_soap_message_register_close(
2204 callback_handle->message,
2205 globus_l_service_session_result_callback,
2206 callback_handle);
2207
2208 1075 if(result != GLOBUS_SUCCESS)
2209 {
2210 goto callback_exit;
2211 }
2212 break;
2213
2214 case GLOBUS_L_SERVICE_ENGINE_RESPONSE_DONE:
2215
2216 1075 if(callback_handle->result != GLOBUS_SUCCESS)
2217 {
2218 0 result = callback_handle->result;
2219 0 goto exit;
2220 }
2221
2222 goto callback_exit;
2223 }
2224
2225 goto exit;
2226
2227 1 error_send_fault:
2228
2229 1 if(service_desc)
2230 {
2231 0 service_desc = NULL;
2232 0 globus_extension_release(ext);
2233 }
2234
2235 1 if(result != GLOBUS_SUCCESS)
2236 {
2237 char * error_str;
2238
2239 1 error_str = globus_error_print_chain(
2240 globus_error_peek(result));
2241 1 GlobusServiceEngineDebugPrintf(
2242 GLOBUS_L_SERVICE_ENGINE_DEBUG_ERROR,
2243 ("SOAP message processing failed:\n%s\n",
2244 error_str));
2245 1 globus_free(error_str);
2246
2247 1 callback_handle->result = result;
2248 /* need to send client FAULT as response */
2249 1 result = globus_callback_register_oneshot(
2250 NULL,
2251 &globus_i_reltime_zero,
2252 globus_l_service_engine_send_client_fault,
2253 callback_handle);
2254 1 if(result != GLOBUS_SUCCESS)
2255 {
2256 0 result = GlobusServiceEngineErrorFailedRequestProcess(
2257 result,
2258 "Failed to register callback "
2259 "to send client fault response");
2260 }
2261 }
2262
2263 goto exit;
2264
2265 1075 callback_exit:
2266
2267 1075 if(result != GLOBUS_SUCCESS)
2268 {
2269 0 ext =
2270 (globus_extension_handle_t)
2271 globus_soap_message_handle_get_attr(
2272 callback_handle->message,
2273 GLOBUS_I_SERVICE_DESCRIPTOR_KEY);
2274 0 if(ext)
2275 {
2276 0 service_desc =
2277 (globus_service_descriptor_t *)
2278 globus_extension_reference(ext);
2279
2280 0 globus_assert_string(service_desc,
2281 "No SERVICE DESCRIPTOR attribute found!");
2282
2283 0 globus_mutex_lock(&service_desc->mutex);
2284 0 result = GlobusServiceEngineErrorSessionFailed(
2285 result, service_desc->name);
2286 0 globus_mutex_unlock(&service_desc->mutex);
2287
2288 0 service_desc = NULL;
2289 0 globus_extension_release(ext);
2290 }
2291 }
2292
2293 1075 globus_mutex_lock(&callback_handle->engine->mutex);
2294 1075 callback_handle->process_callback(
2295 result ? result : callback_handle->callback_result,
2296 callback_handle->engine,
2297 callback_handle->message,
2298 callback_handle->process_args);
2299 1075 globus_mutex_unlock(&callback_handle->engine->mutex);
2300
2301 1075 globus_l_service_session_callback_handle_destroy(callback_handle);
2302
2303 38309 exit:
2304 38309 GlobusServiceEngineDebugExit();
2305 }
2306
2307 globus_result_t
2308 globus_service_session_begin_response(
2309 globus_soap_message_handle_t message)
2310 2122 {
2311 2122 globus_result_t result = GLOBUS_SUCCESS;
2312 GlobusFuncName(globus_service_session_begin_response);
2313 2122 GlobusServiceEngineDebugEnter();
2314
2315 2122 result = globus_soap_message_setup_writer(message);
2316 2122 if(result != GLOBUS_SUCCESS)
2317 {
2318 0 result = GlobusServiceEngineErrorTransportFailed(
2319 result, "Failed to setup message writer");
2320 0 goto exit;
2321 }
2322
2323 2122 result = globus_soap_message_serialize_envelope(message);
2324 2122 if(result != GLOBUS_SUCCESS)
2325 {
2326 0 result = GlobusServiceEngineErrorFailedResponse(result);
2327 0 goto exit;
2328 }
2329
2330 2122 result = globus_soap_message_serialize_header(message);
2331 2122 if(result != GLOBUS_SUCCESS)
2332 {
2333 0 result = GlobusServiceEngineErrorFailedResponse(result);
2334 0 goto exit;
2335 }
2336
2337 2122 result = globus_soap_message_serialize_header_begin_close(message);
2338 2122 if(result != GLOBUS_SUCCESS)
2339 {
2340 0 result = GlobusServiceEngineErrorFailedResponse(result);
2341 0 goto exit;
2342 }
2343
2344 2122 result = globus_soap_message_set_marker(
2345 message,
2346 GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
2347 2122 if(result != GLOBUS_SUCCESS)
2348 {
2349 0 result = GlobusServiceEngineErrorFailedResponse(result);
2350 0 goto exit;
2351 }
2352
2353 2122 result = globus_soap_message_serialize_header_end(message);
2354 2122 if(result != GLOBUS_SUCCESS)
2355 {
2356 0 result = GlobusServiceEngineErrorFailedResponse(result);
2357 0 goto exit;
2358 }
2359
2360 2122 result = globus_soap_message_serialize_body(message);
2361 2122 if(result != GLOBUS_SUCCESS)
2362 {
2363 0 result = GlobusServiceEngineErrorFailedResponse(result);
2364 0 goto exit;
2365 }
2366
2367 2122 result = globus_soap_message_serialize_body_begin_close(
2368 message);
2369 2122 if(result != GLOBUS_SUCCESS)
2370 {
2371 0 result = GlobusServiceEngineErrorFailedResponse(result);
2372 goto exit;
2373 }
2374
2375 2122 exit:
2376
2377 2122 GlobusServiceEngineDebugExit();
2378 2122 return result;
2379 }
2380
2381 globus_result_t
2382 globus_service_session_end_response(
2383 globus_soap_message_handle_t message)
2384 2122 {
2385 2122 globus_result_t result = GLOBUS_SUCCESS;
2386 GlobusFuncName(globus_service_session_end_response);
2387 2122 GlobusServiceEngineDebugEnter();
2388
2389 2122 result = globus_soap_message_serialize_body_end(message);
2390 2122 if(result != GLOBUS_SUCCESS)
2391 {
2392 0 result = GlobusServiceEngineErrorFailedResponse(result);
2393 0 goto exit;
2394 }
2395