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