Code Coverage for SubscriptionManagerService

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		/*
14		* This file is automatically generated by the Globus WSDLtoC converter
15		*/
16
17		#include "globus_soap_message.h"
18		#include "globus_handler.h"
19		#include "globus_xio.h"
20		#include "SubscriptionManagerService_client.h"
21		#include "SubscriptionManagerService_client_internal.h"
22		#include "globus_xsd_type_registry.h"
23		#include "globus_soap_message_fault.h"
24		#include "globus_soap_message_attrs.h"
25		#include "globus_soap_message_markers.h"
26		#include "globus_soap_message_attrs.h"
27		#include "globus_ws_addressing.h"
28
29		static globus_list_t * SubscriptionManagerService_l_extensions = NULL;
30		static globus_mutex_t SubscriptionManagerService_l_extensions_mutex;
31
32		globus_xsd_type_registry_t SubscriptionManagerService_l_registry = NULL;
33
34		static
35		int
36		SubscriptionManagerService_l_client_module_activate();
37
38		static
39		int
40		SubscriptionManagerService_l_client_module_deactivate();
41
42		globus_module_descriptor_t
43		SubscriptionManagerService_i_module =
44		{
45		"SubscriptionManagerService",
46		SubscriptionManagerService_l_client_module_activate,
47		SubscriptionManagerService_l_client_module_deactivate
48		};
49
50		static
51		int
52		SubscriptionManagerService_l_client_module_activate()
53	0	{
54	0	int res = 0;
55	0	globus_result_t result = GLOBUS_SUCCESS;
56	0	res = globus_module_activate(GLOBUS_SOAP_MESSAGE_MODULE);
57	0	if(res != GLOBUS_SUCCESS)
58		{
59	0	return res;
60		}
61
62	0	if(!SubscriptionManagerService_l_registry)
63		{
64	0	result = globus_xsd_type_registry_init(&SubscriptionManagerService_l_registry);
65	0	if(result != GLOBUS_SUCCESS)
66		{
67	0	return (int) result;
68		}
69
70	0	result = SubscriptionManagerService_registry_add_types(SubscriptionManagerService_l_registry);
71	0	if(result != GLOBUS_SUCCESS)
72		{
73	0	return (int) result;
74		}
75		}
76
77	0	if(GLOBUS_GLOBAL_TYPE_REGISTRY == NULL)
78		{
79	0	result = GLOBUS_FAILURE;
80	0	return GLOBUS_FAILURE;
81		}
82
83	0	result = SubscriptionManagerService_registry_add_types(GLOBUS_GLOBAL_TYPE_REGISTRY);
84	0	if(result != GLOBUS_SUCCESS)
85		{
86	0	result = GlobusSoapMessageErrorFailedClientInit(
87		result, "SubscriptionManagerService");
88		}
89
90	0	globus_mutex_init(&SubscriptionManagerService_l_extensions_mutex, NULL);
91
92	0	return res;
93		}
94
95		static
96		void
97		SubscriptionManagerService_l_extension_destroy(
98		void * sym)
99	0	{
100	0	char * symbol = (char *) sym;
101
102	0	globus_extension_deactivate(symbol);
103	0	globus_free(symbol);
104		}
105
106		static
107		int
108		SubscriptionManagerService_l_client_module_deactivate()
109	0	{
110	0	int res = 0;
111
112	0	globus_xsd_type_registry_destroy(SubscriptionManagerService_l_registry);
113	0	SubscriptionManagerService_l_registry = NULL;
114
115	0	globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
116
117	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
118	0	globus_list_destroy_all(
119		SubscriptionManagerService_l_extensions,
120		SubscriptionManagerService_l_extension_destroy);
121	0	SubscriptionManagerService_l_extensions = NULL;
122	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
123	0	globus_mutex_destroy(&SubscriptionManagerService_l_extensions_mutex);
124
125	0	return res;
126		}
127
128		globus_result_t
129		SubscriptionManagerService_client_init(
130		SubscriptionManagerService_client_handle_t * handle,
131		globus_soap_message_attr_t attrs,
132		globus_handler_chain_t chain)
133	0	{
134	0	SubscriptionManagerService_client_handle_t client_handle;
135	0	globus_result_t result = GLOBUS_SUCCESS;
136	0	GlobusFuncName(SubscriptionManagerService_client_init);
137	0	GlobusSoapMessageDebugEnter();
138
139	0	client_handle = malloc(sizeof(struct SubscriptionManagerService_client_handle_s));
140	0	globus_assert_string(client_handle, "Memory allocation failed");
141	0	memset(client_handle, 0, sizeof(struct SubscriptionManagerService_client_handle_s));
142
143	0	if(chain)
144		{
145	0	result = globus_handler_chain_copy(
146		&client_handle->handler_chain, chain);
147	0	if(result != GLOBUS_SUCCESS)
148		{
149	0	goto error;
150		}
151		}
152		else
153		{
154	0	globus_handler_chain_init(&client_handle->handler_chain);
155
156	0	if(attrs &&
157		((int)globus_soap_message_attr_get(
158		attrs,
159		GLOBUS_SOAP_MESSAGE_AUTHENTICATION_METHOD_KEY)) ==
160		GLOBUS_SOAP_MESSAGE_AUTH_SECURE_MESSAGE)
161		{
162	0	result = globus_extension_activate(
163		"globus_handler_ws_secure_message");
164	0	if(result != GLOBUS_SUCCESS)
165		{
166	0	result = GlobusSoapMessageErrorFailedClientInit(
167		result, "SubscriptionManager_GetResourceProperty");
168	0	goto error;
169		}
170
171	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
172	0	globus_list_insert(
173		&SubscriptionManagerService_l_extensions,
174		strdup("globus_handler_ws_secure_message"));
175	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
176
177	0	result = globus_handler_chain_push(
178		client_handle->handler_chain,
179		GLOBUS_HANDLER_TYPE_ALL,
180		"globus_handler_ws_secure_message_client");
181	0	if(result != GLOBUS_SUCCESS)
182		{
183	0	result = GlobusSoapMessageErrorFailedClientInit(
184		result, "SubscriptionManager_GetResourceProperty");
185	0	goto error;
186		}
187		}
188
189	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
190	0	if(result != GLOBUS_SUCCESS)
191		{
192	0	result = GlobusSoapMessageErrorFailedClientInit(
193		result, "SubscriptionManager_GetResourceProperty");
194	0	goto error;
195		}
196
197	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
198	0	globus_list_insert(
199		&SubscriptionManagerService_l_extensions,
200		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
201	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
202
203	0	result = globus_handler_chain_push(
204		client_handle->handler_chain,
205		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
206		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
207	0	if(result != GLOBUS_SUCCESS)
208		{
209	0	result = GlobusSoapMessageErrorFailedClientInit(
210		result, "SubscriptionManager_GetResourceProperty");
211	0	goto error;
212		}
213
214	0	result = globus_handler_chain_push(
215		client_handle->handler_chain,
216		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
217		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
218	0	if(result != GLOBUS_SUCCESS)
219		{
220	0	result = GlobusSoapMessageErrorFailedClientInit(
221		result, "SubscriptionManager_GetResourceProperty");
222	0	goto error;
223		}
224		}
225
226	0	if(attrs)
227		{
228	0	globus_soap_message_attr_copy(
229		&client_handle->attrs, attrs);
230		}
231		else
232		{
233	0	globus_soap_message_attr_init(&client_handle->attrs);
234		}
235
236	0	*handle = client_handle;
237
238	0	GlobusSoapMessageDebugExit();
239	0	return result;
240
241		error:
242	0	globus_free(client_handle);
243	0	GlobusSoapMessageDebugExit();
244	0	return result;
245		}
246
247		void
248		SubscriptionManagerService_client_destroy(
249		SubscriptionManagerService_client_handle_t handle)
250	0	{
251	0	if(handle)
252		{
253	0	if(handle->handler_chain)
254		{
255	0	globus_handler_chain_destroy(handle->handler_chain);
256		}
257
258	0	if(handle->attrs)
259		{
260	0	globus_soap_message_attr_destroy(handle->attrs);
261		}
262
263	0	if(handle->message)
264		{
265	0	globus_soap_message_handle_destroy(handle->message);
266		}
267
268	0	free(handle);
269		}
270		}
271
272		globus_result_t
273		SubscriptionManagerService_client_operation_cancel(
274		SubscriptionManagerService_client_handle_t handle)
275	0	{
276	0	globus_result_t result = GLOBUS_SUCCESS;
277	0	GlobusFuncName(SubscriptionManagerService_client_message_cancel);
278	0	GlobusSoapMessageDebugEnter();
279
280	0	if(handle->message)
281		{
282	0	result = globus_soap_message_cancel_message(handle->message);
283		}
284
285	0	return result;
286		}
287
288		globus_result_t
289		SubscriptionManagerService_client_get_registry(
290		SubscriptionManagerService_client_handle_t handle,
291		globus_xsd_type_registry_t * registry)
292	0	{
293	0	globus_result_t result = GLOBUS_SUCCESS;
294	0	GlobusFuncName(SubscriptionManagerService_client_get_registry);
295	0	GlobusSoapMessageDebugEnter();
296
297	0	*registry = SubscriptionManagerService_l_registry;
298
299	0	GlobusSoapMessageDebugExit();
300	0	return result;
301		}
302
303		globus_result_t
304		SubscriptionManagerService_client_get_handler_chain(
305		SubscriptionManagerService_client_handle_t handle,
306		globus_handler_chain_t * handlers)
307	0	{
308	0	globus_result_t result = GLOBUS_SUCCESS;
309	0	GlobusFuncName(SubscriptionManagerService_client_get_handle_chain);
310	0	GlobusSoapMessageDebugEnter();
311
312	0	*handlers = handle->handler_chain;
313
314	0	GlobusSoapMessageDebugExit();
315	0	return result;
316		}
317
318		globus_result_t
319		SubscriptionManagerService_client_attr_set(
320		SubscriptionManagerService_client_handle_t handle,
321		const char * prop_name,
322		globus_soap_message_attr_copy_func_t copy,
323		globus_soap_message_attr_destroy_func_t destroy,
324		void * value)
325	0	{
326	0	return globus_soap_message_attr_set(
327		handle->attrs,
328		prop_name,
329		copy,
330		destroy,
331		value);
332		}
333
334		void *
335		SubscriptionManagerService_client_attr_remove(
336		SubscriptionManagerService_client_handle_t handle,
337		const char * prop_name)
338	0	{
339	0	return globus_soap_message_attr_remove(
340		handle->attrs,
341		prop_name);
342		}
343
344		void *
345		SubscriptionManagerService_client_attr_get(
346		SubscriptionManagerService_client_handle_t handle,
347		const char * prop_name)
348	0	{
349	0	return globus_soap_message_attr_get(
350		handle->attrs,
351		prop_name);
352		}
353
354		typedef enum
355		{
356		SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT,
357		SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS,
358		SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING,
359		SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS,
360		SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING,
361		SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS,
362		SUBSCRIPTIONMANAGERSERVICE_REQUEST_DONE
363		} SubscriptionManagerService_request_state_t;
364
365		typedef enum
366		{
367		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT,
368		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT_HANDLERS,
369		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING,
370		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS,
371		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE,
372		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS,
373		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED,
374		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DESTROY_HANDLERS,
375		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE,
376		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE
377		} SubscriptionManagerService_response_state_t;
378
379
380
381		typedef struct ResumeSubscription_i_request_handle_s
382		{
383		char * endpoint;
384		int done;
385		globus_mutex_t mutex;
386		SubscriptionManagerService_request_state_t state;
387		SubscriptionManager_ResumeSubscription_request_callback_func_t callback;
388		void * args;
389		SubscriptionManagerService_client_handle_t client_handle;
390		wsnt_ResumeSubscriptionType * ResumeSubscription;
391		globus_callback_handle_t callback_handle;
392		globus_result_t result;
393		} ResumeSubscription_i_request_handle_t;
394
395		static void
396		ResumeSubscription_i_request_callback(
397		void * args);
398
399		static void
400		ResumeSubscription_i_request_done_callback(
401		globus_result_t result,
402		void * args)
403	0	{
404	0	ResumeSubscription_i_request_handle_t * request;
405
406	0	request = (ResumeSubscription_i_request_handle_t *) args;
407	0	globus_assert_string(request, "request handle in callback is NULL");
408
409	0	globus_mutex_lock(&request->mutex);
410	0	request->result = result;
411	0	request->done = 1;
412	0	globus_mutex_unlock(&request->mutex);
413
414	0	ResumeSubscription_i_request_callback(request);
415		}
416
417		static void
418		ResumeSubscription_i_request_handle_destroy(
419		void * args)
420	0	{
421	0	ResumeSubscription_i_request_handle_t * request;
422
423	0	request = (ResumeSubscription_i_request_handle_t *) args;
424	0	globus_assert_string(request, "request handle in callback is NULL");
425
426	0	globus_mutex_destroy(&request->mutex);
427
428	0	if(request->ResumeSubscription)
429		{
430	0	wsnt_ResumeSubscriptionType_destroy(request->ResumeSubscription);
431		}
432	0	if(request->endpoint)
433		{
434	0	globus_free(request->endpoint);
435		}
436
437	0	globus_free(request);
438		}
439
440		static void
441		ResumeSubscription_i_request_callback(
442		void * args)
443	0	{
444	0	globus_soap_message_handle_t message_handle = NULL;
445	0	globus_result_t result = GLOBUS_SUCCESS;
446	0	globus_handler_chain_t chain = NULL;
447	0	ResumeSubscription_i_request_handle_t * request;
448	0	xsd_QName subelement;
449
450	0	request = (ResumeSubscription_i_request_handle_t *) args;
451	0	globus_assert_string(request, "request handle is NULL");
452
453	0	switch(request->state)
454		{
455
456		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT:
457
458	0	globus_mutex_lock(&request->mutex);
459	0	request->done = 0;
460	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS;
461	0	globus_mutex_unlock(&request->mutex);
462
463	0	result = globus_soap_message_get_handler_chain(
464		request->client_handle->message, &chain);
465	0	if(result != GLOBUS_SUCCESS)
466		{
467	0	goto error_exit;
468		}
469
470	0	if(chain)
471		{
472	0	globus_handler_chain_register_invoke(
473		chain,
474		GLOBUS_HANDLER_TYPE_REQUEST_INIT,
475		request->client_handle->message,
476		ResumeSubscription_i_request_done_callback,
477		request);
478		}
479
480	0	break;
481
482		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS:
483
484	0	globus_mutex_lock(&request->mutex);
485	0	request->done = 0;
486	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING;
487	0	globus_mutex_unlock(&request->mutex);
488
489	0	result = globus_soap_message_register_open(
490		request->client_handle->message,
491		request->endpoint,
492		ResumeSubscription_i_request_done_callback,
493		request);
494	0	if(result != GLOBUS_SUCCESS)
495		{
496	0	goto error_exit;
497		}
498
499	0	break;
500
501		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING:
502
503	0	if(request->done)
504		{
505	0	if(request->result != GLOBUS_SUCCESS)
506		{
507	0	result = request->result;
508	0	goto error_exit;
509		}
510
511	0	globus_mutex_lock(&request->mutex);
512	0	request->done = 0;
513	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS;
514	0	globus_mutex_unlock(&request->mutex);
515
516	0	result = globus_soap_message_serialize_envelope(
517		request->client_handle->message);
518	0	if(result != GLOBUS_SUCCESS)
519		{
520	0	goto error_exit;
521		}
522
523	0	result = globus_soap_message_serialize_header(
524		request->client_handle->message);
525	0	if(result != GLOBUS_SUCCESS)
526		{
527	0	goto error_exit;
528		}
529
530	0	result = globus_soap_message_serialize_header_begin_close(
531		request->client_handle->message);
532	0	if(result != GLOBUS_SUCCESS)
533		{
534	0	goto error_exit;
535		}
536
537	0	result = globus_soap_message_set_marker(
538		request->client_handle->message,
539		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
540	0	if(result != GLOBUS_SUCCESS)
541		{
542	0	goto error_exit;
543		}
544
545	0	result = globus_soap_message_serialize_header_end(
546		request->client_handle->message);
547	0	if(result != GLOBUS_SUCCESS)
548		{
549	0	goto error_exit;
550		}
551
552	0	result = globus_soap_message_serialize_body(
553		request->client_handle->message);
554	0	if(result != GLOBUS_SUCCESS)
555		{
556	0	goto error_exit;
557		}
558
559	0	result = globus_soap_message_serialize_body_begin_close(
560		request->client_handle->message);
561	0	if(result != GLOBUS_SUCCESS)
562		{
563	0	goto error_exit;
564		}
565
566	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
567	0	subelement.local = "ResumeSubscription";
568
569	0	result = wsnt_ResumeSubscriptionType_serialize(
570		&subelement,
571		request->ResumeSubscription,
572		request->client_handle->message,
573		0);
574	0	if(result != GLOBUS_SUCCESS)
575		{
576	0	goto error_exit;
577		}
578
579	0	result = globus_soap_message_serialize_body_end(
580		request->client_handle->message);
581	0	if(result != GLOBUS_SUCCESS)
582		{
583	0	goto error_exit;
584		}
585
586	0	result = globus_soap_message_serialize_envelope_end(
587		request->client_handle->message);
588	0	if(result != GLOBUS_SUCCESS)
589		{
590	0	goto error_exit;
591		}
592
593	0	result = globus_soap_message_set_write_position_to_marker(
594		request->client_handle->message,
595		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
596	0	if(result != GLOBUS_SUCCESS)
597		{
598	0	goto error_exit;
599		}
600
601	0	result = globus_soap_message_get_handler_chain(
602		request->client_handle->message, &chain);
603	0	if(result != GLOBUS_SUCCESS)
604		{
605	0	goto error_exit;
606		}
607
608	0	if(chain)
609		{
610	0	globus_handler_chain_register_invoke(
611		chain,
612		GLOBUS_HANDLER_TYPE_REQUEST,
613		request->client_handle->message,
614		ResumeSubscription_i_request_done_callback,
615		request);
616		}
617		}
618
619	0	break;
620
621		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS:
622
623	0	if(request->done)
624		{
625	0	if(request->result != GLOBUS_SUCCESS)
626		{
627	0	result = request->result;
628	0	goto error_exit;
629		}
630
631	0	globus_mutex_lock(&request->mutex);
632	0	request->done = 0;
633	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING;
634	0	globus_mutex_unlock(&request->mutex);
635
636	0	result = globus_soap_message_register_write_request(
637		request->client_handle->message,
638		ResumeSubscription_i_request_done_callback,
639		request,
640
641		GLOBUS_TRUE);
642
643	0	if(result != GLOBUS_SUCCESS)
644		{
645	0	goto error_exit;
646		}
647		}
648
649	0	break;
650
651		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING:
652
653	0	if(request->done)
654		{
655	0	if(request->result != GLOBUS_SUCCESS)
656		{
657	0	result = request->result;
658	0	goto error_exit;
659		}
660
661	0	globus_mutex_lock(&request->mutex);
662	0	request->done = 0;
663	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS;
664	0	globus_mutex_unlock(&request->mutex);
665
666	0	result = globus_soap_message_get_handler_chain(
667		request->client_handle->message, &chain);
668	0	if(result != GLOBUS_SUCCESS)
669		{
670	0	goto error_exit;
671		}
672
673	0	if(chain)
674		{
675	0	globus_handler_chain_register_invoke(
676		chain,
677		GLOBUS_HANDLER_TYPE_REQUEST_DESTROY,
678		request->client_handle->message,
679		ResumeSubscription_i_request_done_callback,
680		request);
681		}
682		}
683
684	0	break;
685
686		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS:
687
688	0	if(request->done)
689		{
690	0	if(request->result != GLOBUS_SUCCESS)
691		{
692	0	result = request->result;
693	0	goto error_exit;
694		}
695
696	0	globus_mutex_lock(&request->mutex);
697	0	request->done = 0;
698	0	globus_mutex_unlock(&request->mutex);
699
700	0	request->callback(
701		request->client_handle,
702		request->args, GLOBUS_SUCCESS);
703
704	0	ResumeSubscription_i_request_handle_destroy(request);
705		}
706
707	0	break;
708
709		default:
710
711	0	globus_assert_string(NULL, "Unkown request state");
712	0	break;
713		}
714
715	0	return;
716
717		error_exit:
718
719	0	result = GlobusSoapMessageErrorClientRequestFailed(
720		result, "SubscriptionManager_ResumeSubscription");
721
722	0	globus_mutex_lock(&request->mutex);
723	0	message_handle = request->client_handle->message;
724	0	request->client_handle->message = NULL;
725	0	globus_mutex_unlock(&request->mutex);
726
727	0	request->callback(request->client_handle, request->args, result);
728
729	0	globus_soap_message_handle_destroy(message_handle);
730	0	ResumeSubscription_i_request_handle_destroy(request);
731		}
732
733		globus_result_t
734		SubscriptionManager_ResumeSubscription_epr_register_request(
735		SubscriptionManagerService_client_handle_t client_handle,
736		const wsa_EndpointReferenceType * epr,
737		const wsnt_ResumeSubscriptionType * ResumeSubscription,
738		SubscriptionManager_ResumeSubscription_request_callback_func_t callback,
739		void * user_args)
740	0	{
741	0	globus_result_t result = GLOBUS_SUCCESS;
742
743	0	globus_assert_string(epr, "NULL EndpointReference");
744	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
745
746	0	globus_soap_message_attr_set(
747		client_handle->attrs,
748		WSADDR_EPR_KEY,
749		wsa_EndpointReferenceType_copy_wrapper,
750		wsa_EndpointReferenceType_destroy_wrapper,
751		(void *)epr);
752
753	0	result = SubscriptionManager_ResumeSubscription_register_request(
754		client_handle,
755		epr->Address.base_value,
756		ResumeSubscription,
757		callback,
758		user_args);
759
760	0	return result;
761		}
762
763		globus_result_t
764		SubscriptionManager_ResumeSubscription_register_request(
765		SubscriptionManagerService_client_handle_t client_handle,
766		const char * endpoint,
767		const wsnt_ResumeSubscriptionType * ResumeSubscription,
768		SubscriptionManager_ResumeSubscription_request_callback_func_t callback,
769		void * user_args)
770	0	{
771	0	globus_handler_chain_t chain = NULL;
772	0	globus_result_t result = GLOBUS_SUCCESS;
773	0	ResumeSubscription_i_request_handle_t * request = NULL;
774
775	0	if(client_handle->message != NULL)
776		{
777	0	result = GlobusSoapMessageErrorClientAlreadyInvoked();
778	0	goto exit;
779		}
780
781	0	result = globus_soap_message_handle_init(&client_handle->message, NULL);
782	0	if(result != GLOBUS_SUCCESS)
783		{
784	0	result = GlobusSoapMessageErrorFailedClientInit(
785		result, "SubscriptionManager_ResumeSubscription");
786	0	goto error_exit;
787		}
788
789	0	globus_soap_message_handle_set_registry(
790		client_handle->message, SubscriptionManagerService_l_registry);
791
792	0	chain = client_handle->handler_chain;
793	0	if(!chain)
794		{
795	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
796	0	if(result != GLOBUS_SUCCESS)
797		{
798	0	result = GlobusSoapMessageErrorFailedClientInit(
799		result, "SubscriptionManager_ResumeSubscription");
800	0	goto exit;
801		}
802
803	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
804	0	globus_list_insert(
805		&SubscriptionManagerService_l_extensions,
806		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
807	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
808
809	0	globus_handler_chain_init(&chain);
810	0	result = globus_handler_chain_push(
811		chain,
812		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
813		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
814	0	if(result != GLOBUS_SUCCESS)
815		{
816	0	result = GlobusSoapMessageErrorFailedClientInit(
817		result, "SubscriptionManager_ResumeSubscription");
818	0	goto error_exit;
819		}
820
821	0	result = globus_handler_chain_push(
822		chain,
823		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
824		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
825	0	if(result != GLOBUS_SUCCESS)
826		{
827	0	result = GlobusSoapMessageErrorFailedClientInit(
828		result, "SubscriptionManager_ResumeSubscription");
829	0	goto error_exit;
830		}
831		}
832
833	0	globus_soap_message_set_handler_chain(
834		client_handle->message, chain);
835
836	0	request = globus_malloc(sizeof(ResumeSubscription_i_request_handle_t));
837	0	globus_assert_string(request, "Memory allocation failed.");
838	0	memset(request, 0, sizeof(ResumeSubscription_i_request_handle_t));
839
840	0	if(!endpoint)
841		{
842	0	endpoint = (char *)globus_soap_message_attr_get(
843		client_handle->attrs, GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY);
844	0	if(!endpoint)
845		{
846	0	wsa_EndpointReferenceType * epr;
847	0	epr = (wsa_EndpointReferenceType *)
848		globus_soap_message_attr_get(
849		client_handle->attrs, WSADDR_EPR_KEY);
850	0	if(epr && epr->Address.base_value)
851		{
852	0	endpoint = epr->Address.base_value;
853		}
854		}
855		}
856
857	0	globus_assert_string(endpoint, "NULL endpoint");
858
859	0	request->endpoint = globus_libc_strdup(endpoint);
860	0	request->callback = callback;
861	0	request->args = user_args;
862	0	request->client_handle = client_handle;
863	0	wsnt_ResumeSubscriptionType_copy(&request->ResumeSubscription, ResumeSubscription);
864	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT;
865	0	globus_mutex_init(&request->mutex, NULL);
866
867	0	result = globus_soap_message_attr_set(
868		client_handle->attrs,
869		WSADDR_DESTINATION_KEY,
870		globus_soap_message_attr_copy_string,
871		globus_libc_free,
872		(void *)endpoint);
873	0	if(result != GLOBUS_SUCCESS)
874		{
875	0	result = GlobusSoapMessageErrorClientRequestFailed(
876		result, "SubscriptionManager_ResumeSubscription");
877	0	goto error_exit;
878		}
879
880	0	result = globus_soap_message_attr_set(
881		client_handle->attrs,
882		WSADDR_ACTION_REQUEST_KEY,
883		NULL,
884		NULL,
885		"http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification/ResumeSubscription");
886	0	if(result != GLOBUS_SUCCESS)
887		{
888	0	result = GlobusSoapMessageErrorClientRequestFailed(
889		result, "SubscriptionManager_ResumeSubscription");
890	0	goto error_exit;
891		}
892
893	0	result = globus_soap_message_attr_set(
894		client_handle->attrs,
895		GLOBUS_SOAP_MESSAGE_SOAP_ACTION_KEY,
896		NULL,
897		NULL,
898		"http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification/ResumeSubscription");
899	0	if(result != GLOBUS_SUCCESS)
900		{
901	0	result = GlobusSoapMessageErrorClientRequestFailed(
902		result, "SubscriptionManager_ResumeSubscription");
903	0	goto error_exit;
904		}
905
906	0	result = globus_soap_message_handle_set_attrs(
907		client_handle->message, client_handle->attrs);
908	0	if(result != GLOBUS_SUCCESS)
909		{
910	0	result = GlobusSoapMessageErrorClientRequestFailed(
911		result, "SubscriptionManager_ResumeSubscription");
912		}
913
914	0	result = globus_callback_register_oneshot(
915		&request->callback_handle,
916		NULL,
917		ResumeSubscription_i_request_callback,
918		request);
919	0	if(result != GLOBUS_SUCCESS)
920		{
921	0	result = GlobusSoapMessageErrorClientRequestFailed(
922		result, "SubscriptionManager_ResumeSubscription");
923		goto error_exit;
924		}
925
926	0	goto exit;
927
928		error_exit:
929
930	0	if(request)
931		{
932	0	globus_mutex_destroy(&request->mutex);
933
934	0	if(request->ResumeSubscription)
935		{
936	0	wsnt_ResumeSubscriptionType_destroy(request->ResumeSubscription);
937		}
938	0	if(request->endpoint)
939		{
940	0	globus_free(request->endpoint);
941		}
942
943	0	globus_free(request);
944		}
945
946	0	if(client_handle->message)
947		{
948	0	globus_soap_message_handle_destroy(client_handle->message);
949	0	client_handle->message = NULL;
950		}
951
952		exit:
953
954	0	return result;
955		}
956
957		typedef struct ResumeSubscription_i_blocking_request_callback_s
958		{
959
960		SubscriptionManager_ResumeSubscription_response_callback_func_t callback;
961		void * args;
962
963		} ResumeSubscription_i_blocking_request_callback_t;
964
965		static
966		void
967		ResumeSubscription_i_blocking_request_callback(
968		SubscriptionManagerService_client_handle_t handle,
969		void * user_args,
970		globus_result_t error)
971	0	{
972	0	globus_soap_message_handle_t message_handle = NULL;
973	0	globus_result_t result = GLOBUS_SUCCESS;
974	0	ResumeSubscription_i_blocking_request_callback_t * callback_handle;
975
976	0	callback_handle = (ResumeSubscription_i_blocking_request_callback_t *) user_args;
977	0	globus_assert_string(callback_handle, "callback_handle is NULL");
978
979
980	0	if(error != GLOBUS_SUCCESS \|\|
981		globus_soap_message_is_cancelled(handle->message))
982		{
983	0	message_handle = handle->message;
984	0	handle->message = NULL;
985
986	0	callback_handle->callback(
987		handle,
988		callback_handle->args,
989		error,
990		NULL,
991		SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT,
992		NULL);
993
994	0	globus_soap_message_handle_destroy(message_handle);
995		}
996		else
997		{
998	0	result = SubscriptionManager_ResumeSubscription_register_response(
999		handle,
1000		callback_handle->callback,
1001		callback_handle->args);
1002	0	if(result != GLOBUS_SUCCESS)
1003		{
1004	0	callback_handle->callback(
1005		handle,
1006		callback_handle->args,
1007		result,
1008		NULL,
1009		SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT,
1010		NULL);
1011		}
1012		}
1013
1014	0	free(callback_handle);
1015		}
1016
1017
1018
1019		typedef struct ResumeSubscription_i_response_handle_s
1020		{
1021		int done;
1022		globus_mutex_t mutex;
1023		SubscriptionManagerService_response_state_t state;
1024		SubscriptionManager_ResumeSubscription_response_callback_func_t callback;
1025		void * args;
1026		SubscriptionManagerService_client_handle_t client_handle;
1027		wsnt_ResumeSubscriptionResponseType * ResumeSubscriptionResponse;
1028		globus_callback_handle_t callback_handle;
1029		globus_result_t result;
1030		globus_result_t fault_result;
1031		int fault_type;
1032		xsd_any * fault;
1033		} ResumeSubscription_i_response_handle_t;
1034
1035		static void
1036		ResumeSubscription_i_response_callback(
1037		void * args);
1038
1039		static void
1040		ResumeSubscription_i_response_done_callback(
1041		globus_result_t result,
1042		void * args)
1043	0	{
1044	0	ResumeSubscription_i_response_handle_t * response;
1045
1046	0	response = (ResumeSubscription_i_response_handle_t *) args;
1047	0	globus_assert_string(response, "response handle in callback is NULL");
1048
1049	0	globus_mutex_lock(&response->mutex);
1050	0	response->result = result;
1051	0	response->done = 1;
1052	0	globus_mutex_unlock(&response->mutex);
1053
1054	0	ResumeSubscription_i_response_callback(response);
1055		}
1056
1057		static void
1058		ResumeSubscription_i_response_handle_destroy(
1059		void * args)
1060	0	{
1061	0	ResumeSubscription_i_response_handle_t * response;
1062
1063	0	response = (ResumeSubscription_i_response_handle_t *) args;
1064	0	globus_assert_string(response, "response handle in callback is NULL");
1065
1066	0	globus_mutex_destroy(&response->mutex);
1067
1068	0	free(response);
1069		}
1070
1071		static void
1072		ResumeSubscription_i_deserialize_fault(
1073		globus_soap_message_handle_t handle,
1074		const xsd_QName * fault_qname,
1075		int * fault_type,
1076		void * args)
1077	0	{
1078	0	*fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT;
1079
1080	0	if(fault_qname)
1081		{
1082	0	if(fault_qname == (&wsnt_ResourceUnknownFaultType_qname) \|\|
1083		fault_qname == (&wsnt_ResourceUnknownFault_qname))
1084		{
1085	0	*fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_RESOURCEUNKNOWNFAULT;
1086		}
1087	0	else if(fault_qname == (&wsnt_ResumeFailedFaultType_qname) \|\|
1088		fault_qname == (&wsnt_ResumeFailedFault_qname))
1089		{
1090	0	*fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_RESUMEFAILEDFAULT;
1091		}
1092		else
1093		{
1094	0	*fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_UNKNOWN_FAULT;
1095		}
1096		}
1097		}
1098
1099		static void
1100		ResumeSubscription_i_response_callback(
1101		void * args)
1102	0	{
1103	0	xsd_QName subelement;
1104	0	globus_soap_message_handle_t message_handle = NULL;
1105	0	globus_soap_message_fault_t soap_fault;
1106	0	globus_result_t result = GLOBUS_SUCCESS;
1107	0	globus_handler_chain_t chain = NULL;
1108	0	xsd_QName * header_element = NULL;
1109	0	int must;
1110	0	ResumeSubscription_i_response_handle_t * response;
1111	0	response = (ResumeSubscription_i_response_handle_t *) args;
1112	0	globus_assert_string(response, "response handle in callback is NULL");
1113
1114	0	switch(response->state)
1115		{
1116
1117		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT:
1118
1119	0	globus_mutex_lock(&response->mutex);
1120	0	response->done = 0;
1121	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING;
1122	0	globus_mutex_unlock(&response->mutex);
1123
1124	0	result = globus_soap_message_register_read_response(
1125		response->client_handle->message,
1126		ResumeSubscription_i_response_done_callback,
1127		response);
1128	0	if(result != GLOBUS_SUCCESS)
1129		{
1130	0	goto error_exit;
1131		}
1132
1133	0	break;
1134
1135		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING:
1136
1137	0	if(response->done)
1138		{
1139	0	if(response->result != GLOBUS_SUCCESS)
1140		{
1141	0	if(GlobusSoapMessageErrorCheckFailedResponse(response->result) \|\|
1142		GlobusSoapMessageErrorCheckBadRequest(response->result))
1143		{
1144	0	response->result = GLOBUS_SUCCESS;
1145		}
1146		else
1147		{
1148	0	result = response->result;
1149	0	goto error_exit;
1150		}
1151		}
1152
1153	0	globus_mutex_lock(&response->mutex);
1154	0	response->done = 0;
1155	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
1156	0	globus_mutex_unlock(&response->mutex);
1157
1158	0	result = globus_soap_message_deserialize_envelope(
1159		response->client_handle->message);
1160	0	if(result != GLOBUS_SUCCESS)
1161		{
1162	0	goto error_exit;
1163		}
1164
1165	0	result = globus_soap_message_deserialize_element_begin_close(
1166		response->client_handle->message);
1167	0	if(result != GLOBUS_SUCCESS)
1168		{
1169	0	goto error_exit;
1170		}
1171
1172	0	result = globus_soap_message_deserialize_header(
1173		response->client_handle->message);
1174	0	if(result != GLOBUS_SUCCESS)
1175		{
1176	0	if(GlobusSoapMessageStatusElementNotFoundCheck(result))
1177		{
1178	0	globus_soap_message_deserialize_push_element(
1179		response->client_handle->message);
1180	0	result = GLOBUS_SUCCESS;
1181	0	globus_mutex_lock(&response->mutex);
1182	0	response->state =
1183		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED;
1184	0	globus_mutex_unlock(&response->mutex);
1185	0	ResumeSubscription_i_response_done_callback(
1186		result, response);
1187	0	break;
1188		}
1189
1190	0	goto error_exit;
1191		}
1192
1193	0	globus_mutex_lock(&response->mutex);
1194	0	response->done = 1;
1195	0	globus_mutex_unlock(&response->mutex);
1196		}
1197
1198		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS:
1199
1200	0	if(response->done)
1201		{
1202	0	if(response->result != GLOBUS_SUCCESS)
1203		{
1204	0	if(GlobusSoapMessageErrorCheckFailedResponse(
1205		response->result) \|\|
1206		GlobusSoapMessageErrorCheckBadRequest(response->result))
1207		{
1208	0	response->result = GLOBUS_SUCCESS;
1209		}
1210		else
1211		{
1212	0	result = response->result;
1213	0	goto error_exit;
1214		}
1215		}
1216
1217	0	globus_mutex_lock(&response->mutex);
1218	0	response->done = 0;
1219	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
1220	0	globus_mutex_unlock(&response->mutex);
1221
1222	0	xsd_QName_init(&header_element);
1223
1224	0	result = globus_soap_message_deserialize_element_unknown(
1225		response->client_handle->message,
1226		header_element);
1227	0	if(result != GLOBUS_SUCCESS)
1228		{
1229	0	if(!GlobusSoapMessageStatusFailedElementCheck(result))
1230		{
1231	0	xsd_QName_destroy(header_element);
1232	0	goto error_exit;
1233		}
1234		else
1235		{
1236	0	globus_mutex_lock(&response->mutex);
1237	0	response->done = 1;
1238	0	response->state =
1239		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE;
1240	0	globus_mutex_unlock(&response->mutex);
1241
1242	0	globus_callback_register_oneshot(
1243		NULL,
1244		&globus_i_reltime_zero,
1245		ResumeSubscription_i_response_callback,
1246		(void *)response);
1247	0	xsd_QName_destroy(header_element);
1248	0	break;
1249		}
1250		}
1251
1252	0	result = globus_soap_message_deserialize_int_attribute(
1253		response->client_handle->message,
1254		&soap_mustUnderstand_qname,
1255		&must);
1256	0	if(result == GLOBUS_SUCCESS && (must == 1))
1257		{
1258	0	globus_soap_message_add_required_header_element(
1259		response->client_handle->message,
1260		header_element);
1261		}
1262	0	else if(result != GLOBUS_SUCCESS &&
1263		!GlobusSoapMessageStatusAttributeNotFoundCheck(result))
1264		{
1265	0	xsd_QName_destroy(header_element);
1266	0	goto error_exit;
1267		}
1268
1269	0	globus_soap_message_deserialize_push_element(
1270		response->client_handle->message);
1271
1272	0	result = globus_soap_message_get_handler_chain(
1273		response->client_handle->message, &chain);
1274	0	if(result != GLOBUS_SUCCESS)
1275		{
1276	0	goto error_exit;
1277		}
1278
1279	0	if(chain)
1280		{
1281	0	result = globus_handler_chain_register_trigger(
1282		chain,
1283		response->client_handle->message,
1284		header_element,
1285		ResumeSubscription_i_response_done_callback,
1286		response);
1287	0	if(result == GLOBUS_SUCCESS)
1288		{
1289	0	xsd_QName_destroy(header_element);
1290	0	break;
1291		}
1292	0	else if(!GlobusHandlerStatusNotTriggeredCheck(result))
1293		{
1294	0	xsd_QName_destroy(header_element);
1295	0	goto error_exit;
1296		}
1297		}
1298
1299	0	xsd_QName_destroy(header_element);
1300	0	result = globus_soap_message_deserialize_skip(
1301		response->client_handle->message);
1302	0	if(result != GLOBUS_SUCCESS)
1303		{
1304	0	goto error_exit;
1305		}
1306
1307	0	globus_mutex_lock(&response->mutex);
1308	0	response->done = 1;
1309	0	globus_mutex_unlock(&response->mutex);
1310	0	globus_callback_register_oneshot(
1311		NULL,
1312		&globus_i_reltime_zero,
1313		ResumeSubscription_i_response_callback,
1314		(void *)response);
1315		}
1316
1317	0	break;
1318
1319		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE:
1320
1321	0	if(response->done)
1322		{
1323	0	if(response->result != GLOBUS_SUCCESS)
1324		{
1325	0	result = response->result;
1326	0	goto error_exit;
1327		}
1328
1329	0	globus_mutex_lock(&response->mutex);
1330	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
1331	0	globus_mutex_unlock(&response->mutex);
1332
1333	0	result = globus_soap_message_deserialize_header_end(
1334		response->client_handle->message);
1335	0	if(result != GLOBUS_SUCCESS)
1336		{
1337	0	goto error_exit;
1338		}
1339
1340	0	result = globus_soap_message_deserialize_body(
1341		response->client_handle->message);
1342	0	if(result != GLOBUS_SUCCESS)
1343		{
1344	0	goto error_exit;
1345		}
1346		}
1347
1348		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED:
1349
1350	0	if(response->done)
1351		{
1352	0	if(response->result != GLOBUS_SUCCESS)
1353		{
1354	0	result = response->result;
1355	0	goto error_exit;
1356		}
1357
1358	0	globus_mutex_lock(&response->mutex);
1359	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
1360	0	globus_mutex_unlock(&response->mutex);
1361
1362	0	response->fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT;
1363	0	response->fault_result = GLOBUS_SUCCESS;
1364
1365	0	result = globus_soap_message_deserialize_fault(
1366		response->client_handle->message,
1367		&soap_fault,
1368		ResumeSubscription_i_deserialize_fault,
1369		&response->fault,
1370		&response->fault_type);
1371	0	if(result != GLOBUS_SUCCESS)
1372		{
1373	0	if(response->result != GLOBUS_SUCCESS)
1374		{
1375	0	result = response->result;
1376		}
1377	0	goto error_exit;
1378		}
1379
1380	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT)
1381		{
1382	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
1383	0	subelement.local = "ResumeSubscriptionResponse";
1384
1385	0	result = wsnt_ResumeSubscriptionResponseType_deserialize_pointer(
1386		&subelement,
1387		&response->ResumeSubscriptionResponse,
1388		response->client_handle->message,
1389		0);
1390	0	if(result != GLOBUS_SUCCESS)
1391		{
1392	0	goto error_exit;
1393		}
1394		}
1395		else
1396		{
1397	0	if(soap_fault)
1398		{
1399	0	response->fault_result = GlobusSoapMessageErrorFault(
1400		soap_fault);
1401		}
1402
1403	0	result = globus_soap_message_deserialize_fault_end(
1404		response->client_handle->message,
1405		response->fault
1406		? response->fault->element
1407		: &soap_fault_qname);
1408	0	if(result != GLOBUS_SUCCESS)
1409		{
1410	0	goto error_exit;
1411		}
1412		}
1413
1414	0	result = globus_soap_message_deserialize_body_end(
1415		response->client_handle->message);
1416	0	if(result != GLOBUS_SUCCESS)
1417		{
1418	0	goto error_exit;
1419		}
1420
1421	0	result = globus_soap_message_deserialize_envelope_end(
1422		response->client_handle->message);
1423	0	if(result != GLOBUS_SUCCESS)
1424		{
1425	0	goto error_exit;
1426		}
1427
1428
1429	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT)
1430		{
1431	0	result = globus_soap_message_get_handler_chain(
1432		response->client_handle->message, &chain);
1433	0	if(result != GLOBUS_SUCCESS)
1434		{
1435	0	goto error_exit;
1436		}
1437
1438	0	if(chain)
1439		{
1440	0	globus_handler_chain_register_invoke(
1441		chain,
1442		GLOBUS_HANDLER_TYPE_RESPONSE,
1443		response->client_handle->message,
1444		ResumeSubscription_i_response_done_callback,
1445		response);
1446		}
1447		}
1448		else
1449		{
1450	0	globus_mutex_lock(&response->mutex);
1451	0	response->done = 1;
1452	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE;
1453	0	globus_mutex_unlock(&response->mutex);
1454	0	globus_callback_register_oneshot(
1455		NULL,
1456		&globus_i_reltime_zero,
1457		ResumeSubscription_i_response_callback,
1458		(void *)response);
1459		}
1460		}
1461
1462	0	break;
1463
1464		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS:
1465
1466	0	if(response->done)
1467		{
1468	0	if(response->result != GLOBUS_SUCCESS)
1469		{
1470	0	result = response->result;
1471	0	goto error_exit;
1472		}
1473
1474	0	result = globus_soap_message_check_required_headers(
1475		response->client_handle->message);
1476	0	if(result != GLOBUS_SUCCESS)
1477		{
1478		/* continue on in case fault was returned and
1479		* no header elements exist
1480		*/
1481	0	response->result = result;
1482		}
1483		}
1484
1485		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE:
1486
1487	0	if(response->done)
1488		{
1489	0	if(response->result != GLOBUS_SUCCESS)
1490		{
1491	0	result = response->result;
1492	0	goto error_exit;
1493		}
1494
1495	0	globus_mutex_lock(&response->mutex);
1496	0	response->done = 0;
1497	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE;
1498	0	globus_mutex_unlock(&response->mutex);
1499
1500	0	result = globus_soap_message_register_close(
1501		response->client_handle->message,
1502		ResumeSubscription_i_response_done_callback,
1503		response);
1504	0	if(result != GLOBUS_SUCCESS)
1505		{
1506	0	goto error_exit;
1507		}
1508		}
1509
1510	0	break;
1511
1512		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE:
1513
1514
1515	0	if(response->done)
1516		{
1517	0	if(response->result != GLOBUS_SUCCESS)
1518		{
1519	0	result = response->result;
1520	0	goto error_exit;
1521		}
1522
1523	0	globus_mutex_lock(&response->mutex);
1524	0	response->done = 0;
1525	0	message_handle = response->client_handle->message;
1526	0	response->client_handle->message = NULL;
1527	0	globus_mutex_unlock(&response->mutex);
1528
1529	0	response->callback(
1530		response->client_handle,
1531		response->args,
1532		response->fault_result,
1533		response->ResumeSubscriptionResponse,
1534		response->fault_type,
1535		response->fault);
1536
1537	0	if(response->ResumeSubscriptionResponse)
1538		{
1539	0	wsnt_ResumeSubscriptionResponseType_destroy(response->ResumeSubscriptionResponse);
1540		}
1541
1542	0	if(response->fault)
1543		{
1544	0	xsd_any_destroy(response->fault);
1545	0	response->fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT;
1546	0	response->fault = NULL;
1547		}
1548
1549	0	globus_soap_message_handle_destroy(message_handle);
1550	0	ResumeSubscription_i_response_handle_destroy(response);
1551		}
1552
1553	0	break;
1554
1555		default:
1556
1557	0	globus_assert_string(NULL, "Unknown response state");
1558		}
1559
1560	0	return;
1561
1562		error_exit:
1563
1564	0	if(!GlobusSoapMessageStatusCheck(result))
1565		{
1566	0	result = GlobusSoapMessageErrorClientResponseFailed(
1567		result, "SubscriptionManager_ResumeSubscription");
1568		}
1569
1570	0	globus_mutex_lock(&response->mutex);
1571	0	message_handle = response->client_handle->message;
1572	0	response->client_handle->message = NULL;
1573	0	globus_mutex_unlock(&response->mutex);
1574
1575	0	response->callback(
1576		response->client_handle,
1577		response->args,
1578		result,
1579		response->ResumeSubscriptionResponse,
1580		response->fault_type,
1581		response->fault);
1582
1583	0	if(response->ResumeSubscriptionResponse)
1584		{
1585	0	wsnt_ResumeSubscriptionResponseType_destroy(response->ResumeSubscriptionResponse);
1586		}
1587
1588	0	if(response->fault)
1589		{
1590	0	xsd_any_destroy(response->fault);
1591
1592	0	response->fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT;
1593	0	response->fault = NULL;
1594		}
1595
1596	0	globus_soap_message_handle_destroy(message_handle);
1597	0	ResumeSubscription_i_response_handle_destroy(response);
1598		}
1599
1600		globus_result_t
1601		SubscriptionManager_ResumeSubscription_register_response(
1602		SubscriptionManagerService_client_handle_t client_handle,
1603		SubscriptionManager_ResumeSubscription_response_callback_func_t callback,
1604		void * user_args)
1605	0	{
1606	0	globus_result_t result = GLOBUS_SUCCESS;
1607	0	ResumeSubscription_i_response_handle_t * response;
1608
1609	0	response = globus_malloc(
1610		sizeof(ResumeSubscription_i_response_handle_t));
1611	0	globus_assert_string(response, "Memory allocation failed.");
1612	0	memset(response, 0, sizeof(ResumeSubscription_i_response_handle_t));
1613
1614	0	response->callback = callback;
1615	0	response->args = user_args;
1616	0	response->client_handle = client_handle;
1617	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT;
1618	0	globus_mutex_init(&response->mutex, NULL);
1619
1620	0	result = globus_soap_message_handle_set_attr(
1621		client_handle->message,
1622		WSADDR_ACTION_RESPONSE_KEY,
1623		globus_soap_message_attr_copy_string,
1624		globus_libc_free,
1625		"http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification/ResumeSubscriptionResponse");
1626	0	if(result != GLOBUS_SUCCESS)
1627		{
1628	0	if(!GlobusSoapMessageStatusCheck(result))
1629		{
1630	0	result = GlobusSoapMessageErrorClientRequestFailed(
1631		result, "SubscriptionManager_ResumeSubscription");
1632	0	goto exit;
1633		}
1634		}
1635
1636	0	result = globus_callback_register_oneshot(
1637		&response->callback_handle,
1638		NULL,
1639		ResumeSubscription_i_response_callback,
1640		response);
1641	0	if(result != GLOBUS_SUCCESS)
1642		{
1643	0	result = GlobusSoapMessageErrorClientResponseFailed(
1644		result, "SubscriptionManager_ResumeSubscription");
1645	0	goto exit;
1646		}
1647
1648	0	return result;
1649
1650		exit:
1651	0	globus_mutex_destroy(&response->mutex);
1652	0	globus_free(response);
1653	0	return result;
1654		}
1655
1656		globus_result_t
1657		SubscriptionManager_ResumeSubscription_epr_register(
1658		SubscriptionManagerService_client_handle_t handle,
1659		const wsa_EndpointReferenceType * epr,
1660		const wsnt_ResumeSubscriptionType * ResumeSubscription,
1661		SubscriptionManager_ResumeSubscription_response_callback_func_t callback,
1662		void * user_args)
1663	0	{
1664	0	globus_result_t result = GLOBUS_SUCCESS;
1665
1666	0	globus_assert_string(epr, "NULL EndpointReference");
1667	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
1668
1669	0	globus_soap_message_attr_set(
1670		handle->attrs,
1671		WSADDR_EPR_KEY,
1672		wsa_EndpointReferenceType_copy_wrapper,
1673		wsa_EndpointReferenceType_destroy_wrapper,
1674		(void *)epr);
1675
1676	0	result = SubscriptionManager_ResumeSubscription_register(
1677		handle,
1678		epr->Address.base_value,
1679		ResumeSubscription,
1680		callback,
1681		user_args);
1682
1683	0	return result;
1684		}
1685
1686		globus_result_t
1687		SubscriptionManager_ResumeSubscription_register(
1688		SubscriptionManagerService_client_handle_t handle,
1689		const char * endpoint,
1690		const wsnt_ResumeSubscriptionType * ResumeSubscription,
1691		SubscriptionManager_ResumeSubscription_response_callback_func_t callback,
1692		void * user_args)
1693	0	{
1694	0	ResumeSubscription_i_blocking_request_callback_t * callback_handle;
1695	0	globus_result_t result = GLOBUS_SUCCESS;
1696
1697	0	callback_handle = globus_malloc(
1698		sizeof(ResumeSubscription_i_blocking_request_callback_t));
1699	0	globus_assert_string(callback_handle, "Memory allocation failed");
1700	0	memset(callback_handle, 0,
1701		sizeof(ResumeSubscription_i_blocking_request_callback_t));
1702
1703	0	callback_handle->callback = callback;
1704	0	callback_handle->args = user_args;
1705
1706	0	result = SubscriptionManager_ResumeSubscription_register_request(
1707		handle,
1708		endpoint,
1709		ResumeSubscription,
1710		ResumeSubscription_i_blocking_request_callback,
1711		callback_handle);
1712	0	if(result != GLOBUS_SUCCESS)
1713		{
1714	0	globus_free(callback_handle);
1715		goto exit;
1716		}
1717
1718		exit:
1719
1720	0	return result;
1721		}
1722
1723		typedef struct ResumeSubscription_i_blocking_response_callback_s
1724		{
1725		globus_result_t result;
1726		SubscriptionManager_ResumeSubscription_fault_t fault_type;
1727		xsd_any * fault;
1728		wsnt_ResumeSubscriptionResponseType * ResumeSubscriptionResponse;
1729		int done;
1730		globus_cond_t cond;
1731		globus_mutex_t mutex;
1732		} ResumeSubscription_i_blocking_response_callback_t;
1733
1734		static
1735		void
1736		ResumeSubscription_i_blocking_response_callback(
1737		SubscriptionManagerService_client_handle_t handle,
1738		void * user_args,
1739		globus_result_t result,
1740		const wsnt_ResumeSubscriptionResponseType * ResumeSubscriptionResponse,
1741		SubscriptionManager_ResumeSubscription_fault_t fault_type,
1742		const xsd_any * fault)
1743	0	{
1744	0	ResumeSubscription_i_blocking_response_callback_t * callback_handle;
1745
1746	0	callback_handle = (ResumeSubscription_i_blocking_response_callback_t *) user_args;
1747
1748	0	callback_handle->result = result;
1749	0	if(result == GLOBUS_SUCCESS)
1750		{
1751	0	wsnt_ResumeSubscriptionResponseType_copy(
1752		&callback_handle->ResumeSubscriptionResponse, ResumeSubscriptionResponse);
1753		}
1754		else
1755		{
1756	0	callback_handle->fault_type = fault_type;
1757	0	if(fault_type != GLOBUS_SUCCESS)
1758		{
1759	0	xsd_any_copy(&callback_handle->fault, fault);
1760		}
1761		}
1762
1763	0	globus_mutex_lock(&callback_handle->mutex);
1764	0	globus_cond_signal(&callback_handle->cond);
1765	0	callback_handle->done = 1;
1766	0	globus_mutex_unlock(&callback_handle->mutex);
1767		}
1768
1769
1770		globus_result_t
1771		SubscriptionManager_ResumeSubscription_epr(
1772		SubscriptionManagerService_client_handle_t handle,
1773		const wsa_EndpointReferenceType * epr,
1774		const wsnt_ResumeSubscriptionType * ResumeSubscription,
1775		wsnt_ResumeSubscriptionResponseType * * ResumeSubscriptionResponse,
1776		SubscriptionManager_ResumeSubscription_fault_t * fault_type,
1777		xsd_any * * fault)
1778	0	{
1779	0	globus_result_t result = GLOBUS_SUCCESS;
1780
1781	0	globus_assert_string(epr, "NULL EndpointReference");
1782	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
1783
1784	0	*fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT;
1785
1786	0	globus_soap_message_attr_set(
1787		handle->attrs,
1788		WSADDR_EPR_KEY,
1789		wsa_EndpointReferenceType_copy_wrapper,
1790		wsa_EndpointReferenceType_destroy_wrapper,
1791		(void *)epr);
1792
1793	0	result = SubscriptionManager_ResumeSubscription(
1794		handle,
1795		epr->Address.base_value,
1796		ResumeSubscription,
1797		ResumeSubscriptionResponse,
1798		fault_type,
1799		fault);
1800
1801	0	return result;
1802		}
1803
1804		globus_result_t
1805		SubscriptionManager_ResumeSubscription(
1806		SubscriptionManagerService_client_handle_t handle,
1807		const char * endpoint,
1808		const wsnt_ResumeSubscriptionType * ResumeSubscription,
1809		wsnt_ResumeSubscriptionResponseType * * ResumeSubscriptionResponse,
1810		SubscriptionManager_ResumeSubscription_fault_t * fault_type,
1811		xsd_any * * fault)
1812	0	{
1813	0	globus_result_t result = GLOBUS_SUCCESS;
1814
1815	0	ResumeSubscription_i_blocking_response_callback_t * callback_handle;
1816	0	*fault_type = SUBSCRIPTIONMANAGER_RESUMESUBSCRIPTION_NOFAULT;
1817
1818	0	callback_handle = globus_malloc(
1819		sizeof(ResumeSubscription_i_blocking_response_callback_t));
1820	0	globus_assert_string(callback_handle, "Memory allocation failed");
1821	0	memset(callback_handle, 0,
1822		sizeof(ResumeSubscription_i_blocking_response_callback_t));
1823
1824	0	globus_mutex_init(&callback_handle->mutex, NULL);
1825	0	globus_cond_init(&callback_handle->cond, NULL);
1826
1827	0	result = SubscriptionManager_ResumeSubscription_register(
1828		handle,
1829		endpoint,
1830		ResumeSubscription,
1831		ResumeSubscription_i_blocking_response_callback,
1832		callback_handle);
1833	0	if(result != GLOBUS_SUCCESS)
1834		{
1835	0	goto exit;
1836		}
1837
1838
1839	0	globus_mutex_lock(&callback_handle->mutex);
1840	0	while(!callback_handle->done)
1841		{
1842	0	globus_cond_wait(&callback_handle->cond, &callback_handle->mutex);
1843		}
1844	0	globus_mutex_unlock(&callback_handle->mutex);
1845
1846	0	result = callback_handle->result;
1847	0	if(result != GLOBUS_SUCCESS)
1848		{
1849
1850	0	*fault_type = callback_handle->fault_type;
1851	0	*fault = callback_handle->fault;
1852
1853	0	goto exit;
1854		}
1855
1856	0	*ResumeSubscriptionResponse = callback_handle->ResumeSubscriptionResponse;
1857
1858		exit:
1859
1860	0	globus_mutex_destroy(&callback_handle->mutex);
1861	0	globus_cond_destroy(&callback_handle->cond);
1862
1863	0	free(callback_handle);
1864
1865	0	return result;
1866		}
1867
1868
1869
1870		typedef struct PauseSubscription_i_request_handle_s
1871		{
1872		char * endpoint;
1873		int done;
1874		globus_mutex_t mutex;
1875		SubscriptionManagerService_request_state_t state;
1876		SubscriptionManager_PauseSubscription_request_callback_func_t callback;
1877		void * args;
1878		SubscriptionManagerService_client_handle_t client_handle;
1879		wsnt_PauseSubscriptionType * PauseSubscription;
1880		globus_callback_handle_t callback_handle;
1881		globus_result_t result;
1882		} PauseSubscription_i_request_handle_t;
1883
1884		static void
1885		PauseSubscription_i_request_callback(
1886		void * args);
1887
1888		static void
1889		PauseSubscription_i_request_done_callback(
1890		globus_result_t result,
1891		void * args)
1892	0	{
1893	0	PauseSubscription_i_request_handle_t * request;
1894
1895	0	request = (PauseSubscription_i_request_handle_t *) args;
1896	0	globus_assert_string(request, "request handle in callback is NULL");
1897
1898	0	globus_mutex_lock(&request->mutex);
1899	0	request->result = result;
1900	0	request->done = 1;
1901	0	globus_mutex_unlock(&request->mutex);
1902
1903	0	PauseSubscription_i_request_callback(request);
1904		}
1905
1906		static void
1907		PauseSubscription_i_request_handle_destroy(
1908		void * args)
1909	0	{
1910	0	PauseSubscription_i_request_handle_t * request;
1911
1912	0	request = (PauseSubscription_i_request_handle_t *) args;
1913	0	globus_assert_string(request, "request handle in callback is NULL");
1914
1915	0	globus_mutex_destroy(&request->mutex);
1916
1917	0	if(request->PauseSubscription)
1918		{
1919	0	wsnt_PauseSubscriptionType_destroy(request->PauseSubscription);
1920		}
1921	0	if(request->endpoint)
1922		{
1923	0	globus_free(request->endpoint);
1924		}
1925
1926	0	globus_free(request);
1927		}
1928
1929		static void
1930		PauseSubscription_i_request_callback(
1931		void * args)
1932	0	{
1933	0	globus_soap_message_handle_t message_handle = NULL;
1934	0	globus_result_t result = GLOBUS_SUCCESS;
1935	0	globus_handler_chain_t chain = NULL;
1936	0	PauseSubscription_i_request_handle_t * request;
1937	0	xsd_QName subelement;
1938
1939	0	request = (PauseSubscription_i_request_handle_t *) args;
1940	0	globus_assert_string(request, "request handle is NULL");
1941
1942	0	switch(request->state)
1943		{
1944
1945		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT:
1946
1947	0	globus_mutex_lock(&request->mutex);
1948	0	request->done = 0;
1949	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS;
1950	0	globus_mutex_unlock(&request->mutex);
1951
1952	0	result = globus_soap_message_get_handler_chain(
1953		request->client_handle->message, &chain);
1954	0	if(result != GLOBUS_SUCCESS)
1955		{
1956	0	goto error_exit;
1957		}
1958
1959	0	if(chain)
1960		{
1961	0	globus_handler_chain_register_invoke(
1962		chain,
1963		GLOBUS_HANDLER_TYPE_REQUEST_INIT,
1964		request->client_handle->message,
1965		PauseSubscription_i_request_done_callback,
1966		request);
1967		}
1968
1969	0	break;
1970
1971		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS:
1972
1973	0	globus_mutex_lock(&request->mutex);
1974	0	request->done = 0;
1975	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING;
1976	0	globus_mutex_unlock(&request->mutex);
1977
1978	0	result = globus_soap_message_register_open(
1979		request->client_handle->message,
1980		request->endpoint,
1981		PauseSubscription_i_request_done_callback,
1982		request);
1983	0	if(result != GLOBUS_SUCCESS)
1984		{
1985	0	goto error_exit;
1986		}
1987
1988	0	break;
1989
1990		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING:
1991
1992	0	if(request->done)
1993		{
1994	0	if(request->result != GLOBUS_SUCCESS)
1995		{
1996	0	result = request->result;
1997	0	goto error_exit;
1998		}
1999
2000	0	globus_mutex_lock(&request->mutex);
2001	0	request->done = 0;
2002	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS;
2003	0	globus_mutex_unlock(&request->mutex);
2004
2005	0	result = globus_soap_message_serialize_envelope(
2006		request->client_handle->message);
2007	0	if(result != GLOBUS_SUCCESS)
2008		{
2009	0	goto error_exit;
2010		}
2011
2012	0	result = globus_soap_message_serialize_header(
2013		request->client_handle->message);
2014	0	if(result != GLOBUS_SUCCESS)
2015		{
2016	0	goto error_exit;
2017		}
2018
2019	0	result = globus_soap_message_serialize_header_begin_close(
2020		request->client_handle->message);
2021	0	if(result != GLOBUS_SUCCESS)
2022		{
2023	0	goto error_exit;
2024		}
2025
2026	0	result = globus_soap_message_set_marker(
2027		request->client_handle->message,
2028		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
2029	0	if(result != GLOBUS_SUCCESS)
2030		{
2031	0	goto error_exit;
2032		}
2033
2034	0	result = globus_soap_message_serialize_header_end(
2035		request->client_handle->message);
2036	0	if(result != GLOBUS_SUCCESS)
2037		{
2038	0	goto error_exit;
2039		}
2040
2041	0	result = globus_soap_message_serialize_body(
2042		request->client_handle->message);
2043	0	if(result != GLOBUS_SUCCESS)
2044		{
2045	0	goto error_exit;
2046		}
2047
2048	0	result = globus_soap_message_serialize_body_begin_close(
2049		request->client_handle->message);
2050	0	if(result != GLOBUS_SUCCESS)
2051		{
2052	0	goto error_exit;
2053		}
2054
2055	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
2056	0	subelement.local = "PauseSubscription";
2057
2058	0	result = wsnt_PauseSubscriptionType_serialize(
2059		&subelement,
2060		request->PauseSubscription,
2061		request->client_handle->message,
2062		0);
2063	0	if(result != GLOBUS_SUCCESS)
2064		{
2065	0	goto error_exit;
2066		}
2067
2068	0	result = globus_soap_message_serialize_body_end(
2069		request->client_handle->message);
2070	0	if(result != GLOBUS_SUCCESS)
2071		{
2072	0	goto error_exit;
2073		}
2074
2075	0	result = globus_soap_message_serialize_envelope_end(
2076		request->client_handle->message);
2077	0	if(result != GLOBUS_SUCCESS)
2078		{
2079	0	goto error_exit;
2080		}
2081
2082	0	result = globus_soap_message_set_write_position_to_marker(
2083		request->client_handle->message,
2084		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
2085	0	if(result != GLOBUS_SUCCESS)
2086		{
2087	0	goto error_exit;
2088		}
2089
2090	0	result = globus_soap_message_get_handler_chain(
2091		request->client_handle->message, &chain);
2092	0	if(result != GLOBUS_SUCCESS)
2093		{
2094	0	goto error_exit;
2095		}
2096
2097	0	if(chain)
2098		{
2099	0	globus_handler_chain_register_invoke(
2100		chain,
2101		GLOBUS_HANDLER_TYPE_REQUEST,
2102		request->client_handle->message,
2103		PauseSubscription_i_request_done_callback,
2104		request);
2105		}
2106		}
2107
2108	0	break;
2109
2110		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS:
2111
2112	0	if(request->done)
2113		{
2114	0	if(request->result != GLOBUS_SUCCESS)
2115		{
2116	0	result = request->result;
2117	0	goto error_exit;
2118		}
2119
2120	0	globus_mutex_lock(&request->mutex);
2121	0	request->done = 0;
2122	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING;
2123	0	globus_mutex_unlock(&request->mutex);
2124
2125	0	result = globus_soap_message_register_write_request(
2126		request->client_handle->message,
2127		PauseSubscription_i_request_done_callback,
2128		request,
2129
2130		GLOBUS_TRUE);
2131
2132	0	if(result != GLOBUS_SUCCESS)
2133		{
2134	0	goto error_exit;
2135		}
2136		}
2137
2138	0	break;
2139
2140		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING:
2141
2142	0	if(request->done)
2143		{
2144	0	if(request->result != GLOBUS_SUCCESS)
2145		{
2146	0	result = request->result;
2147	0	goto error_exit;
2148		}
2149
2150	0	globus_mutex_lock(&request->mutex);
2151	0	request->done = 0;
2152	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS;
2153	0	globus_mutex_unlock(&request->mutex);
2154
2155	0	result = globus_soap_message_get_handler_chain(
2156		request->client_handle->message, &chain);
2157	0	if(result != GLOBUS_SUCCESS)
2158		{
2159	0	goto error_exit;
2160		}
2161
2162	0	if(chain)
2163		{
2164	0	globus_handler_chain_register_invoke(
2165		chain,
2166		GLOBUS_HANDLER_TYPE_REQUEST_DESTROY,
2167		request->client_handle->message,
2168		PauseSubscription_i_request_done_callback,
2169		request);
2170		}
2171		}
2172
2173	0	break;
2174
2175		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS:
2176
2177	0	if(request->done)
2178		{
2179	0	if(request->result != GLOBUS_SUCCESS)
2180		{
2181	0	result = request->result;
2182	0	goto error_exit;
2183		}
2184
2185	0	globus_mutex_lock(&request->mutex);
2186	0	request->done = 0;
2187	0	globus_mutex_unlock(&request->mutex);
2188
2189	0	request->callback(
2190		request->client_handle,
2191		request->args, GLOBUS_SUCCESS);
2192
2193	0	PauseSubscription_i_request_handle_destroy(request);
2194		}
2195
2196	0	break;
2197
2198		default:
2199
2200	0	globus_assert_string(NULL, "Unkown request state");
2201	0	break;
2202		}
2203
2204	0	return;
2205
2206		error_exit:
2207
2208	0	result = GlobusSoapMessageErrorClientRequestFailed(
2209		result, "SubscriptionManager_PauseSubscription");
2210
2211	0	globus_mutex_lock(&request->mutex);
2212	0	message_handle = request->client_handle->message;
2213	0	request->client_handle->message = NULL;
2214	0	globus_mutex_unlock(&request->mutex);
2215
2216	0	request->callback(request->client_handle, request->args, result);
2217
2218	0	globus_soap_message_handle_destroy(message_handle);
2219	0	PauseSubscription_i_request_handle_destroy(request);
2220		}
2221
2222		globus_result_t
2223		SubscriptionManager_PauseSubscription_epr_register_request(
2224		SubscriptionManagerService_client_handle_t client_handle,
2225		const wsa_EndpointReferenceType * epr,
2226		const wsnt_PauseSubscriptionType * PauseSubscription,
2227		SubscriptionManager_PauseSubscription_request_callback_func_t callback,
2228		void * user_args)
2229	0	{
2230	0	globus_result_t result = GLOBUS_SUCCESS;
2231
2232	0	globus_assert_string(epr, "NULL EndpointReference");
2233	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
2234
2235	0	globus_soap_message_attr_set(
2236		client_handle->attrs,
2237		WSADDR_EPR_KEY,
2238		wsa_EndpointReferenceType_copy_wrapper,
2239		wsa_EndpointReferenceType_destroy_wrapper,
2240		(void *)epr);
2241
2242	0	result = SubscriptionManager_PauseSubscription_register_request(
2243		client_handle,
2244		epr->Address.base_value,
2245		PauseSubscription,
2246		callback,
2247		user_args);
2248
2249	0	return result;
2250		}
2251
2252		globus_result_t
2253		SubscriptionManager_PauseSubscription_register_request(
2254		SubscriptionManagerService_client_handle_t client_handle,
2255		const char * endpoint,
2256		const wsnt_PauseSubscriptionType * PauseSubscription,
2257		SubscriptionManager_PauseSubscription_request_callback_func_t callback,
2258		void * user_args)
2259	0	{
2260	0	globus_handler_chain_t chain = NULL;
2261	0	globus_result_t result = GLOBUS_SUCCESS;
2262	0	PauseSubscription_i_request_handle_t * request = NULL;
2263
2264	0	if(client_handle->message != NULL)
2265		{
2266	0	result = GlobusSoapMessageErrorClientAlreadyInvoked();
2267	0	goto exit;
2268		}
2269
2270	0	result = globus_soap_message_handle_init(&client_handle->message, NULL);
2271	0	if(result != GLOBUS_SUCCESS)
2272		{
2273	0	result = GlobusSoapMessageErrorFailedClientInit(
2274		result, "SubscriptionManager_PauseSubscription");
2275	0	goto error_exit;
2276		}
2277
2278	0	globus_soap_message_handle_set_registry(
2279		client_handle->message, SubscriptionManagerService_l_registry);
2280
2281	0	chain = client_handle->handler_chain;
2282	0	if(!chain)
2283		{
2284	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
2285	0	if(result != GLOBUS_SUCCESS)
2286		{
2287	0	result = GlobusSoapMessageErrorFailedClientInit(
2288		result, "SubscriptionManager_PauseSubscription");
2289	0	goto exit;
2290		}
2291
2292	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
2293	0	globus_list_insert(
2294		&SubscriptionManagerService_l_extensions,
2295		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
2296	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
2297
2298	0	globus_handler_chain_init(&chain);
2299	0	result = globus_handler_chain_push(
2300		chain,
2301		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
2302		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
2303	0	if(result != GLOBUS_SUCCESS)
2304		{
2305	0	result = GlobusSoapMessageErrorFailedClientInit(
2306		result, "SubscriptionManager_PauseSubscription");
2307	0	goto error_exit;
2308		}
2309
2310	0	result = globus_handler_chain_push(
2311		chain,
2312		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
2313		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
2314	0	if(result != GLOBUS_SUCCESS)
2315		{
2316	0	result = GlobusSoapMessageErrorFailedClientInit(
2317		result, "SubscriptionManager_PauseSubscription");
2318	0	goto error_exit;
2319		}
2320		}
2321
2322	0	globus_soap_message_set_handler_chain(
2323		client_handle->message, chain);
2324
2325	0	request = globus_malloc(sizeof(PauseSubscription_i_request_handle_t));
2326	0	globus_assert_string(request, "Memory allocation failed.");
2327	0	memset(request, 0, sizeof(PauseSubscription_i_request_handle_t));
2328
2329	0	if(!endpoint)
2330		{
2331	0	endpoint = (char *)globus_soap_message_attr_get(
2332		client_handle->attrs, GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY);
2333	0	if(!endpoint)
2334		{
2335	0	wsa_EndpointReferenceType * epr;
2336	0	epr = (wsa_EndpointReferenceType *)
2337		globus_soap_message_attr_get(
2338		client_handle->attrs, WSADDR_EPR_KEY);
2339	0	if(epr && epr->Address.base_value)
2340		{
2341	0	endpoint = epr->Address.base_value;
2342		}
2343		}
2344		}
2345
2346	0	globus_assert_string(endpoint, "NULL endpoint");
2347
2348	0	request->endpoint = globus_libc_strdup(endpoint);
2349	0	request->callback = callback;
2350	0	request->args = user_args;
2351	0	request->client_handle = client_handle;
2352	0	wsnt_PauseSubscriptionType_copy(&request->PauseSubscription, PauseSubscription);
2353	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT;
2354	0	globus_mutex_init(&request->mutex, NULL);
2355
2356	0	result = globus_soap_message_attr_set(
2357		client_handle->attrs,
2358		WSADDR_DESTINATION_KEY,
2359		globus_soap_message_attr_copy_string,
2360		globus_libc_free,
2361		(void *)endpoint);
2362	0	if(result != GLOBUS_SUCCESS)
2363		{
2364	0	result = GlobusSoapMessageErrorClientRequestFailed(
2365		result, "SubscriptionManager_PauseSubscription");
2366	0	goto error_exit;
2367		}
2368
2369	0	result = globus_soap_message_attr_set(
2370		client_handle->attrs,
2371		WSADDR_ACTION_REQUEST_KEY,
2372		NULL,
2373		NULL,
2374		"http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification/PauseSubscription");
2375	0	if(result != GLOBUS_SUCCESS)
2376		{
2377	0	result = GlobusSoapMessageErrorClientRequestFailed(
2378		result, "SubscriptionManager_PauseSubscription");
2379	0	goto error_exit;
2380		}
2381
2382	0	result = globus_soap_message_attr_set(
2383		client_handle->attrs,
2384		GLOBUS_SOAP_MESSAGE_SOAP_ACTION_KEY,
2385		NULL,
2386		NULL,
2387		"http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification/PauseSubscription");
2388	0	if(result != GLOBUS_SUCCESS)
2389		{
2390	0	result = GlobusSoapMessageErrorClientRequestFailed(
2391		result, "SubscriptionManager_PauseSubscription");
2392	0	goto error_exit;
2393		}
2394
2395	0	result = globus_soap_message_handle_set_attrs(
2396		client_handle->message, client_handle->attrs);
2397	0	if(result != GLOBUS_SUCCESS)
2398		{
2399	0	result = GlobusSoapMessageErrorClientRequestFailed(
2400		result, "SubscriptionManager_PauseSubscription");
2401		}
2402
2403	0	result = globus_callback_register_oneshot(
2404		&request->callback_handle,
2405		NULL,
2406		PauseSubscription_i_request_callback,
2407		request);
2408	0	if(result != GLOBUS_SUCCESS)
2409		{
2410	0	result = GlobusSoapMessageErrorClientRequestFailed(
2411		result, "SubscriptionManager_PauseSubscription");
2412		goto error_exit;
2413		}
2414
2415	0	goto exit;
2416
2417		error_exit:
2418
2419	0	if(request)
2420		{
2421	0	globus_mutex_destroy(&request->mutex);
2422
2423	0	if(request->PauseSubscription)
2424		{
2425	0	wsnt_PauseSubscriptionType_destroy(request->PauseSubscription);
2426		}
2427	0	if(request->endpoint)
2428		{
2429	0	globus_free(request->endpoint);
2430		}
2431
2432	0	globus_free(request);
2433		}
2434
2435	0	if(client_handle->message)
2436		{
2437	0	globus_soap_message_handle_destroy(client_handle->message);
2438	0	client_handle->message = NULL;
2439		}
2440
2441		exit:
2442
2443	0	return result;
2444		}
2445
2446		typedef struct PauseSubscription_i_blocking_request_callback_s
2447		{
2448
2449		SubscriptionManager_PauseSubscription_response_callback_func_t callback;
2450		void * args;
2451
2452		} PauseSubscription_i_blocking_request_callback_t;
2453
2454		static
2455		void
2456		PauseSubscription_i_blocking_request_callback(
2457		SubscriptionManagerService_client_handle_t handle,
2458		void * user_args,
2459		globus_result_t error)
2460	0	{
2461	0	globus_soap_message_handle_t message_handle = NULL;
2462	0	globus_result_t result = GLOBUS_SUCCESS;
2463	0	PauseSubscription_i_blocking_request_callback_t * callback_handle;
2464
2465	0	callback_handle = (PauseSubscription_i_blocking_request_callback_t *) user_args;
2466	0	globus_assert_string(callback_handle, "callback_handle is NULL");
2467
2468
2469	0	if(error != GLOBUS_SUCCESS \|\|
2470		globus_soap_message_is_cancelled(handle->message))
2471		{
2472	0	message_handle = handle->message;
2473	0	handle->message = NULL;
2474
2475	0	callback_handle->callback(
2476		handle,
2477		callback_handle->args,
2478		error,
2479		NULL,
2480		SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT,
2481		NULL);
2482
2483	0	globus_soap_message_handle_destroy(message_handle);
2484		}
2485		else
2486		{
2487	0	result = SubscriptionManager_PauseSubscription_register_response(
2488		handle,
2489		callback_handle->callback,
2490		callback_handle->args);
2491	0	if(result != GLOBUS_SUCCESS)
2492		{
2493	0	callback_handle->callback(
2494		handle,
2495		callback_handle->args,
2496		result,
2497		NULL,
2498		SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT,
2499		NULL);
2500		}
2501		}
2502
2503	0	free(callback_handle);
2504		}
2505
2506
2507
2508		typedef struct PauseSubscription_i_response_handle_s
2509		{
2510		int done;
2511		globus_mutex_t mutex;
2512		SubscriptionManagerService_response_state_t state;
2513		SubscriptionManager_PauseSubscription_response_callback_func_t callback;
2514		void * args;
2515		SubscriptionManagerService_client_handle_t client_handle;
2516		wsnt_PauseSubscriptionResponseType * PauseSubscriptionResponse;
2517		globus_callback_handle_t callback_handle;
2518		globus_result_t result;
2519		globus_result_t fault_result;
2520		int fault_type;
2521		xsd_any * fault;
2522		} PauseSubscription_i_response_handle_t;
2523
2524		static void
2525		PauseSubscription_i_response_callback(
2526		void * args);
2527
2528		static void
2529		PauseSubscription_i_response_done_callback(
2530		globus_result_t result,
2531		void * args)
2532	0	{
2533	0	PauseSubscription_i_response_handle_t * response;
2534
2535	0	response = (PauseSubscription_i_response_handle_t *) args;
2536	0	globus_assert_string(response, "response handle in callback is NULL");
2537
2538	0	globus_mutex_lock(&response->mutex);
2539	0	response->result = result;
2540	0	response->done = 1;
2541	0	globus_mutex_unlock(&response->mutex);
2542
2543	0	PauseSubscription_i_response_callback(response);
2544		}
2545
2546		static void
2547		PauseSubscription_i_response_handle_destroy(
2548		void * args)
2549	0	{
2550	0	PauseSubscription_i_response_handle_t * response;
2551
2552	0	response = (PauseSubscription_i_response_handle_t *) args;
2553	0	globus_assert_string(response, "response handle in callback is NULL");
2554
2555	0	globus_mutex_destroy(&response->mutex);
2556
2557	0	free(response);
2558		}
2559
2560		static void
2561		PauseSubscription_i_deserialize_fault(
2562		globus_soap_message_handle_t handle,
2563		const xsd_QName * fault_qname,
2564		int * fault_type,
2565		void * args)
2566	0	{
2567	0	*fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT;
2568
2569	0	if(fault_qname)
2570		{
2571	0	if(fault_qname == (&wsnt_ResourceUnknownFaultType_qname) \|\|
2572		fault_qname == (&wsnt_ResourceUnknownFault_qname))
2573		{
2574	0	*fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_RESOURCEUNKNOWNFAULT;
2575		}
2576	0	else if(fault_qname == (&wsnt_PauseFailedFaultType_qname) \|\|
2577		fault_qname == (&wsnt_PauseFailedFault_qname))
2578		{
2579	0	*fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_PAUSEFAILEDFAULT;
2580		}
2581		else
2582		{
2583	0	*fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_UNKNOWN_FAULT;
2584		}
2585		}
2586		}
2587
2588		static void
2589		PauseSubscription_i_response_callback(
2590		void * args)
2591	0	{
2592	0	xsd_QName subelement;
2593	0	globus_soap_message_handle_t message_handle = NULL;
2594	0	globus_soap_message_fault_t soap_fault;
2595	0	globus_result_t result = GLOBUS_SUCCESS;
2596	0	globus_handler_chain_t chain = NULL;
2597	0	xsd_QName * header_element = NULL;
2598	0	int must;
2599	0	PauseSubscription_i_response_handle_t * response;
2600	0	response = (PauseSubscription_i_response_handle_t *) args;
2601	0	globus_assert_string(response, "response handle in callback is NULL");
2602
2603	0	switch(response->state)
2604		{
2605
2606		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT:
2607
2608	0	globus_mutex_lock(&response->mutex);
2609	0	response->done = 0;
2610	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING;
2611	0	globus_mutex_unlock(&response->mutex);
2612
2613	0	result = globus_soap_message_register_read_response(
2614		response->client_handle->message,
2615		PauseSubscription_i_response_done_callback,
2616		response);
2617	0	if(result != GLOBUS_SUCCESS)
2618		{
2619	0	goto error_exit;
2620		}
2621
2622	0	break;
2623
2624		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING:
2625
2626	0	if(response->done)
2627		{
2628	0	if(response->result != GLOBUS_SUCCESS)
2629		{
2630	0	if(GlobusSoapMessageErrorCheckFailedResponse(response->result) \|\|
2631		GlobusSoapMessageErrorCheckBadRequest(response->result))
2632		{
2633	0	response->result = GLOBUS_SUCCESS;
2634		}
2635		else
2636		{
2637	0	result = response->result;
2638	0	goto error_exit;
2639		}
2640		}
2641
2642	0	globus_mutex_lock(&response->mutex);
2643	0	response->done = 0;
2644	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
2645	0	globus_mutex_unlock(&response->mutex);
2646
2647	0	result = globus_soap_message_deserialize_envelope(
2648		response->client_handle->message);
2649	0	if(result != GLOBUS_SUCCESS)
2650		{
2651	0	goto error_exit;
2652		}
2653
2654	0	result = globus_soap_message_deserialize_element_begin_close(
2655		response->client_handle->message);
2656	0	if(result != GLOBUS_SUCCESS)
2657		{
2658	0	goto error_exit;
2659		}
2660
2661	0	result = globus_soap_message_deserialize_header(
2662		response->client_handle->message);
2663	0	if(result != GLOBUS_SUCCESS)
2664		{
2665	0	if(GlobusSoapMessageStatusElementNotFoundCheck(result))
2666		{
2667	0	globus_soap_message_deserialize_push_element(
2668		response->client_handle->message);
2669	0	result = GLOBUS_SUCCESS;
2670	0	globus_mutex_lock(&response->mutex);
2671	0	response->state =
2672		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED;
2673	0	globus_mutex_unlock(&response->mutex);
2674	0	PauseSubscription_i_response_done_callback(
2675		result, response);
2676	0	break;
2677		}
2678
2679	0	goto error_exit;
2680		}
2681
2682	0	globus_mutex_lock(&response->mutex);
2683	0	response->done = 1;
2684	0	globus_mutex_unlock(&response->mutex);
2685		}
2686
2687		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS:
2688
2689	0	if(response->done)
2690		{
2691	0	if(response->result != GLOBUS_SUCCESS)
2692		{
2693	0	if(GlobusSoapMessageErrorCheckFailedResponse(
2694		response->result) \|\|
2695		GlobusSoapMessageErrorCheckBadRequest(response->result))
2696		{
2697	0	response->result = GLOBUS_SUCCESS;
2698		}
2699		else
2700		{
2701	0	result = response->result;
2702	0	goto error_exit;
2703		}
2704		}
2705
2706	0	globus_mutex_lock(&response->mutex);
2707	0	response->done = 0;
2708	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
2709	0	globus_mutex_unlock(&response->mutex);
2710
2711	0	xsd_QName_init(&header_element);
2712
2713	0	result = globus_soap_message_deserialize_element_unknown(
2714		response->client_handle->message,
2715		header_element);
2716	0	if(result != GLOBUS_SUCCESS)
2717		{
2718	0	if(!GlobusSoapMessageStatusFailedElementCheck(result))
2719		{
2720	0	xsd_QName_destroy(header_element);
2721	0	goto error_exit;
2722		}
2723		else
2724		{
2725	0	globus_mutex_lock(&response->mutex);
2726	0	response->done = 1;
2727	0	response->state =
2728		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE;
2729	0	globus_mutex_unlock(&response->mutex);
2730
2731	0	globus_callback_register_oneshot(
2732		NULL,
2733		&globus_i_reltime_zero,
2734		PauseSubscription_i_response_callback,
2735		(void *)response);
2736	0	xsd_QName_destroy(header_element);
2737	0	break;
2738		}
2739		}
2740
2741	0	result = globus_soap_message_deserialize_int_attribute(
2742		response->client_handle->message,
2743		&soap_mustUnderstand_qname,
2744		&must);
2745	0	if(result == GLOBUS_SUCCESS && (must == 1))
2746		{
2747	0	globus_soap_message_add_required_header_element(
2748		response->client_handle->message,
2749		header_element);
2750		}
2751	0	else if(result != GLOBUS_SUCCESS &&
2752		!GlobusSoapMessageStatusAttributeNotFoundCheck(result))
2753		{
2754	0	xsd_QName_destroy(header_element);
2755	0	goto error_exit;
2756		}
2757
2758	0	globus_soap_message_deserialize_push_element(
2759		response->client_handle->message);
2760
2761	0	result = globus_soap_message_get_handler_chain(
2762		response->client_handle->message, &chain);
2763	0	if(result != GLOBUS_SUCCESS)
2764		{
2765	0	goto error_exit;
2766		}
2767
2768	0	if(chain)
2769		{
2770	0	result = globus_handler_chain_register_trigger(
2771		chain,
2772		response->client_handle->message,
2773		header_element,
2774		PauseSubscription_i_response_done_callback,
2775		response);
2776	0	if(result == GLOBUS_SUCCESS)
2777		{
2778	0	xsd_QName_destroy(header_element);
2779	0	break;
2780		}
2781	0	else if(!GlobusHandlerStatusNotTriggeredCheck(result))
2782		{
2783	0	xsd_QName_destroy(header_element);
2784	0	goto error_exit;
2785		}
2786		}
2787
2788	0	xsd_QName_destroy(header_element);
2789	0	result = globus_soap_message_deserialize_skip(
2790		response->client_handle->message);
2791	0	if(result != GLOBUS_SUCCESS)
2792		{
2793	0	goto error_exit;
2794		}
2795
2796	0	globus_mutex_lock(&response->mutex);
2797	0	response->done = 1;
2798	0	globus_mutex_unlock(&response->mutex);
2799	0	globus_callback_register_oneshot(
2800		NULL,
2801		&globus_i_reltime_zero,
2802		PauseSubscription_i_response_callback,
2803		(void *)response);
2804		}
2805
2806	0	break;
2807
2808		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE:
2809
2810	0	if(response->done)
2811		{
2812	0	if(response->result != GLOBUS_SUCCESS)
2813		{
2814	0	result = response->result;
2815	0	goto error_exit;
2816		}
2817
2818	0	globus_mutex_lock(&response->mutex);
2819	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
2820	0	globus_mutex_unlock(&response->mutex);
2821
2822	0	result = globus_soap_message_deserialize_header_end(
2823		response->client_handle->message);
2824	0	if(result != GLOBUS_SUCCESS)
2825		{
2826	0	goto error_exit;
2827		}
2828
2829	0	result = globus_soap_message_deserialize_body(
2830		response->client_handle->message);
2831	0	if(result != GLOBUS_SUCCESS)
2832		{
2833	0	goto error_exit;
2834		}
2835		}
2836
2837		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED:
2838
2839	0	if(response->done)
2840		{
2841	0	if(response->result != GLOBUS_SUCCESS)
2842		{
2843	0	result = response->result;
2844	0	goto error_exit;
2845		}
2846
2847	0	globus_mutex_lock(&response->mutex);
2848	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
2849	0	globus_mutex_unlock(&response->mutex);
2850
2851	0	response->fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT;
2852	0	response->fault_result = GLOBUS_SUCCESS;
2853
2854	0	result = globus_soap_message_deserialize_fault(
2855		response->client_handle->message,
2856		&soap_fault,
2857		PauseSubscription_i_deserialize_fault,
2858		&response->fault,
2859		&response->fault_type);
2860	0	if(result != GLOBUS_SUCCESS)
2861		{
2862	0	if(response->result != GLOBUS_SUCCESS)
2863		{
2864	0	result = response->result;
2865		}
2866	0	goto error_exit;
2867		}
2868
2869	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT)
2870		{
2871	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
2872	0	subelement.local = "PauseSubscriptionResponse";
2873
2874	0	result = wsnt_PauseSubscriptionResponseType_deserialize_pointer(
2875		&subelement,
2876		&response->PauseSubscriptionResponse,
2877		response->client_handle->message,
2878		0);
2879	0	if(result != GLOBUS_SUCCESS)
2880		{
2881	0	goto error_exit;
2882		}
2883		}
2884		else
2885		{
2886	0	if(soap_fault)
2887		{
2888	0	response->fault_result = GlobusSoapMessageErrorFault(
2889		soap_fault);
2890		}
2891
2892	0	result = globus_soap_message_deserialize_fault_end(
2893		response->client_handle->message,
2894		response->fault
2895		? response->fault->element
2896		: &soap_fault_qname);
2897	0	if(result != GLOBUS_SUCCESS)
2898		{
2899	0	goto error_exit;
2900		}
2901		}
2902
2903	0	result = globus_soap_message_deserialize_body_end(
2904		response->client_handle->message);
2905	0	if(result != GLOBUS_SUCCESS)
2906		{
2907	0	goto error_exit;
2908		}
2909
2910	0	result = globus_soap_message_deserialize_envelope_end(
2911		response->client_handle->message);
2912	0	if(result != GLOBUS_SUCCESS)
2913		{
2914	0	goto error_exit;
2915		}
2916
2917
2918	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT)
2919		{
2920	0	result = globus_soap_message_get_handler_chain(
2921		response->client_handle->message, &chain);
2922	0	if(result != GLOBUS_SUCCESS)
2923		{
2924	0	goto error_exit;
2925		}
2926
2927	0	if(chain)
2928		{
2929	0	globus_handler_chain_register_invoke(
2930		chain,
2931		GLOBUS_HANDLER_TYPE_RESPONSE,
2932		response->client_handle->message,
2933		PauseSubscription_i_response_done_callback,
2934		response);
2935		}
2936		}
2937		else
2938		{
2939	0	globus_mutex_lock(&response->mutex);
2940	0	response->done = 1;
2941	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE;
2942	0	globus_mutex_unlock(&response->mutex);
2943	0	globus_callback_register_oneshot(
2944		NULL,
2945		&globus_i_reltime_zero,
2946		PauseSubscription_i_response_callback,
2947		(void *)response);
2948		}
2949		}
2950
2951	0	break;
2952
2953		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS:
2954
2955	0	if(response->done)
2956		{
2957	0	if(response->result != GLOBUS_SUCCESS)
2958		{
2959	0	result = response->result;
2960	0	goto error_exit;
2961		}
2962
2963	0	result = globus_soap_message_check_required_headers(
2964		response->client_handle->message);
2965	0	if(result != GLOBUS_SUCCESS)
2966		{
2967		/* continue on in case fault was returned and
2968		* no header elements exist
2969		*/
2970	0	response->result = result;
2971		}
2972		}
2973
2974		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE:
2975
2976	0	if(response->done)
2977		{
2978	0	if(response->result != GLOBUS_SUCCESS)
2979		{
2980	0	result = response->result;
2981	0	goto error_exit;
2982		}
2983
2984	0	globus_mutex_lock(&response->mutex);
2985	0	response->done = 0;
2986	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE;
2987	0	globus_mutex_unlock(&response->mutex);
2988
2989	0	result = globus_soap_message_register_close(
2990		response->client_handle->message,
2991		PauseSubscription_i_response_done_callback,
2992		response);
2993	0	if(result != GLOBUS_SUCCESS)
2994		{
2995	0	goto error_exit;
2996		}
2997		}
2998
2999	0	break;
3000
3001		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE:
3002
3003
3004	0	if(response->done)
3005		{
3006	0	if(response->result != GLOBUS_SUCCESS)
3007		{
3008	0	result = response->result;
3009	0	goto error_exit;
3010		}
3011
3012	0	globus_mutex_lock(&response->mutex);
3013	0	response->done = 0;
3014	0	message_handle = response->client_handle->message;
3015	0	response->client_handle->message = NULL;
3016	0	globus_mutex_unlock(&response->mutex);
3017
3018	0	response->callback(
3019		response->client_handle,
3020		response->args,
3021		response->fault_result,
3022		response->PauseSubscriptionResponse,
3023		response->fault_type,
3024		response->fault);
3025
3026	0	if(response->PauseSubscriptionResponse)
3027		{
3028	0	wsnt_PauseSubscriptionResponseType_destroy(response->PauseSubscriptionResponse);
3029		}
3030
3031	0	if(response->fault)
3032		{
3033	0	xsd_any_destroy(response->fault);
3034	0	response->fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT;
3035	0	response->fault = NULL;
3036		}
3037
3038	0	globus_soap_message_handle_destroy(message_handle);
3039	0	PauseSubscription_i_response_handle_destroy(response);
3040		}
3041
3042	0	break;
3043
3044		default:
3045
3046	0	globus_assert_string(NULL, "Unknown response state");
3047		}
3048
3049	0	return;
3050
3051		error_exit:
3052
3053	0	if(!GlobusSoapMessageStatusCheck(result))
3054		{
3055	0	result = GlobusSoapMessageErrorClientResponseFailed(
3056		result, "SubscriptionManager_PauseSubscription");
3057		}
3058
3059	0	globus_mutex_lock(&response->mutex);
3060	0	message_handle = response->client_handle->message;
3061	0	response->client_handle->message = NULL;
3062	0	globus_mutex_unlock(&response->mutex);
3063
3064	0	response->callback(
3065		response->client_handle,
3066		response->args,
3067		result,
3068		response->PauseSubscriptionResponse,
3069		response->fault_type,
3070		response->fault);
3071
3072	0	if(response->PauseSubscriptionResponse)
3073		{
3074	0	wsnt_PauseSubscriptionResponseType_destroy(response->PauseSubscriptionResponse);
3075		}
3076
3077	0	if(response->fault)
3078		{
3079	0	xsd_any_destroy(response->fault);
3080
3081	0	response->fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT;
3082	0	response->fault = NULL;
3083		}
3084
3085	0	globus_soap_message_handle_destroy(message_handle);
3086	0	PauseSubscription_i_response_handle_destroy(response);
3087		}
3088
3089		globus_result_t
3090		SubscriptionManager_PauseSubscription_register_response(
3091		SubscriptionManagerService_client_handle_t client_handle,
3092		SubscriptionManager_PauseSubscription_response_callback_func_t callback,
3093		void * user_args)
3094	0	{
3095	0	globus_result_t result = GLOBUS_SUCCESS;
3096	0	PauseSubscription_i_response_handle_t * response;
3097
3098	0	response = globus_malloc(
3099		sizeof(PauseSubscription_i_response_handle_t));
3100	0	globus_assert_string(response, "Memory allocation failed.");
3101	0	memset(response, 0, sizeof(PauseSubscription_i_response_handle_t));
3102
3103	0	response->callback = callback;
3104	0	response->args = user_args;
3105	0	response->client_handle = client_handle;
3106	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT;
3107	0	globus_mutex_init(&response->mutex, NULL);
3108
3109	0	result = globus_soap_message_handle_set_attr(
3110		client_handle->message,
3111		WSADDR_ACTION_RESPONSE_KEY,
3112		globus_soap_message_attr_copy_string,
3113		globus_libc_free,
3114		"http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification/PauseSubscriptionResponse");
3115	0	if(result != GLOBUS_SUCCESS)
3116		{
3117	0	if(!GlobusSoapMessageStatusCheck(result))
3118		{
3119	0	result = GlobusSoapMessageErrorClientRequestFailed(
3120		result, "SubscriptionManager_PauseSubscription");
3121	0	goto exit;
3122		}
3123		}
3124
3125	0	result = globus_callback_register_oneshot(
3126		&response->callback_handle,
3127		NULL,
3128		PauseSubscription_i_response_callback,
3129		response);
3130	0	if(result != GLOBUS_SUCCESS)
3131		{
3132	0	result = GlobusSoapMessageErrorClientResponseFailed(
3133		result, "SubscriptionManager_PauseSubscription");
3134	0	goto exit;
3135		}
3136
3137	0	return result;
3138
3139		exit:
3140	0	globus_mutex_destroy(&response->mutex);
3141	0	globus_free(response);
3142	0	return result;
3143		}
3144
3145		globus_result_t
3146		SubscriptionManager_PauseSubscription_epr_register(
3147		SubscriptionManagerService_client_handle_t handle,
3148		const wsa_EndpointReferenceType * epr,
3149		const wsnt_PauseSubscriptionType * PauseSubscription,
3150		SubscriptionManager_PauseSubscription_response_callback_func_t callback,
3151		void * user_args)
3152	0	{
3153	0	globus_result_t result = GLOBUS_SUCCESS;
3154
3155	0	globus_assert_string(epr, "NULL EndpointReference");
3156	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
3157
3158	0	globus_soap_message_attr_set(
3159		handle->attrs,
3160		WSADDR_EPR_KEY,
3161		wsa_EndpointReferenceType_copy_wrapper,
3162		wsa_EndpointReferenceType_destroy_wrapper,
3163		(void *)epr);
3164
3165	0	result = SubscriptionManager_PauseSubscription_register(
3166		handle,
3167		epr->Address.base_value,
3168		PauseSubscription,
3169		callback,
3170		user_args);
3171
3172	0	return result;
3173		}
3174
3175		globus_result_t
3176		SubscriptionManager_PauseSubscription_register(
3177		SubscriptionManagerService_client_handle_t handle,
3178		const char * endpoint,
3179		const wsnt_PauseSubscriptionType * PauseSubscription,
3180		SubscriptionManager_PauseSubscription_response_callback_func_t callback,
3181		void * user_args)
3182	0	{
3183	0	PauseSubscription_i_blocking_request_callback_t * callback_handle;
3184	0	globus_result_t result = GLOBUS_SUCCESS;
3185
3186	0	callback_handle = globus_malloc(
3187		sizeof(PauseSubscription_i_blocking_request_callback_t));
3188	0	globus_assert_string(callback_handle, "Memory allocation failed");
3189	0	memset(callback_handle, 0,
3190		sizeof(PauseSubscription_i_blocking_request_callback_t));
3191
3192	0	callback_handle->callback = callback;
3193	0	callback_handle->args = user_args;
3194
3195	0	result = SubscriptionManager_PauseSubscription_register_request(
3196		handle,
3197		endpoint,
3198		PauseSubscription,
3199		PauseSubscription_i_blocking_request_callback,
3200		callback_handle);
3201	0	if(result != GLOBUS_SUCCESS)
3202		{
3203	0	globus_free(callback_handle);
3204		goto exit;
3205		}
3206
3207		exit:
3208
3209	0	return result;
3210		}
3211
3212		typedef struct PauseSubscription_i_blocking_response_callback_s
3213		{
3214		globus_result_t result;
3215		SubscriptionManager_PauseSubscription_fault_t fault_type;
3216		xsd_any * fault;
3217		wsnt_PauseSubscriptionResponseType * PauseSubscriptionResponse;
3218		int done;
3219		globus_cond_t cond;
3220		globus_mutex_t mutex;
3221		} PauseSubscription_i_blocking_response_callback_t;
3222
3223		static
3224		void
3225		PauseSubscription_i_blocking_response_callback(
3226		SubscriptionManagerService_client_handle_t handle,
3227		void * user_args,
3228		globus_result_t result,
3229		const wsnt_PauseSubscriptionResponseType * PauseSubscriptionResponse,
3230		SubscriptionManager_PauseSubscription_fault_t fault_type,
3231		const xsd_any * fault)
3232	0	{
3233	0	PauseSubscription_i_blocking_response_callback_t * callback_handle;
3234
3235	0	callback_handle = (PauseSubscription_i_blocking_response_callback_t *) user_args;
3236
3237	0	callback_handle->result = result;
3238	0	if(result == GLOBUS_SUCCESS)
3239		{
3240	0	wsnt_PauseSubscriptionResponseType_copy(
3241		&callback_handle->PauseSubscriptionResponse, PauseSubscriptionResponse);
3242		}
3243		else
3244		{
3245	0	callback_handle->fault_type = fault_type;
3246	0	if(fault_type != GLOBUS_SUCCESS)
3247		{
3248	0	xsd_any_copy(&callback_handle->fault, fault);
3249		}
3250		}
3251
3252	0	globus_mutex_lock(&callback_handle->mutex);
3253	0	globus_cond_signal(&callback_handle->cond);
3254	0	callback_handle->done = 1;
3255	0	globus_mutex_unlock(&callback_handle->mutex);
3256		}
3257
3258
3259		globus_result_t
3260		SubscriptionManager_PauseSubscription_epr(
3261		SubscriptionManagerService_client_handle_t handle,
3262		const wsa_EndpointReferenceType * epr,
3263		const wsnt_PauseSubscriptionType * PauseSubscription,
3264		wsnt_PauseSubscriptionResponseType * * PauseSubscriptionResponse,
3265		SubscriptionManager_PauseSubscription_fault_t * fault_type,
3266		xsd_any * * fault)
3267	0	{
3268	0	globus_result_t result = GLOBUS_SUCCESS;
3269
3270	0	globus_assert_string(epr, "NULL EndpointReference");
3271	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
3272
3273	0	*fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT;
3274
3275	0	globus_soap_message_attr_set(
3276		handle->attrs,
3277		WSADDR_EPR_KEY,
3278		wsa_EndpointReferenceType_copy_wrapper,
3279		wsa_EndpointReferenceType_destroy_wrapper,
3280		(void *)epr);
3281
3282	0	result = SubscriptionManager_PauseSubscription(
3283		handle,
3284		epr->Address.base_value,
3285		PauseSubscription,
3286		PauseSubscriptionResponse,
3287		fault_type,
3288		fault);
3289
3290	0	return result;
3291		}
3292
3293		globus_result_t
3294		SubscriptionManager_PauseSubscription(
3295		SubscriptionManagerService_client_handle_t handle,
3296		const char * endpoint,
3297		const wsnt_PauseSubscriptionType * PauseSubscription,
3298		wsnt_PauseSubscriptionResponseType * * PauseSubscriptionResponse,
3299		SubscriptionManager_PauseSubscription_fault_t * fault_type,
3300		xsd_any * * fault)
3301	0	{
3302	0	globus_result_t result = GLOBUS_SUCCESS;
3303
3304	0	PauseSubscription_i_blocking_response_callback_t * callback_handle;
3305	0	*fault_type = SUBSCRIPTIONMANAGER_PAUSESUBSCRIPTION_NOFAULT;
3306
3307	0	callback_handle = globus_malloc(
3308		sizeof(PauseSubscription_i_blocking_response_callback_t));
3309	0	globus_assert_string(callback_handle, "Memory allocation failed");
3310	0	memset(callback_handle, 0,
3311		sizeof(PauseSubscription_i_blocking_response_callback_t));
3312
3313	0	globus_mutex_init(&callback_handle->mutex, NULL);
3314	0	globus_cond_init(&callback_handle->cond, NULL);
3315
3316	0	result = SubscriptionManager_PauseSubscription_register(
3317		handle,
3318		endpoint,
3319		PauseSubscription,
3320		PauseSubscription_i_blocking_response_callback,
3321		callback_handle);
3322	0	if(result != GLOBUS_SUCCESS)
3323		{
3324	0	goto exit;
3325		}
3326
3327
3328	0	globus_mutex_lock(&callback_handle->mutex);
3329	0	while(!callback_handle->done)
3330		{
3331	0	globus_cond_wait(&callback_handle->cond, &callback_handle->mutex);
3332		}
3333	0	globus_mutex_unlock(&callback_handle->mutex);
3334
3335	0	result = callback_handle->result;
3336	0	if(result != GLOBUS_SUCCESS)
3337		{
3338
3339	0	*fault_type = callback_handle->fault_type;
3340	0	*fault = callback_handle->fault;
3341
3342	0	goto exit;
3343		}
3344
3345	0	*PauseSubscriptionResponse = callback_handle->PauseSubscriptionResponse;
3346
3347		exit:
3348
3349	0	globus_mutex_destroy(&callback_handle->mutex);
3350	0	globus_cond_destroy(&callback_handle->cond);
3351
3352	0	free(callback_handle);
3353
3354	0	return result;
3355		}
3356
3357
3358
3359		typedef struct SetTerminationTime_i_request_handle_s
3360		{
3361		char * endpoint;
3362		int done;
3363		globus_mutex_t mutex;
3364		SubscriptionManagerService_request_state_t state;
3365		SubscriptionManager_SetTerminationTime_request_callback_func_t callback;
3366		void * args;
3367		SubscriptionManagerService_client_handle_t client_handle;
3368		wsrl_SetTerminationTimeType * SetTerminationTime;
3369		globus_callback_handle_t callback_handle;
3370		globus_result_t result;
3371		} SetTerminationTime_i_request_handle_t;
3372
3373		static void
3374		SetTerminationTime_i_request_callback(
3375		void * args);
3376
3377		static void
3378		SetTerminationTime_i_request_done_callback(
3379		globus_result_t result,
3380		void * args)
3381	0	{
3382	0	SetTerminationTime_i_request_handle_t * request;
3383
3384	0	request = (SetTerminationTime_i_request_handle_t *) args;
3385	0	globus_assert_string(request, "request handle in callback is NULL");
3386
3387	0	globus_mutex_lock(&request->mutex);
3388	0	request->result = result;
3389	0	request->done = 1;
3390	0	globus_mutex_unlock(&request->mutex);
3391
3392	0	SetTerminationTime_i_request_callback(request);
3393		}
3394
3395		static void
3396		SetTerminationTime_i_request_handle_destroy(
3397		void * args)
3398	0	{
3399	0	SetTerminationTime_i_request_handle_t * request;
3400
3401	0	request = (SetTerminationTime_i_request_handle_t *) args;
3402	0	globus_assert_string(request, "request handle in callback is NULL");
3403
3404	0	globus_mutex_destroy(&request->mutex);
3405
3406	0	if(request->SetTerminationTime)
3407		{
3408	0	wsrl_SetTerminationTimeType_destroy(request->SetTerminationTime);
3409		}
3410	0	if(request->endpoint)
3411		{
3412	0	globus_free(request->endpoint);
3413		}
3414
3415	0	globus_free(request);
3416		}
3417
3418		static void
3419		SetTerminationTime_i_request_callback(
3420		void * args)
3421	0	{
3422	0	globus_soap_message_handle_t message_handle = NULL;
3423	0	globus_result_t result = GLOBUS_SUCCESS;
3424	0	globus_handler_chain_t chain = NULL;
3425	0	SetTerminationTime_i_request_handle_t * request;
3426	0	xsd_QName subelement;
3427
3428	0	request = (SetTerminationTime_i_request_handle_t *) args;
3429	0	globus_assert_string(request, "request handle is NULL");
3430
3431	0	switch(request->state)
3432		{
3433
3434		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT:
3435
3436	0	globus_mutex_lock(&request->mutex);
3437	0	request->done = 0;
3438	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS;
3439	0	globus_mutex_unlock(&request->mutex);
3440
3441	0	result = globus_soap_message_get_handler_chain(
3442		request->client_handle->message, &chain);
3443	0	if(result != GLOBUS_SUCCESS)
3444		{
3445	0	goto error_exit;
3446		}
3447
3448	0	if(chain)
3449		{
3450	0	globus_handler_chain_register_invoke(
3451		chain,
3452		GLOBUS_HANDLER_TYPE_REQUEST_INIT,
3453		request->client_handle->message,
3454		SetTerminationTime_i_request_done_callback,
3455		request);
3456		}
3457
3458	0	break;
3459
3460		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS:
3461
3462	0	globus_mutex_lock(&request->mutex);
3463	0	request->done = 0;
3464	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING;
3465	0	globus_mutex_unlock(&request->mutex);
3466
3467	0	result = globus_soap_message_register_open(
3468		request->client_handle->message,
3469		request->endpoint,
3470		SetTerminationTime_i_request_done_callback,
3471		request);
3472	0	if(result != GLOBUS_SUCCESS)
3473		{
3474	0	goto error_exit;
3475		}
3476
3477	0	break;
3478
3479		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING:
3480
3481	0	if(request->done)
3482		{
3483	0	if(request->result != GLOBUS_SUCCESS)
3484		{
3485	0	result = request->result;
3486	0	goto error_exit;
3487		}
3488
3489	0	globus_mutex_lock(&request->mutex);
3490	0	request->done = 0;
3491	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS;
3492	0	globus_mutex_unlock(&request->mutex);
3493
3494	0	result = globus_soap_message_serialize_envelope(
3495		request->client_handle->message);
3496	0	if(result != GLOBUS_SUCCESS)
3497		{
3498	0	goto error_exit;
3499		}
3500
3501	0	result = globus_soap_message_serialize_header(
3502		request->client_handle->message);
3503	0	if(result != GLOBUS_SUCCESS)
3504		{
3505	0	goto error_exit;
3506		}
3507
3508	0	result = globus_soap_message_serialize_header_begin_close(
3509		request->client_handle->message);
3510	0	if(result != GLOBUS_SUCCESS)
3511		{
3512	0	goto error_exit;
3513		}
3514
3515	0	result = globus_soap_message_set_marker(
3516		request->client_handle->message,
3517		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
3518	0	if(result != GLOBUS_SUCCESS)
3519		{
3520	0	goto error_exit;
3521		}
3522
3523	0	result = globus_soap_message_serialize_header_end(
3524		request->client_handle->message);
3525	0	if(result != GLOBUS_SUCCESS)
3526		{
3527	0	goto error_exit;
3528		}
3529
3530	0	result = globus_soap_message_serialize_body(
3531		request->client_handle->message);
3532	0	if(result != GLOBUS_SUCCESS)
3533		{
3534	0	goto error_exit;
3535		}
3536
3537	0	result = globus_soap_message_serialize_body_begin_close(
3538		request->client_handle->message);
3539	0	if(result != GLOBUS_SUCCESS)
3540		{
3541	0	goto error_exit;
3542		}
3543
3544	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
3545	0	subelement.local = "SetTerminationTime";
3546
3547	0	result = wsrl_SetTerminationTimeType_serialize(
3548		&subelement,
3549		request->SetTerminationTime,
3550		request->client_handle->message,
3551		0);
3552	0	if(result != GLOBUS_SUCCESS)
3553		{
3554	0	goto error_exit;
3555		}
3556
3557	0	result = globus_soap_message_serialize_body_end(
3558		request->client_handle->message);
3559	0	if(result != GLOBUS_SUCCESS)
3560		{
3561	0	goto error_exit;
3562		}
3563
3564	0	result = globus_soap_message_serialize_envelope_end(
3565		request->client_handle->message);
3566	0	if(result != GLOBUS_SUCCESS)
3567		{
3568	0	goto error_exit;
3569		}
3570
3571	0	result = globus_soap_message_set_write_position_to_marker(
3572		request->client_handle->message,
3573		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
3574	0	if(result != GLOBUS_SUCCESS)
3575		{
3576	0	goto error_exit;
3577		}
3578
3579	0	result = globus_soap_message_get_handler_chain(
3580		request->client_handle->message, &chain);
3581	0	if(result != GLOBUS_SUCCESS)
3582		{
3583	0	goto error_exit;
3584		}
3585
3586	0	if(chain)
3587		{
3588	0	globus_handler_chain_register_invoke(
3589		chain,
3590		GLOBUS_HANDLER_TYPE_REQUEST,
3591		request->client_handle->message,
3592		SetTerminationTime_i_request_done_callback,
3593		request);
3594		}
3595		}
3596
3597	0	break;
3598
3599		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS:
3600
3601	0	if(request->done)
3602		{
3603	0	if(request->result != GLOBUS_SUCCESS)
3604		{
3605	0	result = request->result;
3606	0	goto error_exit;
3607		}
3608
3609	0	globus_mutex_lock(&request->mutex);
3610	0	request->done = 0;
3611	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING;
3612	0	globus_mutex_unlock(&request->mutex);
3613
3614	0	result = globus_soap_message_register_write_request(
3615		request->client_handle->message,
3616		SetTerminationTime_i_request_done_callback,
3617		request,
3618
3619		GLOBUS_TRUE);
3620
3621	0	if(result != GLOBUS_SUCCESS)
3622		{
3623	0	goto error_exit;
3624		}
3625		}
3626
3627	0	break;
3628
3629		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING:
3630
3631	0	if(request->done)
3632		{
3633	0	if(request->result != GLOBUS_SUCCESS)
3634		{
3635	0	result = request->result;
3636	0	goto error_exit;
3637		}
3638
3639	0	globus_mutex_lock(&request->mutex);
3640	0	request->done = 0;
3641	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS;
3642	0	globus_mutex_unlock(&request->mutex);
3643
3644	0	result = globus_soap_message_get_handler_chain(
3645		request->client_handle->message, &chain);
3646	0	if(result != GLOBUS_SUCCESS)
3647		{
3648	0	goto error_exit;
3649		}
3650
3651	0	if(chain)
3652		{
3653	0	globus_handler_chain_register_invoke(
3654		chain,
3655		GLOBUS_HANDLER_TYPE_REQUEST_DESTROY,
3656		request->client_handle->message,
3657		SetTerminationTime_i_request_done_callback,
3658		request);
3659		}
3660		}
3661
3662	0	break;
3663
3664		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS:
3665
3666	0	if(request->done)
3667		{
3668	0	if(request->result != GLOBUS_SUCCESS)
3669		{
3670	0	result = request->result;
3671	0	goto error_exit;
3672		}
3673
3674	0	globus_mutex_lock(&request->mutex);
3675	0	request->done = 0;
3676	0	globus_mutex_unlock(&request->mutex);
3677
3678	0	request->callback(
3679		request->client_handle,
3680		request->args, GLOBUS_SUCCESS);
3681
3682	0	SetTerminationTime_i_request_handle_destroy(request);
3683		}
3684
3685	0	break;
3686
3687		default:
3688
3689	0	globus_assert_string(NULL, "Unkown request state");
3690	0	break;
3691		}
3692
3693	0	return;
3694
3695		error_exit:
3696
3697	0	result = GlobusSoapMessageErrorClientRequestFailed(
3698		result, "SubscriptionManager_SetTerminationTime");
3699
3700	0	globus_mutex_lock(&request->mutex);
3701	0	message_handle = request->client_handle->message;
3702	0	request->client_handle->message = NULL;
3703	0	globus_mutex_unlock(&request->mutex);
3704
3705	0	request->callback(request->client_handle, request->args, result);
3706
3707	0	globus_soap_message_handle_destroy(message_handle);
3708	0	SetTerminationTime_i_request_handle_destroy(request);
3709		}
3710
3711		globus_result_t
3712		SubscriptionManager_SetTerminationTime_epr_register_request(
3713		SubscriptionManagerService_client_handle_t client_handle,
3714		const wsa_EndpointReferenceType * epr,
3715		const wsrl_SetTerminationTimeType * SetTerminationTime,
3716		SubscriptionManager_SetTerminationTime_request_callback_func_t callback,
3717		void * user_args)
3718	0	{
3719	0	globus_result_t result = GLOBUS_SUCCESS;
3720
3721	0	globus_assert_string(epr, "NULL EndpointReference");
3722	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
3723
3724	0	globus_soap_message_attr_set(
3725		client_handle->attrs,
3726		WSADDR_EPR_KEY,
3727		wsa_EndpointReferenceType_copy_wrapper,
3728		wsa_EndpointReferenceType_destroy_wrapper,
3729		(void *)epr);
3730
3731	0	result = SubscriptionManager_SetTerminationTime_register_request(
3732		client_handle,
3733		epr->Address.base_value,
3734		SetTerminationTime,
3735		callback,
3736		user_args);
3737
3738	0	return result;
3739		}
3740
3741		globus_result_t
3742		SubscriptionManager_SetTerminationTime_register_request(
3743		SubscriptionManagerService_client_handle_t client_handle,
3744		const char * endpoint,
3745		const wsrl_SetTerminationTimeType * SetTerminationTime,
3746		SubscriptionManager_SetTerminationTime_request_callback_func_t callback,
3747		void * user_args)
3748	0	{
3749	0	globus_handler_chain_t chain = NULL;
3750	0	globus_result_t result = GLOBUS_SUCCESS;
3751	0	SetTerminationTime_i_request_handle_t * request = NULL;
3752
3753	0	if(client_handle->message != NULL)
3754		{
3755	0	result = GlobusSoapMessageErrorClientAlreadyInvoked();
3756	0	goto exit;
3757		}
3758
3759	0	result = globus_soap_message_handle_init(&client_handle->message, NULL);
3760	0	if(result != GLOBUS_SUCCESS)
3761		{
3762	0	result = GlobusSoapMessageErrorFailedClientInit(
3763		result, "SubscriptionManager_SetTerminationTime");
3764	0	goto error_exit;
3765		}
3766
3767	0	globus_soap_message_handle_set_registry(
3768		client_handle->message, SubscriptionManagerService_l_registry);
3769
3770	0	chain = client_handle->handler_chain;
3771	0	if(!chain)
3772		{
3773	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
3774	0	if(result != GLOBUS_SUCCESS)
3775		{
3776	0	result = GlobusSoapMessageErrorFailedClientInit(
3777		result, "SubscriptionManager_SetTerminationTime");
3778	0	goto exit;
3779		}
3780
3781	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
3782	0	globus_list_insert(
3783		&SubscriptionManagerService_l_extensions,
3784		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
3785	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
3786
3787	0	globus_handler_chain_init(&chain);
3788	0	result = globus_handler_chain_push(
3789		chain,
3790		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
3791		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
3792	0	if(result != GLOBUS_SUCCESS)
3793		{
3794	0	result = GlobusSoapMessageErrorFailedClientInit(
3795		result, "SubscriptionManager_SetTerminationTime");
3796	0	goto error_exit;
3797		}
3798
3799	0	result = globus_handler_chain_push(
3800		chain,
3801		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
3802		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
3803	0	if(result != GLOBUS_SUCCESS)
3804		{
3805	0	result = GlobusSoapMessageErrorFailedClientInit(
3806		result, "SubscriptionManager_SetTerminationTime");
3807	0	goto error_exit;
3808		}
3809		}
3810
3811	0	globus_soap_message_set_handler_chain(
3812		client_handle->message, chain);
3813
3814	0	request = globus_malloc(sizeof(SetTerminationTime_i_request_handle_t));
3815	0	globus_assert_string(request, "Memory allocation failed.");
3816	0	memset(request, 0, sizeof(SetTerminationTime_i_request_handle_t));
3817
3818	0	if(!endpoint)
3819		{
3820	0	endpoint = (char *)globus_soap_message_attr_get(
3821		client_handle->attrs, GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY);
3822	0	if(!endpoint)
3823		{
3824	0	wsa_EndpointReferenceType * epr;
3825	0	epr = (wsa_EndpointReferenceType *)
3826		globus_soap_message_attr_get(
3827		client_handle->attrs, WSADDR_EPR_KEY);
3828	0	if(epr && epr->Address.base_value)
3829		{
3830	0	endpoint = epr->Address.base_value;
3831		}
3832		}
3833		}
3834
3835	0	globus_assert_string(endpoint, "NULL endpoint");
3836
3837	0	request->endpoint = globus_libc_strdup(endpoint);
3838	0	request->callback = callback;
3839	0	request->args = user_args;
3840	0	request->client_handle = client_handle;
3841	0	wsrl_SetTerminationTimeType_copy(&request->SetTerminationTime, SetTerminationTime);
3842	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT;
3843	0	globus_mutex_init(&request->mutex, NULL);
3844
3845	0	result = globus_soap_message_attr_set(
3846		client_handle->attrs,
3847		WSADDR_DESTINATION_KEY,
3848		globus_soap_message_attr_copy_string,
3849		globus_libc_free,
3850		(void *)endpoint);
3851	0	if(result != GLOBUS_SUCCESS)
3852		{
3853	0	result = GlobusSoapMessageErrorClientRequestFailed(
3854		result, "SubscriptionManager_SetTerminationTime");
3855	0	goto error_exit;
3856		}
3857
3858	0	result = globus_soap_message_attr_set(
3859		client_handle->attrs,
3860		WSADDR_ACTION_REQUEST_KEY,
3861		NULL,
3862		NULL,
3863		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime/SetTerminationTime");
3864	0	if(result != GLOBUS_SUCCESS)
3865		{
3866	0	result = GlobusSoapMessageErrorClientRequestFailed(
3867		result, "SubscriptionManager_SetTerminationTime");
3868	0	goto error_exit;
3869		}
3870
3871	0	result = globus_soap_message_attr_set(
3872		client_handle->attrs,
3873		GLOBUS_SOAP_MESSAGE_SOAP_ACTION_KEY,
3874		NULL,
3875		NULL,
3876		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime/SetTerminationTime");
3877	0	if(result != GLOBUS_SUCCESS)
3878		{
3879	0	result = GlobusSoapMessageErrorClientRequestFailed(
3880		result, "SubscriptionManager_SetTerminationTime");
3881	0	goto error_exit;
3882		}
3883
3884	0	result = globus_soap_message_handle_set_attrs(
3885		client_handle->message, client_handle->attrs);
3886	0	if(result != GLOBUS_SUCCESS)
3887		{
3888	0	result = GlobusSoapMessageErrorClientRequestFailed(
3889		result, "SubscriptionManager_SetTerminationTime");
3890		}
3891
3892	0	result = globus_callback_register_oneshot(
3893		&request->callback_handle,
3894		NULL,
3895		SetTerminationTime_i_request_callback,
3896		request);
3897	0	if(result != GLOBUS_SUCCESS)
3898		{
3899	0	result = GlobusSoapMessageErrorClientRequestFailed(
3900		result, "SubscriptionManager_SetTerminationTime");
3901		goto error_exit;
3902		}
3903
3904	0	goto exit;
3905
3906		error_exit:
3907
3908	0	if(request)
3909		{
3910	0	globus_mutex_destroy(&request->mutex);
3911
3912	0	if(request->SetTerminationTime)
3913		{
3914	0	wsrl_SetTerminationTimeType_destroy(request->SetTerminationTime);
3915		}
3916	0	if(request->endpoint)
3917		{
3918	0	globus_free(request->endpoint);
3919		}
3920
3921	0	globus_free(request);
3922		}
3923
3924	0	if(client_handle->message)
3925		{
3926	0	globus_soap_message_handle_destroy(client_handle->message);
3927	0	client_handle->message = NULL;
3928		}
3929
3930		exit:
3931
3932	0	return result;
3933		}
3934
3935		typedef struct SetTerminationTime_i_blocking_request_callback_s
3936		{
3937
3938		SubscriptionManager_SetTerminationTime_response_callback_func_t callback;
3939		void * args;
3940
3941		} SetTerminationTime_i_blocking_request_callback_t;
3942
3943		static
3944		void
3945		SetTerminationTime_i_blocking_request_callback(
3946		SubscriptionManagerService_client_handle_t handle,
3947		void * user_args,
3948		globus_result_t error)
3949	0	{
3950	0	globus_soap_message_handle_t message_handle = NULL;
3951	0	globus_result_t result = GLOBUS_SUCCESS;
3952	0	SetTerminationTime_i_blocking_request_callback_t * callback_handle;
3953
3954	0	callback_handle = (SetTerminationTime_i_blocking_request_callback_t *) user_args;
3955	0	globus_assert_string(callback_handle, "callback_handle is NULL");
3956
3957
3958	0	if(error != GLOBUS_SUCCESS \|\|
3959		globus_soap_message_is_cancelled(handle->message))
3960		{
3961	0	message_handle = handle->message;
3962	0	handle->message = NULL;
3963
3964	0	callback_handle->callback(
3965		handle,
3966		callback_handle->args,
3967		error,
3968		NULL,
3969		SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT,
3970		NULL);
3971
3972	0	globus_soap_message_handle_destroy(message_handle);
3973		}
3974		else
3975		{
3976	0	result = SubscriptionManager_SetTerminationTime_register_response(
3977		handle,
3978		callback_handle->callback,
3979		callback_handle->args);
3980	0	if(result != GLOBUS_SUCCESS)
3981		{
3982	0	callback_handle->callback(
3983		handle,
3984		callback_handle->args,
3985		result,
3986		NULL,
3987		SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT,
3988		NULL);
3989		}
3990		}
3991
3992	0	free(callback_handle);
3993		}
3994
3995
3996
3997		typedef struct SetTerminationTime_i_response_handle_s
3998		{
3999		int done;
4000		globus_mutex_t mutex;
4001		SubscriptionManagerService_response_state_t state;
4002		SubscriptionManager_SetTerminationTime_response_callback_func_t callback;
4003		void * args;
4004		SubscriptionManagerService_client_handle_t client_handle;
4005		wsrl_SetTerminationTimeResponseType * SetTerminationTimeResponse;
4006		globus_callback_handle_t callback_handle;
4007		globus_result_t result;
4008		globus_result_t fault_result;
4009		int fault_type;
4010		xsd_any * fault;
4011		} SetTerminationTime_i_response_handle_t;
4012
4013		static void
4014		SetTerminationTime_i_response_callback(
4015		void * args);
4016
4017		static void
4018		SetTerminationTime_i_response_done_callback(
4019		globus_result_t result,
4020		void * args)
4021	0	{
4022	0	SetTerminationTime_i_response_handle_t * response;
4023
4024	0	response = (SetTerminationTime_i_response_handle_t *) args;
4025	0	globus_assert_string(response, "response handle in callback is NULL");
4026
4027	0	globus_mutex_lock(&response->mutex);
4028	0	response->result = result;
4029	0	response->done = 1;
4030	0	globus_mutex_unlock(&response->mutex);
4031
4032	0	SetTerminationTime_i_response_callback(response);
4033		}
4034
4035		static void
4036		SetTerminationTime_i_response_handle_destroy(
4037		void * args)
4038	0	{
4039	0	SetTerminationTime_i_response_handle_t * response;
4040
4041	0	response = (SetTerminationTime_i_response_handle_t *) args;
4042	0	globus_assert_string(response, "response handle in callback is NULL");
4043
4044	0	globus_mutex_destroy(&response->mutex);
4045
4046	0	free(response);
4047		}
4048
4049		static void
4050		SetTerminationTime_i_deserialize_fault(
4051		globus_soap_message_handle_t handle,
4052		const xsd_QName * fault_qname,
4053		int * fault_type,
4054		void * args)
4055	0	{
4056	0	*fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT;
4057
4058	0	if(fault_qname)
4059		{
4060	0	if(fault_qname == (&wsrl_ResourceUnknownFaultType_qname) \|\|
4061		fault_qname == (&wsrl_ResourceUnknownFault_qname))
4062		{
4063	0	*fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_RESOURCEUNKNOWNFAULT;
4064		}
4065	0	else if(fault_qname == (&wsrl_TerminationTimeChangeRejectedFaultType_qname) \|\|
4066		fault_qname == (&wsrl_TerminationTimeChangeRejectedFault_qname))
4067		{
4068	0	*fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_TERMINATIONTIMECHANGEREJECTEDFAULT;
4069		}
4070	0	else if(fault_qname == (&wsrl_UnableToSetTerminationTimeFaultType_qname) \|\|
4071		fault_qname == (&wsrl_UnableToSetTerminationTimeFault_qname))
4072		{
4073	0	*fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_UNABLETOSETTERMINATIONTIMEFAULT;
4074		}
4075		else
4076		{
4077	0	*fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_UNKNOWN_FAULT;
4078		}
4079		}
4080		}
4081
4082		static void
4083		SetTerminationTime_i_response_callback(
4084		void * args)
4085	0	{
4086	0	xsd_QName subelement;
4087	0	globus_soap_message_handle_t message_handle = NULL;
4088	0	globus_soap_message_fault_t soap_fault;
4089	0	globus_result_t result = GLOBUS_SUCCESS;
4090	0	globus_handler_chain_t chain = NULL;
4091	0	xsd_QName * header_element = NULL;
4092	0	int must;
4093	0	SetTerminationTime_i_response_handle_t * response;
4094	0	response = (SetTerminationTime_i_response_handle_t *) args;
4095	0	globus_assert_string(response, "response handle in callback is NULL");
4096
4097	0	switch(response->state)
4098		{
4099
4100		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT:
4101
4102	0	globus_mutex_lock(&response->mutex);
4103	0	response->done = 0;
4104	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING;
4105	0	globus_mutex_unlock(&response->mutex);
4106
4107	0	result = globus_soap_message_register_read_response(
4108		response->client_handle->message,
4109		SetTerminationTime_i_response_done_callback,
4110		response);
4111	0	if(result != GLOBUS_SUCCESS)
4112		{
4113	0	goto error_exit;
4114		}
4115
4116	0	break;
4117
4118		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING:
4119
4120	0	if(response->done)
4121		{
4122	0	if(response->result != GLOBUS_SUCCESS)
4123		{
4124	0	if(GlobusSoapMessageErrorCheckFailedResponse(response->result) \|\|
4125		GlobusSoapMessageErrorCheckBadRequest(response->result))
4126		{
4127	0	response->result = GLOBUS_SUCCESS;
4128		}
4129		else
4130		{
4131	0	result = response->result;
4132	0	goto error_exit;
4133		}
4134		}
4135
4136	0	globus_mutex_lock(&response->mutex);
4137	0	response->done = 0;
4138	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
4139	0	globus_mutex_unlock(&response->mutex);
4140
4141	0	result = globus_soap_message_deserialize_envelope(
4142		response->client_handle->message);
4143	0	if(result != GLOBUS_SUCCESS)
4144		{
4145	0	goto error_exit;
4146		}
4147
4148	0	result = globus_soap_message_deserialize_element_begin_close(
4149		response->client_handle->message);
4150	0	if(result != GLOBUS_SUCCESS)
4151		{
4152	0	goto error_exit;
4153		}
4154
4155	0	result = globus_soap_message_deserialize_header(
4156		response->client_handle->message);
4157	0	if(result != GLOBUS_SUCCESS)
4158		{
4159	0	if(GlobusSoapMessageStatusElementNotFoundCheck(result))
4160		{
4161	0	globus_soap_message_deserialize_push_element(
4162		response->client_handle->message);
4163	0	result = GLOBUS_SUCCESS;
4164	0	globus_mutex_lock(&response->mutex);
4165	0	response->state =
4166		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED;
4167	0	globus_mutex_unlock(&response->mutex);
4168	0	SetTerminationTime_i_response_done_callback(
4169		result, response);
4170	0	break;
4171		}
4172
4173	0	goto error_exit;
4174		}
4175
4176	0	globus_mutex_lock(&response->mutex);
4177	0	response->done = 1;
4178	0	globus_mutex_unlock(&response->mutex);
4179		}
4180
4181		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS:
4182
4183	0	if(response->done)
4184		{
4185	0	if(response->result != GLOBUS_SUCCESS)
4186		{
4187	0	if(GlobusSoapMessageErrorCheckFailedResponse(
4188		response->result) \|\|
4189		GlobusSoapMessageErrorCheckBadRequest(response->result))
4190		{
4191	0	response->result = GLOBUS_SUCCESS;
4192		}
4193		else
4194		{
4195	0	result = response->result;
4196	0	goto error_exit;
4197		}
4198		}
4199
4200	0	globus_mutex_lock(&response->mutex);
4201	0	response->done = 0;
4202	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
4203	0	globus_mutex_unlock(&response->mutex);
4204
4205	0	xsd_QName_init(&header_element);
4206
4207	0	result = globus_soap_message_deserialize_element_unknown(
4208		response->client_handle->message,
4209		header_element);
4210	0	if(result != GLOBUS_SUCCESS)
4211		{
4212	0	if(!GlobusSoapMessageStatusFailedElementCheck(result))
4213		{
4214	0	xsd_QName_destroy(header_element);
4215	0	goto error_exit;
4216		}
4217		else
4218		{
4219	0	globus_mutex_lock(&response->mutex);
4220	0	response->done = 1;
4221	0	response->state =
4222		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE;
4223	0	globus_mutex_unlock(&response->mutex);
4224
4225	0	globus_callback_register_oneshot(
4226		NULL,
4227		&globus_i_reltime_zero,
4228		SetTerminationTime_i_response_callback,
4229		(void *)response);
4230	0	xsd_QName_destroy(header_element);
4231	0	break;
4232		}
4233		}
4234
4235	0	result = globus_soap_message_deserialize_int_attribute(
4236		response->client_handle->message,
4237		&soap_mustUnderstand_qname,
4238		&must);
4239	0	if(result == GLOBUS_SUCCESS && (must == 1))
4240		{
4241	0	globus_soap_message_add_required_header_element(
4242		response->client_handle->message,
4243		header_element);
4244		}
4245	0	else if(result != GLOBUS_SUCCESS &&
4246		!GlobusSoapMessageStatusAttributeNotFoundCheck(result))
4247		{
4248	0	xsd_QName_destroy(header_element);
4249	0	goto error_exit;
4250		}
4251
4252	0	globus_soap_message_deserialize_push_element(
4253		response->client_handle->message);
4254
4255	0	result = globus_soap_message_get_handler_chain(
4256		response->client_handle->message, &chain);
4257	0	if(result != GLOBUS_SUCCESS)
4258		{
4259	0	goto error_exit;
4260		}
4261
4262	0	if(chain)
4263		{
4264	0	result = globus_handler_chain_register_trigger(
4265		chain,
4266		response->client_handle->message,
4267		header_element,
4268		SetTerminationTime_i_response_done_callback,
4269		response);
4270	0	if(result == GLOBUS_SUCCESS)
4271		{
4272	0	xsd_QName_destroy(header_element);
4273	0	break;
4274		}
4275	0	else if(!GlobusHandlerStatusNotTriggeredCheck(result))
4276		{
4277	0	xsd_QName_destroy(header_element);
4278	0	goto error_exit;
4279		}
4280		}
4281
4282	0	xsd_QName_destroy(header_element);
4283	0	result = globus_soap_message_deserialize_skip(
4284		response->client_handle->message);
4285	0	if(result != GLOBUS_SUCCESS)
4286		{
4287	0	goto error_exit;
4288		}
4289
4290	0	globus_mutex_lock(&response->mutex);
4291	0	response->done = 1;
4292	0	globus_mutex_unlock(&response->mutex);
4293	0	globus_callback_register_oneshot(
4294		NULL,
4295		&globus_i_reltime_zero,
4296		SetTerminationTime_i_response_callback,
4297		(void *)response);
4298		}
4299
4300	0	break;
4301
4302		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE:
4303
4304	0	if(response->done)
4305		{
4306	0	if(response->result != GLOBUS_SUCCESS)
4307		{
4308	0	result = response->result;
4309	0	goto error_exit;
4310		}
4311
4312	0	globus_mutex_lock(&response->mutex);
4313	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
4314	0	globus_mutex_unlock(&response->mutex);
4315
4316	0	result = globus_soap_message_deserialize_header_end(
4317		response->client_handle->message);
4318	0	if(result != GLOBUS_SUCCESS)
4319		{
4320	0	goto error_exit;
4321		}
4322
4323	0	result = globus_soap_message_deserialize_body(
4324		response->client_handle->message);
4325	0	if(result != GLOBUS_SUCCESS)
4326		{
4327	0	goto error_exit;
4328		}
4329		}
4330
4331		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED:
4332
4333	0	if(response->done)
4334		{
4335	0	if(response->result != GLOBUS_SUCCESS)
4336		{
4337	0	result = response->result;
4338	0	goto error_exit;
4339		}
4340
4341	0	globus_mutex_lock(&response->mutex);
4342	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
4343	0	globus_mutex_unlock(&response->mutex);
4344
4345	0	response->fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT;
4346	0	response->fault_result = GLOBUS_SUCCESS;
4347
4348	0	result = globus_soap_message_deserialize_fault(
4349		response->client_handle->message,
4350		&soap_fault,
4351		SetTerminationTime_i_deserialize_fault,
4352		&response->fault,
4353		&response->fault_type);
4354	0	if(result != GLOBUS_SUCCESS)
4355		{
4356	0	if(response->result != GLOBUS_SUCCESS)
4357		{
4358	0	result = response->result;
4359		}
4360	0	goto error_exit;
4361		}
4362
4363	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT)
4364		{
4365	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
4366	0	subelement.local = "SetTerminationTimeResponse";
4367
4368	0	result = wsrl_SetTerminationTimeResponseType_deserialize_pointer(
4369		&subelement,
4370		&response->SetTerminationTimeResponse,
4371		response->client_handle->message,
4372		0);
4373	0	if(result != GLOBUS_SUCCESS)
4374		{
4375	0	goto error_exit;
4376		}
4377		}
4378		else
4379		{
4380	0	if(soap_fault)
4381		{
4382	0	response->fault_result = GlobusSoapMessageErrorFault(
4383		soap_fault);
4384		}
4385
4386	0	result = globus_soap_message_deserialize_fault_end(
4387		response->client_handle->message,
4388		response->fault
4389		? response->fault->element
4390		: &soap_fault_qname);
4391	0	if(result != GLOBUS_SUCCESS)
4392		{
4393	0	goto error_exit;
4394		}
4395		}
4396
4397	0	result = globus_soap_message_deserialize_body_end(
4398		response->client_handle->message);
4399	0	if(result != GLOBUS_SUCCESS)
4400		{
4401	0	goto error_exit;
4402		}
4403
4404	0	result = globus_soap_message_deserialize_envelope_end(
4405		response->client_handle->message);
4406	0	if(result != GLOBUS_SUCCESS)
4407		{
4408	0	goto error_exit;
4409		}
4410
4411
4412	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT)
4413		{
4414	0	result = globus_soap_message_get_handler_chain(
4415		response->client_handle->message, &chain);
4416	0	if(result != GLOBUS_SUCCESS)
4417		{
4418	0	goto error_exit;
4419		}
4420
4421	0	if(chain)
4422		{
4423	0	globus_handler_chain_register_invoke(
4424		chain,
4425		GLOBUS_HANDLER_TYPE_RESPONSE,
4426		response->client_handle->message,
4427		SetTerminationTime_i_response_done_callback,
4428		response);
4429		}
4430		}
4431		else
4432		{
4433	0	globus_mutex_lock(&response->mutex);
4434	0	response->done = 1;
4435	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE;
4436	0	globus_mutex_unlock(&response->mutex);
4437	0	globus_callback_register_oneshot(
4438		NULL,
4439		&globus_i_reltime_zero,
4440		SetTerminationTime_i_response_callback,
4441		(void *)response);
4442		}
4443		}
4444
4445	0	break;
4446
4447		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS:
4448
4449	0	if(response->done)
4450		{
4451	0	if(response->result != GLOBUS_SUCCESS)
4452		{
4453	0	result = response->result;
4454	0	goto error_exit;
4455		}
4456
4457	0	result = globus_soap_message_check_required_headers(
4458		response->client_handle->message);
4459	0	if(result != GLOBUS_SUCCESS)
4460		{
4461		/* continue on in case fault was returned and
4462		* no header elements exist
4463		*/
4464	0	response->result = result;
4465		}
4466		}
4467
4468		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE:
4469
4470	0	if(response->done)
4471		{
4472	0	if(response->result != GLOBUS_SUCCESS)
4473		{
4474	0	result = response->result;
4475	0	goto error_exit;
4476		}
4477
4478	0	globus_mutex_lock(&response->mutex);
4479	0	response->done = 0;
4480	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE;
4481	0	globus_mutex_unlock(&response->mutex);
4482
4483	0	result = globus_soap_message_register_close(
4484		response->client_handle->message,
4485		SetTerminationTime_i_response_done_callback,
4486		response);
4487	0	if(result != GLOBUS_SUCCESS)
4488		{
4489	0	goto error_exit;
4490		}
4491		}
4492
4493	0	break;
4494
4495		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE:
4496
4497
4498	0	if(response->done)
4499		{
4500	0	if(response->result != GLOBUS_SUCCESS)
4501		{
4502	0	result = response->result;
4503	0	goto error_exit;
4504		}
4505
4506	0	globus_mutex_lock(&response->mutex);
4507	0	response->done = 0;
4508	0	message_handle = response->client_handle->message;
4509	0	response->client_handle->message = NULL;
4510	0	globus_mutex_unlock(&response->mutex);
4511
4512	0	response->callback(
4513		response->client_handle,
4514		response->args,
4515		response->fault_result,
4516		response->SetTerminationTimeResponse,
4517		response->fault_type,
4518		response->fault);
4519
4520	0	if(response->SetTerminationTimeResponse)
4521		{
4522	0	wsrl_SetTerminationTimeResponseType_destroy(response->SetTerminationTimeResponse);
4523		}
4524
4525	0	if(response->fault)
4526		{
4527	0	xsd_any_destroy(response->fault);
4528	0	response->fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT;
4529	0	response->fault = NULL;
4530		}
4531
4532	0	globus_soap_message_handle_destroy(message_handle);
4533	0	SetTerminationTime_i_response_handle_destroy(response);
4534		}
4535
4536	0	break;
4537
4538		default:
4539
4540	0	globus_assert_string(NULL, "Unknown response state");
4541		}
4542
4543	0	return;
4544
4545		error_exit:
4546
4547	0	if(!GlobusSoapMessageStatusCheck(result))
4548		{
4549	0	result = GlobusSoapMessageErrorClientResponseFailed(
4550		result, "SubscriptionManager_SetTerminationTime");
4551		}
4552
4553	0	globus_mutex_lock(&response->mutex);
4554	0	message_handle = response->client_handle->message;
4555	0	response->client_handle->message = NULL;
4556	0	globus_mutex_unlock(&response->mutex);
4557
4558	0	response->callback(
4559		response->client_handle,
4560		response->args,
4561		result,
4562		response->SetTerminationTimeResponse,
4563		response->fault_type,
4564		response->fault);
4565
4566	0	if(response->SetTerminationTimeResponse)
4567		{
4568	0	wsrl_SetTerminationTimeResponseType_destroy(response->SetTerminationTimeResponse);
4569		}
4570
4571	0	if(response->fault)
4572		{
4573	0	xsd_any_destroy(response->fault);
4574
4575	0	response->fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT;
4576	0	response->fault = NULL;
4577		}
4578
4579	0	globus_soap_message_handle_destroy(message_handle);
4580	0	SetTerminationTime_i_response_handle_destroy(response);
4581		}
4582
4583		globus_result_t
4584		SubscriptionManager_SetTerminationTime_register_response(
4585		SubscriptionManagerService_client_handle_t client_handle,
4586		SubscriptionManager_SetTerminationTime_response_callback_func_t callback,
4587		void * user_args)
4588	0	{
4589	0	globus_result_t result = GLOBUS_SUCCESS;
4590	0	SetTerminationTime_i_response_handle_t * response;
4591
4592	0	response = globus_malloc(
4593		sizeof(SetTerminationTime_i_response_handle_t));
4594	0	globus_assert_string(response, "Memory allocation failed.");
4595	0	memset(response, 0, sizeof(SetTerminationTime_i_response_handle_t));
4596
4597	0	response->callback = callback;
4598	0	response->args = user_args;
4599	0	response->client_handle = client_handle;
4600	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT;
4601	0	globus_mutex_init(&response->mutex, NULL);
4602
4603	0	result = globus_soap_message_handle_set_attr(
4604		client_handle->message,
4605		WSADDR_ACTION_RESPONSE_KEY,
4606		globus_soap_message_attr_copy_string,
4607		globus_libc_free,
4608		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime/SetTerminationTimeResponse");
4609	0	if(result != GLOBUS_SUCCESS)
4610		{
4611	0	if(!GlobusSoapMessageStatusCheck(result))
4612		{
4613	0	result = GlobusSoapMessageErrorClientRequestFailed(
4614		result, "SubscriptionManager_SetTerminationTime");
4615	0	goto exit;
4616		}
4617		}
4618
4619	0	result = globus_callback_register_oneshot(
4620		&response->callback_handle,
4621		NULL,
4622		SetTerminationTime_i_response_callback,
4623		response);
4624	0	if(result != GLOBUS_SUCCESS)
4625		{
4626	0	result = GlobusSoapMessageErrorClientResponseFailed(
4627		result, "SubscriptionManager_SetTerminationTime");
4628	0	goto exit;
4629		}
4630
4631	0	return result;
4632
4633		exit:
4634	0	globus_mutex_destroy(&response->mutex);
4635	0	globus_free(response);
4636	0	return result;
4637		}
4638
4639		globus_result_t
4640		SubscriptionManager_SetTerminationTime_epr_register(
4641		SubscriptionManagerService_client_handle_t handle,
4642		const wsa_EndpointReferenceType * epr,
4643		const wsrl_SetTerminationTimeType * SetTerminationTime,
4644		SubscriptionManager_SetTerminationTime_response_callback_func_t callback,
4645		void * user_args)
4646	0	{
4647	0	globus_result_t result = GLOBUS_SUCCESS;
4648
4649	0	globus_assert_string(epr, "NULL EndpointReference");
4650	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
4651
4652	0	globus_soap_message_attr_set(
4653		handle->attrs,
4654		WSADDR_EPR_KEY,
4655		wsa_EndpointReferenceType_copy_wrapper,
4656		wsa_EndpointReferenceType_destroy_wrapper,
4657		(void *)epr);
4658
4659	0	result = SubscriptionManager_SetTerminationTime_register(
4660		handle,
4661		epr->Address.base_value,
4662		SetTerminationTime,
4663		callback,
4664		user_args);
4665
4666	0	return result;
4667		}
4668
4669		globus_result_t
4670		SubscriptionManager_SetTerminationTime_register(
4671		SubscriptionManagerService_client_handle_t handle,
4672		const char * endpoint,
4673		const wsrl_SetTerminationTimeType * SetTerminationTime,
4674		SubscriptionManager_SetTerminationTime_response_callback_func_t callback,
4675		void * user_args)
4676	0	{
4677	0	SetTerminationTime_i_blocking_request_callback_t * callback_handle;
4678	0	globus_result_t result = GLOBUS_SUCCESS;
4679
4680	0	callback_handle = globus_malloc(
4681		sizeof(SetTerminationTime_i_blocking_request_callback_t));
4682	0	globus_assert_string(callback_handle, "Memory allocation failed");
4683	0	memset(callback_handle, 0,
4684		sizeof(SetTerminationTime_i_blocking_request_callback_t));
4685
4686	0	callback_handle->callback = callback;
4687	0	callback_handle->args = user_args;
4688
4689	0	result = SubscriptionManager_SetTerminationTime_register_request(
4690		handle,
4691		endpoint,
4692		SetTerminationTime,
4693		SetTerminationTime_i_blocking_request_callback,
4694		callback_handle);
4695	0	if(result != GLOBUS_SUCCESS)
4696		{
4697	0	globus_free(callback_handle);
4698		goto exit;
4699		}
4700
4701		exit:
4702
4703	0	return result;
4704		}
4705
4706		typedef struct SetTerminationTime_i_blocking_response_callback_s
4707		{
4708		globus_result_t result;
4709		SubscriptionManager_SetTerminationTime_fault_t fault_type;
4710		xsd_any * fault;
4711		wsrl_SetTerminationTimeResponseType * SetTerminationTimeResponse;
4712		int done;
4713		globus_cond_t cond;
4714		globus_mutex_t mutex;
4715		} SetTerminationTime_i_blocking_response_callback_t;
4716
4717		static
4718		void
4719		SetTerminationTime_i_blocking_response_callback(
4720		SubscriptionManagerService_client_handle_t handle,
4721		void * user_args,
4722		globus_result_t result,
4723		const wsrl_SetTerminationTimeResponseType * SetTerminationTimeResponse,
4724		SubscriptionManager_SetTerminationTime_fault_t fault_type,
4725		const xsd_any * fault)
4726	0	{
4727	0	SetTerminationTime_i_blocking_response_callback_t * callback_handle;
4728
4729	0	callback_handle = (SetTerminationTime_i_blocking_response_callback_t *) user_args;
4730
4731	0	callback_handle->result = result;
4732	0	if(result == GLOBUS_SUCCESS)
4733		{
4734	0	wsrl_SetTerminationTimeResponseType_copy(
4735		&callback_handle->SetTerminationTimeResponse, SetTerminationTimeResponse);
4736		}
4737		else
4738		{
4739	0	callback_handle->fault_type = fault_type;
4740	0	if(fault_type != GLOBUS_SUCCESS)
4741		{
4742	0	xsd_any_copy(&callback_handle->fault, fault);
4743		}
4744		}
4745
4746	0	globus_mutex_lock(&callback_handle->mutex);
4747	0	globus_cond_signal(&callback_handle->cond);
4748	0	callback_handle->done = 1;
4749	0	globus_mutex_unlock(&callback_handle->mutex);
4750		}
4751
4752
4753		globus_result_t
4754		SubscriptionManager_SetTerminationTime_epr(
4755		SubscriptionManagerService_client_handle_t handle,
4756		const wsa_EndpointReferenceType * epr,
4757		const wsrl_SetTerminationTimeType * SetTerminationTime,
4758		wsrl_SetTerminationTimeResponseType * * SetTerminationTimeResponse,
4759		SubscriptionManager_SetTerminationTime_fault_t * fault_type,
4760		xsd_any * * fault)
4761	0	{
4762	0	globus_result_t result = GLOBUS_SUCCESS;
4763
4764	0	globus_assert_string(epr, "NULL EndpointReference");
4765	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
4766
4767	0	*fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT;
4768
4769	0	globus_soap_message_attr_set(
4770		handle->attrs,
4771		WSADDR_EPR_KEY,
4772		wsa_EndpointReferenceType_copy_wrapper,
4773		wsa_EndpointReferenceType_destroy_wrapper,
4774		(void *)epr);
4775
4776	0	result = SubscriptionManager_SetTerminationTime(
4777		handle,
4778		epr->Address.base_value,
4779		SetTerminationTime,
4780		SetTerminationTimeResponse,
4781		fault_type,
4782		fault);
4783
4784	0	return result;
4785		}
4786
4787		globus_result_t
4788		SubscriptionManager_SetTerminationTime(
4789		SubscriptionManagerService_client_handle_t handle,
4790		const char * endpoint,
4791		const wsrl_SetTerminationTimeType * SetTerminationTime,
4792		wsrl_SetTerminationTimeResponseType * * SetTerminationTimeResponse,
4793		SubscriptionManager_SetTerminationTime_fault_t * fault_type,
4794		xsd_any * * fault)
4795	0	{
4796	0	globus_result_t result = GLOBUS_SUCCESS;
4797
4798	0	SetTerminationTime_i_blocking_response_callback_t * callback_handle;
4799	0	*fault_type = SUBSCRIPTIONMANAGER_SETTERMINATIONTIME_NOFAULT;
4800
4801	0	callback_handle = globus_malloc(
4802		sizeof(SetTerminationTime_i_blocking_response_callback_t));
4803	0	globus_assert_string(callback_handle, "Memory allocation failed");
4804	0	memset(callback_handle, 0,
4805		sizeof(SetTerminationTime_i_blocking_response_callback_t));
4806
4807	0	globus_mutex_init(&callback_handle->mutex, NULL);
4808	0	globus_cond_init(&callback_handle->cond, NULL);
4809
4810	0	result = SubscriptionManager_SetTerminationTime_register(
4811		handle,
4812		endpoint,
4813		SetTerminationTime,
4814		SetTerminationTime_i_blocking_response_callback,
4815		callback_handle);
4816	0	if(result != GLOBUS_SUCCESS)
4817		{
4818	0	goto exit;
4819		}
4820
4821
4822	0	globus_mutex_lock(&callback_handle->mutex);
4823	0	while(!callback_handle->done)
4824		{
4825	0	globus_cond_wait(&callback_handle->cond, &callback_handle->mutex);
4826		}
4827	0	globus_mutex_unlock(&callback_handle->mutex);
4828
4829	0	result = callback_handle->result;
4830	0	if(result != GLOBUS_SUCCESS)
4831		{
4832
4833	0	*fault_type = callback_handle->fault_type;
4834	0	*fault = callback_handle->fault;
4835
4836	0	goto exit;
4837		}
4838
4839	0	*SetTerminationTimeResponse = callback_handle->SetTerminationTimeResponse;
4840
4841		exit:
4842
4843	0	globus_mutex_destroy(&callback_handle->mutex);
4844	0	globus_cond_destroy(&callback_handle->cond);
4845
4846	0	free(callback_handle);
4847
4848	0	return result;
4849		}
4850
4851
4852
4853		typedef struct Destroy_i_request_handle_s
4854		{
4855		char * endpoint;
4856		int done;
4857		globus_mutex_t mutex;
4858		SubscriptionManagerService_request_state_t state;
4859		SubscriptionManager_Destroy_request_callback_func_t callback;
4860		void * args;
4861		SubscriptionManagerService_client_handle_t client_handle;
4862		wsrl_DestroyType * Destroy;
4863		globus_callback_handle_t callback_handle;
4864		globus_result_t result;
4865		} Destroy_i_request_handle_t;
4866
4867		static void
4868		Destroy_i_request_callback(
4869		void * args);
4870
4871		static void
4872		Destroy_i_request_done_callback(
4873		globus_result_t result,
4874		void * args)
4875	0	{
4876	0	Destroy_i_request_handle_t * request;
4877
4878	0	request = (Destroy_i_request_handle_t *) args;
4879	0	globus_assert_string(request, "request handle in callback is NULL");
4880
4881	0	globus_mutex_lock(&request->mutex);
4882	0	request->result = result;
4883	0	request->done = 1;
4884	0	globus_mutex_unlock(&request->mutex);
4885
4886	0	Destroy_i_request_callback(request);
4887		}
4888
4889		static void
4890		Destroy_i_request_handle_destroy(
4891		void * args)
4892	0	{
4893	0	Destroy_i_request_handle_t * request;
4894
4895	0	request = (Destroy_i_request_handle_t *) args;
4896	0	globus_assert_string(request, "request handle in callback is NULL");
4897
4898	0	globus_mutex_destroy(&request->mutex);
4899
4900	0	if(request->Destroy)
4901		{
4902	0	wsrl_DestroyType_destroy(request->Destroy);
4903		}
4904	0	if(request->endpoint)
4905		{
4906	0	globus_free(request->endpoint);
4907		}
4908
4909	0	globus_free(request);
4910		}
4911
4912		static void
4913		Destroy_i_request_callback(
4914		void * args)
4915	0	{
4916	0	globus_soap_message_handle_t message_handle = NULL;
4917	0	globus_result_t result = GLOBUS_SUCCESS;
4918	0	globus_handler_chain_t chain = NULL;
4919	0	Destroy_i_request_handle_t * request;
4920	0	xsd_QName subelement;
4921
4922	0	request = (Destroy_i_request_handle_t *) args;
4923	0	globus_assert_string(request, "request handle is NULL");
4924
4925	0	switch(request->state)
4926		{
4927
4928		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT:
4929
4930	0	globus_mutex_lock(&request->mutex);
4931	0	request->done = 0;
4932	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS;
4933	0	globus_mutex_unlock(&request->mutex);
4934
4935	0	result = globus_soap_message_get_handler_chain(
4936		request->client_handle->message, &chain);
4937	0	if(result != GLOBUS_SUCCESS)
4938		{
4939	0	goto error_exit;
4940		}
4941
4942	0	if(chain)
4943		{
4944	0	globus_handler_chain_register_invoke(
4945		chain,
4946		GLOBUS_HANDLER_TYPE_REQUEST_INIT,
4947		request->client_handle->message,
4948		Destroy_i_request_done_callback,
4949		request);
4950		}
4951
4952	0	break;
4953
4954		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS:
4955
4956	0	globus_mutex_lock(&request->mutex);
4957	0	request->done = 0;
4958	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING;
4959	0	globus_mutex_unlock(&request->mutex);
4960
4961	0	result = globus_soap_message_register_open(
4962		request->client_handle->message,
4963		request->endpoint,
4964		Destroy_i_request_done_callback,
4965		request);
4966	0	if(result != GLOBUS_SUCCESS)
4967		{
4968	0	goto error_exit;
4969		}
4970
4971	0	break;
4972
4973		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING:
4974
4975	0	if(request->done)
4976		{
4977	0	if(request->result != GLOBUS_SUCCESS)
4978		{
4979	0	result = request->result;
4980	0	goto error_exit;
4981		}
4982
4983	0	globus_mutex_lock(&request->mutex);
4984	0	request->done = 0;
4985	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS;
4986	0	globus_mutex_unlock(&request->mutex);
4987
4988	0	result = globus_soap_message_serialize_envelope(
4989		request->client_handle->message);
4990	0	if(result != GLOBUS_SUCCESS)
4991		{
4992	0	goto error_exit;
4993		}
4994
4995	0	result = globus_soap_message_serialize_header(
4996		request->client_handle->message);
4997	0	if(result != GLOBUS_SUCCESS)
4998		{
4999	0	goto error_exit;
5000		}
5001
5002	0	result = globus_soap_message_serialize_header_begin_close(
5003		request->client_handle->message);
5004	0	if(result != GLOBUS_SUCCESS)
5005		{
5006	0	goto error_exit;
5007		}
5008
5009	0	result = globus_soap_message_set_marker(
5010		request->client_handle->message,
5011		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
5012	0	if(result != GLOBUS_SUCCESS)
5013		{
5014	0	goto error_exit;
5015		}
5016
5017	0	result = globus_soap_message_serialize_header_end(
5018		request->client_handle->message);
5019	0	if(result != GLOBUS_SUCCESS)
5020		{
5021	0	goto error_exit;
5022		}
5023
5024	0	result = globus_soap_message_serialize_body(
5025		request->client_handle->message);
5026	0	if(result != GLOBUS_SUCCESS)
5027		{
5028	0	goto error_exit;
5029		}
5030
5031	0	result = globus_soap_message_serialize_body_begin_close(
5032		request->client_handle->message);
5033	0	if(result != GLOBUS_SUCCESS)
5034		{
5035	0	goto error_exit;
5036		}
5037
5038	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
5039	0	subelement.local = "Destroy";
5040
5041	0	result = wsrl_DestroyType_serialize(
5042		&subelement,
5043		request->Destroy,
5044		request->client_handle->message,
5045		0);
5046	0	if(result != GLOBUS_SUCCESS)
5047		{
5048	0	goto error_exit;
5049		}
5050
5051	0	result = globus_soap_message_serialize_body_end(
5052		request->client_handle->message);
5053	0	if(result != GLOBUS_SUCCESS)
5054		{
5055	0	goto error_exit;
5056		}
5057
5058	0	result = globus_soap_message_serialize_envelope_end(
5059		request->client_handle->message);
5060	0	if(result != GLOBUS_SUCCESS)
5061		{
5062	0	goto error_exit;
5063		}
5064
5065	0	result = globus_soap_message_set_write_position_to_marker(
5066		request->client_handle->message,
5067		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
5068	0	if(result != GLOBUS_SUCCESS)
5069		{
5070	0	goto error_exit;
5071		}
5072
5073	0	result = globus_soap_message_get_handler_chain(
5074		request->client_handle->message, &chain);
5075	0	if(result != GLOBUS_SUCCESS)
5076		{
5077	0	goto error_exit;
5078		}
5079
5080	0	if(chain)
5081		{
5082	0	globus_handler_chain_register_invoke(
5083		chain,
5084		GLOBUS_HANDLER_TYPE_REQUEST,
5085		request->client_handle->message,
5086		Destroy_i_request_done_callback,
5087		request);
5088		}
5089		}
5090
5091	0	break;
5092
5093		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS:
5094
5095	0	if(request->done)
5096		{
5097	0	if(request->result != GLOBUS_SUCCESS)
5098		{
5099	0	result = request->result;
5100	0	goto error_exit;
5101		}
5102
5103	0	globus_mutex_lock(&request->mutex);
5104	0	request->done = 0;
5105	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING;
5106	0	globus_mutex_unlock(&request->mutex);
5107
5108	0	result = globus_soap_message_register_write_request(
5109		request->client_handle->message,
5110		Destroy_i_request_done_callback,
5111		request,
5112
5113		GLOBUS_TRUE);
5114
5115	0	if(result != GLOBUS_SUCCESS)
5116		{
5117	0	goto error_exit;
5118		}
5119		}
5120
5121	0	break;
5122
5123		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING:
5124
5125	0	if(request->done)
5126		{
5127	0	if(request->result != GLOBUS_SUCCESS)
5128		{
5129	0	result = request->result;
5130	0	goto error_exit;
5131		}
5132
5133	0	globus_mutex_lock(&request->mutex);
5134	0	request->done = 0;
5135	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS;
5136	0	globus_mutex_unlock(&request->mutex);
5137
5138	0	result = globus_soap_message_get_handler_chain(
5139		request->client_handle->message, &chain);
5140	0	if(result != GLOBUS_SUCCESS)
5141		{
5142	0	goto error_exit;
5143		}
5144
5145	0	if(chain)
5146		{
5147	0	globus_handler_chain_register_invoke(
5148		chain,
5149		GLOBUS_HANDLER_TYPE_REQUEST_DESTROY,
5150		request->client_handle->message,
5151		Destroy_i_request_done_callback,
5152		request);
5153		}
5154		}
5155
5156	0	break;
5157
5158		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS:
5159
5160	0	if(request->done)
5161		{
5162	0	if(request->result != GLOBUS_SUCCESS)
5163		{
5164	0	result = request->result;
5165	0	goto error_exit;
5166		}
5167
5168	0	globus_mutex_lock(&request->mutex);
5169	0	request->done = 0;
5170	0	globus_mutex_unlock(&request->mutex);
5171
5172	0	request->callback(
5173		request->client_handle,
5174		request->args, GLOBUS_SUCCESS);
5175
5176	0	Destroy_i_request_handle_destroy(request);
5177		}
5178
5179	0	break;
5180
5181		default:
5182
5183	0	globus_assert_string(NULL, "Unkown request state");
5184	0	break;
5185		}
5186
5187	0	return;
5188
5189		error_exit:
5190
5191	0	result = GlobusSoapMessageErrorClientRequestFailed(
5192		result, "SubscriptionManager_Destroy");
5193
5194	0	globus_mutex_lock(&request->mutex);
5195	0	message_handle = request->client_handle->message;
5196	0	request->client_handle->message = NULL;
5197	0	globus_mutex_unlock(&request->mutex);
5198
5199	0	request->callback(request->client_handle, request->args, result);
5200
5201	0	globus_soap_message_handle_destroy(message_handle);
5202	0	Destroy_i_request_handle_destroy(request);
5203		}
5204
5205		globus_result_t
5206		SubscriptionManager_Destroy_epr_register_request(
5207		SubscriptionManagerService_client_handle_t client_handle,
5208		const wsa_EndpointReferenceType * epr,
5209		const wsrl_DestroyType * Destroy,
5210		SubscriptionManager_Destroy_request_callback_func_t callback,
5211		void * user_args)
5212	0	{
5213	0	globus_result_t result = GLOBUS_SUCCESS;
5214
5215	0	globus_assert_string(epr, "NULL EndpointReference");
5216	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
5217
5218	0	globus_soap_message_attr_set(
5219		client_handle->attrs,
5220		WSADDR_EPR_KEY,
5221		wsa_EndpointReferenceType_copy_wrapper,
5222		wsa_EndpointReferenceType_destroy_wrapper,
5223		(void *)epr);
5224
5225	0	result = SubscriptionManager_Destroy_register_request(
5226		client_handle,
5227		epr->Address.base_value,
5228		Destroy,
5229		callback,
5230		user_args);
5231
5232	0	return result;
5233		}
5234
5235		globus_result_t
5236		SubscriptionManager_Destroy_register_request(
5237		SubscriptionManagerService_client_handle_t client_handle,
5238		const char * endpoint,
5239		const wsrl_DestroyType * Destroy,
5240		SubscriptionManager_Destroy_request_callback_func_t callback,
5241		void * user_args)
5242	0	{
5243	0	globus_handler_chain_t chain = NULL;
5244	0	globus_result_t result = GLOBUS_SUCCESS;
5245	0	Destroy_i_request_handle_t * request = NULL;
5246
5247	0	if(client_handle->message != NULL)
5248		{
5249	0	result = GlobusSoapMessageErrorClientAlreadyInvoked();
5250	0	goto exit;
5251		}
5252
5253	0	result = globus_soap_message_handle_init(&client_handle->message, NULL);
5254	0	if(result != GLOBUS_SUCCESS)
5255		{
5256	0	result = GlobusSoapMessageErrorFailedClientInit(
5257		result, "SubscriptionManager_Destroy");
5258	0	goto error_exit;
5259		}
5260
5261	0	globus_soap_message_handle_set_registry(
5262		client_handle->message, SubscriptionManagerService_l_registry);
5263
5264	0	chain = client_handle->handler_chain;
5265	0	if(!chain)
5266		{
5267	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
5268	0	if(result != GLOBUS_SUCCESS)
5269		{
5270	0	result = GlobusSoapMessageErrorFailedClientInit(
5271		result, "SubscriptionManager_Destroy");
5272	0	goto exit;
5273		}
5274
5275	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
5276	0	globus_list_insert(
5277		&SubscriptionManagerService_l_extensions,
5278		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
5279	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
5280
5281	0	globus_handler_chain_init(&chain);
5282	0	result = globus_handler_chain_push(
5283		chain,
5284		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
5285		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
5286	0	if(result != GLOBUS_SUCCESS)
5287		{
5288	0	result = GlobusSoapMessageErrorFailedClientInit(
5289		result, "SubscriptionManager_Destroy");
5290	0	goto error_exit;
5291		}
5292
5293	0	result = globus_handler_chain_push(
5294		chain,
5295		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
5296		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
5297	0	if(result != GLOBUS_SUCCESS)
5298		{
5299	0	result = GlobusSoapMessageErrorFailedClientInit(
5300		result, "SubscriptionManager_Destroy");
5301	0	goto error_exit;
5302		}
5303		}
5304
5305	0	globus_soap_message_set_handler_chain(
5306		client_handle->message, chain);
5307
5308	0	request = globus_malloc(sizeof(Destroy_i_request_handle_t));
5309	0	globus_assert_string(request, "Memory allocation failed.");
5310	0	memset(request, 0, sizeof(Destroy_i_request_handle_t));
5311
5312	0	if(!endpoint)
5313		{
5314	0	endpoint = (char *)globus_soap_message_attr_get(
5315		client_handle->attrs, GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY);
5316	0	if(!endpoint)
5317		{
5318	0	wsa_EndpointReferenceType * epr;
5319	0	epr = (wsa_EndpointReferenceType *)
5320		globus_soap_message_attr_get(
5321		client_handle->attrs, WSADDR_EPR_KEY);
5322	0	if(epr && epr->Address.base_value)
5323		{
5324	0	endpoint = epr->Address.base_value;
5325		}
5326		}
5327		}
5328
5329	0	globus_assert_string(endpoint, "NULL endpoint");
5330
5331	0	request->endpoint = globus_libc_strdup(endpoint);
5332	0	request->callback = callback;
5333	0	request->args = user_args;
5334	0	request->client_handle = client_handle;
5335	0	wsrl_DestroyType_copy(&request->Destroy, Destroy);
5336	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT;
5337	0	globus_mutex_init(&request->mutex, NULL);
5338
5339	0	result = globus_soap_message_attr_set(
5340		client_handle->attrs,
5341		WSADDR_DESTINATION_KEY,
5342		globus_soap_message_attr_copy_string,
5343		globus_libc_free,
5344		(void *)endpoint);
5345	0	if(result != GLOBUS_SUCCESS)
5346		{
5347	0	result = GlobusSoapMessageErrorClientRequestFailed(
5348		result, "SubscriptionManager_Destroy");
5349	0	goto error_exit;
5350		}
5351
5352	0	result = globus_soap_message_attr_set(
5353		client_handle->attrs,
5354		WSADDR_ACTION_REQUEST_KEY,
5355		NULL,
5356		NULL,
5357		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime/Destroy");
5358	0	if(result != GLOBUS_SUCCESS)
5359		{
5360	0	result = GlobusSoapMessageErrorClientRequestFailed(
5361		result, "SubscriptionManager_Destroy");
5362	0	goto error_exit;
5363		}
5364
5365	0	result = globus_soap_message_attr_set(
5366		client_handle->attrs,
5367		GLOBUS_SOAP_MESSAGE_SOAP_ACTION_KEY,
5368		NULL,
5369		NULL,
5370		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime/Destroy");
5371	0	if(result != GLOBUS_SUCCESS)
5372		{
5373	0	result = GlobusSoapMessageErrorClientRequestFailed(
5374		result, "SubscriptionManager_Destroy");
5375	0	goto error_exit;
5376		}
5377
5378	0	result = globus_soap_message_handle_set_attrs(
5379		client_handle->message, client_handle->attrs);
5380	0	if(result != GLOBUS_SUCCESS)
5381		{
5382	0	result = GlobusSoapMessageErrorClientRequestFailed(
5383		result, "SubscriptionManager_Destroy");
5384		}
5385
5386	0	result = globus_callback_register_oneshot(
5387		&request->callback_handle,
5388		NULL,
5389		Destroy_i_request_callback,
5390		request);
5391	0	if(result != GLOBUS_SUCCESS)
5392		{
5393	0	result = GlobusSoapMessageErrorClientRequestFailed(
5394		result, "SubscriptionManager_Destroy");
5395		goto error_exit;
5396		}
5397
5398	0	goto exit;
5399
5400		error_exit:
5401
5402	0	if(request)
5403		{
5404	0	globus_mutex_destroy(&request->mutex);
5405
5406	0	if(request->Destroy)
5407		{
5408	0	wsrl_DestroyType_destroy(request->Destroy);
5409		}
5410	0	if(request->endpoint)
5411		{
5412	0	globus_free(request->endpoint);
5413		}
5414
5415	0	globus_free(request);
5416		}
5417
5418	0	if(client_handle->message)
5419		{
5420	0	globus_soap_message_handle_destroy(client_handle->message);
5421	0	client_handle->message = NULL;
5422		}
5423
5424		exit:
5425
5426	0	return result;
5427		}
5428
5429		typedef struct Destroy_i_blocking_request_callback_s
5430		{
5431
5432		SubscriptionManager_Destroy_response_callback_func_t callback;
5433		void * args;
5434
5435		} Destroy_i_blocking_request_callback_t;
5436
5437		static
5438		void
5439		Destroy_i_blocking_request_callback(
5440		SubscriptionManagerService_client_handle_t handle,
5441		void * user_args,
5442		globus_result_t error)
5443	0	{
5444	0	globus_soap_message_handle_t message_handle = NULL;
5445	0	globus_result_t result = GLOBUS_SUCCESS;
5446	0	Destroy_i_blocking_request_callback_t * callback_handle;
5447
5448	0	callback_handle = (Destroy_i_blocking_request_callback_t *) user_args;
5449	0	globus_assert_string(callback_handle, "callback_handle is NULL");
5450
5451
5452	0	if(error != GLOBUS_SUCCESS \|\|
5453		globus_soap_message_is_cancelled(handle->message))
5454		{
5455	0	message_handle = handle->message;
5456	0	handle->message = NULL;
5457
5458	0	callback_handle->callback(
5459		handle,
5460		callback_handle->args,
5461		error,
5462		NULL,
5463		SUBSCRIPTIONMANAGER_DESTROY_NOFAULT,
5464		NULL);
5465
5466	0	globus_soap_message_handle_destroy(message_handle);
5467		}
5468		else
5469		{
5470	0	result = SubscriptionManager_Destroy_register_response(
5471		handle,
5472		callback_handle->callback,
5473		callback_handle->args);
5474	0	if(result != GLOBUS_SUCCESS)
5475		{
5476	0	callback_handle->callback(
5477		handle,
5478		callback_handle->args,
5479		result,
5480		NULL,
5481		SUBSCRIPTIONMANAGER_DESTROY_NOFAULT,
5482		NULL);
5483		}
5484		}
5485
5486	0	free(callback_handle);
5487		}
5488
5489
5490
5491		typedef struct Destroy_i_response_handle_s
5492		{
5493		int done;
5494		globus_mutex_t mutex;
5495		SubscriptionManagerService_response_state_t state;
5496		SubscriptionManager_Destroy_response_callback_func_t callback;
5497		void * args;
5498		SubscriptionManagerService_client_handle_t client_handle;
5499		wsrl_DestroyResponseType * DestroyResponse;
5500		globus_callback_handle_t callback_handle;
5501		globus_result_t result;
5502		globus_result_t fault_result;
5503		int fault_type;
5504		xsd_any * fault;
5505		} Destroy_i_response_handle_t;
5506
5507		static void
5508		Destroy_i_response_callback(
5509		void * args);
5510
5511		static void
5512		Destroy_i_response_done_callback(
5513		globus_result_t result,
5514		void * args)
5515	0	{
5516	0	Destroy_i_response_handle_t * response;
5517
5518	0	response = (Destroy_i_response_handle_t *) args;
5519	0	globus_assert_string(response, "response handle in callback is NULL");
5520
5521	0	globus_mutex_lock(&response->mutex);
5522	0	response->result = result;
5523	0	response->done = 1;
5524	0	globus_mutex_unlock(&response->mutex);
5525
5526	0	Destroy_i_response_callback(response);
5527		}
5528
5529		static void
5530		Destroy_i_response_handle_destroy(
5531		void * args)
5532	0	{
5533	0	Destroy_i_response_handle_t * response;
5534
5535	0	response = (Destroy_i_response_handle_t *) args;
5536	0	globus_assert_string(response, "response handle in callback is NULL");
5537
5538	0	globus_mutex_destroy(&response->mutex);
5539
5540	0	free(response);
5541		}
5542
5543		static void
5544		Destroy_i_deserialize_fault(
5545		globus_soap_message_handle_t handle,
5546		const xsd_QName * fault_qname,
5547		int * fault_type,
5548		void * args)
5549	0	{
5550	0	*fault_type = SUBSCRIPTIONMANAGER_DESTROY_NOFAULT;
5551
5552	0	if(fault_qname)
5553		{
5554	0	if(fault_qname == (&wsrl_ResourceUnknownFaultType_qname) \|\|
5555		fault_qname == (&wsrl_ResourceUnknownFault_qname))
5556		{
5557	0	*fault_type = SUBSCRIPTIONMANAGER_DESTROY_RESOURCEUNKNOWNFAULT;
5558		}
5559	0	else if(fault_qname == (&wsrl_ResourceNotDestroyedFaultType_qname) \|\|
5560		fault_qname == (&wsrl_ResourceNotDestroyedFault_qname))
5561		{
5562	0	*fault_type = SUBSCRIPTIONMANAGER_DESTROY_RESOURCENOTDESTROYEDFAULT;
5563		}
5564		else
5565		{
5566	0	*fault_type = SUBSCRIPTIONMANAGER_DESTROY_UNKNOWN_FAULT;
5567		}
5568		}
5569		}
5570
5571		static void
5572		Destroy_i_response_callback(
5573		void * args)
5574	0	{
5575	0	xsd_QName subelement;
5576	0	globus_soap_message_handle_t message_handle = NULL;
5577	0	globus_soap_message_fault_t soap_fault;
5578	0	globus_result_t result = GLOBUS_SUCCESS;
5579	0	globus_handler_chain_t chain = NULL;
5580	0	xsd_QName * header_element = NULL;
5581	0	int must;
5582	0	Destroy_i_response_handle_t * response;
5583	0	response = (Destroy_i_response_handle_t *) args;
5584	0	globus_assert_string(response, "response handle in callback is NULL");
5585
5586	0	switch(response->state)
5587		{
5588
5589		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT:
5590
5591	0	globus_mutex_lock(&response->mutex);
5592	0	response->done = 0;
5593	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING;
5594	0	globus_mutex_unlock(&response->mutex);
5595
5596	0	result = globus_soap_message_register_read_response(
5597		response->client_handle->message,
5598		Destroy_i_response_done_callback,
5599		response);
5600	0	if(result != GLOBUS_SUCCESS)
5601		{
5602	0	goto error_exit;
5603		}
5604
5605	0	break;
5606
5607		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING:
5608
5609	0	if(response->done)
5610		{
5611	0	if(response->result != GLOBUS_SUCCESS)
5612		{
5613	0	if(GlobusSoapMessageErrorCheckFailedResponse(response->result) \|\|
5614		GlobusSoapMessageErrorCheckBadRequest(response->result))
5615		{
5616	0	response->result = GLOBUS_SUCCESS;
5617		}
5618		else
5619		{
5620	0	result = response->result;
5621	0	goto error_exit;
5622		}
5623		}
5624
5625	0	globus_mutex_lock(&response->mutex);
5626	0	response->done = 0;
5627	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
5628	0	globus_mutex_unlock(&response->mutex);
5629
5630	0	result = globus_soap_message_deserialize_envelope(
5631		response->client_handle->message);
5632	0	if(result != GLOBUS_SUCCESS)
5633		{
5634	0	goto error_exit;
5635		}
5636
5637	0	result = globus_soap_message_deserialize_element_begin_close(
5638		response->client_handle->message);
5639	0	if(result != GLOBUS_SUCCESS)
5640		{
5641	0	goto error_exit;
5642		}
5643
5644	0	result = globus_soap_message_deserialize_header(
5645		response->client_handle->message);
5646	0	if(result != GLOBUS_SUCCESS)
5647		{
5648	0	if(GlobusSoapMessageStatusElementNotFoundCheck(result))
5649		{
5650	0	globus_soap_message_deserialize_push_element(
5651		response->client_handle->message);
5652	0	result = GLOBUS_SUCCESS;
5653	0	globus_mutex_lock(&response->mutex);
5654	0	response->state =
5655		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED;
5656	0	globus_mutex_unlock(&response->mutex);
5657	0	Destroy_i_response_done_callback(
5658		result, response);
5659	0	break;
5660		}
5661
5662	0	goto error_exit;
5663		}
5664
5665	0	globus_mutex_lock(&response->mutex);
5666	0	response->done = 1;
5667	0	globus_mutex_unlock(&response->mutex);
5668		}
5669
5670		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS:
5671
5672	0	if(response->done)
5673		{
5674	0	if(response->result != GLOBUS_SUCCESS)
5675		{
5676	0	if(GlobusSoapMessageErrorCheckFailedResponse(
5677		response->result) \|\|
5678		GlobusSoapMessageErrorCheckBadRequest(response->result))
5679		{
5680	0	response->result = GLOBUS_SUCCESS;
5681		}
5682		else
5683		{
5684	0	result = response->result;
5685	0	goto error_exit;
5686		}
5687		}
5688
5689	0	globus_mutex_lock(&response->mutex);
5690	0	response->done = 0;
5691	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
5692	0	globus_mutex_unlock(&response->mutex);
5693
5694	0	xsd_QName_init(&header_element);
5695
5696	0	result = globus_soap_message_deserialize_element_unknown(
5697		response->client_handle->message,
5698		header_element);
5699	0	if(result != GLOBUS_SUCCESS)
5700		{
5701	0	if(!GlobusSoapMessageStatusFailedElementCheck(result))
5702		{
5703	0	xsd_QName_destroy(header_element);
5704	0	goto error_exit;
5705		}
5706		else
5707		{
5708	0	globus_mutex_lock(&response->mutex);
5709	0	response->done = 1;
5710	0	response->state =
5711		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE;
5712	0	globus_mutex_unlock(&response->mutex);
5713
5714	0	globus_callback_register_oneshot(
5715		NULL,
5716		&globus_i_reltime_zero,
5717		Destroy_i_response_callback,
5718		(void *)response);
5719	0	xsd_QName_destroy(header_element);
5720	0	break;
5721		}
5722		}
5723
5724	0	result = globus_soap_message_deserialize_int_attribute(
5725		response->client_handle->message,
5726		&soap_mustUnderstand_qname,
5727		&must);
5728	0	if(result == GLOBUS_SUCCESS && (must == 1))
5729		{
5730	0	globus_soap_message_add_required_header_element(
5731		response->client_handle->message,
5732		header_element);
5733		}
5734	0	else if(result != GLOBUS_SUCCESS &&
5735		!GlobusSoapMessageStatusAttributeNotFoundCheck(result))
5736		{
5737	0	xsd_QName_destroy(header_element);
5738	0	goto error_exit;
5739		}
5740
5741	0	globus_soap_message_deserialize_push_element(
5742		response->client_handle->message);
5743
5744	0	result = globus_soap_message_get_handler_chain(
5745		response->client_handle->message, &chain);
5746	0	if(result != GLOBUS_SUCCESS)
5747		{
5748	0	goto error_exit;
5749		}
5750
5751	0	if(chain)
5752		{
5753	0	result = globus_handler_chain_register_trigger(
5754		chain,
5755		response->client_handle->message,
5756		header_element,
5757		Destroy_i_response_done_callback,
5758		response);
5759	0	if(result == GLOBUS_SUCCESS)
5760		{
5761	0	xsd_QName_destroy(header_element);
5762	0	break;
5763		}
5764	0	else if(!GlobusHandlerStatusNotTriggeredCheck(result))
5765		{
5766	0	xsd_QName_destroy(header_element);
5767	0	goto error_exit;
5768		}
5769		}
5770
5771	0	xsd_QName_destroy(header_element);
5772	0	result = globus_soap_message_deserialize_skip(
5773		response->client_handle->message);
5774	0	if(result != GLOBUS_SUCCESS)
5775		{
5776	0	goto error_exit;
5777		}
5778
5779	0	globus_mutex_lock(&response->mutex);
5780	0	response->done = 1;
5781	0	globus_mutex_unlock(&response->mutex);
5782	0	globus_callback_register_oneshot(
5783		NULL,
5784		&globus_i_reltime_zero,
5785		Destroy_i_response_callback,
5786		(void *)response);
5787		}
5788
5789	0	break;
5790
5791		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE:
5792
5793	0	if(response->done)
5794		{
5795	0	if(response->result != GLOBUS_SUCCESS)
5796		{
5797	0	result = response->result;
5798	0	goto error_exit;
5799		}
5800
5801	0	globus_mutex_lock(&response->mutex);
5802	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
5803	0	globus_mutex_unlock(&response->mutex);
5804
5805	0	result = globus_soap_message_deserialize_header_end(
5806		response->client_handle->message);
5807	0	if(result != GLOBUS_SUCCESS)
5808		{
5809	0	goto error_exit;
5810		}
5811
5812	0	result = globus_soap_message_deserialize_body(
5813		response->client_handle->message);
5814	0	if(result != GLOBUS_SUCCESS)
5815		{
5816	0	goto error_exit;
5817		}
5818		}
5819
5820		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED:
5821
5822	0	if(response->done)
5823		{
5824	0	if(response->result != GLOBUS_SUCCESS)
5825		{
5826	0	result = response->result;
5827	0	goto error_exit;
5828		}
5829
5830	0	globus_mutex_lock(&response->mutex);
5831	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
5832	0	globus_mutex_unlock(&response->mutex);
5833
5834	0	response->fault_type = SUBSCRIPTIONMANAGER_DESTROY_NOFAULT;
5835	0	response->fault_result = GLOBUS_SUCCESS;
5836
5837	0	result = globus_soap_message_deserialize_fault(
5838		response->client_handle->message,
5839		&soap_fault,
5840		Destroy_i_deserialize_fault,
5841		&response->fault,
5842		&response->fault_type);
5843	0	if(result != GLOBUS_SUCCESS)
5844		{
5845	0	if(response->result != GLOBUS_SUCCESS)
5846		{
5847	0	result = response->result;
5848		}
5849	0	goto error_exit;
5850		}
5851
5852	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_DESTROY_NOFAULT)
5853		{
5854	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
5855	0	subelement.local = "DestroyResponse";
5856
5857	0	result = wsrl_DestroyResponseType_deserialize_pointer(
5858		&subelement,
5859		&response->DestroyResponse,
5860		response->client_handle->message,
5861		0);
5862	0	if(result != GLOBUS_SUCCESS)
5863		{
5864	0	goto error_exit;
5865		}
5866		}
5867		else
5868		{
5869	0	if(soap_fault)
5870		{
5871	0	response->fault_result = GlobusSoapMessageErrorFault(
5872		soap_fault);
5873		}
5874
5875	0	result = globus_soap_message_deserialize_fault_end(
5876		response->client_handle->message,
5877		response->fault
5878		? response->fault->element
5879		: &soap_fault_qname);
5880	0	if(result != GLOBUS_SUCCESS)
5881		{
5882	0	goto error_exit;
5883		}
5884		}
5885
5886	0	result = globus_soap_message_deserialize_body_end(
5887		response->client_handle->message);
5888	0	if(result != GLOBUS_SUCCESS)
5889		{
5890	0	goto error_exit;
5891		}
5892
5893	0	result = globus_soap_message_deserialize_envelope_end(
5894		response->client_handle->message);
5895	0	if(result != GLOBUS_SUCCESS)
5896		{
5897	0	goto error_exit;
5898		}
5899
5900
5901	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_DESTROY_NOFAULT)
5902		{
5903	0	result = globus_soap_message_get_handler_chain(
5904		response->client_handle->message, &chain);
5905	0	if(result != GLOBUS_SUCCESS)
5906		{
5907	0	goto error_exit;
5908		}
5909
5910	0	if(chain)
5911		{
5912	0	globus_handler_chain_register_invoke(
5913		chain,
5914		GLOBUS_HANDLER_TYPE_RESPONSE,
5915		response->client_handle->message,
5916		Destroy_i_response_done_callback,
5917		response);
5918		}
5919		}
5920		else
5921		{
5922	0	globus_mutex_lock(&response->mutex);
5923	0	response->done = 1;
5924	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE;
5925	0	globus_mutex_unlock(&response->mutex);
5926	0	globus_callback_register_oneshot(
5927		NULL,
5928		&globus_i_reltime_zero,
5929		Destroy_i_response_callback,
5930		(void *)response);
5931		}
5932		}
5933
5934	0	break;
5935
5936		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS:
5937
5938	0	if(response->done)
5939		{
5940	0	if(response->result != GLOBUS_SUCCESS)
5941		{
5942	0	result = response->result;
5943	0	goto error_exit;
5944		}
5945
5946	0	result = globus_soap_message_check_required_headers(
5947		response->client_handle->message);
5948	0	if(result != GLOBUS_SUCCESS)
5949		{
5950		/* continue on in case fault was returned and
5951		* no header elements exist
5952		*/
5953	0	response->result = result;
5954		}
5955		}
5956
5957		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE:
5958
5959	0	if(response->done)
5960		{
5961	0	if(response->result != GLOBUS_SUCCESS)
5962		{
5963	0	result = response->result;
5964	0	goto error_exit;
5965		}
5966
5967	0	globus_mutex_lock(&response->mutex);
5968	0	response->done = 0;
5969	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE;
5970	0	globus_mutex_unlock(&response->mutex);
5971
5972	0	result = globus_soap_message_register_close(
5973		response->client_handle->message,
5974		Destroy_i_response_done_callback,
5975		response);
5976	0	if(result != GLOBUS_SUCCESS)
5977		{
5978	0	goto error_exit;
5979		}
5980		}
5981
5982	0	break;
5983
5984		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE:
5985
5986
5987	0	if(response->done)
5988		{
5989	0	if(response->result != GLOBUS_SUCCESS)
5990		{
5991	0	result = response->result;
5992	0	goto error_exit;
5993		}
5994
5995	0	globus_mutex_lock(&response->mutex);
5996	0	response->done = 0;
5997	0	message_handle = response->client_handle->message;
5998	0	response->client_handle->message = NULL;
5999	0	globus_mutex_unlock(&response->mutex);
6000
6001	0	response->callback(
6002		response->client_handle,
6003		response->args,
6004		response->fault_result,
6005		response->DestroyResponse,
6006		response->fault_type,
6007		response->fault);
6008
6009	0	if(response->DestroyResponse)
6010		{
6011	0	wsrl_DestroyResponseType_destroy(response->DestroyResponse);
6012		}
6013
6014	0	if(response->fault)
6015		{
6016	0	xsd_any_destroy(response->fault);
6017	0	response->fault_type = SUBSCRIPTIONMANAGER_DESTROY_NOFAULT;
6018	0	response->fault = NULL;
6019		}
6020
6021	0	globus_soap_message_handle_destroy(message_handle);
6022	0	Destroy_i_response_handle_destroy(response);
6023		}
6024
6025	0	break;
6026
6027		default:
6028
6029	0	globus_assert_string(NULL, "Unknown response state");
6030		}
6031
6032	0	return;
6033
6034		error_exit:
6035
6036	0	if(!GlobusSoapMessageStatusCheck(result))
6037		{
6038	0	result = GlobusSoapMessageErrorClientResponseFailed(
6039		result, "SubscriptionManager_Destroy");
6040		}
6041
6042	0	globus_mutex_lock(&response->mutex);
6043	0	message_handle = response->client_handle->message;
6044	0	response->client_handle->message = NULL;
6045	0	globus_mutex_unlock(&response->mutex);
6046
6047	0	response->callback(
6048		response->client_handle,
6049		response->args,
6050		result,
6051		response->DestroyResponse,
6052		response->fault_type,
6053		response->fault);
6054
6055	0	if(response->DestroyResponse)
6056		{
6057	0	wsrl_DestroyResponseType_destroy(response->DestroyResponse);
6058		}
6059
6060	0	if(response->fault)
6061		{
6062	0	xsd_any_destroy(response->fault);
6063
6064	0	response->fault_type = SUBSCRIPTIONMANAGER_DESTROY_NOFAULT;
6065	0	response->fault = NULL;
6066		}
6067
6068	0	globus_soap_message_handle_destroy(message_handle);
6069	0	Destroy_i_response_handle_destroy(response);
6070		}
6071
6072		globus_result_t
6073		SubscriptionManager_Destroy_register_response(
6074		SubscriptionManagerService_client_handle_t client_handle,
6075		SubscriptionManager_Destroy_response_callback_func_t callback,
6076		void * user_args)
6077	0	{
6078	0	globus_result_t result = GLOBUS_SUCCESS;
6079	0	Destroy_i_response_handle_t * response;
6080
6081	0	response = globus_malloc(
6082		sizeof(Destroy_i_response_handle_t));
6083	0	globus_assert_string(response, "Memory allocation failed.");
6084	0	memset(response, 0, sizeof(Destroy_i_response_handle_t));
6085
6086	0	response->callback = callback;
6087	0	response->args = user_args;
6088	0	response->client_handle = client_handle;
6089	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT;
6090	0	globus_mutex_init(&response->mutex, NULL);
6091
6092	0	result = globus_soap_message_handle_set_attr(
6093		client_handle->message,
6094		WSADDR_ACTION_RESPONSE_KEY,
6095		globus_soap_message_attr_copy_string,
6096		globus_libc_free,
6097		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime/DestroyResponse");
6098	0	if(result != GLOBUS_SUCCESS)
6099		{
6100	0	if(!GlobusSoapMessageStatusCheck(result))
6101		{
6102	0	result = GlobusSoapMessageErrorClientRequestFailed(
6103		result, "SubscriptionManager_Destroy");
6104	0	goto exit;
6105		}
6106		}
6107
6108	0	result = globus_callback_register_oneshot(
6109		&response->callback_handle,
6110		NULL,
6111		Destroy_i_response_callback,
6112		response);
6113	0	if(result != GLOBUS_SUCCESS)
6114		{
6115	0	result = GlobusSoapMessageErrorClientResponseFailed(
6116		result, "SubscriptionManager_Destroy");
6117	0	goto exit;
6118		}
6119
6120	0	return result;
6121
6122		exit:
6123	0	globus_mutex_destroy(&response->mutex);
6124	0	globus_free(response);
6125	0	return result;
6126		}
6127
6128		globus_result_t
6129		SubscriptionManager_Destroy_epr_register(
6130		SubscriptionManagerService_client_handle_t handle,
6131		const wsa_EndpointReferenceType * epr,
6132		const wsrl_DestroyType * Destroy,
6133		SubscriptionManager_Destroy_response_callback_func_t callback,
6134		void * user_args)
6135	0	{
6136	0	globus_result_t result = GLOBUS_SUCCESS;
6137
6138	0	globus_assert_string(epr, "NULL EndpointReference");
6139	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
6140
6141	0	globus_soap_message_attr_set(
6142		handle->attrs,
6143		WSADDR_EPR_KEY,
6144		wsa_EndpointReferenceType_copy_wrapper,
6145		wsa_EndpointReferenceType_destroy_wrapper,
6146		(void *)epr);
6147
6148	0	result = SubscriptionManager_Destroy_register(
6149		handle,
6150		epr->Address.base_value,
6151		Destroy,
6152		callback,
6153		user_args);
6154
6155	0	return result;
6156		}
6157
6158		globus_result_t
6159		SubscriptionManager_Destroy_register(
6160		SubscriptionManagerService_client_handle_t handle,
6161		const char * endpoint,
6162		const wsrl_DestroyType * Destroy,
6163		SubscriptionManager_Destroy_response_callback_func_t callback,
6164		void * user_args)
6165	0	{
6166	0	Destroy_i_blocking_request_callback_t * callback_handle;
6167	0	globus_result_t result = GLOBUS_SUCCESS;
6168
6169	0	callback_handle = globus_malloc(
6170		sizeof(Destroy_i_blocking_request_callback_t));
6171	0	globus_assert_string(callback_handle, "Memory allocation failed");
6172	0	memset(callback_handle, 0,
6173		sizeof(Destroy_i_blocking_request_callback_t));
6174
6175	0	callback_handle->callback = callback;
6176	0	callback_handle->args = user_args;
6177
6178	0	result = SubscriptionManager_Destroy_register_request(
6179		handle,
6180		endpoint,
6181		Destroy,
6182		Destroy_i_blocking_request_callback,
6183		callback_handle);
6184	0	if(result != GLOBUS_SUCCESS)
6185		{
6186	0	globus_free(callback_handle);
6187		goto exit;
6188		}
6189
6190		exit:
6191
6192	0	return result;
6193		}
6194
6195		typedef struct Destroy_i_blocking_response_callback_s
6196		{
6197		globus_result_t result;
6198		SubscriptionManager_Destroy_fault_t fault_type;
6199		xsd_any * fault;
6200		wsrl_DestroyResponseType * DestroyResponse;
6201		int done;
6202		globus_cond_t cond;
6203		globus_mutex_t mutex;
6204		} Destroy_i_blocking_response_callback_t;
6205
6206		static
6207		void
6208		Destroy_i_blocking_response_callback(
6209		SubscriptionManagerService_client_handle_t handle,
6210		void * user_args,
6211		globus_result_t result,
6212		const wsrl_DestroyResponseType * DestroyResponse,
6213		SubscriptionManager_Destroy_fault_t fault_type,
6214		const xsd_any * fault)
6215	0	{
6216	0	Destroy_i_blocking_response_callback_t * callback_handle;
6217
6218	0	callback_handle = (Destroy_i_blocking_response_callback_t *) user_args;
6219
6220	0	callback_handle->result = result;
6221	0	if(result == GLOBUS_SUCCESS)
6222		{
6223	0	wsrl_DestroyResponseType_copy(
6224		&callback_handle->DestroyResponse, DestroyResponse);
6225		}
6226		else
6227		{
6228	0	callback_handle->fault_type = fault_type;
6229	0	if(fault_type != GLOBUS_SUCCESS)
6230		{
6231	0	xsd_any_copy(&callback_handle->fault, fault);
6232		}
6233		}
6234
6235	0	globus_mutex_lock(&callback_handle->mutex);
6236	0	globus_cond_signal(&callback_handle->cond);
6237	0	callback_handle->done = 1;
6238	0	globus_mutex_unlock(&callback_handle->mutex);
6239		}
6240
6241
6242		globus_result_t
6243		SubscriptionManager_Destroy_epr(
6244		SubscriptionManagerService_client_handle_t handle,
6245		const wsa_EndpointReferenceType * epr,
6246		const wsrl_DestroyType * Destroy,
6247		wsrl_DestroyResponseType * * DestroyResponse,
6248		SubscriptionManager_Destroy_fault_t * fault_type,
6249		xsd_any * * fault)
6250	0	{
6251	0	globus_result_t result = GLOBUS_SUCCESS;
6252
6253	0	globus_assert_string(epr, "NULL EndpointReference");
6254	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
6255
6256	0	*fault_type = SUBSCRIPTIONMANAGER_DESTROY_NOFAULT;
6257
6258	0	globus_soap_message_attr_set(
6259		handle->attrs,
6260		WSADDR_EPR_KEY,
6261		wsa_EndpointReferenceType_copy_wrapper,
6262		wsa_EndpointReferenceType_destroy_wrapper,
6263		(void *)epr);
6264
6265	0	result = SubscriptionManager_Destroy(
6266		handle,
6267		epr->Address.base_value,
6268		Destroy,
6269		DestroyResponse,
6270		fault_type,
6271		fault);
6272
6273	0	return result;
6274		}
6275
6276		globus_result_t
6277		SubscriptionManager_Destroy(
6278		SubscriptionManagerService_client_handle_t handle,
6279		const char * endpoint,
6280		const wsrl_DestroyType * Destroy,
6281		wsrl_DestroyResponseType * * DestroyResponse,
6282		SubscriptionManager_Destroy_fault_t * fault_type,
6283		xsd_any * * fault)
6284	0	{
6285	0	globus_result_t result = GLOBUS_SUCCESS;
6286
6287	0	Destroy_i_blocking_response_callback_t * callback_handle;
6288	0	*fault_type = SUBSCRIPTIONMANAGER_DESTROY_NOFAULT;
6289
6290	0	callback_handle = globus_malloc(
6291		sizeof(Destroy_i_blocking_response_callback_t));
6292	0	globus_assert_string(callback_handle, "Memory allocation failed");
6293	0	memset(callback_handle, 0,
6294		sizeof(Destroy_i_blocking_response_callback_t));
6295
6296	0	globus_mutex_init(&callback_handle->mutex, NULL);
6297	0	globus_cond_init(&callback_handle->cond, NULL);
6298
6299	0	result = SubscriptionManager_Destroy_register(
6300		handle,
6301		endpoint,
6302		Destroy,
6303		Destroy_i_blocking_response_callback,
6304		callback_handle);
6305	0	if(result != GLOBUS_SUCCESS)
6306		{
6307	0	goto exit;
6308		}
6309
6310
6311	0	globus_mutex_lock(&callback_handle->mutex);
6312	0	while(!callback_handle->done)
6313		{
6314	0	globus_cond_wait(&callback_handle->cond, &callback_handle->mutex);
6315		}
6316	0	globus_mutex_unlock(&callback_handle->mutex);
6317
6318	0	result = callback_handle->result;
6319	0	if(result != GLOBUS_SUCCESS)
6320		{
6321
6322	0	*fault_type = callback_handle->fault_type;
6323	0	*fault = callback_handle->fault;
6324
6325	0	goto exit;
6326		}
6327
6328	0	*DestroyResponse = callback_handle->DestroyResponse;
6329
6330		exit:
6331
6332	0	globus_mutex_destroy(&callback_handle->mutex);
6333	0	globus_cond_destroy(&callback_handle->cond);
6334
6335	0	free(callback_handle);
6336
6337	0	return result;
6338		}
6339
6340
6341
6342		typedef struct GetResourceProperty_i_request_handle_s
6343		{
6344		char * endpoint;
6345		int done;
6346		globus_mutex_t mutex;
6347		SubscriptionManagerService_request_state_t state;
6348		SubscriptionManager_GetResourceProperty_request_callback_func_t callback;
6349		void * args;
6350		SubscriptionManagerService_client_handle_t client_handle;
6351		xsd_QName * GetResourceProperty;
6352		globus_callback_handle_t callback_handle;
6353		globus_result_t result;
6354		} GetResourceProperty_i_request_handle_t;
6355
6356		static void
6357		GetResourceProperty_i_request_callback(
6358		void * args);
6359
6360		static void
6361		GetResourceProperty_i_request_done_callback(
6362		globus_result_t result,
6363		void * args)
6364	0	{
6365	0	GetResourceProperty_i_request_handle_t * request;
6366
6367	0	request = (GetResourceProperty_i_request_handle_t *) args;
6368	0	globus_assert_string(request, "request handle in callback is NULL");
6369
6370	0	globus_mutex_lock(&request->mutex);
6371	0	request->result = result;
6372	0	request->done = 1;
6373	0	globus_mutex_unlock(&request->mutex);
6374
6375	0	GetResourceProperty_i_request_callback(request);
6376		}
6377
6378		static void
6379		GetResourceProperty_i_request_handle_destroy(
6380		void * args)
6381	0	{
6382	0	GetResourceProperty_i_request_handle_t * request;
6383
6384	0	request = (GetResourceProperty_i_request_handle_t *) args;
6385	0	globus_assert_string(request, "request handle in callback is NULL");
6386
6387	0	globus_mutex_destroy(&request->mutex);
6388
6389	0	if(request->GetResourceProperty)
6390		{
6391	0	xsd_QName_destroy(request->GetResourceProperty);
6392		}
6393	0	if(request->endpoint)
6394		{
6395	0	globus_free(request->endpoint);
6396		}
6397
6398	0	globus_free(request);
6399		}
6400
6401		static void
6402		GetResourceProperty_i_request_callback(
6403		void * args)
6404	0	{
6405	0	globus_soap_message_handle_t message_handle = NULL;
6406	0	globus_result_t result = GLOBUS_SUCCESS;
6407	0	globus_handler_chain_t chain = NULL;
6408	0	GetResourceProperty_i_request_handle_t * request;
6409	0	xsd_QName subelement;
6410
6411	0	request = (GetResourceProperty_i_request_handle_t *) args;
6412	0	globus_assert_string(request, "request handle is NULL");
6413
6414	0	switch(request->state)
6415		{
6416
6417		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT:
6418
6419	0	globus_mutex_lock(&request->mutex);
6420	0	request->done = 0;
6421	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS;
6422	0	globus_mutex_unlock(&request->mutex);
6423
6424	0	result = globus_soap_message_get_handler_chain(
6425		request->client_handle->message, &chain);
6426	0	if(result != GLOBUS_SUCCESS)
6427		{
6428	0	goto error_exit;
6429		}
6430
6431	0	if(chain)
6432		{
6433	0	globus_handler_chain_register_invoke(
6434		chain,
6435		GLOBUS_HANDLER_TYPE_REQUEST_INIT,
6436		request->client_handle->message,
6437		GetResourceProperty_i_request_done_callback,
6438		request);
6439		}
6440
6441	0	break;
6442
6443		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT_HANDLERS:
6444
6445	0	globus_mutex_lock(&request->mutex);
6446	0	request->done = 0;
6447	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING;
6448	0	globus_mutex_unlock(&request->mutex);
6449
6450	0	result = globus_soap_message_register_open(
6451		request->client_handle->message,
6452		request->endpoint,
6453		GetResourceProperty_i_request_done_callback,
6454		request);
6455	0	if(result != GLOBUS_SUCCESS)
6456		{
6457	0	goto error_exit;
6458		}
6459
6460	0	break;
6461
6462		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_OPENING:
6463
6464	0	if(request->done)
6465		{
6466	0	if(request->result != GLOBUS_SUCCESS)
6467		{
6468	0	result = request->result;
6469	0	goto error_exit;
6470		}
6471
6472	0	globus_mutex_lock(&request->mutex);
6473	0	request->done = 0;
6474	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS;
6475	0	globus_mutex_unlock(&request->mutex);
6476
6477	0	result = globus_soap_message_serialize_envelope(
6478		request->client_handle->message);
6479	0	if(result != GLOBUS_SUCCESS)
6480		{
6481	0	goto error_exit;
6482		}
6483
6484	0	result = globus_soap_message_serialize_header(
6485		request->client_handle->message);
6486	0	if(result != GLOBUS_SUCCESS)
6487		{
6488	0	goto error_exit;
6489		}
6490
6491	0	result = globus_soap_message_serialize_header_begin_close(
6492		request->client_handle->message);
6493	0	if(result != GLOBUS_SUCCESS)
6494		{
6495	0	goto error_exit;
6496		}
6497
6498	0	result = globus_soap_message_set_marker(
6499		request->client_handle->message,
6500		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
6501	0	if(result != GLOBUS_SUCCESS)
6502		{
6503	0	goto error_exit;
6504		}
6505
6506	0	result = globus_soap_message_serialize_header_end(
6507		request->client_handle->message);
6508	0	if(result != GLOBUS_SUCCESS)
6509		{
6510	0	goto error_exit;
6511		}
6512
6513	0	result = globus_soap_message_serialize_body(
6514		request->client_handle->message);
6515	0	if(result != GLOBUS_SUCCESS)
6516		{
6517	0	goto error_exit;
6518		}
6519
6520	0	result = globus_soap_message_serialize_body_begin_close(
6521		request->client_handle->message);
6522	0	if(result != GLOBUS_SUCCESS)
6523		{
6524	0	goto error_exit;
6525		}
6526
6527	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceProperties-1.2-draft-01.xsd";
6528	0	subelement.local = "GetResourceProperty";
6529
6530	0	result = xsd_QName_serialize(
6531		&subelement,
6532		request->GetResourceProperty,
6533		request->client_handle->message,
6534		0);
6535	0	if(result != GLOBUS_SUCCESS)
6536		{
6537	0	goto error_exit;
6538		}
6539
6540	0	result = globus_soap_message_serialize_body_end(
6541		request->client_handle->message);
6542	0	if(result != GLOBUS_SUCCESS)
6543		{
6544	0	goto error_exit;
6545		}
6546
6547	0	result = globus_soap_message_serialize_envelope_end(
6548		request->client_handle->message);
6549	0	if(result != GLOBUS_SUCCESS)
6550		{
6551	0	goto error_exit;
6552		}
6553
6554	0	result = globus_soap_message_set_write_position_to_marker(
6555		request->client_handle->message,
6556		GLOBUS_SOAP_MESSAGE_MARKER_HEADER_CONTENT);
6557	0	if(result != GLOBUS_SUCCESS)
6558		{
6559	0	goto error_exit;
6560		}
6561
6562	0	result = globus_soap_message_get_handler_chain(
6563		request->client_handle->message, &chain);
6564	0	if(result != GLOBUS_SUCCESS)
6565		{
6566	0	goto error_exit;
6567		}
6568
6569	0	if(chain)
6570		{
6571	0	globus_handler_chain_register_invoke(
6572		chain,
6573		GLOBUS_HANDLER_TYPE_REQUEST,
6574		request->client_handle->message,
6575		GetResourceProperty_i_request_done_callback,
6576		request);
6577		}
6578		}
6579
6580	0	break;
6581
6582		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_INVOKING_HANDLERS:
6583
6584	0	if(request->done)
6585		{
6586	0	if(request->result != GLOBUS_SUCCESS)
6587		{
6588	0	result = request->result;
6589	0	goto error_exit;
6590		}
6591
6592	0	globus_mutex_lock(&request->mutex);
6593	0	request->done = 0;
6594	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING;
6595	0	globus_mutex_unlock(&request->mutex);
6596
6597	0	result = globus_soap_message_register_write_request(
6598		request->client_handle->message,
6599		GetResourceProperty_i_request_done_callback,
6600		request,
6601
6602		GLOBUS_TRUE);
6603
6604	0	if(result != GLOBUS_SUCCESS)
6605		{
6606	0	goto error_exit;
6607		}
6608		}
6609
6610	0	break;
6611
6612		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_SENDING:
6613
6614	0	if(request->done)
6615		{
6616	0	if(request->result != GLOBUS_SUCCESS)
6617		{
6618	0	result = request->result;
6619	0	goto error_exit;
6620		}
6621
6622	0	globus_mutex_lock(&request->mutex);
6623	0	request->done = 0;
6624	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS;
6625	0	globus_mutex_unlock(&request->mutex);
6626
6627	0	result = globus_soap_message_get_handler_chain(
6628		request->client_handle->message, &chain);
6629	0	if(result != GLOBUS_SUCCESS)
6630		{
6631	0	goto error_exit;
6632		}
6633
6634	0	if(chain)
6635		{
6636	0	globus_handler_chain_register_invoke(
6637		chain,
6638		GLOBUS_HANDLER_TYPE_REQUEST_DESTROY,
6639		request->client_handle->message,
6640		GetResourceProperty_i_request_done_callback,
6641		request);
6642		}
6643		}
6644
6645	0	break;
6646
6647		case SUBSCRIPTIONMANAGERSERVICE_REQUEST_DESTROY_HANDLERS:
6648
6649	0	if(request->done)
6650		{
6651	0	if(request->result != GLOBUS_SUCCESS)
6652		{
6653	0	result = request->result;
6654	0	goto error_exit;
6655		}
6656
6657	0	globus_mutex_lock(&request->mutex);
6658	0	request->done = 0;
6659	0	globus_mutex_unlock(&request->mutex);
6660
6661	0	request->callback(
6662		request->client_handle,
6663		request->args, GLOBUS_SUCCESS);
6664
6665	0	GetResourceProperty_i_request_handle_destroy(request);
6666		}
6667
6668	0	break;
6669
6670		default:
6671
6672	0	globus_assert_string(NULL, "Unkown request state");
6673	0	break;
6674		}
6675
6676	0	return;
6677
6678		error_exit:
6679
6680	0	result = GlobusSoapMessageErrorClientRequestFailed(
6681		result, "SubscriptionManager_GetResourceProperty");
6682
6683	0	globus_mutex_lock(&request->mutex);
6684	0	message_handle = request->client_handle->message;
6685	0	request->client_handle->message = NULL;
6686	0	globus_mutex_unlock(&request->mutex);
6687
6688	0	request->callback(request->client_handle, request->args, result);
6689
6690	0	globus_soap_message_handle_destroy(message_handle);
6691	0	GetResourceProperty_i_request_handle_destroy(request);
6692		}
6693
6694		globus_result_t
6695		SubscriptionManager_GetResourceProperty_epr_register_request(
6696		SubscriptionManagerService_client_handle_t client_handle,
6697		const wsa_EndpointReferenceType * epr,
6698		const xsd_QName * GetResourceProperty,
6699		SubscriptionManager_GetResourceProperty_request_callback_func_t callback,
6700		void * user_args)
6701	0	{
6702	0	globus_result_t result = GLOBUS_SUCCESS;
6703
6704	0	globus_assert_string(epr, "NULL EndpointReference");
6705	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
6706
6707	0	globus_soap_message_attr_set(
6708		client_handle->attrs,
6709		WSADDR_EPR_KEY,
6710		wsa_EndpointReferenceType_copy_wrapper,
6711		wsa_EndpointReferenceType_destroy_wrapper,
6712		(void *)epr);
6713
6714	0	result = SubscriptionManager_GetResourceProperty_register_request(
6715		client_handle,
6716		epr->Address.base_value,
6717		GetResourceProperty,
6718		callback,
6719		user_args);
6720
6721	0	return result;
6722		}
6723
6724		globus_result_t
6725		SubscriptionManager_GetResourceProperty_register_request(
6726		SubscriptionManagerService_client_handle_t client_handle,
6727		const char * endpoint,
6728		const xsd_QName * GetResourceProperty,
6729		SubscriptionManager_GetResourceProperty_request_callback_func_t callback,
6730		void * user_args)
6731	0	{
6732	0	globus_handler_chain_t chain = NULL;
6733	0	globus_result_t result = GLOBUS_SUCCESS;
6734	0	GetResourceProperty_i_request_handle_t * request = NULL;
6735
6736	0	if(client_handle->message != NULL)
6737		{
6738	0	result = GlobusSoapMessageErrorClientAlreadyInvoked();
6739	0	goto exit;
6740		}
6741
6742	0	result = globus_soap_message_handle_init(&client_handle->message, NULL);
6743	0	if(result != GLOBUS_SUCCESS)
6744		{
6745	0	result = GlobusSoapMessageErrorFailedClientInit(
6746		result, "SubscriptionManager_GetResourceProperty");
6747	0	goto error_exit;
6748		}
6749
6750	0	globus_soap_message_handle_set_registry(
6751		client_handle->message, SubscriptionManagerService_l_registry);
6752
6753	0	chain = client_handle->handler_chain;
6754	0	if(!chain)
6755		{
6756	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
6757	0	if(result != GLOBUS_SUCCESS)
6758		{
6759	0	result = GlobusSoapMessageErrorFailedClientInit(
6760		result, "SubscriptionManager_GetResourceProperty");
6761	0	goto exit;
6762		}
6763
6764	0	globus_mutex_lock(&SubscriptionManagerService_l_extensions_mutex);
6765	0	globus_list_insert(
6766		&SubscriptionManagerService_l_extensions,
6767		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
6768	0	globus_mutex_unlock(&SubscriptionManagerService_l_extensions_mutex);
6769
6770	0	globus_handler_chain_init(&chain);
6771	0	result = globus_handler_chain_push(
6772		chain,
6773		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
6774		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
6775	0	if(result != GLOBUS_SUCCESS)
6776		{
6777	0	result = GlobusSoapMessageErrorFailedClientInit(
6778		result, "SubscriptionManager_GetResourceProperty");
6779	0	goto error_exit;
6780		}
6781
6782	0	result = globus_handler_chain_push(
6783		chain,
6784		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
6785		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
6786	0	if(result != GLOBUS_SUCCESS)
6787		{
6788	0	result = GlobusSoapMessageErrorFailedClientInit(
6789		result, "SubscriptionManager_GetResourceProperty");
6790	0	goto error_exit;
6791		}
6792		}
6793
6794	0	globus_soap_message_set_handler_chain(
6795		client_handle->message, chain);
6796
6797	0	request = globus_malloc(sizeof(GetResourceProperty_i_request_handle_t));
6798	0	globus_assert_string(request, "Memory allocation failed.");
6799	0	memset(request, 0, sizeof(GetResourceProperty_i_request_handle_t));
6800
6801	0	if(!endpoint)
6802		{
6803	0	endpoint = (char *)globus_soap_message_attr_get(
6804		client_handle->attrs, GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY);
6805	0	if(!endpoint)
6806		{
6807	0	wsa_EndpointReferenceType * epr;
6808	0	epr = (wsa_EndpointReferenceType *)
6809		globus_soap_message_attr_get(
6810		client_handle->attrs, WSADDR_EPR_KEY);
6811	0	if(epr && epr->Address.base_value)
6812		{
6813	0	endpoint = epr->Address.base_value;
6814		}
6815		}
6816		}
6817
6818	0	globus_assert_string(endpoint, "NULL endpoint");
6819
6820	0	request->endpoint = globus_libc_strdup(endpoint);
6821	0	request->callback = callback;
6822	0	request->args = user_args;
6823	0	request->client_handle = client_handle;
6824	0	xsd_QName_copy(&request->GetResourceProperty, GetResourceProperty);
6825	0	request->state = SUBSCRIPTIONMANAGERSERVICE_REQUEST_INIT;
6826	0	globus_mutex_init(&request->mutex, NULL);
6827
6828	0	result = globus_soap_message_attr_set(
6829		client_handle->attrs,
6830		WSADDR_DESTINATION_KEY,
6831		globus_soap_message_attr_copy_string,
6832		globus_libc_free,
6833		(void *)endpoint);
6834	0	if(result != GLOBUS_SUCCESS)
6835		{
6836	0	result = GlobusSoapMessageErrorClientRequestFailed(
6837		result, "SubscriptionManager_GetResourceProperty");
6838	0	goto error_exit;
6839		}
6840
6841	0	result = globus_soap_message_attr_set(
6842		client_handle->attrs,
6843		WSADDR_ACTION_REQUEST_KEY,
6844		NULL,
6845		NULL,
6846		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceProperties/GetResourceProperty");
6847	0	if(result != GLOBUS_SUCCESS)
6848		{
6849	0	result = GlobusSoapMessageErrorClientRequestFailed(
6850		result, "SubscriptionManager_GetResourceProperty");
6851	0	goto error_exit;
6852		}
6853
6854	0	result = globus_soap_message_attr_set(
6855		client_handle->attrs,
6856		GLOBUS_SOAP_MESSAGE_SOAP_ACTION_KEY,
6857		NULL,
6858		NULL,
6859		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceProperties/GetResourceProperty");
6860	0	if(result != GLOBUS_SUCCESS)
6861		{
6862	0	result = GlobusSoapMessageErrorClientRequestFailed(
6863		result, "SubscriptionManager_GetResourceProperty");
6864	0	goto error_exit;
6865		}
6866
6867	0	result = globus_soap_message_handle_set_attrs(
6868		client_handle->message, client_handle->attrs);
6869	0	if(result != GLOBUS_SUCCESS)
6870		{
6871	0	result = GlobusSoapMessageErrorClientRequestFailed(
6872		result, "SubscriptionManager_GetResourceProperty");
6873		}
6874
6875	0	result = globus_callback_register_oneshot(
6876		&request->callback_handle,
6877		NULL,
6878		GetResourceProperty_i_request_callback,
6879		request);
6880	0	if(result != GLOBUS_SUCCESS)
6881		{
6882	0	result = GlobusSoapMessageErrorClientRequestFailed(
6883		result, "SubscriptionManager_GetResourceProperty");
6884		goto error_exit;
6885		}
6886
6887	0	goto exit;
6888
6889		error_exit:
6890
6891	0	if(request)
6892		{
6893	0	globus_mutex_destroy(&request->mutex);
6894
6895	0	if(request->GetResourceProperty)
6896		{
6897	0	xsd_QName_destroy(request->GetResourceProperty);
6898		}
6899	0	if(request->endpoint)
6900		{
6901	0	globus_free(request->endpoint);
6902		}
6903
6904	0	globus_free(request);
6905		}
6906
6907	0	if(client_handle->message)
6908		{
6909	0	globus_soap_message_handle_destroy(client_handle->message);
6910	0	client_handle->message = NULL;
6911		}
6912
6913		exit:
6914
6915	0	return result;
6916		}
6917
6918		typedef struct GetResourceProperty_i_blocking_request_callback_s
6919		{
6920
6921		SubscriptionManager_GetResourceProperty_response_callback_func_t callback;
6922		void * args;
6923
6924		} GetResourceProperty_i_blocking_request_callback_t;
6925
6926		static
6927		void
6928		GetResourceProperty_i_blocking_request_callback(
6929		SubscriptionManagerService_client_handle_t handle,
6930		void * user_args,
6931		globus_result_t error)
6932	0	{
6933	0	globus_soap_message_handle_t message_handle = NULL;
6934	0	globus_result_t result = GLOBUS_SUCCESS;
6935	0	GetResourceProperty_i_blocking_request_callback_t * callback_handle;
6936
6937	0	callback_handle = (GetResourceProperty_i_blocking_request_callback_t *) user_args;
6938	0	globus_assert_string(callback_handle, "callback_handle is NULL");
6939
6940
6941	0	if(error != GLOBUS_SUCCESS \|\|
6942		globus_soap_message_is_cancelled(handle->message))
6943		{
6944	0	message_handle = handle->message;
6945	0	handle->message = NULL;
6946
6947	0	callback_handle->callback(
6948		handle,
6949		callback_handle->args,
6950		error,
6951		NULL,
6952		SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT,
6953		NULL);
6954
6955	0	globus_soap_message_handle_destroy(message_handle);
6956		}
6957		else
6958		{
6959	0	result = SubscriptionManager_GetResourceProperty_register_response(
6960		handle,
6961		callback_handle->callback,
6962		callback_handle->args);
6963	0	if(result != GLOBUS_SUCCESS)
6964		{
6965	0	callback_handle->callback(
6966		handle,
6967		callback_handle->args,
6968		result,
6969		NULL,
6970		SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT,
6971		NULL);
6972		}
6973		}
6974
6975	0	free(callback_handle);
6976		}
6977
6978
6979
6980		typedef struct GetResourceProperty_i_response_handle_s
6981		{
6982		int done;
6983		globus_mutex_t mutex;
6984		SubscriptionManagerService_response_state_t state;
6985		SubscriptionManager_GetResourceProperty_response_callback_func_t callback;
6986		void * args;
6987		SubscriptionManagerService_client_handle_t client_handle;
6988		wsrp_GetResourcePropertyResponseType * GetResourcePropertyResponse;
6989		globus_callback_handle_t callback_handle;
6990		globus_result_t result;
6991		globus_result_t fault_result;
6992		int fault_type;
6993		xsd_any * fault;
6994		} GetResourceProperty_i_response_handle_t;
6995
6996		static void
6997		GetResourceProperty_i_response_callback(
6998		void * args);
6999
7000		static void
7001		GetResourceProperty_i_response_done_callback(
7002		globus_result_t result,
7003		void * args)
7004	0	{
7005	0	GetResourceProperty_i_response_handle_t * response;
7006
7007	0	response = (GetResourceProperty_i_response_handle_t *) args;
7008	0	globus_assert_string(response, "response handle in callback is NULL");
7009
7010	0	globus_mutex_lock(&response->mutex);
7011	0	response->result = result;
7012	0	response->done = 1;
7013	0	globus_mutex_unlock(&response->mutex);
7014
7015	0	GetResourceProperty_i_response_callback(response);
7016		}
7017
7018		static void
7019		GetResourceProperty_i_response_handle_destroy(
7020		void * args)
7021	0	{
7022	0	GetResourceProperty_i_response_handle_t * response;
7023
7024	0	response = (GetResourceProperty_i_response_handle_t *) args;
7025	0	globus_assert_string(response, "response handle in callback is NULL");
7026
7027	0	globus_mutex_destroy(&response->mutex);
7028
7029	0	free(response);
7030		}
7031
7032		static void
7033		GetResourceProperty_i_deserialize_fault(
7034		globus_soap_message_handle_t handle,
7035		const xsd_QName * fault_qname,
7036		int * fault_type,
7037		void * args)
7038	0	{
7039	0	*fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT;
7040
7041	0	if(fault_qname)
7042		{
7043	0	if(fault_qname == (&wsrp_ResourceUnknownFaultType_qname) \|\|
7044		fault_qname == (&wsrp_ResourceUnknownFault_qname))
7045		{
7046	0	*fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_RESOURCEUNKNOWNFAULT;
7047		}
7048	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) \|\|
7049		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
7050		{
7051	0	*fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_INVALIDRESOURCEPROPERTYQNAMEFAULT;
7052		}
7053		else
7054		{
7055	0	*fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_UNKNOWN_FAULT;
7056		}
7057		}
7058		}
7059
7060		static void
7061		GetResourceProperty_i_response_callback(
7062		void * args)
7063	0	{
7064	0	xsd_QName subelement;
7065	0	globus_soap_message_handle_t message_handle = NULL;
7066	0	globus_soap_message_fault_t soap_fault;
7067	0	globus_result_t result = GLOBUS_SUCCESS;
7068	0	globus_handler_chain_t chain = NULL;
7069	0	xsd_QName * header_element = NULL;
7070	0	int must;
7071	0	GetResourceProperty_i_response_handle_t * response;
7072	0	response = (GetResourceProperty_i_response_handle_t *) args;
7073	0	globus_assert_string(response, "response handle in callback is NULL");
7074
7075	0	switch(response->state)
7076		{
7077
7078		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT:
7079
7080	0	globus_mutex_lock(&response->mutex);
7081	0	response->done = 0;
7082	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING;
7083	0	globus_mutex_unlock(&response->mutex);
7084
7085	0	result = globus_soap_message_register_read_response(
7086		response->client_handle->message,
7087		GetResourceProperty_i_response_done_callback,
7088		response);
7089	0	if(result != GLOBUS_SUCCESS)
7090		{
7091	0	goto error_exit;
7092		}
7093
7094	0	break;
7095
7096		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_READING:
7097
7098	0	if(response->done)
7099		{
7100	0	if(response->result != GLOBUS_SUCCESS)
7101		{
7102	0	if(GlobusSoapMessageErrorCheckFailedResponse(response->result) \|\|
7103		GlobusSoapMessageErrorCheckBadRequest(response->result))
7104		{
7105	0	response->result = GLOBUS_SUCCESS;
7106		}
7107		else
7108		{
7109	0	result = response->result;
7110	0	goto error_exit;
7111		}
7112		}
7113
7114	0	globus_mutex_lock(&response->mutex);
7115	0	response->done = 0;
7116	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
7117	0	globus_mutex_unlock(&response->mutex);
7118
7119	0	result = globus_soap_message_deserialize_envelope(
7120		response->client_handle->message);
7121	0	if(result != GLOBUS_SUCCESS)
7122		{
7123	0	goto error_exit;
7124		}
7125
7126	0	result = globus_soap_message_deserialize_element_begin_close(
7127		response->client_handle->message);
7128	0	if(result != GLOBUS_SUCCESS)
7129		{
7130	0	goto error_exit;
7131		}
7132
7133	0	result = globus_soap_message_deserialize_header(
7134		response->client_handle->message);
7135	0	if(result != GLOBUS_SUCCESS)
7136		{
7137	0	if(GlobusSoapMessageStatusElementNotFoundCheck(result))
7138		{
7139	0	globus_soap_message_deserialize_push_element(
7140		response->client_handle->message);
7141	0	result = GLOBUS_SUCCESS;
7142	0	globus_mutex_lock(&response->mutex);
7143	0	response->state =
7144		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED;
7145	0	globus_mutex_unlock(&response->mutex);
7146	0	GetResourceProperty_i_response_done_callback(
7147		result, response);
7148	0	break;
7149		}
7150
7151	0	goto error_exit;
7152		}
7153
7154	0	globus_mutex_lock(&response->mutex);
7155	0	response->done = 1;
7156	0	globus_mutex_unlock(&response->mutex);
7157		}
7158
7159		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS:
7160
7161	0	if(response->done)
7162		{
7163	0	if(response->result != GLOBUS_SUCCESS)
7164		{
7165	0	if(GlobusSoapMessageErrorCheckFailedResponse(
7166		response->result) \|\|
7167		GlobusSoapMessageErrorCheckBadRequest(response->result))
7168		{
7169	0	response->result = GLOBUS_SUCCESS;
7170		}
7171		else
7172		{
7173	0	result = response->result;
7174	0	goto error_exit;
7175		}
7176		}
7177
7178	0	globus_mutex_lock(&response->mutex);
7179	0	response->done = 0;
7180	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_TRIGGER_HANDLERS;
7181	0	globus_mutex_unlock(&response->mutex);
7182
7183	0	xsd_QName_init(&header_element);
7184
7185	0	result = globus_soap_message_deserialize_element_unknown(
7186		response->client_handle->message,
7187		header_element);
7188	0	if(result != GLOBUS_SUCCESS)
7189		{
7190	0	if(!GlobusSoapMessageStatusFailedElementCheck(result))
7191		{
7192	0	xsd_QName_destroy(header_element);
7193	0	goto error_exit;
7194		}
7195		else
7196		{
7197	0	globus_mutex_lock(&response->mutex);
7198	0	response->done = 1;
7199	0	response->state =
7200		SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE;
7201	0	globus_mutex_unlock(&response->mutex);
7202
7203	0	globus_callback_register_oneshot(
7204		NULL,
7205		&globus_i_reltime_zero,
7206		GetResourceProperty_i_response_callback,
7207		(void *)response);
7208	0	xsd_QName_destroy(header_element);
7209	0	break;
7210		}
7211		}
7212
7213	0	result = globus_soap_message_deserialize_int_attribute(
7214		response->client_handle->message,
7215		&soap_mustUnderstand_qname,
7216		&must);
7217	0	if(result == GLOBUS_SUCCESS && (must == 1))
7218		{
7219	0	globus_soap_message_add_required_header_element(
7220		response->client_handle->message,
7221		header_element);
7222		}
7223	0	else if(result != GLOBUS_SUCCESS &&
7224		!GlobusSoapMessageStatusAttributeNotFoundCheck(result))
7225		{
7226	0	xsd_QName_destroy(header_element);
7227	0	goto error_exit;
7228		}
7229
7230	0	globus_soap_message_deserialize_push_element(
7231		response->client_handle->message);
7232
7233	0	result = globus_soap_message_get_handler_chain(
7234		response->client_handle->message, &chain);
7235	0	if(result != GLOBUS_SUCCESS)
7236		{
7237	0	goto error_exit;
7238		}
7239
7240	0	if(chain)
7241		{
7242	0	result = globus_handler_chain_register_trigger(
7243		chain,
7244		response->client_handle->message,
7245		header_element,
7246		GetResourceProperty_i_response_done_callback,
7247		response);
7248	0	if(result == GLOBUS_SUCCESS)
7249		{
7250	0	xsd_QName_destroy(header_element);
7251	0	break;
7252		}
7253	0	else if(!GlobusHandlerStatusNotTriggeredCheck(result))
7254		{
7255	0	xsd_QName_destroy(header_element);
7256	0	goto error_exit;
7257		}
7258		}
7259
7260	0	xsd_QName_destroy(header_element);
7261	0	result = globus_soap_message_deserialize_skip(
7262		response->client_handle->message);
7263	0	if(result != GLOBUS_SUCCESS)
7264		{
7265	0	goto error_exit;
7266		}
7267
7268	0	globus_mutex_lock(&response->mutex);
7269	0	response->done = 1;
7270	0	globus_mutex_unlock(&response->mutex);
7271	0	globus_callback_register_oneshot(
7272		NULL,
7273		&globus_i_reltime_zero,
7274		GetResourceProperty_i_response_callback,
7275		(void *)response);
7276		}
7277
7278	0	break;
7279
7280		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HANDLER_DESERIALIZE:
7281
7282	0	if(response->done)
7283		{
7284	0	if(response->result != GLOBUS_SUCCESS)
7285		{
7286	0	result = response->result;
7287	0	goto error_exit;
7288		}
7289
7290	0	globus_mutex_lock(&response->mutex);
7291	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
7292	0	globus_mutex_unlock(&response->mutex);
7293
7294	0	result = globus_soap_message_deserialize_header_end(
7295		response->client_handle->message);
7296	0	if(result != GLOBUS_SUCCESS)
7297		{
7298	0	goto error_exit;
7299		}
7300
7301	0	result = globus_soap_message_deserialize_body(
7302		response->client_handle->message);
7303	0	if(result != GLOBUS_SUCCESS)
7304		{
7305	0	goto error_exit;
7306		}
7307		}
7308
7309		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_HEADER_FAILED:
7310
7311	0	if(response->done)
7312		{
7313	0	if(response->result != GLOBUS_SUCCESS)
7314		{
7315	0	result = response->result;
7316	0	goto error_exit;
7317		}
7318
7319	0	globus_mutex_lock(&response->mutex);
7320	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS;
7321	0	globus_mutex_unlock(&response->mutex);
7322
7323	0	response->fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT;
7324	0	response->fault_result = GLOBUS_SUCCESS;
7325
7326	0	result = globus_soap_message_deserialize_fault(
7327		response->client_handle->message,
7328		&soap_fault,
7329		GetResourceProperty_i_deserialize_fault,
7330		&response->fault,
7331		&response->fault_type);
7332	0	if(result != GLOBUS_SUCCESS)
7333		{
7334	0	if(response->result != GLOBUS_SUCCESS)
7335		{
7336	0	result = response->result;
7337		}
7338	0	goto error_exit;
7339		}
7340
7341	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT)
7342		{
7343	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceProperties-1.2-draft-01.xsd";
7344	0	subelement.local = "GetResourcePropertyResponse";
7345
7346	0	result = wsrp_GetResourcePropertyResponseType_deserialize_pointer(
7347		&subelement,
7348		&response->GetResourcePropertyResponse,
7349		response->client_handle->message,
7350		0);
7351	0	if(result != GLOBUS_SUCCESS)
7352		{
7353	0	goto error_exit;
7354		}
7355		}
7356		else
7357		{
7358	0	if(soap_fault)
7359		{
7360	0	response->fault_result = GlobusSoapMessageErrorFault(
7361		soap_fault);
7362		}
7363
7364	0	result = globus_soap_message_deserialize_fault_end(
7365		response->client_handle->message,
7366		response->fault
7367		? response->fault->element
7368		: &soap_fault_qname);
7369	0	if(result != GLOBUS_SUCCESS)
7370		{
7371	0	goto error_exit;
7372		}
7373		}
7374
7375	0	result = globus_soap_message_deserialize_body_end(
7376		response->client_handle->message);
7377	0	if(result != GLOBUS_SUCCESS)
7378		{
7379	0	goto error_exit;
7380		}
7381
7382	0	result = globus_soap_message_deserialize_envelope_end(
7383		response->client_handle->message);
7384	0	if(result != GLOBUS_SUCCESS)
7385		{
7386	0	goto error_exit;
7387		}
7388
7389
7390	0	if(!soap_fault && response->fault_type == SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT)
7391		{
7392	0	result = globus_soap_message_get_handler_chain(
7393		response->client_handle->message, &chain);
7394	0	if(result != GLOBUS_SUCCESS)
7395		{
7396	0	goto error_exit;
7397		}
7398
7399	0	if(chain)
7400		{
7401	0	globus_handler_chain_register_invoke(
7402		chain,
7403		GLOBUS_HANDLER_TYPE_RESPONSE,
7404		response->client_handle->message,
7405		GetResourceProperty_i_response_done_callback,
7406		response);
7407		}
7408		}
7409		else
7410		{
7411	0	globus_mutex_lock(&response->mutex);
7412	0	response->done = 1;
7413	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE;
7414	0	globus_mutex_unlock(&response->mutex);
7415	0	globus_callback_register_oneshot(
7416		NULL,
7417		&globus_i_reltime_zero,
7418		GetResourceProperty_i_response_callback,
7419		(void *)response);
7420		}
7421		}
7422
7423	0	break;
7424
7425		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INVOKING_HANDLERS:
7426
7427	0	if(response->done)
7428		{
7429	0	if(response->result != GLOBUS_SUCCESS)
7430		{
7431	0	result = response->result;
7432	0	goto error_exit;
7433		}
7434
7435	0	result = globus_soap_message_check_required_headers(
7436		response->client_handle->message);
7437	0	if(result != GLOBUS_SUCCESS)
7438		{
7439		/* continue on in case fault was returned and
7440		* no header elements exist
7441		*/
7442	0	response->result = result;
7443		}
7444		}
7445
7446		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_CLOSE:
7447
7448	0	if(response->done)
7449		{
7450	0	if(response->result != GLOBUS_SUCCESS)
7451		{
7452	0	result = response->result;
7453	0	goto error_exit;
7454		}
7455
7456	0	globus_mutex_lock(&response->mutex);
7457	0	response->done = 0;
7458	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE;
7459	0	globus_mutex_unlock(&response->mutex);
7460
7461	0	result = globus_soap_message_register_close(
7462		response->client_handle->message,
7463		GetResourceProperty_i_response_done_callback,
7464		response);
7465	0	if(result != GLOBUS_SUCCESS)
7466		{
7467	0	goto error_exit;
7468		}
7469		}
7470
7471	0	break;
7472
7473		case SUBSCRIPTIONMANAGERSERVICE_RESPONSE_DONE:
7474
7475
7476	0	if(response->done)
7477		{
7478	0	if(response->result != GLOBUS_SUCCESS)
7479		{
7480	0	result = response->result;
7481	0	goto error_exit;
7482		}
7483
7484	0	globus_mutex_lock(&response->mutex);
7485	0	response->done = 0;
7486	0	message_handle = response->client_handle->message;
7487	0	response->client_handle->message = NULL;
7488	0	globus_mutex_unlock(&response->mutex);
7489
7490	0	response->callback(
7491		response->client_handle,
7492		response->args,
7493		response->fault_result,
7494		response->GetResourcePropertyResponse,
7495		response->fault_type,
7496		response->fault);
7497
7498	0	if(response->GetResourcePropertyResponse)
7499		{
7500	0	wsrp_GetResourcePropertyResponseType_destroy(response->GetResourcePropertyResponse);
7501		}
7502
7503	0	if(response->fault)
7504		{
7505	0	xsd_any_destroy(response->fault);
7506	0	response->fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT;
7507	0	response->fault = NULL;
7508		}
7509
7510	0	globus_soap_message_handle_destroy(message_handle);
7511	0	GetResourceProperty_i_response_handle_destroy(response);
7512		}
7513
7514	0	break;
7515
7516		default:
7517
7518	0	globus_assert_string(NULL, "Unknown response state");
7519		}
7520
7521	0	return;
7522
7523		error_exit:
7524
7525	0	if(!GlobusSoapMessageStatusCheck(result))
7526		{
7527	0	result = GlobusSoapMessageErrorClientResponseFailed(
7528		result, "SubscriptionManager_GetResourceProperty");
7529		}
7530
7531	0	globus_mutex_lock(&response->mutex);
7532	0	message_handle = response->client_handle->message;
7533	0	response->client_handle->message = NULL;
7534	0	globus_mutex_unlock(&response->mutex);
7535
7536	0	response->callback(
7537		response->client_handle,
7538		response->args,
7539		result,
7540		response->GetResourcePropertyResponse,
7541		response->fault_type,
7542		response->fault);
7543
7544	0	if(response->GetResourcePropertyResponse)
7545		{
7546	0	wsrp_GetResourcePropertyResponseType_destroy(response->GetResourcePropertyResponse);
7547		}
7548
7549	0	if(response->fault)
7550		{
7551	0	xsd_any_destroy(response->fault);
7552
7553	0	response->fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT;
7554	0	response->fault = NULL;
7555		}
7556
7557	0	globus_soap_message_handle_destroy(message_handle);
7558	0	GetResourceProperty_i_response_handle_destroy(response);
7559		}
7560
7561		globus_result_t
7562		SubscriptionManager_GetResourceProperty_register_response(
7563		SubscriptionManagerService_client_handle_t client_handle,
7564		SubscriptionManager_GetResourceProperty_response_callback_func_t callback,
7565		void * user_args)
7566	0	{
7567	0	globus_result_t result = GLOBUS_SUCCESS;
7568	0	GetResourceProperty_i_response_handle_t * response;
7569
7570	0	response = globus_malloc(
7571		sizeof(GetResourceProperty_i_response_handle_t));
7572	0	globus_assert_string(response, "Memory allocation failed.");
7573	0	memset(response, 0, sizeof(GetResourceProperty_i_response_handle_t));
7574
7575	0	response->callback = callback;
7576	0	response->args = user_args;
7577	0	response->client_handle = client_handle;
7578	0	response->state = SUBSCRIPTIONMANAGERSERVICE_RESPONSE_INIT;
7579	0	globus_mutex_init(&response->mutex, NULL);
7580
7581	0	result = globus_soap_message_handle_set_attr(
7582		client_handle->message,
7583		WSADDR_ACTION_RESPONSE_KEY,
7584		globus_soap_message_attr_copy_string,
7585		globus_libc_free,
7586		"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceProperties/GetResourcePropertyResponse");
7587	0	if(result != GLOBUS_SUCCESS)
7588		{
7589	0	if(!GlobusSoapMessageStatusCheck(result))
7590		{
7591	0	result = GlobusSoapMessageErrorClientRequestFailed(
7592		result, "SubscriptionManager_GetResourceProperty");
7593	0	goto exit;
7594		}
7595		}
7596
7597	0	result = globus_callback_register_oneshot(
7598		&response->callback_handle,
7599		NULL,
7600		GetResourceProperty_i_response_callback,
7601		response);
7602	0	if(result != GLOBUS_SUCCESS)
7603		{
7604	0	result = GlobusSoapMessageErrorClientResponseFailed(
7605		result, "SubscriptionManager_GetResourceProperty");
7606	0	goto exit;
7607		}
7608
7609	0	return result;
7610
7611		exit:
7612	0	globus_mutex_destroy(&response->mutex);
7613	0	globus_free(response);
7614	0	return result;
7615		}
7616
7617		globus_result_t
7618		SubscriptionManager_GetResourceProperty_epr_register(
7619		SubscriptionManagerService_client_handle_t handle,
7620		const wsa_EndpointReferenceType * epr,
7621		const xsd_QName * GetResourceProperty,
7622		SubscriptionManager_GetResourceProperty_response_callback_func_t callback,
7623		void * user_args)
7624	0	{
7625	0	globus_result_t result = GLOBUS_SUCCESS;
7626
7627	0	globus_assert_string(epr, "NULL EndpointReference");
7628	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
7629
7630	0	globus_soap_message_attr_set(
7631		handle->attrs,
7632		WSADDR_EPR_KEY,
7633		wsa_EndpointReferenceType_copy_wrapper,
7634		wsa_EndpointReferenceType_destroy_wrapper,
7635		(void *)epr);
7636
7637	0	result = SubscriptionManager_GetResourceProperty_register(
7638		handle,
7639		epr->Address.base_value,
7640		GetResourceProperty,
7641		callback,
7642		user_args);
7643
7644	0	return result;
7645		}
7646
7647		globus_result_t
7648		SubscriptionManager_GetResourceProperty_register(
7649		SubscriptionManagerService_client_handle_t handle,
7650		const char * endpoint,
7651		const xsd_QName * GetResourceProperty,
7652		SubscriptionManager_GetResourceProperty_response_callback_func_t callback,
7653		void * user_args)
7654	0	{
7655	0	GetResourceProperty_i_blocking_request_callback_t * callback_handle;
7656	0	globus_result_t result = GLOBUS_SUCCESS;
7657
7658	0	callback_handle = globus_malloc(
7659		sizeof(GetResourceProperty_i_blocking_request_callback_t));
7660	0	globus_assert_string(callback_handle, "Memory allocation failed");
7661	0	memset(callback_handle, 0,
7662		sizeof(GetResourceProperty_i_blocking_request_callback_t));
7663
7664	0	callback_handle->callback = callback;
7665	0	callback_handle->args = user_args;
7666
7667	0	result = SubscriptionManager_GetResourceProperty_register_request(
7668		handle,
7669		endpoint,
7670		GetResourceProperty,
7671		GetResourceProperty_i_blocking_request_callback,
7672		callback_handle);
7673	0	if(result != GLOBUS_SUCCESS)
7674		{
7675	0	globus_free(callback_handle);
7676		goto exit;
7677		}
7678
7679		exit:
7680
7681	0	return result;
7682		}
7683
7684		typedef struct GetResourceProperty_i_blocking_response_callback_s
7685		{
7686		globus_result_t result;
7687		SubscriptionManager_GetResourceProperty_fault_t fault_type;
7688		xsd_any * fault;
7689		wsrp_GetResourcePropertyResponseType * GetResourcePropertyResponse;
7690		int done;
7691		globus_cond_t cond;
7692		globus_mutex_t mutex;
7693		} GetResourceProperty_i_blocking_response_callback_t;
7694
7695		static
7696		void
7697		GetResourceProperty_i_blocking_response_callback(
7698		SubscriptionManagerService_client_handle_t handle,
7699		void * user_args,
7700		globus_result_t result,
7701		const wsrp_GetResourcePropertyResponseType * GetResourcePropertyResponse,
7702		SubscriptionManager_GetResourceProperty_fault_t fault_type,
7703		const xsd_any * fault)
7704	0	{
7705	0	GetResourceProperty_i_blocking_response_callback_t * callback_handle;
7706
7707	0	callback_handle = (GetResourceProperty_i_blocking_response_callback_t *) user_args;
7708
7709	0	callback_handle->result = result;
7710	0	if(result == GLOBUS_SUCCESS)
7711		{
7712	0	wsrp_GetResourcePropertyResponseType_copy(
7713		&callback_handle->GetResourcePropertyResponse, GetResourcePropertyResponse);
7714		}
7715		else
7716		{
7717	0	callback_handle->fault_type = fault_type;
7718	0	if(fault_type != GLOBUS_SUCCESS)
7719		{
7720	0	xsd_any_copy(&callback_handle->fault, fault);
7721		}
7722		}
7723
7724	0	globus_mutex_lock(&callback_handle->mutex);
7725	0	globus_cond_signal(&callback_handle->cond);
7726	0	callback_handle->done = 1;
7727	0	globus_mutex_unlock(&callback_handle->mutex);
7728		}
7729
7730
7731		globus_result_t
7732		SubscriptionManager_GetResourceProperty_epr(
7733		SubscriptionManagerService_client_handle_t handle,
7734		const wsa_EndpointReferenceType * epr,
7735		const xsd_QName * GetResourceProperty,
7736		wsrp_GetResourcePropertyResponseType * * GetResourcePropertyResponse,
7737		SubscriptionManager_GetResourceProperty_fault_t * fault_type,
7738		xsd_any * * fault)
7739	0	{
7740	0	globus_result_t result = GLOBUS_SUCCESS;
7741
7742	0	globus_assert_string(epr, "NULL EndpointReference");
7743	0	globus_assert_string(epr->Address.base_value, "NULL EndpointReference Address");
7744
7745	0	*fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT;
7746
7747	0	globus_soap_message_attr_set(
7748		handle->attrs,
7749		WSADDR_EPR_KEY,
7750		wsa_EndpointReferenceType_copy_wrapper,
7751		wsa_EndpointReferenceType_destroy_wrapper,
7752		(void *)epr);
7753
7754	0	result = SubscriptionManager_GetResourceProperty(
7755		handle,
7756		epr->Address.base_value,
7757		GetResourceProperty,
7758		GetResourcePropertyResponse,
7759		fault_type,
7760		fault);
7761
7762	0	return result;
7763		}
7764
7765		globus_result_t
7766		SubscriptionManager_GetResourceProperty(
7767		SubscriptionManagerService_client_handle_t handle,
7768		const char * endpoint,
7769		const xsd_QName * GetResourceProperty,
7770		wsrp_GetResourcePropertyResponseType * * GetResourcePropertyResponse,
7771		SubscriptionManager_GetResourceProperty_fault_t * fault_type,
7772		xsd_any * * fault)
7773	0	{
7774	0	globus_result_t result = GLOBUS_SUCCESS;
7775
7776	0	GetResourceProperty_i_blocking_response_callback_t * callback_handle;
7777	0	*fault_type = SUBSCRIPTIONMANAGER_GETRESOURCEPROPERTY_NOFAULT;
7778
7779	0	callback_handle = globus_malloc(
7780		sizeof(GetResourceProperty_i_blocking_response_callback_t));
7781	0	globus_assert_string(callback_handle, "Memory allocation failed");
7782	0	memset(callback_handle, 0,
7783		sizeof(GetResourceProperty_i_blocking_response_callback_t));
7784
7785	0	globus_mutex_init(&callback_handle->mutex, NULL);
7786	0	globus_cond_init(&callback_handle->cond, NULL);
7787
7788	0	result = SubscriptionManager_GetResourceProperty_register(
7789		handle,
7790		endpoint,
7791		GetResourceProperty,
7792		GetResourceProperty_i_blocking_response_callback,
7793		callback_handle);
7794	0	if(result != GLOBUS_SUCCESS)
7795		{
7796	0	goto exit;
7797		}
7798
7799
7800	0	globus_mutex_lock(&callback_handle->mutex);
7801	0	while(!callback_handle->done)
7802		{
7803	0	globus_cond_wait(&callback_handle->cond, &callback_handle->mutex);
7804		}
7805	0	globus_mutex_unlock(&callback_handle->mutex);
7806
7807	0	result = callback_handle->result;
7808	0	if(result != GLOBUS_SUCCESS)
7809		{
7810
7811	0	*fault_type = callback_handle->fault_type;
7812	0	*fault = callback_handle->fault;
7813
7814	0	goto exit;
7815		}
7816
7817	0	*GetResourcePropertyResponse = callback_handle->GetResourcePropertyResponse;
7818
7819		exit:
7820
7821	0	globus_mutex_destroy(&callback_handle->mutex);
7822	0	globus_cond_destroy(&callback_handle->cond);
7823
7824	0	free(callback_handle);
7825
7826	0	return result;