1		/*
2		* Copyright 1999-2006 University of Chicago
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17
18		#include "globus_ws_addressing.h"
19		#include "globus_extension.h"
20		#include "globus_common.h"
21		#include "globus_handler.h"
22		#include "globus_soap_message_fault.h"
23		#include "globus_xml_buffer.h"
24		#include "globus_soap_message_attrs.h"
25
26		#include "wsa_AttributedURI.h"
27		#include "wsa_Relationship.h"
28		#include "wsa_EndpointReferenceType.h"
29
30		#include "wsa_MessageID.h"
31		#include "wsa_RelatesTo.h"
32		#include "wsa_To.h"
33		#include "wsa_Action.h"
34		#include "wsa_From.h"
35		#include "wsa_ReplyTo.h"
36		#include "wsa_FaultTo.h"
37
38		#include "version.h"
39
40		#define WS_ADDRESSING_CLIENT_REQUEST_ALREADY_INVOKED \
41		"WS_ADDRESSING_CLIENT_REQUEST_ALREADY_INVOKED"
42
43		#define WS_ADDRESSING_CLIENT_MESSAGEID_ALREADY_INVOKED \
44		"WS_ADDRESSING_CLIENT_MESSAGEID_ALREADY_INVOKED"
45
46		#define WS_ADDRESSING_CLIENT_RELATESTO_ALREADY_INVOKED \
47		"WS_ADDRESSING_CLIENT_RELATESTO_ALREADY_INVOKED"
48
49		#define WS_ADDRESSING_CLIENT_TO_ALREADY_INVOKED \
50		"WS_ADDRESSING_CLIENT_TO_ALREADY_INVOKED"
51
52		#define WS_ADDRESSING_CLIENT_ACTION_ALREADY_INVOKED \
53		"WS_ADDRESSING_CLIENT_ACTION_ALREADY_INVOKED"
54
55		#define WS_ADDRESSING_CLIENT_FROM_ALREADY_INVOKED \
56		"WS_ADDRESSING_CLIENT_FROM_ALREADY_INVOKED"
57
58		#define WS_ADDRESSING_CLIENT_RESPONSE_ALREADY_INVOKED \
59		"WS_ADDRESSING_CLIENT_RESPONSE_ALREADY_INVOKED"
60
61		#define WS_ADDRESSING_SERVER_RESPONSE_ALREADY_INVOKED \
62		"WS_ADDRESSING_SERVER_RESPONSE_ALREADY_INVOKED"
63
64		#define WS_ADDRESSING_SERVER_MESSAGEID_ALREADY_INVOKED \
65		"WS_ADDRESSING_SERVER_MESSAGEID_ALREADY_INVOKED"
66
67		#define WS_ADDRESSING_SERVER_RELATESTO_ALREADY_INVOKED \
68		"WS_ADDRESSING_SERVER_RELATESTO_ALREADY_INVOKED"
69
70		#define WS_ADDRESSING_SERVER_TO_ALREADY_INVOKED \
71		"WS_ADDRESSING_SERVER_TO_ALREADY_INVOKED"
72
73		#define WS_ADDRESSING_SERVER_ACTION_ALREADY_INVOKED \
74		"WS_ADDRESSING_SERVER_ACTION_ALREADY_INVOKED"
75
76		#define WS_ADDRESSING_SERVER_FROM_ALREADY_INVOKED \
77		"WS_ADDRESSING_SERVER_FROM_ALREADY_INVOKED"
78
79		#define WS_ADDRESSING_SERVER_REQUEST_ALREADY_INVOKED \
80		"WS_ADDRESSING_SERVER_REQUEST_ALREADY_INVOKED"
81
82
83		int
84		globus_l_handler_ws_addressing_activate(void);
85
86		int
87		globus_l_handler_ws_addressing_deactivate(void);
88
89
90		GlobusExtensionDefineModule(globus_handler_ws_addressing) =
91		{
92		GLOBUS_HANDLER_WS_ADDRESSING_MODULE,
93		globus_l_handler_ws_addressing_activate,
94		globus_l_handler_ws_addressing_deactivate,
95		NULL,
96		NULL,
97		&local_version
98		};
99
100		#define GLOBUS_L_WS_ADDRESSING_DEBUG_TRACE 2
101		#define GLOBUS_L_WS_ADDRESSING_DEBUG_DEBUG 4
102
103	0	GlobusDebugDefine(GLOBUS_HANDLER_WS_ADDRESSING);
104
105		#define GlobusWSAddressingDebugPrintf(LEVEL, MESSAGE) \
106		GlobusDebugPrintf(GLOBUS_HANDLER_WS_ADDRESSING, LEVEL, MESSAGE)
107
108		#define GlobusWSAddressingDebugEnter() \
109		GlobusWSAddressingDebugPrintf(GLOBUS_L_WS_ADDRESSING_DEBUG_TRACE, \
110		("[%s] Entering", _globus_func_name))
111
112		#define GlobusWSAddressingDebugExit() \
113		GlobusWSAddressingDebugPrintf(GLOBUS_L_WS_ADDRESSING_DEBUG_TRACE, \
114		("[%s] Exiting", _globus_func_name))
115
116		#define GlobusWSAddressingErrorSerializeFailed(ERROR, MESSAGE)          \
117		globus_error_put(                                                   \
118		globus_error_construct_error(                                   \
119		GlobusExtensionMyModule(globus_handler_ws_addressing),      \
120		(ERROR ? globus_error_get(ERROR) : NULL),                   \
121		0,                                                          \
122		__FILE__,                                                   \
123		_globus_func_name,                                          \
124		__LINE__,                                                   \
125		MESSAGE))
126
127		#define GlobusWSAddressingErrorDeserializeFailed(ERROR, MESSAGE)        \
128		globus_error_put(                                                   \
129		globus_error_construct_error(                                   \
130		GlobusExtensionMyModule(globus_handler_ws_addressing),      \
131		(ERROR ? globus_error_get(ERROR) : NULL),                   \
132		0,                                                          \
133		__FILE__,                                                   \
134		_globus_func_name,                                          \
135		__LINE__,                                                   \
136		globus_common_create_string MESSAGE))
137
138		#define GlobusWSAddressingErrorRequiredElementNotFound(MESSAGE)         \
139		globus_error_put(                                                   \
140		globus_error_construct_error(                                   \
141		GlobusExtensionMyModule(globus_handler_ws_addressing),      \
142		NULL,                                                       \
143		0,                                                          \
144		__FILE__,                                                   \
145		_globus_func_name,                                          \
146		__LINE__,                                                   \
147		"Required element %s not found", MESSAGE))
148
149		#define GlobusWSAddressingErrorMemoryAllocationFailed(LENGTH, MESSAGE) \
150		globus_error_put(                                                  \
151		globus_error_construct_error(                                  \
152		GlobusExtensionMyModule(globus_handler_ws_addressing),     \
153		NULL,                                                      \
154		0,                                                         \
155		__FILE__,                                                  \
156		_globus_func_name,                                         \
157		__LINE__,                                                  \
158		"Memory allocation failed (%d bytes): %s",                 \
159		LENGTH, MESSAGE))
160
161		#define GlobusWSAddressingErrorFailedDefaultTrigger(ELEMENT)        \
162		globus_error_put(                                               \
163		globus_error_construct_error(                               \
164		GlobusExtensionMyModule(globus_handler_ws_addressing),  \
165		NULL,                                                   \
166		0,                                                      \
167		__FILE__,                                               \
168		_globus_func_name,                                      \
169		__LINE__,                                               \
170		"Failed to handle {%s}%s element",                      \
171		ELEMENT->Namespace,                                     \
172		ELEMENT->local))
173
174		static
175		globus_result_t
176		globus_l_uuid_copy(
177		void **                             new_id,
178		const void *                        id);
179
180		void
181		globus_handler_ws_addressing_client_request_invoke(
182		globus_handler_session_descriptor_t session,
183		globus_soap_message_handle_t        message_handle,
184		globus_result_t                     result)
185		{
186	3267	globus_uuid_t *                     uuid = NULL;
187	3267	char *                              uuid_string = NULL;
188	3267	wsa_AttributedURI                   MessageID;
189	3267	wsa_AttributedURI                   To;
190	3267	wsa_AttributedURI                   Action;
191	3267	char *                              action_uri = NULL;
192	3267	wsa_EndpointReferenceType           default_From;
193	3267	wsa_EndpointReferenceType *         source_endpoint = NULL;
194	3267	wsa_EndpointReferenceType *         reply_endpoint = NULL;
195	3267	wsa_EndpointReferenceType *         fault_endpoint = NULL;
196	3267	wsa_EndpointReferenceType *         endpoint_reference = NULL;
197	3267	GlobusFuncName(globus_ws_addressing_handler_client_request_invoke);
198	3267	GlobusWSAddressingDebugEnter();
199
200	3267	if(result != GLOBUS_SUCCESS)
201		{
202	0	goto exit;
203		}
204
205	3267	if(globus_soap_message_handle_get_attr(
206		message_handle,
207		WS_ADDRESSING_CLIENT_REQUEST_ALREADY_INVOKED))
208		{
209	0	goto exit;
210		}
211
212	3267	endpoint_reference = (wsa_EndpointReferenceType *)
213		globus_soap_message_handle_get_attr(
214		message_handle, WSADDR_OUTBOUND_EPR_KEY);
215	3267	if(!endpoint_reference)
216		{
217	3267	endpoint_reference = (wsa_EndpointReferenceType *)
218		globus_soap_message_handle_get_attr(
219		message_handle, WSADDR_EPR_KEY);
220		}
221
222	3267	uuid = globus_malloc(sizeof(globus_uuid_t));
223	3267	if(!uuid)
224		{
225	0	result = GlobusWSAddressingErrorMemoryAllocationFailed(
226		sizeof(globus_uuid_t), "uuid");
227	0	goto exit;
228		}
229
230	3267	globus_uuid_create(uuid);
231
232	3267	uuid_string = globus_common_create_string("uuid:%s", uuid->text);
233	3267	MessageID.base_value = uuid_string;
234	3267	MessageID.anyAttributes = NULL;
235
236	3267	result = wsa_AttributedURI_serialize(
237		(xsd_QName *)&wsa_MessageID_qname,
238		&MessageID,
239		message_handle,
240		0);
241	3267	if(result != GLOBUS_SUCCESS)
242		{
243	0	globus_free(uuid_string);
244	0	globus_free(uuid);
245	0	result = GlobusWSAddressingErrorSerializeFailed(
246		result, "MessageID element");
247	0	goto exit;
248		}
249
250	3267	globus_free(uuid_string);
251
252	3267	globus_soap_message_handle_set_attr(
253		message_handle,
254		WSADDR_OUTBOUND_MESSAGE_ID_KEY,
255		globus_l_uuid_copy,
256		globus_libc_free,
257		(void *) uuid);
258
259	3267	globus_free(uuid);
260
261	3267	To.base_value = (char *) globus_soap_message_handle_get_attr(
262		message_handle, WSADDR_DESTINATION_KEY);
263	3267	if(!To.base_value)
264		{
265	0	result = GlobusWSAddressingErrorSerializeFailed(
266		GLOBUS_SUCCESS, "No destination endpoint");
267	0	goto exit;
268		}
269
270	3267	To.anyAttributes = NULL;
271
272	3267	result = wsa_AttributedURI_serialize(
273		(xsd_QName *)&wsa_To_qname,
274		&To,
275		message_handle,
276		0);
277	3267	if(result != GLOBUS_SUCCESS)
278		{
279	0	result = GlobusWSAddressingErrorSerializeFailed(
280		result, "To element");
281	0	goto exit;
282		}
283
284	3267	action_uri = (char *) globus_soap_message_handle_get_attr(
285		message_handle, WSADDR_ACTION_REQUEST_KEY);
286	3267	if(!action_uri)
287		{
288	0	result = GlobusWSAddressingErrorSerializeFailed(
289		GLOBUS_SUCCESS, "No SOAPAction defined");
290	0	goto exit;
291		}
292
293	3267	Action.base_value = action_uri;
294	3267	Action.anyAttributes = NULL;
295
296	3267	result = wsa_AttributedURI_serialize(
297		(xsd_QName *)&wsa_Action_qname,
298		&Action,
299		message_handle,
300		0);
301	3267	if(result != GLOBUS_SUCCESS)
302		{
303	0	result = GlobusWSAddressingErrorSerializeFailed(
304		result, "Action element");
305	0	goto exit;
306		}
307
308	3267	source_endpoint = globus_soap_message_handle_get_attr(
309		message_handle,
310		WSADDR_SOURCE_ENDPOINT_KEY);
311	3267	if(!source_endpoint)
312		{
313	3267	memset(&default_From, 0, sizeof(wsa_EndpointReferenceType));
314	3267	default_From.Address.base_value = WSADDRESSING_ANON_NS;
315	3267	source_endpoint = &default_From;
316		}
317
318	3267	result = wsa_EndpointReferenceType_serialize(
319		(xsd_QName *)&wsa_From_qname,
320		source_endpoint,
321		message_handle,
322		0);
323	3267	if(result != GLOBUS_SUCCESS)
324		{
325	0	result = GlobusWSAddressingErrorSerializeFailed(
326		result, "From element");
327	0	goto exit;
328		}
329
330	3267	reply_endpoint = globus_soap_message_handle_get_attr(
331		message_handle,
332		WSADDR_REPLY_ENDPOINT_KEY);
333	3267	if(reply_endpoint)
334		{
335
336	0	result = wsa_EndpointReferenceType_serialize(
337		(xsd_QName *)&wsa_ReplyTo_qname,
338		reply_endpoint,
339		message_handle,
340		0);
341	0	if(result != GLOBUS_SUCCESS)
342		{
343	0	result = GlobusWSAddressingErrorSerializeFailed(
344		result, "ReplyTo element");
345	0	goto exit;
346		}
347		}
348
349	3267	fault_endpoint = globus_soap_message_handle_get_attr(
350		message_handle,
351		WSADDR_FAULT_ENDPOINT_KEY);
352	3267	if(fault_endpoint)
353		{
354	0	result = wsa_EndpointReferenceType_serialize(
355		(xsd_QName *)&wsa_FaultTo_qname,
356		fault_endpoint,
357		message_handle,
358		0);
359	0	if(result != GLOBUS_SUCCESS)
360		{
361	0	result = GlobusWSAddressingErrorSerializeFailed(
362		result, "FaultTo element");
363	0	goto exit;
364		}
365		}
366
367	3267	if(endpoint_reference && endpoint_reference->ReferenceProperties)
368		{
369	3169	wsa_ReferencePropertiesType * props;
370	3169	int i = 0;
371
372	3169	props = endpoint_reference->ReferenceProperties;
373	9507	for(; i < props->any.length; ++i)
374		{
375	3169	result = props->any.elements[i].any_info->serialize(
376		props->any.elements[i].element,
377		props->any.elements[i].value,
378		message_handle,
379		0);
380	3169	if(result != GLOBUS_SUCCESS)
381		{
382	0	result = GlobusWSAddressingErrorSerializeFailed(
383		result, "Reference Properties");
384	0	goto exit;
385		}
386		}
387		}
388
389	3267	globus_soap_message_handle_set_attr(
390		message_handle,
391		WS_ADDRESSING_CLIENT_REQUEST_ALREADY_INVOKED,
392		NULL, NULL, (void *)1);
393
394		exit:
395
396	3267	globus_handler_finished(session, result);
397	3267	GlobusWSAddressingDebugExit();
398		}
399
400		static
401		void
402		globus_l_handler_ws_addressing_client_invoke_MessageID(
403		globus_handler_session_descriptor_t session,
404		globus_soap_message_handle_t        message_handle,
405		globus_result_t                     result)
406	3246	{
407	3246	wsa_AttributedURI                   value;
408	3246	globus_uuid_t *                     message_uuid = NULL;
409	3246	GlobusFuncName(globus_ws_addressing_handler_client_invoke_MessageID);
410	3246	GlobusWSAddressingDebugEnter();
411
412	3246	if(result != GLOBUS_SUCCESS)
413		{
414	0	goto exit;
415		}
416
417	3246	if(globus_soap_message_handle_get_attr(
418		message_handle,
419		WS_ADDRESSING_CLIENT_MESSAGEID_ALREADY_INVOKED))
420		{
421	0	goto exit;
422		}
423
424	3246	wsa_AttributedURI_init_contents(&value);
425
426	3246	result = wsa_AttributedURI_deserialize(
427		&wsa_MessageID_qname,
428		&value,
429		message_handle,
430		0);
431	3246	if(result != GLOBUS_SUCCESS)
432		{
433	0	result = GlobusWSAddressingErrorDeserializeFailed(
434		result,
435		("Failed to deserialize MessageID"));
436	0	goto exit;
437		}
438
439	3246	message_uuid = globus_malloc(sizeof(globus_uuid_t));
440	3246	if(!message_uuid)
441		{
442	0	result = GlobusWSAddressingErrorMemoryAllocationFailed(
443		sizeof(globus_uuid_t), "message uuid");
444	0	goto exit;
445		}
446
447	3246	result = globus_uuid_import(
448		message_uuid, value.base_value + 5);
449	3246	if(result != GLOBUS_SUCCESS)
450		{
451	0	globus_free(message_uuid);
452	0	result = GlobusWSAddressingErrorDeserializeFailed(
453		GLOBUS_SUCCESS,
454		("Failed to import uuid from string; %s",
455		value.base_value));
456	0	goto MessageID_destroy;
457		}
458
459	3246	globus_soap_message_handle_set_attr(
460		message_handle,
461		WSADDR_MESSAGE_ID_KEY,
462		globus_l_uuid_copy,
463		globus_libc_free,
464		(void *) message_uuid);
465
466	3246	globus_free(message_uuid);
467
468		MessageID_destroy:
469
470	3246	wsa_AttributedURI_destroy_contents(&value);
471
472	3246	globus_soap_message_handle_set_attr(
473		message_handle,
474		WS_ADDRESSING_CLIENT_MESSAGEID_ALREADY_INVOKED,
475		NULL, NULL, (void *)1);
476
477		exit:
478
479	3246	GlobusWSAddressingDebugExit();
480	3246	globus_handler_finished(session, result);
481		return;
482		}
483
484		static
485		void
486		globus_l_handler_ws_addressing_client_invoke_RelatesTo(
487		globus_handler_session_descriptor_t session,
488		globus_soap_message_handle_t        message_handle,
489		globus_result_t                     result)
490	3245	{
491	3245	wsa_Relationship                    value;
492	3245	globus_uuid_t *                     message_uuid;
493	3245	globus_uuid_t *                     outbound_uuid = NULL;
494	3245	GlobusFuncName(globus_ws_addressing_handler_client_invoke_RelatesTo);
495	3245	GlobusWSAddressingDebugEnter();
496
497	3245	if(result != GLOBUS_SUCCESS)
498		{
499	0	goto exit;
500		}
501
502	3245	if(globus_soap_message_handle_get_attr(
503		message_handle,
504		WS_ADDRESSING_CLIENT_RELATESTO_ALREADY_INVOKED))
505		{
506	0	goto exit;
507		}
508
509	3245	wsa_Relationship_init_contents(&value);
510
511	3245	result = wsa_Relationship_deserialize(
512		&wsa_RelatesTo_qname,
513		&value,
514		message_handle,
515		0);
516	3245	if(result != GLOBUS_SUCCESS)
517		{
518	0	result = GlobusWSAddressingErrorDeserializeFailed(
519		result,
520		("Failed to deserialize RelatesTo"));
521	0	goto exit;
522		}
523
524	3245	if(!value.base_value)
525		{
526	0	result = GlobusWSAddressingErrorDeserializeFailed(
527		GLOBUS_SUCCESS,
528		("Failed to get required UUID value from "
529		"message information header element: RelatesTo"));
530	0	goto exit;
531		}
532
533	3245	message_uuid = globus_malloc(sizeof(globus_uuid_t));
534	3245	if(!message_uuid)
535		{
536	0	result = GlobusWSAddressingErrorMemoryAllocationFailed(
537		sizeof(globus_uuid_t), "message uuid");
538	0	goto exit;
539		}
540
541	3245	result = globus_uuid_import(
542		message_uuid, value.base_value + 5);
543	3245	if(result != GLOBUS_SUCCESS)
544		{
545	0	result = GlobusWSAddressingErrorDeserializeFailed(
546		GLOBUS_SUCCESS,
547		("Failed to import uuid from string; %s",
548		value));
549	0	goto RelatesTo_destroy;
550		}
551
552	3245	outbound_uuid =
553		(globus_uuid_t *) globus_soap_message_handle_get_attr(
554		message_handle,
555		WSADDR_OUTBOUND_MESSAGE_ID_KEY);
556	3245	if(!outbound_uuid)
557		{
558	0	result = GlobusWSAddressingErrorDeserializeFailed(
559		GLOBUS_SUCCESS,
560		("Failed to get request message UUID"
561		" from message properties"));
562	0	goto RelatesTo_destroy;
563		}
564
565	3245	if(! GLOBUS_UUID_MATCH((*outbound_uuid), (*message_uuid)))
566		{
567	0	result = GlobusWSAddressingErrorDeserializeFailed(
568		GLOBUS_SUCCESS,
569		("UUID match failure: request message UUID: %s\n"
570		"                    response message UUID: %s\n",
571		outbound_uuid->text, message_uuid->text));
572	0	goto RelatesTo_destroy;
573		}
574
575	3245	globus_soap_message_handle_set_attr(
576		message_handle,
577		WSADDR_RELATES_TO_KEY,
578		globus_l_uuid_copy,
579		globus_libc_free,
580		(void *)message_uuid);
581
582	3245	globus_free(message_uuid);
583
584		RelatesTo_destroy:
585
586	3245	wsa_Relationship_destroy_contents(&value);
587
588	3245	globus_soap_message_handle_set_attr(
589		message_handle,
590		WS_ADDRESSING_CLIENT_RELATESTO_ALREADY_INVOKED,
591		NULL, NULL, (void *)1);
592
593		exit:
594
595	3245	GlobusWSAddressingDebugExit();
596	3245	globus_handler_finished(session, result);
597		return;
598		}
599
600		static
601		void
602		globus_l_handler_ws_addressing_client_invoke_To(
603		globus_handler_session_descriptor_t session,
604		globus_soap_message_handle_t        message_handle,
605		globus_result_t                     result)
606	3245	{
607	3245	wsa_AttributedURI                   value;
608	3245	char *                              source_endpoint = NULL;
609	3245	GlobusFuncName(globus_ws_addressing_handler_client_invoke_To);
610	3245	GlobusWSAddressingDebugEnter();
611
612	3245	if(result != GLOBUS_SUCCESS)
613		{
614	0	goto exit;
615		}
616
617	3245	if(globus_soap_message_handle_get_attr(
618		message_handle,
619		WS_ADDRESSING_CLIENT_TO_ALREADY_INVOKED))
620		{
621	0	goto exit;
622		}
623
624	3245	wsa_AttributedURI_init_contents(&value);
625
626	3245	result = wsa_AttributedURI_deserialize(
627		&wsa_To_qname,
628		&value,
629		message_handle,
630		0);
631	3245	if(result != GLOBUS_SUCCESS)
632		{
633	0	result = GlobusWSAddressingErrorDeserializeFailed(
634		result,
635		("Failed to deserialize Action"));
636	0	goto exit;
637		}
638
639	3245	source_endpoint = globus_soap_message_handle_get_attr(
640		message_handle,
641		WSADDR_SOURCE_ENDPOINT_KEY);
642	3245	if(source_endpoint && strcmp(source_endpoint, value.base_value))
643		{
644	0	result = GlobusWSAddressingErrorDeserializeFailed(
645		GLOBUS_SUCCESS,
646		("Expected source endpoint: %s in "
647		"To field of reply, received: %s",
648		source_endpoint,
649		value.base_value));
650	0	goto To_destroy;
651		}
652	3245	else if(!source_endpoint && strncmp(WSADDRESSING_ANON_NS,
653		value.base_value,
654		sizeof(WSADDRESSING_ANON_NS)))
655		{
656	0	result = GlobusWSAddressingErrorDeserializeFailed(
657		GLOBUS_SUCCESS,
658		("Expected anonymous endpoint in "
659		"To field of reply"));
660		goto To_destroy;
661		}
662
663		To_destroy:
664
665	3245	wsa_AttributedURI_destroy_contents(&value);
666
667	3245	globus_soap_message_handle_set_attr(
668		message_handle,
669		WS_ADDRESSING_CLIENT_TO_ALREADY_INVOKED,
670		NULL, NULL, (void *)1);
671
672		exit:
673
674	3245	GlobusWSAddressingDebugExit();
675	3245	globus_handler_finished(session, result);
676		return;
677		}
678
679		static
680		void
681		globus_l_handler_ws_addressing_client_invoke_Action(
682		globus_handler_session_descriptor_t session,
683		globus_soap_message_handle_t        message_handle,
684		globus_result_t                     result)
685	3246	{
686	3246	wsa_AttributedURI                   value;
687	3246	char *                              response_action = NULL;
688	3246	GlobusFuncName(globus_ws_addressing_handler_client_invoke_Action);
689	3246	GlobusWSAddressingDebugEnter();
690
691	3246	if(result != GLOBUS_SUCCESS)
692		{
693	0	goto exit;
694		}
695
696	3246	if(globus_soap_message_handle_get_attr(
697		message_handle,
698		WS_ADDRESSING_CLIENT_ACTION_ALREADY_INVOKED))
699		{
700	0	goto exit;
701		}
702
703	3246	wsa_AttributedURI_init_contents(&value);
704
705	3246	result = wsa_AttributedURI_deserialize(
706		&wsa_Action_qname,
707		&value,
708		message_handle,
709		0);
710	3246	if(result != GLOBUS_SUCCESS)
711		{
712	0	result = GlobusWSAddressingErrorDeserializeFailed(
713		result,
714		("Failed to deserialize Action"));
715	0	goto exit;
716		}
717
718	3246	if(!strncmp(WSADDRESSING_FAULT_NS,
719		value.base_value,
720		sizeof(WSADDRESSING_FAULT_NS)))
721		{
722		/* found a fault */
723	79	result = GLOBUS_SUCCESS;
724	79	goto Action_destroy;
725		}
726
727	3167	response_action = globus_soap_message_handle_get_attr(
728		message_handle,
729		WSADDR_ACTION_RESPONSE_KEY);
730	3167	if(!response_action || strcmp(response_action, value.base_value))
731		{
732	0	result = GlobusWSAddressingErrorDeserializeFailed(
733		GLOBUS_SUCCESS,
734		("\nExpected Action element: %s"
735		"\n             But received: %s",
736		(value.base_value ? value.base_value : "(null)"),
737		response_action));
738	0	goto Action_destroy;
739		}
740
741	3167	globus_soap_message_handle_set_attr(
742		message_handle,
743		WSADDR_ACTION_RESPONSE_KEY,
744		globus_soap_message_attr_copy_string,
745		globus_libc_free,
746		value.base_value);
747
748		Action_destroy:
749
750	3246	wsa_AttributedURI_destroy_contents(&value);
751
752	3246	globus_soap_message_handle_set_attr(
753		message_handle,
754		WS_ADDRESSING_CLIENT_ACTION_ALREADY_INVOKED,
755		NULL, NULL, (void *)1);
756
757		exit:
758
759	3246	GlobusWSAddressingDebugExit();
760	3246	globus_handler_finished(session, result);
761		return;
762		}
763
764		static
765		void
766		globus_l_handler_ws_addressing_client_invoke_From(
767		globus_handler_session_descriptor_t session,
768		globus_soap_message_handle_t        message_handle,
769		globus_result_t                     result)
770	942	{
771	942	char *                              destination;
772	942	wsa_EndpointReferenceType *         from_epr;
773	942	GlobusFuncName(globus_ws_addressing_handler_client_invoke_From);
774	942	GlobusWSAddressingDebugEnter();
775
776	942	if(result != GLOBUS_SUCCESS)
777		{
778	0	goto exit;
779		}
780
781	942	if(globus_soap_message_handle_get_attr(
782		message_handle,
783		WS_ADDRESSING_CLIENT_FROM_ALREADY_INVOKED))
784		{
785	0	goto exit;
786		}
787
788	942	wsa_EndpointReferenceType_init(
789		&from_epr);
790
791	942	result = wsa_EndpointReferenceType_deserialize(
792		&wsa_From_qname,
793		from_epr,
794		message_handle,
795		0);
796	942	if(result != GLOBUS_SUCCESS)
797		{
798	0	result = GlobusWSAddressingErrorDeserializeFailed(
799		result, ("Failed to deserialize From element"));
800	0	goto exit;
801		}
802
803	942	destination =
804		globus_soap_message_handle_get_attr(
805		message_handle,
806		WSADDR_DESTINATION_KEY);
807	942	if(!destination)
808		{
809	0	result = GlobusWSAddressingErrorDeserializeFailed(
810		GLOBUS_SUCCESS,
811		("No destination endpoint"));
812	0	goto destroy_From;
813		}
814
815	942	if(xmlStrcmp((xmlChar *) destination, (xmlChar *) from_epr->Address.base_value))
816		{
817	0	result = GlobusWSAddressingErrorDeserializeFailed(
818		GLOBUS_SUCCESS,
819		("Received From:Address: %s\nExpected: %s",
820		from_epr->Address.base_value, destination));
821	0	goto destroy_From;
822		}
823
824	942	result = globus_soap_message_handle_set_attr(
825		message_handle, WSADDR_EPR_KEY,
826		wsa_EndpointReferenceType_copy_wrapper,
827		wsa_EndpointReferenceType_destroy_wrapper,
828		(void *)from_epr);
829	942	if(result != GLOBUS_SUCCESS)
830		{
831	0	result = GlobusWSAddressingErrorDeserializeFailed(
832		result, ("Failed to set EndpointReference "
833		"in message properties"));
834		goto destroy_From;
835		}
836
837		destroy_From:
838
839	942	wsa_EndpointReferenceType_destroy(from_epr);
840
841	942	globus_soap_message_handle_set_attr(
842		message_handle,
843		WS_ADDRESSING_CLIENT_FROM_ALREADY_INVOKED,
844		NULL, NULL, (void *)1);
845
846		exit:
847
848	942	GlobusWSAddressingDebugExit();
849	942	globus_handler_finished(session, result);
850		return;
851		}
852
853		static
854		void
855		globus_handler_ws_addressing_client_response_invoke(
856		globus_handler_session_descriptor_t session,
857		globus_soap_message_handle_t        message_handle,
858		globus_result_t                     result)
859	3167	{
860	3167	GlobusFuncName(globus_ws_addressing_handler_client_response_invoke);
861	3167	GlobusWSAddressingDebugEnter();
862
863	3167	if(globus_soap_message_handle_get_attr(
864		message_handle,
865		WS_ADDRESSING_CLIENT_RESPONSE_ALREADY_INVOKED))
866		{
867	0	goto exit;
868		}
869
870	3167	if(!globus_soap_message_handle_get_attr(
871		message_handle,
872		WSADDR_ACTION_RESPONSE_KEY))
873		{
874	0	result = GlobusWSAddressingErrorRequiredElementNotFound(
875		"{"WSADDRESSING_NS"}Action");
876	0	goto exit;
877		}
878
879	3167	if(!globus_soap_message_handle_get_attr(
880		message_handle,
881		WSADDR_DESTINATION_KEY))
882		{
883	0	result = GlobusWSAddressingErrorRequiredElementNotFound(
884		"{"WSADDRESSING_NS"}To");
885	0	goto exit;
886		}
887
888	3167	if(!globus_soap_message_handle_get_attr(
889		message_handle,
890		WSADDR_RELATES_TO_KEY))
891		{
892	0	result = GlobusWSAddressingErrorRequiredElementNotFound(
893		"{"WSADDRESSING_NS"}RelatesTo");
894	0	goto exit;
895		}
896
897	3167	globus_soap_message_handle_set_attr(
898		message_handle,
899		WS_ADDRESSING_CLIENT_RESPONSE_ALREADY_INVOKED,
900		NULL, NULL, (void *)1);
901
902		exit:
903
904	3167	GlobusWSAddressingDebugExit();
905	3167	globus_handler_finished(session, result);
906		return;
907		}
908
909
910		void
911		globus_handler_ws_addressing_server_response_invoke(
912		globus_handler_session_descriptor_t session,
913		globus_soap_message_handle_t        message_handle,
914		globus_result_t                     result)
915	2394	{
916	2394	globus_uuid_t *                     uuid = NULL;
917	2394	char *                              uuid_string = NULL;
918	2394	wsa_AttributedURI                   MessageID;
919	2394	wsa_AttributedURI                   To;
920	2394	wsa_AttributedURI                   Action;
921	2394	wsa_AttributedURI                   RelatesTo;
922	2394	char *                              soap_action = NULL;
923	2394	wsa_EndpointReferenceType *         endpoint_reference = NULL;
924	2394	wsa_EndpointReferenceType *         source_endpoint = NULL;
925	2394	wsa_EndpointReferenceType           default_From;
926	2394	GlobusFuncName(globus_handler_ws_addressing_server_response_invoke);
927	2394	GlobusWSAddressingDebugEnter();
928
929	2394	if(result != GLOBUS_SUCCESS)
930		{
931	0	goto exit;
932		}
933
934	2394	if(globus_soap_message_handle_get_attr(
935		message_handle,
936		WS_ADDRESSING_SERVER_RESPONSE_ALREADY_INVOKED))
937		{
938	0	goto exit;
939		}
940
941	2394	endpoint_reference = (wsa_EndpointReferenceType *)
942		globus_soap_message_handle_get_attr(
943		message_handle, WSADDR_OUTBOUND_EPR_KEY);
944	2394	if(!endpoint_reference)
945		{
946	2394	endpoint_reference = (wsa_EndpointReferenceType *)
947		globus_soap_message_handle_get_attr(
948		message_handle, WSADDR_EPR_KEY);
949		}
950
951	2394	uuid = malloc(sizeof(globus_uuid_t));
952	2394	if(!uuid)
953		{
954	0	result = GlobusWSAddressingErrorMemoryAllocationFailed(
955		sizeof(globus_uuid_t), "uuid");
956	0	goto exit;
957		}
958	2394	globus_uuid_create(uuid);
959
960	2394	uuid_string = globus_common_create_string("uuid:%s", uuid->text);
961	2394	MessageID.base_value = uuid_string;
962	2394	MessageID.anyAttributes = NULL;
963
964	2394	result = wsa_AttributedURI_serialize(
965		(xsd_QName *)&wsa_MessageID_qname,
966		&MessageID,
967		message_handle,
968		0);
969	2394	if(result != GLOBUS_SUCCESS)
970		{
971	0	result = GlobusWSAddressingErrorSerializeFailed(
972		result, "MessageID element");
973	0	goto exit;
974		}
975
976	2394	To.anyAttributes = NULL;
977	2394	To.base_value = globus_soap_message_handle_get_attr(
978		message_handle, WSADDR_REQUEST_ENDPOINT_KEY);
979	2394	result = wsa_AttributedURI_serialize(
980		(xsd_QName *)&wsa_To_qname,
981		&To,
982		message_handle,
983		0);
984	2394	if(result != GLOBUS_SUCCESS)
985		{
986	0	result = GlobusWSAddressingErrorSerializeFailed(
987		result, "To element");
988	0	goto exit;
989		}
990
991	2394	source_endpoint = globus_soap_message_handle_get_attr(
992		message_handle, WSADDR_SOURCE_ENDPOINT_KEY);
993	2394	if(!source_endpoint)
994		{
995	2394	char *                          base_service_endpoint;
996	2394	memset(&default_From, 0, sizeof(wsa_EndpointReferenceType));
997	2394	base_service_endpoint =
998		globus_soap_message_handle_get_attr(
999		message_handle,
1000		GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY);
1001	2394	if(default_From.Address.base_value)
1002		{
1003	0	default_From.ReferenceProperties =
1004		(endpoint_reference ?
1005		endpoint_reference->ReferenceProperties : NULL);
1006	0	source_endpoint = &default_From;
1007		}
1008		}
1009
1010	2394	if(source_endpoint)
1011		{
1012	0	result = wsa_EndpointReferenceType_serialize(
1013		(xsd_QName *)&wsa_From_qname,
1014		source_endpoint,
1015		message_handle,
1016		0);
1017	0	if(result != GLOBUS_SUCCESS)
1018		{
1019	0	result = GlobusWSAddressingErrorSerializeFailed(
1020		GLOBUS_FAILURE, "{"WSADDRESSING_NS"}From element");
1021	0	goto exit;
1022		}
1023		}
1024
1025	2394	soap_action = (char *) globus_soap_message_handle_get_attr(
1026		message_handle, WSADDR_ACTION_RESPONSE_KEY);
1027	2394	if(!soap_action)
1028		{
1029	0	result = GlobusWSAddressingErrorSerializeFailed(
1030		GLOBUS_FAILURE,
1031		"No "WSADDRESSING_NS
1032		"#ResponseAction property defined");
1033	0	goto exit;
1034		}
1035
1036	2394	Action.base_value = soap_action;
1037	2394	Action.anyAttributes = NULL;
1038
1039	2394	result = wsa_AttributedURI_serialize(
1040		(xsd_QName *)&wsa_Action_qname,
1041		&Action,
1042		message_handle,
1043		0);
1044	2394	if(result != GLOBUS_SUCCESS)
1045		{
1046	0	result = GlobusWSAddressingErrorSerializeFailed(
1047		result, "Action element");
1048	0	goto exit;
1049		}
1050
1051	2394	uuid_string = globus_soap_message_handle_get_attr(
1052		message_handle,
1053		WSADDR_INBOUND_MESSAGE_ID_KEY);
1054	2394	if(!uuid_string)
1055		{
1056	91	result = GlobusWSAddressingErrorSerializeFailed(
1057		result, "RelatesTo element");
1058	91	goto exit;
1059		}
1060
1061	2303	RelatesTo.base_value = uuid_string;
1062	2303	RelatesTo.anyAttributes = NULL;
1063
1064	2303	result = wsa_AttributedURI_serialize(
1065		(xsd_QName *)&wsa_RelatesTo_qname,
1066		&RelatesTo,
1067		message_handle,
1068		0);
1069	2303	if(result != GLOBUS_SUCCESS)
1070		{
1071	0	result = GlobusWSAddressingErrorSerializeFailed(
1072		result, "RelatesTo element");
1073	0	goto exit;
1074		}
1075
1076	2303	globus_soap_message_handle_set_attr(
1077		message_handle,
1078		WS_ADDRESSING_SERVER_RESPONSE_ALREADY_INVOKED,
1079		NULL, NULL, (void *)1);
1080
1081		exit:
1082
1083	2394	globus_handler_finished(session, result);
1084	2394	GlobusWSAddressingDebugExit();
1085	2394	return;
1086		}
1087
1088		static
1089		void
1090		globus_l_handler_ws_addressing_server_invoke_MessageID(
1091		globus_handler_session_descriptor_t session,
1092		globus_soap_message_handle_t        message_handle,
1093		globus_result_t                     result)
1094	2333	{
1095	2333	wsa_AttributedURI                   messID;
1096	2333	GlobusFuncName(globus_handler_ws_addressing_server_invoke_MessageID);
1097	2333	GlobusWSAddressingDebugEnter();
1098
1099	2333	if(result != GLOBUS_SUCCESS)
1100		{
1101	0	goto exit;
1102		}
1103
1104	2333	if(globus_soap_message_handle_get_attr(
1105		message_handle,
1106		WS_ADDRESSING_SERVER_MESSAGEID_ALREADY_INVOKED))
1107		{
1108	0	goto exit;
1109		}
1110
1111
1112	2333	wsa_AttributedURI_init_contents(&messID);
1113
1114	2333	result = wsa_AttributedURI_deserialize(
1115		&wsa_MessageID_qname,
1116		&messID,
1117		message_handle,
1118		0);
1119	2333	if(result != GLOBUS_SUCCESS)
1120		{
1121	0	result = GlobusWSAddressingErrorDeserializeFailed(
1122		result, ("Failed to deserialize MessageID element"));
1123	0	goto exit;
1124		}
1125
1126	2333	globus_soap_message_handle_set_attr(
1127		message_handle,
1128		WSADDR_INBOUND_MESSAGE_ID_KEY,
1129		globus_soap_message_attr_copy_string,
1130		globus_libc_free,
1131		messID.base_value);
1132
1133	2333	wsa_AttributedURI_destroy_contents(&messID);
1134
1135	2333	globus_soap_message_remove_required_header_element(
1136		message_handle, &wsa_MessageID_qname);
1137
1138	2333	globus_soap_message_handle_set_attr(
1139		message_handle,
1140		WS_ADDRESSING_SERVER_MESSAGEID_ALREADY_INVOKED,
1141		NULL, NULL, (void *)1);
1142
1143		exit:
1144
1145	2333	globus_handler_finished(session, result);
1146	2333	GlobusWSAddressingDebugExit();
1147	2333	return;
1148		}
1149
1150		static
1151		void
1152		globus_l_handler_ws_addressing_server_invoke_From(
1153		globus_handler_session_descriptor_t session,
1154		globus_soap_message_handle_t        message_handle,
1155		globus_result_t                     result)
1156	2333	{
1157	2333	wsa_EndpointReferenceType           from_epr;
1158	2333	GlobusFuncName(globus_handler_ws_addressing_server_invoke_From);
1159	2333	GlobusWSAddressingDebugEnter();
1160
1161	2333	if(result != GLOBUS_SUCCESS)
1162		{
1163	0	goto exit;
1164		}
1165
1166	2333	if(globus_soap_message_handle_get_attr(
1167		message_handle,
1168		WS_ADDRESSING_SERVER_FROM_ALREADY_INVOKED))
1169		{
1170	0	goto exit;
1171		}
1172
1173	2333	wsa_EndpointReferenceType_init_contents(&from_epr);
1174
1175	2333	result = wsa_EndpointReferenceType_deserialize(
1176		&wsa_From_qname,
1177		&from_epr,
1178		message_handle,
1179		0);
1180	2333	if(result != GLOBUS_SUCCESS)
1181		{
1182	0	result = GlobusWSAddressingErrorDeserializeFailed(
1183		result, ("Failed to deserialize From element"));
1184	0	goto exit;
1185		}
1186
1187	2333	globus_soap_message_handle_set_attr(
1188		message_handle,
1189		WSADDR_REQUEST_ENDPOINT_KEY,
1190		globus_soap_message_attr_copy_string,
1191		globus_libc_free,
1192		from_epr.Address.base_value);
1193
1194	2333	wsa_EndpointReferenceType_destroy_contents(
1195		&from_epr);
1196
1197	2333	globus_soap_message_remove_required_header_element(
1198		message_handle, &wsa_From_qname);
1199
1200	2333	globus_soap_message_handle_set_attr(
1201		message_handle,
1202		WS_ADDRESSING_SERVER_FROM_ALREADY_INVOKED,
1203		NULL, NULL, (void *)1);
1204
1205		exit:
1206
1207	2333	globus_handler_finished(session, result);
1208	2333	GlobusWSAddressingDebugExit();
1209	2333	return;
1210		}
1211
1212		static
1213		void
1214		globus_l_handler_ws_addressing_server_invoke_To(
1215		globus_handler_session_descriptor_t session,
1216		globus_soap_message_handle_t        message_handle,
1217		globus_result_t                     result)
1218	2333	{
1219	2333	wsa_EndpointReferenceType *         dest_epr;
1220	2333	wsa_AttributedURI                   To;
1221	2333	GlobusFuncName(globus_handler_ws_addressing_server_invoke_To);
1222	2333	GlobusWSAddressingDebugEnter();
1223
1224	2333	if(result != GLOBUS_SUCCESS)
1225		{
1226	0	goto exit;
1227		}
1228
1229	2333	if(globus_soap_message_handle_get_attr(
1230		message_handle,
1231		WS_ADDRESSING_SERVER_TO_ALREADY_INVOKED))
1232		{
1233	0	goto exit;
1234		}
1235
1236	2333	wsa_AttributedURI_init_contents(&To);
1237
1238	2333	result = wsa_AttributedURI_deserialize(
1239		&wsa_To_qname,
1240		&To,
1241		message_handle,
1242		0);
1243	2333	if(result != GLOBUS_SUCCESS)
1244		{
1245	0	result = GlobusWSAddressingErrorDeserializeFailed(
1246		result, ("Failed to deserialize To element"));
1247	0	goto exit;
1248		}
1249
1250	2333	globus_soap_message_handle_set_attr(
1251		message_handle,
1252		GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY,
1253		globus_soap_message_attr_copy_string,
1254		globus_libc_free,
1255		To.base_value);
1256
1257	2333	wsa_EndpointReferenceType_init(&dest_epr);
1258
1259	2333	dest_epr->Address.base_value = globus_libc_strdup(To.base_value);
1260
1261	2333	wsa_AttributedURI_destroy_contents(&To);
1262
1263	2333	globus_soap_message_handle_set_attr(
1264		message_handle,
1265		WSADDR_EPR_KEY,
1266		wsa_EndpointReferenceType_copy_wrapper,
1267		wsa_EndpointReferenceType_destroy_wrapper,
1268		(void *) dest_epr);
1269
1270	2333	wsa_EndpointReferenceType_destroy(dest_epr);
1271
1272	2333	globus_soap_message_remove_required_header_element(
1273		message_handle, &wsa_To_qname);
1274
1275	2333	globus_soap_message_handle_set_attr(
1276		message_handle,
1277		WS_ADDRESSING_SERVER_TO_ALREADY_INVOKED,
1278		NULL, NULL, (void *)1);
1279
1280		exit:
1281
1282	2333	globus_handler_finished(session, result);
1283	2333	GlobusWSAddressingDebugExit();
1284	2333	return;
1285		}
1286
1287		static
1288		void
1289		globus_l_handler_ws_addressing_server_invoke_Action(
1290		globus_handler_session_descriptor_t session,
1291		globus_soap_message_handle_t        message_handle,
1292		globus_result_t                     result)
1293	2333	{
1294	2333	wsa_AttributedURI                   Action;
1295	2333	GlobusFuncName(globus_handler_ws_addressing_server_invoke_Action);
1296	2333	GlobusWSAddressingDebugEnter();
1297
1298	2333	if(result != GLOBUS_SUCCESS)
1299		{
1300	0	goto exit;
1301		}
1302
1303	2333	if(globus_soap_message_handle_get_attr(
1304		message_handle,
1305		WS_ADDRESSING_SERVER_ACTION_ALREADY_INVOKED))
1306		{
1307	0	goto exit;
1308		}
1309
1310	2333	wsa_AttributedURI_init_contents(&Action);
1311
1312	2333	result = wsa_AttributedURI_deserialize(
1313		&wsa_Action_qname,
1314		&Action,
1315		message_handle,
1316		0);
1317	2333	if(result != GLOBUS_SUCCESS)
1318		{
1319	0	result = GlobusWSAddressingErrorDeserializeFailed(
1320		result, ("Failed to deserialize Action element"));
1321	0	goto exit;
1322		}
1323
1324	2333	globus_soap_message_handle_set_attr(
1325		message_handle,
1326		WSADDR_ACTION_REQUEST_KEY,
1327		globus_soap_message_attr_copy_string,
1328		globus_libc_free,
1329		Action.base_value);
1330
1331	2333	globus_soap_message_remove_required_header_element(
1332		message_handle, &wsa_Action_qname);
1333
1334	2333	globus_soap_message_handle_set_attr(
1335		message_handle,
1336		WS_ADDRESSING_SERVER_ACTION_ALREADY_INVOKED,
1337		NULL, NULL, (void *)1);
1338	2333	wsa_AttributedURI_destroy_contents(&Action);
1339
1340		exit:
1341
1342	2333	globus_handler_finished(session, result);
1343	2333	GlobusWSAddressingDebugExit();
1344	2333	return;
1345		}
1346
1347		static
1348		void
1349		globus_handler_ws_addressing_server_request_default_trigger(
1350		globus_handler_session_descriptor_t session,
1351		globus_soap_message_handle_t        message_handle,
1352		globus_result_t                     result)
1353	2252	{
1354	2252	wsa_EndpointReferenceType *         dest_epr;
1355	2252	GlobusFuncName(
1356		globus_handler_ws_addressing_server_request_default_trigger);
1357	2252	GlobusWSAddressingDebugEnter();
1358
1359	2252	if(result != GLOBUS_SUCCESS)
1360		{
1361	0	goto exit;
1362		}
1363
1364	2252	dest_epr = globus_soap_message_handle_get_attr(
1365		message_handle,
1366		WSADDR_OUTBOUND_EPR_KEY);
1367	2252	if(!dest_epr)
1368		{
1369	2252	dest_epr = globus_soap_message_handle_get_attr(
1370		message_handle,
1371		WSADDR_EPR_KEY);
1372		}
1373
1374	2252	if(dest_epr)
1375		{
1376	2252	wsa_ReferencePropertiesType_init(&dest_epr->ReferenceProperties);
1377
1378	2252	result = xsd_any_array_deserialize(
1379		NULL,
1380		&dest_epr->ReferenceProperties->any,
1381		message_handle,
1382		0);
1383	2252	if(result != GLOBUS_SUCCESS)
1384		{
1385	0	result = GlobusWSAddressingErrorDeserializeFailed(
1386		result,
1387		("Failed to deserialize ReferenceProperties elements"));
1388	0	goto exit;
1389		}
1390		}
1391		else
1392		{
1393	0	xsd_QName                       header_elem;
1394	0	result = globus_soap_message_deserialize_element_unknown(
1395		message_handle, &header_elem);
1396	0	if(result != GLOBUS_SUCCESS)
1397		{
1398	0	result = GlobusWSAddressingErrorDeserializeFailed(
1399		result,
1400		("Failed skipping unknown header element"));
1401	0	goto exit;
1402		}
1403
1404	0	result = globus_soap_message_deserialize_skip(
1405		message_handle);
1406	0	if(result != GLOBUS_SUCCESS)
1407		{
1408	0	result = GlobusWSAddressingErrorDeserializeFailed(
1409		result,
1410		("Failed skipping unknown header element"));
1411	0	goto exit;
1412		}
1413
1414	0	result = globus_soap_message_deserialize_element_end(
1415		message_handle,
1416		&header_elem);
1417	0	if(result != GLOBUS_SUCCESS)
1418		{
1419	0	result = GlobusWSAddressingErrorDeserializeFailed(
1420		result,
1421		("Failed skipping unknown header element"));
1422		goto exit;
1423		}
1424		}
1425
1426		exit:
1427
1428	2252	globus_handler_finished(session, result);
1429	2252	GlobusWSAddressingDebugExit();
1430	2252	return;
1431		}
1432
1433		static
1434		void
1435		globus_handler_ws_addressing_server_request_invoke(
1436		globus_handler_session_descriptor_t session,
1437		globus_soap_message_handle_t        message_handle,
1438		globus_result_t                     result)
1439	2332	{
1440	2332	int                                 To_handled = 0;
1441	2332	int                                 Action_handled = 0;
1442	2332	GlobusFuncName(globus_handler_ws_addressing_server_request_invoke);
1443	2332	GlobusWSAddressingDebugEnter();
1444
1445	2332	if(globus_soap_message_handle_get_attr(
1446		message_handle,
1447		WS_ADDRESSING_SERVER_REQUEST_ALREADY_INVOKED))
1448		{
1449	0	goto exit;
1450		}
1451
1452	2332	if(globus_soap_message_handle_get_attr(
1453		message_handle,
1454		GLOBUS_SOAP_MESSAGE_SERVICE_ENDPOINT_KEY))
1455		{
1456	2332	To_handled = 1;
1457		}
1458
1459	2332	if(globus_soap_message_handle_get_attr(
1460		message_handle,
1461		WSADDR_ACTION_REQUEST_KEY))
1462		{
1463	2332	Action_handled = 1;
1464		}
1465
1466	2332	if(!To_handled || !Action_handled)
1467		{
1468	0	xsd_QName *                     missing_header_qname;
1469	0	xsd_any *                       missing_header;
1470	0	globus_soap_message_fault_t     soap_fault;
1471
1472	0	globus_soap_message_fault_init(&soap_fault);
1473
1474	0	xsd_QName_init(&missing_header_qname);
1475	0	if(!To_handled)
1476		{
1477	0	missing_header_qname->local =
1478		globus_libc_strdup(wsa_To_qname.local);
1479	0	missing_header_qname->Namespace =
1480		globus_libc_strdup(wsa_To_qname.Namespace);
1481		}
1482		else
1483		{
1484	0	missing_header_qname->local =
1485		globus_libc_strdup(wsa_Action_qname.local);
1486	0	missing_header_qname->Namespace =
1487		globus_libc_strdup(wsa_Action_qname.Namespace);
1488		}
1489
1490	0	xsd_any_init((void *)&missing_header);
1491	0	missing_header->any_info = &xsd_QName_contents_info;
1492	0	missing_header->value = (void *)missing_header_qname;
1493
1494	0	soap_fault->faultcode =
1495		globus_libc_strdup("MessageInformationHeaderRequired");
1496	0	soap_fault->faultstring = globus_libc_strdup(
1497		"A required message information header: To, MessageID, "
1498		"or Action is not present.");
1499	0	soap_fault->detail = missing_header;
1500
1501	0	result = GlobusSoapMessageErrorFault(soap_fault);
1502	0	goto exit;
1503		}
1504
1505	2332	globus_soap_message_handle_set_attr(
1506		message_handle,
1507		WS_ADDRESSING_SERVER_REQUEST_ALREADY_INVOKED,
1508		NULL, NULL, (void *)1);
1509
1510		exit:
1511
1512	2332	globus_handler_finished(session, result);
1513	2332	GlobusWSAddressingDebugExit();
1514	2332	return;
1515		}
1516
1517		#define GLOBUS_L_HANDLER_WSADD_DEFINE_CLIENT_TRIGGER(__ELEMENT__)       \
1518		static globus_handler_trigger_t                                     \
1519		globus_l_handler_ws_addressing_client_trigger_##__ELEMENT__ =       \
1520		{                                                                   \
1521		&wsa_##__ELEMENT__##_qname,                                     \
1522		globus_l_handler_ws_addressing_client_invoke_##__ELEMENT__      \
1523		}
1524
1525		GLOBUS_L_HANDLER_WSADD_DEFINE_CLIENT_TRIGGER(MessageID);
1526		GLOBUS_L_HANDLER_WSADD_DEFINE_CLIENT_TRIGGER(RelatesTo);
1527		GLOBUS_L_HANDLER_WSADD_DEFINE_CLIENT_TRIGGER(To);
1528		GLOBUS_L_HANDLER_WSADD_DEFINE_CLIENT_TRIGGER(Action);
1529		GLOBUS_L_HANDLER_WSADD_DEFINE_CLIENT_TRIGGER(From);
1530
1531		#define GLOBUS_L_HANDLER_WSADD_DEFINE_SERVER_TRIGGER(__ELEMENT__)       \
1532		static globus_handler_trigger_t                                     \
1533		globus_l_handler_ws_addressing_server_trigger_##__ELEMENT__ =       \
1534		{                                                                   \
1535		&wsa_##__ELEMENT__##_qname,                                     \
1536		globus_l_handler_ws_addressing_server_invoke_##__ELEMENT__      \
1537		}
1538
1539		GLOBUS_L_HANDLER_WSADD_DEFINE_SERVER_TRIGGER(MessageID);
1540		GLOBUS_L_HANDLER_WSADD_DEFINE_SERVER_TRIGGER(To);
1541		GLOBUS_L_HANDLER_WSADD_DEFINE_SERVER_TRIGGER(Action);
1542		GLOBUS_L_HANDLER_WSADD_DEFINE_SERVER_TRIGGER(From);
1543
1544		globus_handler_descriptor_t globus_l_handler_ws_addressing_client_descriptor =
1545		{
1546		NULL,
1547		globus_handler_ws_addressing_client_request_invoke,
1548		NULL,
1549		NULL,
1550		globus_handler_ws_addressing_client_response_invoke,
1551		NULL,
1552		NULL,
1553		NULL
1554		};
1555
1556		globus_handler_descriptor_t globus_l_handler_ws_addressing_server_descriptor =
1557		{
1558		NULL,
1559		globus_handler_ws_addressing_server_request_invoke,
1560		NULL,
1561		NULL,
1562		globus_handler_ws_addressing_server_response_invoke,
1563		NULL,
1564		NULL,
1565		globus_handler_ws_addressing_server_request_default_trigger
1566		};
1567
1568		int
1569		globus_l_handler_ws_addressing_activate(void)
1570	233	{
1571	233	int                                 res = 0;
1572	233	GlobusFuncName(globus_l_handler_ws_addressing_activate);
1573
1574	233	GlobusDebugInit(GLOBUS_HANDLER_WS_ADDRESSING, TRACE DEBUG);
1575	233	GlobusWSAddressingDebugEnter();
1576
1577	233	globus_l_handler_ws_addressing_client_descriptor.trigger_list = NULL;
1578
1579	233	globus_list_insert(
1580		&globus_l_handler_ws_addressing_client_descriptor.trigger_list,
1581		&globus_l_handler_ws_addressing_client_trigger_MessageID);
1582	233	globus_list_insert(
1583		&globus_l_handler_ws_addressing_client_descriptor.trigger_list,
1584		&globus_l_handler_ws_addressing_client_trigger_RelatesTo);
1585	233	globus_list_insert(
1586		&globus_l_handler_ws_addressing_client_descriptor.trigger_list,
1587		&globus_l_handler_ws_addressing_client_trigger_To);
1588	233	globus_list_insert(
1589		&globus_l_handler_ws_addressing_client_descriptor.trigger_list,
1590		&globus_l_handler_ws_addressing_client_trigger_Action);
1591	233	globus_list_insert(
1592		&globus_l_handler_ws_addressing_client_descriptor.trigger_list,
1593		&globus_l_handler_ws_addressing_client_trigger_From);
1594
1595	233	res = globus_extension_registry_add(
1596		GLOBUS_HANDLER_REGISTRY,
1597		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT,
1598		GlobusExtensionMyModule(globus_handler_ws_addressing),
1599		&globus_l_handler_ws_addressing_client_descriptor);
1600	233	if(res != GLOBUS_SUCCESS)
1601		{
1602	0	goto exit;
1603		}
1604
1605	233	globus_l_handler_ws_addressing_server_descriptor.trigger_list = NULL;
1606	233	globus_list_insert(
1607		&globus_l_handler_ws_addressing_server_descriptor.trigger_list,
1608		&globus_l_handler_ws_addressing_server_trigger_MessageID);
1609	233	globus_list_insert(
1610		&globus_l_handler_ws_addressing_server_descriptor.trigger_list,
1611		&globus_l_handler_ws_addressing_server_trigger_To);
1612	233	globus_list_insert(
1613		&globus_l_handler_ws_addressing_server_descriptor.trigger_list,
1614		&globus_l_handler_ws_addressing_server_trigger_Action);
1615	233	globus_list_insert(
1616		&globus_l_handler_ws_addressing_server_descriptor.trigger_list,
1617		&globus_l_handler_ws_addressing_server_trigger_From);
1618
1619	233	res = globus_extension_registry_add(
1620		GLOBUS_HANDLER_REGISTRY,
1621		GLOBUS_HANDLER_WS_ADDRESSING_SERVER,
1622		GlobusExtensionMyModule(globus_handler_ws_addressing),
1623		&globus_l_handler_ws_addressing_server_descriptor);
1624
1625		exit:
1626
1627	233	GlobusWSAddressingDebugExit();
1628	233	return res;
1629		}
1630
1631		int
1632		globus_l_handler_ws_addressing_deactivate(void)
1633	164	{
1634	164	GlobusFuncName(globus_l_handler_ws_addressing_deactivate);
1635	164	GlobusWSAddressingDebugEnter();
1636
1637	164	globus_extension_registry_remove(
1638		GLOBUS_HANDLER_REGISTRY,
1639		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
1640
1641	164	globus_extension_registry_remove(
1642		GLOBUS_HANDLER_REGISTRY,
1643		GLOBUS_HANDLER_WS_ADDRESSING_SERVER);
1644
1645	164	globus_list_free(
1646		globus_l_handler_ws_addressing_client_descriptor.trigger_list);
1647
1648	164	globus_list_free(
1649		globus_l_handler_ws_addressing_server_descriptor.trigger_list);
1650
1651	164	globus_l_handler_ws_addressing_client_descriptor.trigger_list = NULL;
1652	164	globus_l_handler_ws_addressing_server_descriptor.trigger_list = NULL;
1653
1654	164	GlobusWSAddressingDebugExit();
1655	164	return 0;
1656		}
1657
1658		static
1659		globus_result_t
1660		globus_l_uuid_copy(
1661		void **                             new_id,
1662		const void *                        id)
1663	9758	{
1664	9758	const globus_uuid_t *               uuid = id;
1665	9758	globus_uuid_t *                     new_uuid;
1666
1667	9758	new_uuid = globus_malloc(sizeof(globus_uuid_t));
1668	9758	globus_uuid_import(new_uuid, uuid->text);
1669
1670	9758	*new_id = new_uuid;
1671	9758	return GLOBUS_SUCCESS;