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 "xsd_any.h"
19		#include "globus_soap_message.h"
20		#include "globus_soap_message_utils.h"
21		#include "globus_i_soap_message.h"
22		#include "globus_xml_buffer.h"
23		#include "globus_i_soap_message_wildcards.h"
24		#include "globus_i_xsd.h"
25
26		GLOBUS_I_XSD_DEFINE_QNAME(xsd, any);
27	72	GLOBUS_I_XSD_DEFINE_TYPE_INIT_ARRAY(xsd_any);
28	69707	GLOBUS_I_XSD_DEFINE_TYPE_DESTROY_ARRAY(xsd_any);
29	20194	GLOBUS_I_XSD_DEFINE_TYPE_COPY_ARRAY(xsd_any);
30	5575	GLOBUS_I_XSD_DEFINE_TYPE_SERIALIZE_ARRAY(xsd_any);
31	9879	GLOBUS_I_XSD_DEFINE_TYPE_DESERIALIZE_ARRAY(xsd_any);
32	2105548	GLOBUS_I_XSD_DEFINE_TYPE_ARRAY_PUSH(xsd_any);
33	745155	GLOBUS_I_XSD_DEFINE_TYPE_INIT(xsd_any);
34	6488259	GLOBUS_I_XSD_DEFINE_TYPE_DESTROY(xsd_any);
35	780118	GLOBUS_I_XSD_DEFINE_TYPE_COPY(xsd_any);
36	146	GLOBUS_I_XSD_DEFINE_INIT_CONTENTS_GENERIC(xsd_any);
37
38		globus_result_t
39		xsd_any_serialize_wrapper(
40		const xsd_QName *                   element_qname,
41		const void *                        instance,
42		globus_soap_message_handle_t        message_handle,
43		globus_xsd_element_options_t        options)
44		{
45	493760	return xsd_any_serialize(
46		element_qname,
47		(xsd_any *) instance,
48		message_handle, options);
49		}
50
51		globus_result_t
52		xsd_any_deserialize_pointer_wrapper(
53		const xsd_QName *                   element_qname,
54		void **                             ip,
55		globus_soap_message_handle_t        message_handle,
56		globus_xsd_element_options_t        options)
57	743974	{
58	743974	return xsd_any_deserialize_pointer(
59		element_qname,
60		(xsd_any **) ip,
61		message_handle, options);
62		}
63
64		struct globus_xsd_type_info_s xsd_any_info =
65		{
66		&xsd_any_qname,
67		xsd_any_serialize_wrapper,
68		xsd_any_deserialize_pointer_wrapper,
69		xsd_any_init_wrapper,
70		xsd_any_destroy_wrapper,
71		xsd_any_copy_wrapper,
72		xsd_any_init_contents_wrapper,
73		xsd_any_destroy_contents_wrapper,
74		xsd_any_copy_contents_wrapper,
75		sizeof(xsd_any),
76		NULL,
77		NULL,
78		&xsd_any_array_info
79		};
80
81		struct globus_xsd_type_info_s xsd_any_array_info =
82		{
83		&xsd_any_qname,
84		xsd_any_array_serialize_wrapper,
85		xsd_any_array_deserialize_wrapper,
86		xsd_any_array_init_wrapper,
87		xsd_any_array_destroy_wrapper,
88		xsd_any_array_copy_wrapper,
89		xsd_any_array_init_contents_wrapper,
90		xsd_any_array_destroy_contents_wrapper,
91		xsd_any_array_copy_contents_wrapper,
92		sizeof(xsd_any),
93		xsd_any_array_push_wrapper,
94		NULL,
95		NULL
96		};
97
98		void
99		xsd_any_destroy_contents(
100		xsd_any *                           instance)
101	2125283	{
102	2125283	GlobusFuncName(xsd_any_destroy_contents);
103	2125283	GlobusSoapMessageDebugEnter();
104
105	2125283	if(instance)
106		{
107	2125283	if(instance->value && instance->any_info)
108		{
109	2124241	instance->any_info->destroy(instance->value);
110	2124241	instance->value = NULL;
111		}
112
113	2125283	if(instance->element)
114		{
115	2116841	xsd_QName_destroy(instance->element);
116	2116841	instance->element = NULL;
117		}
118
119	2125283	xsd_string_array_destroy_contents(&instance->namespaces);
120		}
121
122	2125283	GlobusSoapMessageDebugExit();
123		}
124
125		globus_result_t
126		xsd_any_copy_contents(
127		xsd_any *                           dest,
128		const xsd_any *                     src)
129	764478	{
130	764478	globus_result_t                     result = GLOBUS_SUCCESS;
131	764478	GlobusFuncName(xsd_any_copy_contents);
132	764478	GlobusSoapMessageDebugEnter();
133
134	764478	if(dest && src)
135		{
136	764478	*dest = *src;
137	764478	if(src->element)
138		{
139	756151	result = xsd_QName_copy(&dest->element, src->element);
140	756151	if(result != GLOBUS_SUCCESS)
141		{
142	0	goto error;
143		}
144		}
145
146	764478	if(src->value && src->any_info)
147		{
148	764478	result = src->any_info->copy(&dest->value, src->value);
149	764478	if(result != GLOBUS_SUCCESS)
150		{
151	0	if(dest->element)
152		{
153	0	xsd_QName_destroy(dest->element);
154	0	dest->element = NULL;
155	0	goto error;
156		}
157		}
158		}
159	764478	xsd_string_array_copy_contents(&dest->namespaces, &src->namespaces);
160		}
161
162		error:
163	764478	GlobusSoapMessageDebugExit();
164	764478	return result;
165		}
166
167		globus_result_t
168		xsd_any_serialize(
169		const xsd_QName *                   element_qname,
170		const xsd_any *                     anyinst,
171		globus_soap_message_handle_t        message_handle,
172		globus_xsd_element_options_t        options)
173	494007	{
174	494007	globus_result_t                     result = GLOBUS_SUCCESS;
175	494007	GlobusFuncName(xsd_any_serialize);
176	494007	GlobusSoapMessageDebugEnter();
177
178	494007	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
179		/* serialize contents of type. If there's no element, just serialize
180		* contents
181		*/
182	494007	result = anyinst->any_info->serialize(
183		anyinst->element,
184		anyinst->value,
185		message_handle,
186		options | GLOBUS_XSD_ELEMENT_TYPE_ATTR |
187		((anyinst->element == NULL)
188		? GLOBUS_XSD_ELEMENT_CONTENTS_ONLY
189		: 0));
190	494007	if(result != GLOBUS_SUCCESS)
191		{
192	0	result = GlobusSoapMessageErrorSerializeFailed(
193		result,
194		"Serialization of xsd:any failed",
195		anyinst->element);
196		goto exit;
197		}
198
199		exit:
200
201	494007	GlobusSoapMessageDebugExit();
202	494007	return result;
203		}
204
205		globus_result_t
206		globus_i_xsd_deserialize_from_element_qname(
207		const xsd_QName *                   deselem_qname,
208		globus_xsd_type_info_t *            found_any_info,
209		globus_xsd_type_registry_t          registry,
210		globus_soap_message_handle_t        message_handle)
211	744079	{
212	744079	globus_result_t                     result = GLOBUS_SUCCESS;
213	744079	globus_xsd_type_info_t              any_info = NULL;
214	744079	GlobusFuncName(globus_i_xsd_deserialize_from_element_qname);
215	744079	GlobusSoapMessageDebugEnter();
216
217	744079	GlobusSoapMessageDebugPrintf(
218		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
219		("\tLooking for element {%s}%s:\n",
220		deselem_qname->Namespace,
221		deselem_qname->local));
222
223	744079	GlobusSoapMessageDebugPrintf(
224		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
225		("\t\tin instance registry\n"));
226
227	744079	if(registry)
228		{
229		/* look for element QName in instance registry */
230	0	result = globus_xsd_type_registry_get(
231		registry, deselem_qname, &any_info);
232	0	if(result != GLOBUS_SUCCESS)
233		{
234	0	result = GlobusSoapMessageErrorFailedRegistryLookup(
235		result, deselem_qname);
236	0	goto exit;
237		}
238
239	0	if(GlobusSoapMessageDebug(GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS))
240		{
241	0	if(any_info)
242		{
243	0	GlobusSoapMessageDebugPrintf(
244		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
245		("\tFound type info: {%s}%s\n",
246		any_info->type->Namespace,
247		any_info->type->local));
248		}
249		}
250		}
251
252	744079	if(!any_info)
253		{
254	744079	globus_xsd_type_registry_t      message_registry;
255
256	744079	GlobusSoapMessageDebugPrintf(
257		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
258		("\t\tin message registry\n"));
259
260	744079	globus_soap_message_handle_get_registry(message_handle,
261		&message_registry);
262	744079	if(message_registry)
263		{
264	742586	result = globus_xsd_type_registry_get(
265		message_registry, deselem_qname, &any_info);
266	742586	if(result != GLOBUS_SUCCESS)
267		{
268	0	result = GlobusSoapMessageErrorFailedRegistryLookup(
269		result, deselem_qname);
270	0	goto exit;
271		}
272
273	742586	if(GlobusSoapMessageDebug(GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS))
274		{
275	0	if(any_info)
276		{
277	0	GlobusSoapMessageDebugPrintf(
278		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
279		("\tFound type info: {%s}%s\n",
280		any_info->type->Namespace,
281		any_info->type->local));
282		}
283		}
284		}
285		}
286
287	744079	if(!any_info)
288		{
289	4008	GlobusSoapMessageDebugPrintf(
290		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
291		("\t\tin global registry\n"));
292
293	4008	result = globus_xsd_type_registry_get(
294		GLOBUS_GLOBAL_TYPE_REGISTRY, deselem_qname, &any_info);
295	4008	if(result != GLOBUS_SUCCESS)
296		{
297	0	result = GlobusSoapMessageErrorFailedRegistryLookup(
298		result, deselem_qname);
299	0	goto exit;
300		}
301
302	4008	if(GlobusSoapMessageDebug(GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS))
303		{
304	0	if(any_info)
305		{
306	0	GlobusSoapMessageDebugPrintf(
307		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
308		("Found type info: {%s}%s\n",
309		any_info->type->Namespace,
310		any_info->type->local));
311		}
312		}
313		}
314
315		exit:
316
317	744079	*found_any_info = any_info;
318
319	744079	GlobusSoapMessageDebugExit();
320	744079	return result;
321		}
322
323
324		globus_result_t
325		globus_i_xsd_deserialize_from_xsi_type(
326		globus_xsd_type_info_t *            found_any_info,
327		globus_xsd_type_registry_t          registry,
328		globus_soap_message_handle_t        message_handle)
329	4044	{
330	4044	globus_result_t                     result = GLOBUS_SUCCESS;
331	4044	globus_xsd_type_info_t              any_info = NULL;
332	4044	xsd_QName                           type;
333	4044	xmlChar *                           type_string = NULL;
334	4044	xmlChar *                           type_prefix = NULL;
335	4044	xmlChar *                           type_local = NULL;
336	4044	xmlChar *                           type_ns = NULL;
337	4044	GlobusFuncName(globus_i_xsd_deserialize_from_xsi_type);
338	4044	GlobusSoapMessageDebugEnter();
339
340	4044	type.Namespace = NULL;
341	4044	type.local = NULL;
342
343	4044	type_string = xmlTextReaderGetAttributeNs(
344		message_handle->reader, "type", XSI_NS);
345	4044	if(!type_string)
346		{
347	3403	goto exit;
348		}
349
350	641	type_local = xmlSplitQName2(type_string, &type_prefix);
351	641	if(type_prefix)
352		{
353	641	type_ns = xmlTextReaderLookupNamespace(
354		message_handle->reader, type_prefix);
355	641	if(!type_ns)
356		{
357	0	result = GlobusSoapMessageErrorUndefinedNamespace(type_prefix);
358	0	goto exit;
359		}
360
361	641	type.Namespace = globus_libc_strdup(type_ns);
362		}
363		else
364		{
365	0	type.Namespace = NULL;
366		}
367
368	641	type.local = globus_libc_strdup(type_local);
369
370	641	GlobusSoapMessageDebugPrintf(
371		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
372		("\tLooking for xsi:type {%s}%s:\n",
373		type.Namespace, type.local));
374
375	641	if(!any_info && registry)
376		{
377	0	GlobusSoapMessageDebugPrintf(
378		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
379		("\t\tin instance registry\n"));
380
381	0	result = globus_xsd_type_registry_get(
382		registry, &type, &any_info);
383	0	if(result != GLOBUS_SUCCESS)
384		{
385	0	result = GlobusSoapMessageErrorFailedRegistryLookup(result, &type);
386	0	goto exit;
387		}
388
389	0	if(GlobusSoapMessageDebug(GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS))
390		{
391	0	if(any_info)
392		{
393	0	GlobusSoapMessageDebugPrintf(
394		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
395		("\t\tFound any info: {%s}%s\n",
396		any_info->type->Namespace, any_info->type->local));
397		}
398		}
399		}
400
401	641	if(!any_info)
402		{
403	641	globus_xsd_type_registry_t      message_registry;
404
405	641	GlobusSoapMessageDebugPrintf(
406		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS, ("\t\tin message registry\n"));
407
408	641	globus_soap_message_handle_get_registry(message_handle,
409		&message_registry);
410	641	if(message_registry)
411		{
412	367	result = globus_xsd_type_registry_get(
413		message_registry, &type, &any_info);
414	367	if(result != GLOBUS_SUCCESS)
415		{
416	0	result = GlobusSoapMessageErrorFailedRegistryLookup(
417		result, &type);
418	0	goto exit;
419		}
420		}
421
422	641	if(GlobusSoapMessageDebug(GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS))
423		{
424	0	if(any_info)
425		{
426	0	GlobusSoapMessageDebugPrintf(
427		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
428		("\tFound any info: {%s}%s\n",
429		any_info->type->Namespace,
430		any_info->type->local));
431		}
432		}
433		}
434
435	641	if(!any_info)
436		{
437	615	GlobusSoapMessageDebugPrintf(
438		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
439		("\t\tin global registry\n"));
440
441	615	result = globus_xsd_type_registry_get(
442		GLOBUS_GLOBAL_TYPE_REGISTRY, &type, &any_info);
443	615	if(result != GLOBUS_SUCCESS)
444		{
445	0	result = GlobusSoapMessageErrorFailedRegistryLookup(
446		result, &type);
447	0	goto exit;
448		}
449
450	615	if(GlobusSoapMessageDebug(GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS))
451		{
452	0	if(any_info)
453		{
454	0	GlobusSoapMessageDebugPrintf(
455		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
456		("\tFound any info: {%s}%s\n",
457		any_info->type->Namespace,
458		any_info->type->local));
459		}
460		}
461		}
462
463	641	if(!any_info)
464		{
465	0	any_info = &globus_xml_buffer_contents_info;
466		}
467
468		exit:
469
470	4044	*found_any_info = any_info;
471
472	4044	if(type.local)
473		{
474	641	free(type.local);
475		}
476
477	4044	if(type.Namespace)
478		{
479	641	free(type.Namespace);
480		}
481
482	4044	if (type_string)
483		{
484	641	xmlFree(type_string);
485		}
486
487	4044	if (type_local)
488		{
489	641	xmlFree(type_local);
490		}
491
492	4044	if (type_prefix)
493		{
494	641	xmlFree(type_prefix);
495		}
496
497	4044	if (type_ns)
498		{
499	641	xmlFree(type_ns);
500		}
501
502	4044	GlobusSoapMessageDebugEnter();
503	4044	return result;
504		}
505
506		globus_result_t
507		xsd_any_deserialize(
508		const xsd_QName *                   element_qname,
509		xsd_any *                           instance,
510		globus_soap_message_handle_t        message_handle,
511		globus_xsd_element_options_t        options)
512	399	{
513	399	globus_result_t                     result = GLOBUS_SUCCESS;
514	399	xsd_QName *                         deselem_qname = NULL;
515	399	int                                 element_exists = 0;
516	399	GlobusFuncName(xsd_any_deserialize);
517	399	GlobusSoapMessageDebugEnter();
518
519	399	result = globus_soap_message_deserialize_element(
520		message_handle, NULL);
521	399	if(result != GLOBUS_SUCCESS)
522		{
523	292	if(GlobusSoapMessageStatusFailedWithTextCheck(result))
524		{
525	292	element_exists = 0;
526	292	if (!instance->any_info)
527		{
528	5	instance->any_info = &globus_xml_buffer_contents_info;
529		}
530		}
531	0	else if(!GlobusSoapMessageStatusCheck(result))
532		{
533	0	result = GlobusSoapMessageErrorDeserializeFailed(
534		result, &xsd_any_qname);
535	0	goto exit;
536		}
537		else
538		{
539	107	goto exit;
540		}
541		}
542		else
543		{
544	107	element_exists = 1;
545	107	globus_soap_message_deserialize_push_element(message_handle);
546		}
547
548		/* Deserialize current namespace prefixes into the any */
549	399	result = globus_soap_message_deserialize_get_prefixes(
550		message_handle,
551		&instance->namespaces);
552	399	if (result != GLOBUS_SUCCESS)
553		{
554	0	goto exit;
555		}
556
557	399	GlobusSoapMessageDebugPrintf(
558		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS, ("\n\nDeserializing xsd:any\n"));
559
560		/* only if an element exists, set the instance->element to it */
561	399	if(element_exists)
562		{
563	107	xsd_QName_init(&deselem_qname);
564
565	107	deselem_qname->local = globus_libc_strdup(
566		xmlTextReaderConstLocalName(
567		message_handle->reader));
568	107	deselem_qname->Namespace = globus_libc_strdup(
569		xmlTextReaderConstNamespaceUri(message_handle->reader));
570
571	107	instance->element = deselem_qname;
572
573		/* if instance->any_info isn't set, then look for info in registry
574		* based on QName of element
575		*/
576	107	if(!instance->any_info)
577		{
578	107	result = globus_i_xsd_deserialize_from_element_qname(
579		deselem_qname,
580		&instance->any_info,
581		instance->registry,
582		message_handle);
583	107	if(result != GLOBUS_SUCCESS)
584		{
585	0	result = GlobusSoapMessageErrorDeserializeFailed(
586		result, &xsd_any_qname);
587	0	goto exit;
588		}
589		}
590		}
591
592		/* no any_info, look for xsi:type */
593	399	if(!instance->any_info)
594		{
595	7	result = globus_i_xsd_deserialize_from_xsi_type(
596		&instance->any_info,
597		instance->registry,
598		message_handle);
599	7	if(result != GLOBUS_SUCCESS)
600		{
601	0	result = GlobusSoapMessageErrorDeserializeFailed(
602		result, &xsd_any_qname);
603	0	goto exit;
604		}
605		}
606
607	399	if(!instance->any_info)
608		{
609	2	instance->any_info = (&globus_xml_buffer_contents_info);
610		}
611
612	399	GlobusSoapMessageDebugPrintf(
613		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
614		("Using any info: {%s}%s\n",
615		instance->any_info->type->Namespace,
616		instance->any_info->type->local));
617
618	399	result = instance->any_info->deserialize(
619		deselem_qname,
620		&instance->value,
621		message_handle,
622		options);
623	399	if(result != GLOBUS_SUCCESS)
624		{
625	0	result = GlobusSoapMessageErrorDeserializeFailed(
626		result, instance->any_info->type);
627	0	goto exit;
628		}
629	399	if (instance->any_info == &xsd_QName_info ||
630		instance->any_info == &xsd_QName_contents_info)
631		{
632	205	xsd_string_array_destroy_contents(&instance->namespaces);
633		}
634
635		exit:
636
637	399	if(result != GLOBUS_SUCCESS)
638		{
639	0	xsd_any_destroy_contents(instance);
640		}
641
642	399	GlobusSoapMessageDebugExit();
643	399	return result;
644		}
645
646		globus_result_t
647		xsd_any_deserialize_pointer(
648		const xsd_QName *                   element_qname,
649		xsd_any **                          ip,
650		globus_soap_message_handle_t        message_handle,
651		globus_xsd_element_options_t        options)
652	744079	{
653	744079	xsd_any *                           instance;
654	744079	xsd_QName *                         deselem_qname;
655	744079	int                                 element_exists;
656	744079	globus_result_t                     result = GLOBUS_SUCCESS;
657	744079	GlobusFuncName(xsd_any_deserialize_pointer);
658	744079	GlobusSoapMessageDebugEnter();
659
660	744079	result = xsd_any_init(&instance);
661	744079	if(result != GLOBUS_SUCCESS)
662		{
663	0	result = GlobusSoapMessageErrorDeserializeFailed(
664		result, &xsd_any_qname);
665	0	goto exit;
666		}
667
668	744079	result = globus_soap_message_deserialize_element(
669		message_handle, NULL);
670	744079	if(result != GLOBUS_SUCCESS)
671		{
672	107	if(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
673		GlobusSoapMessageStatusFailedWithTextCheck(result))
674		{
675	30	element_exists = 0;
676	30	if (!instance->any_info)
677		{
678	30	instance->any_info = &globus_xml_buffer_contents_info;
679		}
680	30	result = GLOBUS_SUCCESS;
681		}
682	77	else if(!GlobusSoapMessageStatusCheck(result))
683		{
684	0	result = GlobusSoapMessageErrorDeserializeFailed(
685		result, &xsd_any_qname);
686	0	goto exit;
687		}
688		else
689		{
690	743972	goto exit;
691		}
692		}
693		else
694		{
695	743972	element_exists = 1;
696	743972	globus_soap_message_deserialize_push_element(message_handle);
697		}
698	744002	result = globus_soap_message_deserialize_get_prefixes(message_handle, &instance->namespaces);
699	744002	if (result != GLOBUS_SUCCESS)
700		{
701	0	goto exit;
702		}
703
704	744002	GlobusSoapMessageDebugPrintf(
705		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS, ("\n\nDeserializing xsd:any\n"));
706
707	744002	if(element_exists)
708		{
709	743972	xsd_QName_init(&deselem_qname);
710
711	743972	deselem_qname->local = globus_libc_strdup(
712		xmlTextReaderConstLocalName(message_handle->reader));
713	743972	deselem_qname->Namespace = globus_libc_strdup(
714		xmlTextReaderConstNamespaceUri(message_handle->reader));
715
716	743972	instance->element = deselem_qname;
717
718		/* if instance->any_info isn't set, then look for info in registry
719		* based on QName of element
720		*/
721	743972	if(!instance->any_info)
722		{
723	743972	result = globus_i_xsd_deserialize_from_element_qname(
724		deselem_qname,
725		&instance->any_info,
726		instance->registry,
727		message_handle);
728	743972	if(result != GLOBUS_SUCCESS)
729		{
730	0	result = GlobusSoapMessageErrorDeserializeFailed(
731		result, &xsd_any_qname);
732	0	goto exit;
733		}
734		}
735		}
736
737		/* no any_info, look for xsi:type */
738	744002	if(!instance->any_info)
739		{
740	3882	result = globus_i_xsd_deserialize_from_xsi_type(
741		&instance->any_info,
742		instance->registry,
743		message_handle);
744	3882	if(result != GLOBUS_SUCCESS)
745		{
746	0	result = GlobusSoapMessageErrorDeserializeFailed(
747		result, &xsd_any_qname);
748	0	goto exit;
749		}
750		}
751
752	744002	if(!instance->any_info)
753		{
754	3267	instance->any_info = (&globus_xml_buffer_contents_info);
755		}
756
757	744002	GlobusSoapMessageDebugPrintf(
758		GLOBUS_SOAP_MESSAGE_DEBUG_WILDCARDS,
759		("Using any info: {%s}%s\n",
760		instance->any_info->type->Namespace,
761		instance->any_info->type->local));
762
763	744002	result = instance->any_info->deserialize(
764		deselem_qname,
765		&instance->value,
766		message_handle,
767		options);
768	744002	if(result != GLOBUS_SUCCESS)
769		{
770	0	result = GlobusSoapMessageErrorDeserializeFailed(
771		result, instance->any_info->type);
772	0	goto exit;
773		}
774
775	744002	*ip = instance;
776
777	744002	if (instance->any_info == &xsd_QName_info ||
778		instance->any_info == &xsd_QName_contents_info)
779		{
780	0	xsd_string_array_destroy_contents(&instance->namespaces);
781		}
782		exit:
783
784	744079	if(result != GLOBUS_SUCCESS)
785		{
786	77	xsd_any_destroy(instance);
787		}
788
789	744079	GlobusSoapMessageDebugExit();
790	744079	return result;