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		/*
19		* This file is automatically generated by the Globus WSDLtoC converter
20		*/
21
22		#include "xsd_QName.h"
23		#include "globus_soap_message.h"
24		#include "globus_xsd_type_info.h"
25		#include "wsse_SecurityTokenReferenceType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName wsse_SecurityTokenReferenceType_qname =
29		{
30		WSSE_SECURITYTOKENREFERENCETYPE_NS,
31		WSSE_SECURITYTOKENREFERENCETYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		wsse_SecurityTokenReferenceType_serialize_wrapper(
37		const xsd_QName *                   element_qname,
38		const void *                        instance,
39		globus_soap_message_handle_t        message_handle,
40		globus_xsd_element_options_t        options)
41	0	{
42	0	return wsse_SecurityTokenReferenceType_serialize(
43		element_qname,
44		(const wsse_SecurityTokenReferenceType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		wsse_SecurityTokenReferenceType_deserialize_pointer_wrapper(
50		const xsd_QName *                   element_qname,
51		void **                             ip,
52		globus_soap_message_handle_t        message_handle,
53		globus_xsd_element_options_t        options)
54	0	{
55	0	return wsse_SecurityTokenReferenceType_deserialize_pointer(
56		element_qname,
57		(wsse_SecurityTokenReferenceType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		wsse_SecurityTokenReferenceType_init_wrapper(void **object)
63	0	{
64	0	return wsse_SecurityTokenReferenceType_init(
65		(wsse_SecurityTokenReferenceType **) object);
66		}
67
68		void
69		wsse_SecurityTokenReferenceType_destroy_wrapper(
70		void *                          object)
71	0	{
72	0	wsse_SecurityTokenReferenceType_destroy(
73		(wsse_SecurityTokenReferenceType *) object);
74		}
75
76		globus_result_t
77		wsse_SecurityTokenReferenceType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	0	{
81	0	return wsse_SecurityTokenReferenceType_copy(
82		(wsse_SecurityTokenReferenceType **) dest_obj,
83		(wsse_SecurityTokenReferenceType *) src_obj);
84		}
85
86		globus_result_t
87		wsse_SecurityTokenReferenceType_init_contents_wrapper(void *object)
88	0	{
89	0	return wsse_SecurityTokenReferenceType_init_contents(
90		(wsse_SecurityTokenReferenceType *) object);
91		}
92
93		void
94		wsse_SecurityTokenReferenceType_destroy_contents_wrapper(
95		void *                          object)
96	0	{
97	0	wsse_SecurityTokenReferenceType_destroy_contents(
98		(wsse_SecurityTokenReferenceType *) object);
99		}
100
101		globus_result_t
102		wsse_SecurityTokenReferenceType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	0	{
106	0	return wsse_SecurityTokenReferenceType_copy_contents(
107		(wsse_SecurityTokenReferenceType *) dest_obj,
108		(const wsse_SecurityTokenReferenceType *) src_obj);
109		}
110
111		globus_result_t
112		wsse_SecurityTokenReferenceType_serialize_contents_wrapper(
113		const xsd_QName *                   element_qname,
114		const void *                        instance,
115		globus_soap_message_handle_t        message_handle,
116		globus_xsd_element_options_t        options)
117	0	{
118	0	return wsse_SecurityTokenReferenceType_serialize_contents(
119		element_qname,
120		(wsse_SecurityTokenReferenceType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		wsse_SecurityTokenReferenceType_deserialize_contents_wrapper(
126		const xsd_QName *                   element_qname,
127		void **                             instance,
128		globus_soap_message_handle_t        message_handle,
129		globus_xsd_element_options_t        options)
130	0	{
131	0	globus_result_t                     result;
132	0	GlobusFuncName(wsse_SecurityTokenReferenceType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = wsse_SecurityTokenReferenceType_init(
138		(wsse_SecurityTokenReferenceType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = wsse_SecurityTokenReferenceType_deserialize_contents(
146		element_qname,
147		*(wsse_SecurityTokenReferenceType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		wsse_SecurityTokenReferenceType_array_serialize_wrapper(
156		const xsd_QName *               element,
157		const void *                    instance,
158		globus_soap_message_handle_t    message,
159		globus_xsd_element_options_t    options)
160	0	{
161	0	return wsse_SecurityTokenReferenceType_array_serialize(
162		element,
163		(wsse_SecurityTokenReferenceType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		wsse_SecurityTokenReferenceType_array_deserialize_wrapper(
169		const xsd_QName *                   element_qname,
170		void **                             inst,
171		globus_soap_message_handle_t        message,
172		globus_xsd_element_options_t        options)
173	0	{
174	0	if(!*inst)
175		{
176	0	globus_result_t                 result;
177
178	0	result = wsse_SecurityTokenReferenceType_array_init(
179		(wsse_SecurityTokenReferenceType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return wsse_SecurityTokenReferenceType_array_deserialize(
187		element_qname,
188		*(wsse_SecurityTokenReferenceType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		wsse_SecurityTokenReferenceType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return wsse_SecurityTokenReferenceType_array_init(
197		(wsse_SecurityTokenReferenceType_array **) arr);
198		}
199
200		void
201		wsse_SecurityTokenReferenceType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	wsse_SecurityTokenReferenceType_array_destroy(
205		(wsse_SecurityTokenReferenceType_array *) arr);
206		}
207
208		globus_result_t
209		wsse_SecurityTokenReferenceType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return wsse_SecurityTokenReferenceType_array_copy(
214		(wsse_SecurityTokenReferenceType_array **) dest_arr,
215		(const wsse_SecurityTokenReferenceType_array *) src_arr);
216		}
217
218		globus_result_t
219		wsse_SecurityTokenReferenceType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return wsse_SecurityTokenReferenceType_array_init_contents(
223		(wsse_SecurityTokenReferenceType_array *) arr);
224		}
225
226		void
227		wsse_SecurityTokenReferenceType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	wsse_SecurityTokenReferenceType_array_destroy_contents(
231		(wsse_SecurityTokenReferenceType_array *) arr);
232		}
233
234		globus_result_t
235		wsse_SecurityTokenReferenceType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return wsse_SecurityTokenReferenceType_array_copy_contents(
240		(wsse_SecurityTokenReferenceType_array *) dest_arr,
241		(const wsse_SecurityTokenReferenceType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s wsse_SecurityTokenReferenceType_contents_info =
245		{
246		&wsse_SecurityTokenReferenceType_qname,
247		wsse_SecurityTokenReferenceType_serialize_contents_wrapper,
248		wsse_SecurityTokenReferenceType_deserialize_contents_wrapper,
249		wsse_SecurityTokenReferenceType_init_wrapper,
250		wsse_SecurityTokenReferenceType_destroy_wrapper,
251		wsse_SecurityTokenReferenceType_copy_wrapper,
252		wsse_SecurityTokenReferenceType_init_contents_wrapper,
253		wsse_SecurityTokenReferenceType_destroy_contents_wrapper,
254		wsse_SecurityTokenReferenceType_copy_contents_wrapper,
255		sizeof(wsse_SecurityTokenReferenceType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s wsse_SecurityTokenReferenceType_array_info =
262		{
263		&wsse_SecurityTokenReferenceType_qname,
264		wsse_SecurityTokenReferenceType_array_serialize_wrapper,
265		wsse_SecurityTokenReferenceType_array_deserialize_wrapper,
266		wsse_SecurityTokenReferenceType_array_init_wrapper,
267		wsse_SecurityTokenReferenceType_array_destroy_wrapper,
268		wsse_SecurityTokenReferenceType_array_copy_wrapper,
269		wsse_SecurityTokenReferenceType_array_init_contents_wrapper,
270		wsse_SecurityTokenReferenceType_array_destroy_contents_wrapper,
271		wsse_SecurityTokenReferenceType_array_copy_contents_wrapper,
272		sizeof(wsse_SecurityTokenReferenceType),
273		wsse_SecurityTokenReferenceType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s wsse_SecurityTokenReferenceType_info =
279		{
280		&wsse_SecurityTokenReferenceType_qname,
281		wsse_SecurityTokenReferenceType_serialize_wrapper,
282		wsse_SecurityTokenReferenceType_deserialize_pointer_wrapper,
283		wsse_SecurityTokenReferenceType_init_wrapper,
284		wsse_SecurityTokenReferenceType_destroy_wrapper,
285		wsse_SecurityTokenReferenceType_copy_wrapper,
286		wsse_SecurityTokenReferenceType_init_contents_wrapper,
287		wsse_SecurityTokenReferenceType_destroy_contents_wrapper,
288		wsse_SecurityTokenReferenceType_copy_contents_wrapper,
289		sizeof(wsse_SecurityTokenReferenceType),
290		NULL,
291		&wsse_SecurityTokenReferenceType_contents_info,
292		&wsse_SecurityTokenReferenceType_array_info
293		};
294
295		globus_result_t
296		wsse_SecurityTokenReferenceType_init_contents(
297		wsse_SecurityTokenReferenceType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(wsse_SecurityTokenReferenceType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(wsse_SecurityTokenReferenceType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		wsse_SecurityTokenReferenceType_init(
311		wsse_SecurityTokenReferenceType ** object)
312	0	{
313	0	wsse_SecurityTokenReferenceType * instance;
314	0	globus_result_t                     result = GLOBUS_SUCCESS;
315	0	GlobusFuncName(wsse_SecurityTokenReferenceType_init);
316	0	GlobusSoapMessageDebugEnter();
317
318	0	instance = globus_malloc(sizeof(wsse_SecurityTokenReferenceType));
319	0	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	0	memset(instance, 0, sizeof(wsse_SecurityTokenReferenceType));
326
327	0	*object = instance;
328
329		exit:
330	0	GlobusSoapMessageDebugExit();
331	0	return result;
332		}
333
334		void
335		wsse_SecurityTokenReferenceType_destroy(
336		wsse_SecurityTokenReferenceType * instance)
337	0	{
338	0	GlobusFuncName(wsse_SecurityTokenReferenceType_destroy);
339	0	GlobusSoapMessageDebugEnter();
340
341	0	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	0	wsse_SecurityTokenReferenceType_destroy_contents(instance);
347	0	globus_free(instance);
348
349		exit:
350
351	0	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		wsse_SecurityTokenReferenceType_destroy_contents(
357		wsse_SecurityTokenReferenceType * instance)
358	0	{
359	0	GlobusFuncName(wsse_SecurityTokenReferenceType_destroy_contents);
360	0	GlobusSoapMessageDebugEnter();
361
362	0	if(instance)
363		{
364
365
366	0	xsd_any_destroy_contents(
367		&instance->any);
368
369	0	xsd_anyAttributes_destroy(instance->anyAttributes);
370	0	instance->anyAttributes = NULL;
371
372	0	if(instance->_Usage)
373		{
374	0	wsse_tUsage_destroy(
375		instance->_Usage);
376	0	instance->_Usage = NULL;
377		}
378
379	0	if(instance->_Id)
380		{
381	0	xsd_ID_destroy(
382		instance->_Id);
383	0	instance->_Id = NULL;
384		}
385
386		}
387
388	0	GlobusSoapMessageDebugExit();
389		}
390
391
392		globus_result_t
393		wsse_SecurityTokenReferenceType_copy(
394		wsse_SecurityTokenReferenceType ** dest_obj,
395		const wsse_SecurityTokenReferenceType * src_obj)
396	0	{
397	0	globus_result_t                     result = GLOBUS_SUCCESS;
398	0	wsse_SecurityTokenReferenceType * instance;
399	0	GlobusFuncName(wsse_SecurityTokenReferenceType_copy);
400
401	0	GlobusSoapMessageDebugEnter();
402
403	0	instance = calloc(1, sizeof(wsse_SecurityTokenReferenceType));
404	0	if (instance == NULL)
405		{
406	0	GlobusSoapMessageDebugExit();
407	0	return GlobusSoapMessageErrorOutOfMemory;
408		}
409
410	0	result = wsse_SecurityTokenReferenceType_copy_contents(instance, src_obj);
411	0	if(result != GLOBUS_SUCCESS)
412		{
413	0	globus_free(instance);
414	0	GlobusSoapMessageDebugExit();
415	0	return GlobusSoapMessageErrorOutOfMemory;
416		}
417
418	0	*dest_obj = instance;
419	0	GlobusSoapMessageDebugExit();
420	0	return result;
421		}
422
423		globus_result_t
424		wsse_SecurityTokenReferenceType_copy_contents(
425		wsse_SecurityTokenReferenceType * instance,
426		const wsse_SecurityTokenReferenceType * src_obj)
427	0	{
428	0	globus_result_t                     result = GLOBUS_SUCCESS;
429	0	GlobusFuncName(wsse_SecurityTokenReferenceType_copy_contents);
430
431	0	GlobusSoapMessageDebugEnter();
432
433	0	if(src_obj->anyAttributes)
434		{
435	0	result = xsd_anyAttributes_copy(&instance->anyAttributes,
436		src_obj->anyAttributes);
437	0	if(result != GLOBUS_SUCCESS)
438		{
439	0	result = GlobusSoapMessageErrorCopyAnyAttrsFailed(
440		result, NULL);
441	0	goto xsd_anyAttributes_after_destroy;
442		}
443		}
444		else
445		{
446	0	instance->anyAttributes = NULL;
447		}
448
449	0	if(src_obj->_Usage)
450		{
451	0	result = wsse_tUsage_copy(
452		&instance->_Usage,
453		src_obj->_Usage);
454	0	if(result != GLOBUS_SUCCESS)
455		{
456	0	result = GlobusSoapMessageErrorCopyFailed(
457		result, NULL, &wsse_tUsage_qname);
458	0	goto _Usage_destroy;
459		}
460		}
461		else
462		{
463	0	instance->_Usage = NULL;
464		}
465
466	0	if(src_obj->_Id)
467		{
468	0	result = xsd_ID_copy(
469		&instance->_Id,
470		src_obj->_Id);
471	0	if(result != GLOBUS_SUCCESS)
472		{
473	0	result = GlobusSoapMessageErrorCopyFailed(
474		result, NULL, &xsd_ID_qname);
475	0	goto _Id_destroy;
476		}
477		}
478		else
479		{
480	0	instance->_Id = NULL;
481		}
482
483	0	result = xsd_any_copy_contents(
484		&instance->any,
485		&src_obj->any);
486	0	if(result != GLOBUS_SUCCESS)
487		{
488	0	result = GlobusSoapMessageErrorCopyFailed(
489		result, NULL, &xsd_any_qname);
490	0	goto any_destroy;
491		}
492
493	0	goto exit;
494
495		fail_deserialize:
496
497		xsd_anyAttributes_destroy:
498	0	xsd_anyAttributes_destroy(instance->anyAttributes);
499	0	instance->anyAttributes = NULL;
500		xsd_anyAttributes_after_destroy:
501
502		_Usage_destroy:
503
504	0	if(instance->_Usage)
505		{
506	0	wsse_tUsage_destroy(
507		instance->_Usage);
508	0	instance->_Usage = NULL;
509		}
510
511		_Id_destroy:
512
513	0	if(instance->_Id)
514		{
515	0	xsd_ID_destroy(
516		instance->_Id);
517	0	instance->_Id = NULL;
518		}
519	0	xsd_any_destroy_contents(
520		&instance->any);
521
522		any_destroy:
523
524
525		exit:
526
527	0	GlobusSoapMessageDebugExit();
528	0	return result;
529		}
530
531
532
533		globus_result_t
534		wsse_SecurityTokenReferenceType_serialize_contents(
535		const xsd_QName *                   element_qname, /* ignored */
536		const wsse_SecurityTokenReferenceType *              inst,
537		globus_soap_message_handle_t        message_handle,
538		globus_xsd_element_options_t        options)
539	0	{
540	0	globus_result_t                     result = GLOBUS_SUCCESS;
541	0	GlobusFuncName(wsse_SecurityTokenReferenceType_serialize_contents);
542	0	GlobusSoapMessageDebugEnter();
543
544	0	result = wsse_SecurityTokenReferenceType_serialize(
545		NULL,
546		inst,
547		message_handle,
548		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
549	0	if(result != GLOBUS_SUCCESS)
550		{
551	0	result = GlobusSoapMessageErrorSerializeFailed(
552		result, NULL, element_qname);
553		goto exit;
554		}
555
556		exit:
557
558	0	GlobusSoapMessageDebugExit();
559	0	return result;
560		}
561
562
563
564		globus_result_t
565		wsse_SecurityTokenReferenceType_serialize(
566		const xsd_QName *                   element_qname,
567		const wsse_SecurityTokenReferenceType *              instance,
568		globus_soap_message_handle_t        message_handle,
569		globus_xsd_element_options_t        options)
570	0	{
571	0	globus_result_t                     result = GLOBUS_SUCCESS;
572	0	xsd_QName                           subelement;
573	0	globus_list_t *                     any_attr_keys = NULL;
574	0	globus_list_t *                     any_attr_keys_iterator = NULL;
575	0	xsd_QName *                         type_attr = NULL;
576
577	0	char *                              prefix = NULL;
578	0	int                                 prefix_created;
579	0	int                                 define_prefix = 0;
580	0	int                                 save_options = options;
581
582	0	GlobusFuncName(wsse_SecurityTokenReferenceType_serialize);
583	0	GlobusSoapMessageDebugEnter();
584
585
586	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
587		{
588		/* serialize wsse_SecurityTokenReferenceType element */
589	0	result = globus_soap_message_element_ns_set(
590		message_handle,
591		element_qname,
592		element_qname->Namespace,
593		&options);
594	0	if(result != GLOBUS_SUCCESS)
595		{
596	0	result = GlobusSoapMessageErrorSerializeFailed(
597		result, NULL, element_qname);
598	0	goto exit;
599		}
600
601		{
602		/*
603		int nsi;
604		for (nsi = 0; nsi < instance->any.namespaces.length; nsi++)
605		{
606		if (instance->any.namespaces.elements[nsi] != NULL)
607		{
608		char * prefix;
609		char * ns;
610		prefix = globus_libc_strdup(
611		instance->any.namespaces.elements[nsi]);
612		if (prefix == NULL)
613		{
614		result = GlobusSoapMessageErrorOutOfMemory;
615
616		goto exit;
617		}
618		ns = strchr(prefix, '=');
619		if (ns == NULL)
620		{
621		free(prefix);
622
623		result = GlobusSoapMessageErrorSerializeNamespaceFailed(ns, prefix);
624		goto exit;
625		}
626		*(ns) = '\0';
627		ns++;
628		result = globus_soap_message_serialize_ns_set_prefix(
629		message_handle,
630		element_qname,
631		ns,
632		prefix,
633		&options);
634		free(prefix);
635		if(result != GLOBUS_SUCCESS)
636		{
637		goto exit;
638		}
639		}
640		}
641		*/
642		}
643
644	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
645		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
646		{
647	0	result = globus_soap_message_attribute_ns_set(
648		message_handle,
649		element_qname,
650		"http://www.w3.org/2001/XMLSchema-instance",
651		&options);
652	0	if(result != GLOBUS_SUCCESS)
653		{
654	0	result = GlobusSoapMessageErrorSerializeFailed(
655		result, NULL, element_qname);
656	0	goto exit;
657		}
658		}
659
660	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
661		!globus_soap_message_serialize_is_c14n_subset(message_handle))
662		{
663
664	0	result = globus_soap_message_attribute_ns_set(
665		message_handle,
666		element_qname,
667		wsse_SecurityTokenReferenceType_qname.Namespace,
668		&options);
669	0	if(result != GLOBUS_SUCCESS)
670		{
671	0	result = GlobusSoapMessageErrorSerializeFailed(
672		result, NULL, element_qname);
673	0	goto exit;
674		}
675		}
676
677	0	result = xsd_anyAttributes_namespace_set(
678		message_handle, element_qname, instance->anyAttributes, &options);
679	0	if(result != GLOBUS_SUCCESS)
680		{
681	0	result = GlobusSoapMessageErrorSerializeAnyAttrsFailed(
682		result, "Failed to set namespace");
683	0	goto exit;
684		}
685
686	0	if(instance->_Usage)
687		{
688
689	0	result = globus_soap_message_attribute_ns_set(
690		message_handle,
691		element_qname,
692		"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd",
693		&options);
694
695	0	if(result != GLOBUS_SUCCESS)
696		{
697	0	xsd_QName               error_qname;
698	0	error_qname.local = prefix;
699	0	error_qname.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
700	0	result = GlobusSoapMessageErrorSerializeFailed(result,
701		NULL,
702		&error_qname);
703	0	goto exit;
704		}
705
706
707		}
708
709	0	if(instance->_Id)
710		{
711
712	0	result = globus_soap_message_attribute_ns_set(
713		message_handle,
714		element_qname,
715		"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd",
716		&options);
717
718	0	if(result != GLOBUS_SUCCESS)
719		{
720	0	xsd_QName               error_qname;
721	0	error_qname.local = prefix;
722	0	error_qname.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
723	0	result = GlobusSoapMessageErrorSerializeFailed(result,
724		NULL,
725		&error_qname);
726	0	goto exit;
727		}
728
729
730		}
731
732	0	result = globus_soap_message_serialize_element(
733		message_handle,
734		element_qname,
735		options,
736		&wsse_SecurityTokenReferenceType_qname);
737	0	if(result != GLOBUS_SUCCESS)
738		{
739	0	result = GlobusSoapMessageErrorSerializeFailed(
740		result, NULL, element_qname);
741	0	goto exit;
742		}
743
744	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
745		!globus_soap_message_serialize_is_c14n_subset(message_handle))
746		{
747	0	xsd_QName_init(&type_attr);
748
749	0	type_attr->local = globus_libc_strdup("type");
750	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
751		}
752
753
754		/* serialize namespaces */
755	0	result = globus_soap_message_element_ns_add(
756		message_handle,
757		element_qname,
758		element_qname->Namespace,
759		&options);
760	0	if(result != GLOBUS_SUCCESS)
761		{
762	0	result = GlobusSoapMessageErrorSerializeFailed(
763		result, NULL, element_qname);
764	0	goto exit;
765		}
766
767		{
768		/*
769		int nsi;
770		for (nsi = 0; nsi < instance->any.namespaces.length; nsi++)
771		{
772		if (instance->any.namespaces.elements[nsi] != NULL)
773		{
774		char * prefix;
775		char * ns;
776
777		prefix = globus_libc_strdup(
778		instance->any.namespaces.elements[nsi]);
779		if (prefix == NULL)
780		{
781		result = GlobusSoapMessageErrorOutOfMemory;
782
783		goto exit;
784		}
785		ns = strchr(prefix, '=');
786		if (ns == NULL)
787		{
788		free(prefix);
789
790		result = GlobusSoapMessageErrorSerializeNamespaceFailed(ns, prefix);
791		goto exit;
792		}
793		*(ns) = '\0';
794		ns++;
795		result = globus_soap_message_serialize_ns_add_prefix(
796		message_handle,
797		element_qname,
798		ns,
799		prefix,
800		&options);
801		free(prefix);
802		if(result != GLOBUS_SUCCESS)
803		{
804		goto exit;
805		}
806		}
807		}
808		*/
809		}
810
811	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
812		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
813		{
814	0	result = globus_soap_message_attribute_ns_add(
815		message_handle,
816		element_qname,
817		"http://www.w3.org/2001/XMLSchema-instance",
818		&options);
819	0	if(result != GLOBUS_SUCCESS)
820		{
821	0	result = GlobusSoapMessageErrorSerializeFailed(
822		result, NULL, element_qname);
823	0	goto exit;
824		}
825		}
826	0	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
827		!globus_soap_message_serialize_is_c14n_subset(message_handle))
828		{
829
830	0	result = globus_soap_message_attribute_ns_add(
831		message_handle,
832		element_qname,
833		wsse_SecurityTokenReferenceType_qname.Namespace,
834		&options);
835	0	if(result != GLOBUS_SUCCESS)
836		{
837	0	result = GlobusSoapMessageErrorSerializeFailed(
838		result, NULL, element_qname);
839	0	goto exit;
840		}
841		}
842
843	0	result = xsd_anyAttributes_namespace_add(
844		message_handle, element_qname, instance->anyAttributes, &options);
845	0	if(result != GLOBUS_SUCCESS)
846		{
847	0	result = GlobusSoapMessageErrorSerializeAnyAttrsFailed(
848		result, "Failed to add namespace");
849	0	goto exit;
850		}
851
852	0	if(instance->_Usage)
853		{
854
855	0	result = globus_soap_message_attribute_ns_add(
856		message_handle,
857		element_qname,
858		"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd",
859		&options);
860
861	0	if(result != GLOBUS_SUCCESS)
862		{
863	0	xsd_QName               error_qname;
864	0	error_qname.local = prefix;
865	0	error_qname.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
866	0	result = GlobusSoapMessageErrorSerializeFailed(result,
867		NULL,
868		&error_qname);
869	0	goto exit;
870		}
871
872
873		}
874
875	0	if(instance->_Id)
876		{
877
878	0	result = globus_soap_message_attribute_ns_add(
879		message_handle,
880		element_qname,
881		"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd",
882		&options);
883
884	0	if(result != GLOBUS_SUCCESS)
885		{
886	0	xsd_QName               error_qname;
887	0	error_qname.local = prefix;
888	0	error_qname.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
889	0	result = GlobusSoapMessageErrorSerializeFailed(result,
890		NULL,
891		&error_qname);
892	0	goto exit;
893		}
894
895
896		}
897
898		/* serialize attributes */
899
900	0	if(instance->anyAttributes)
901		{
902	0	any_attr_keys = xsd_anyAttributes_lex_sort(
903		instance->anyAttributes);
904	0	any_attr_keys_iterator = any_attr_keys;
905		}
906
907	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
908	0	subelement.local = "Usage";
909
910	0	if(any_attr_keys_iterator)
911		{
912	0	result = xsd_anyAttributes_serialize_lex_before(
913		message_handle,
914		&any_attr_keys_iterator,
915		instance->anyAttributes,
916		&subelement);
917	0	if(result != GLOBUS_SUCCESS)
918		{
919	0	result = GlobusSoapMessageErrorSerializeFailed(result,
920		NULL,
921		element_qname);
922	0	goto exit;
923		}
924		}
925
926	0	if(instance->_Usage)
927		{
928
929	0	result = wsse_tUsage_serialize_attribute(
930		&subelement,
931		instance->_Usage,
932		message_handle,
933		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
934	0	if(result != GLOBUS_SUCCESS)
935		{
936	0	result = GlobusSoapMessageErrorSerializeFailed(result,
937		NULL,
938		element_qname);
939	0	goto exit;
940		}
941
942		}
943
944	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
945	0	subelement.local = "Id";
946
947	0	if(any_attr_keys_iterator)
948		{
949	0	result = xsd_anyAttributes_serialize_lex_before(
950		message_handle,
951		&any_attr_keys_iterator,
952		instance->anyAttributes,
953		&subelement);
954	0	if(result != GLOBUS_SUCCESS)
955		{
956	0	result = GlobusSoapMessageErrorSerializeFailed(result,
957		NULL,
958		element_qname);
959	0	goto exit;
960		}
961		}
962
963	0	if(instance->_Id)
964		{
965
966	0	result = xsd_ID_serialize_attribute(
967		&subelement,
968		instance->_Id,
969		message_handle,
970		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
971	0	if(result != GLOBUS_SUCCESS)
972		{
973	0	result = GlobusSoapMessageErrorSerializeFailed(result,
974		NULL,
975		element_qname);
976	0	goto exit;
977		}
978
979		}
980
981	0	if(any_attr_keys_iterator)
982		{
983	0	result = xsd_anyAttributes_serialize_lex_before(
984		message_handle,
985		&any_attr_keys_iterator,
986		instance->anyAttributes,
987		type_attr);
988	0	if(result != GLOBUS_SUCCESS)
989		{
990	0	result = GlobusSoapMessageErrorSerializeFailed(result,
991		NULL,
992		element_qname);
993	0	goto exit;
994		}
995		}
996
997	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
998		!globus_soap_message_serialize_is_c14n_subset(message_handle))
999		{
1000	0	result = globus_soap_message_serialize_QName_attribute(
1001		message_handle,
1002		type_attr,
1003		&wsse_SecurityTokenReferenceType_qname);
1004	0	if(result != GLOBUS_SUCCESS)
1005		{
1006	0	result = GlobusSoapMessageErrorSerializeFailed(
1007		result, NULL, element_qname);
1008	0	goto exit;
1009		}
1010		}
1011
1012
1013		}
1014
1015	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1016		{
1017	0	result = globus_soap_message_serialize_element_begin_close(
1018		message_handle, element_qname);
1019	0	if(result != GLOBUS_SUCCESS)
1020		{
1021	0	result = GlobusSoapMessageErrorSerializeFailed(
1022		result, NULL, element_qname);
1023	0	goto exit;
1024		}
1025		}
1026	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
1027
1028
1029		/* serialize contents of type */
1030
1031	0	subelement.local = "any";
1032	0	subelement.Namespace = "http://www.w3.org/2001/XMLSchema";
1033
1034	0	result = xsd_any_serialize(
1035		&subelement,
1036		&instance->any,
1037		message_handle,
1038		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
1039	0	if(result != GLOBUS_SUCCESS)
1040		{
1041	0	result = GlobusSoapMessageErrorSerializeFailed(
1042		result, NULL, &xsd_any_qname);
1043	0	goto exit;
1044		}
1045
1046	0	options = save_options;
1047
1048	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1049		{
1050		/* add end element */
1051	0	result = globus_soap_message_serialize_element_end(
1052		message_handle,
1053		element_qname,
1054		options,
1055		&wsse_SecurityTokenReferenceType_qname);
1056	0	if(result != GLOBUS_SUCCESS)
1057		{
1058	0	result = GlobusSoapMessageErrorSerializeFailed(
1059		result, NULL, element_qname);
1060	0	goto exit;
1061		}
1062
1063	0	globus_soap_message_element_ns_remove(
1064		message_handle,
1065		element_qname->Namespace,
1066		&options);
1067
1068		/* remove namespace/prefix mappings for these types */
1069
1070		{
1071		/*
1072		int nsi;
1073		for (nsi = 0; nsi < instance->any.namespaces.length; nsi++)
1074		{
1075		if (instance->any.namespaces.elements[nsi] != NULL)
1076		{
1077		char * prefix;
1078		char * ns;
1079
1080		prefix = globus_libc_strdup(
1081		instance->any.namespaces.elements[nsi]);
1082		if (prefix == NULL)
1083		{
1084		result = GlobusSoapMessageErrorOutOfMemory;
1085
1086		goto exit;
1087		}
1088		ns = strchr(prefix, '=');
1089		if (ns == NULL)
1090		{
1091		free(prefix);
1092
1093		result = GlobusSoapMessageErrorSerializeNamespaceFailed(ns, prefix);
1094		goto exit;
1095		}
1096		*(ns) = '\0';
1097		ns++;
1098
1099		globus_soap_message_serialize_ns_remove_prefix(
1100		message_handle,
1101		ns,
1102		prefix,
1103		&options);
1104		free(prefix);
1105		}
1106		}
1107		*/
1108		}
1109
1110	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
1111		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
1112		{
1113	0	globus_soap_message_attribute_ns_remove(
1114		message_handle,
1115		"http://www.w3.org/2001/XMLSchema-instance",
1116		&options);
1117		}
1118	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
1119		!globus_soap_message_serialize_is_c14n_subset(message_handle))
1120		{
1121	0	globus_soap_message_attribute_ns_remove(
1122		message_handle,
1123		wsse_SecurityTokenReferenceType_qname.Namespace,
1124		&options);
1125		}
1126
1127	0	result = xsd_anyAttributes_namespace_remove(
1128		message_handle, instance->anyAttributes, &options);
1129	0	if(result != GLOBUS_SUCCESS)
1130		{
1131	0	result = GlobusSoapMessageErrorSerializeAnyAttrsFailed(
1132		result, "Failed to remove namespace");
1133	0	goto exit;
1134		}
1135
1136	0	if(instance->_Usage)
1137		{
1138
1139	0	globus_soap_message_attribute_ns_remove(
1140		message_handle,
1141		"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd",
1142		&options);
1143
1144		}
1145
1146	0	if(instance->_Id)
1147		{
1148
1149	0	globus_soap_message_attribute_ns_remove(
1150		message_handle,
1151		"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd",
1152		&options);
1153
1154		}
1155
1156		}
1157
1158		exit:
1159	0	if (type_attr)
1160		{
1161	0	xsd_QName_destroy(type_attr);
1162		}
1163
1164
1165	0	if(any_attr_keys)
1166		{
1167	0	globus_list_free(any_attr_keys);
1168		}
1169
1170	0	GlobusSoapMessageDebugExit();
1171	0	return result;
1172		}
1173
1174
1175
1176		globus_result_t
1177		wsse_SecurityTokenReferenceType_deserialize_contents(
1178		const xsd_QName *                   element_qname, /* ignored */
1179		wsse_SecurityTokenReferenceType *                    inst,
1180		globus_soap_message_handle_t        message_handle,
1181		globus_xsd_element_options_t        options)
1182	0	{
1183	0	globus_result_t                     result = GLOBUS_SUCCESS;
1184	0	GlobusFuncName(wsse_SecurityTokenReferenceType_deserialize_contents);
1185	0	GlobusSoapMessageDebugEnter();
1186
1187	0	result = wsse_SecurityTokenReferenceType_deserialize(
1188		NULL,
1189		inst,
1190		message_handle,
1191		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1192	0	if(result != GLOBUS_SUCCESS)
1193		{
1194	0	result = GlobusSoapMessageErrorDeserializeFailed(
1195		result, element_qname);
1196		goto exit;
1197		}
1198
1199		exit:
1200
1201	0	GlobusSoapMessageDebugExit();
1202	0	return result;
1203		}
1204
1205
1206
1207		globus_result_t
1208		wsse_SecurityTokenReferenceType_deserialize(
1209		const xsd_QName *                   element_qname,
1210		wsse_SecurityTokenReferenceType *                    instance,
1211		globus_soap_message_handle_t        message_handle,
1212		globus_xsd_element_options_t        options)
1213	0	{
1214	0	globus_result_t                     result = GLOBUS_SUCCESS;
1215	0	xsd_QName                           subelement;
1216	0	GlobusFuncName(wsse_SecurityTokenReferenceType_deserialize);
1217	0	GlobusSoapMessageDebugEnter();
1218
1219
1220	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1221		{
1222	0	result = globus_soap_message_deserialize_element(
1223		message_handle, element_qname);
1224	0	if(result != GLOBUS_SUCCESS)
1225		{
1226	0	result = GlobusSoapMessageErrorDeserializeFailed(
1227		result, element_qname);
1228	0	goto exit;
1229		}
1230
1231	0	result = xsd_anyAttributes_init(&instance->anyAttributes);
1232	0	if(result != GLOBUS_SUCCESS)
1233		{
1234	0	result = GlobusSoapMessageErrorDeserializeFailed(
1235		result, element_qname);
1236	0	goto xsd_anyAttributes_after_destroy;
1237		}
1238
1239	0	result = xsd_anyAttributes_deserialize(
1240		message_handle,
1241		instance->anyAttributes);
1242	0	if(result != GLOBUS_SUCCESS)
1243		{
1244	0	result = GlobusSoapMessageErrorDeserializeFailed(
1245		result, element_qname);
1246	0	goto xsd_anyAttributes_destroy;
1247		}
1248
1249	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
1250	0	subelement.local = "Usage";
1251
1252	0	result = wsse_tUsage_deserialize_attribute_pointer(
1253		&subelement,
1254		&instance->_Usage,
1255		message_handle,
1256		0);
1257	0	if(result != GLOBUS_SUCCESS)
1258		{
1259	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1260	0	goto _Usage_destroy;
1261		}
1262
1263
1264	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
1265	0	subelement.local = "Id";
1266
1267	0	result = xsd_ID_deserialize_attribute_pointer(
1268		&subelement,
1269		&instance->_Id,
1270		message_handle,
1271		0);
1272	0	if(result != GLOBUS_SUCCESS)
1273		{
1274	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1275	0	goto _Id_destroy;
1276		}
1277
1278
1279
1280	0	result = globus_soap_message_deserialize_element_begin_close(
1281		message_handle);
1282	0	if(result != GLOBUS_SUCCESS)
1283		{
1284	0	result = GlobusSoapMessageErrorDeserializeFailed(
1285		result, element_qname);
1286	0	goto fail_deserialize;
1287		}
1288		}
1289
1290	0	subelement.local = "any";
1291	0	subelement.Namespace = "http://www.w3.org/2001/XMLSchema";
1292
1293	0	result = xsd_any_deserialize(
1294		&subelement,
1295		&instance->any,
1296		message_handle,
1297		0);
1298	0	if(result != GLOBUS_SUCCESS)
1299		{
1300	0	result = GlobusSoapMessageErrorDeserializeFailed(
1301		result,
1302		&xsd_any_qname);
1303	0	goto any_destroy;
1304		}
1305
1306	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1307		{
1308	0	result = globus_soap_message_deserialize_element_end(
1309		message_handle,
1310		element_qname);
1311	0	if(result != GLOBUS_SUCCESS)
1312		{
1313	0	result = GlobusSoapMessageErrorDeserializeFailed(
1314		result, element_qname);
1315		goto fail_deserialize;
1316		}
1317		}
1318
1319	0	goto exit;
1320
1321		fail_deserialize:
1322
1323		xsd_anyAttributes_destroy:
1324	0	xsd_anyAttributes_destroy(instance->anyAttributes);
1325	0	instance->anyAttributes = NULL;
1326		xsd_anyAttributes_after_destroy:
1327
1328		_Usage_destroy:
1329		/* output_fail_destroy_attribute() */
1330
1331	0	if(instance->_Usage)
1332		{
1333	0	wsse_tUsage_destroy(
1334		instance->_Usage);
1335	0	instance->_Usage = NULL;
1336		}
1337
1338		_Id_destroy:
1339		/* output_fail_destroy_attribute() */
1340
1341	0	if(instance->_Id)
1342		{
1343	0	xsd_ID_destroy(
1344		instance->_Id);
1345	0	instance->_Id = NULL;
1346		}
1347	0	xsd_any_destroy_contents(
1348		&instance->any);
1349
1350		any_destroy:
1351
1352
1353		exit:
1354
1355	0	GlobusSoapMessageDebugExit();
1356	0	return result;
1357		}
1358
1359
1360
1361		globus_result_t
1362		wsse_SecurityTokenReferenceType_deserialize_pointer(
1363		const xsd_QName *                   element_qname,
1364		wsse_SecurityTokenReferenceType **                   ip,
1365		globus_soap_message_handle_t        message_handle,
1366		globus_xsd_element_options_t        options)
1367	0	{
1368	0	wsse_SecurityTokenReferenceType * instance = NULL;
1369	0	globus_result_t                     result = GLOBUS_SUCCESS;
1370	0	xsd_QName                           subelement;
1371	0	int                                 found_attrs = 0;
1372	0	int                                 empty_element = 0;
1373	0	GlobusFuncName(wsse_SecurityTokenReferenceType_deserialize_pointer);
1374	0	GlobusSoapMessageDebugEnter();
1375
1376	0	*ip = NULL;
1377
1378	0	result = globus_soap_message_deserialize_element(
1379		message_handle, element_qname);
1380	0	if(result != GLOBUS_SUCCESS &&
1381		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1382		GlobusSoapMessageStatusFailedElementCheck(result) ||
1383		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1384		{
1385	0	result = GLOBUS_SUCCESS;
1386	0	goto exit;
1387		}
1388
1389	0	if(result != GLOBUS_SUCCESS)
1390		{
1391	0	result = GlobusSoapMessageErrorDeserializeFailed(
1392		result, element_qname);
1393	0	goto exit;
1394		}
1395
1396	0	if(globus_soap_message_deserialize_element_is_empty(
1397		message_handle))
1398		{
1399	0	empty_element = 1;
1400		}
1401
1402	0	result = wsse_SecurityTokenReferenceType_init(&instance);
1403	0	if(result != GLOBUS_SUCCESS)
1404		{
1405	0	result = GlobusSoapMessageErrorDeserializeFailed(
1406		result, element_qname);
1407	0	goto exit;
1408		}
1409
1410
1411	0	result = xsd_anyAttributes_init(&instance->anyAttributes);
1412	0	if(result != GLOBUS_SUCCESS)
1413		{
1414	0	result = GlobusSoapMessageErrorDeserializeFailed(
1415		result, element_qname);
1416	0	goto xsd_anyAttributes_after_destroy;
1417		}
1418
1419	0	result = xsd_anyAttributes_deserialize(
1420		message_handle,
1421		instance->anyAttributes);
1422	0	if(result != GLOBUS_SUCCESS)
1423		{
1424	0	result = GlobusSoapMessageErrorDeserializeFailed(
1425		result, element_qname);
1426	0	goto xsd_anyAttributes_destroy;
1427		}
1428
1429	0	if(instance->anyAttributes &&
1430		xsd_anyAttributes_size(instance->anyAttributes) > 0)
1431		{
1432	0	found_attrs++;
1433		}
1434
1435	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
1436	0	subelement.local = "Usage";
1437
1438	0	result = wsse_tUsage_deserialize_attribute_pointer(
1439		&subelement,
1440		&instance->_Usage,
1441		message_handle,
1442		0);
1443	0	if(result != GLOBUS_SUCCESS)
1444		{
1445	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1446	0	goto _Usage_destroy;
1447		}
1448
1449
1450	0	if(instance->_Usage)
1451		{
1452	0	found_attrs++;
1453		}
1454
1455	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
1456	0	subelement.local = "Id";
1457
1458	0	result = xsd_ID_deserialize_attribute_pointer(
1459		&subelement,
1460		&instance->_Id,
1461		message_handle,
1462		0);
1463	0	if(result != GLOBUS_SUCCESS)
1464		{
1465	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1466	0	goto _Id_destroy;
1467		}
1468
1469
1470	0	if(instance->_Id)
1471		{
1472	0	found_attrs++;
1473		}
1474
1475
1476	0	if(empty_element)
1477		{
1478	0	result = globus_soap_message_deserialize_element_end(
1479		message_handle,
1480		element_qname);
1481	0	if(result != GLOBUS_SUCCESS)
1482		{
1483	0	result = GlobusSoapMessageErrorDeserializeFailed(
1484		result, element_qname);
1485	0	goto fail_deserialize;
1486		}
1487
1488	0	*ip = instance;
1489	0	goto exit;
1490		}
1491
1492	0	result = globus_soap_message_deserialize_element_begin_close(
1493		message_handle);
1494	0	if(result != GLOBUS_SUCCESS)
1495		{
1496	0	result = GlobusSoapMessageErrorDeserializeFailed(
1497		result, element_qname);
1498	0	goto exit;
1499		}
1500
1501	0	result = wsse_SecurityTokenReferenceType_deserialize(
1502		element_qname,
1503		instance,
1504		message_handle,
1505		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1506
1507	0	result = globus_soap_message_deserialize_element_end(
1508		message_handle,
1509		element_qname);
1510	0	if(result != GLOBUS_SUCCESS)
1511		{
1512	0	result = GlobusSoapMessageErrorDeserializeFailed(
1513		result, element_qname);
1514	0	goto fail_deserialize;
1515		}
1516
1517	0	*ip = instance;
1518
1519	0	goto exit;
1520
1521		fail_deserialize:
1522
1523		xsd_anyAttributes_destroy:
1524	0	xsd_anyAttributes_destroy(instance->anyAttributes);
1525	0	instance->anyAttributes = NULL;
1526		xsd_anyAttributes_after_destroy:
1527
1528		_Usage_destroy:
1529		/* output_fail_destroy_attribute() */
1530
1531	0	if(instance->_Usage)
1532		{
1533	0	wsse_tUsage_destroy(
1534		instance->_Usage);
1535	0	instance->_Usage = NULL;
1536		}
1537
1538		_Id_destroy:
1539		/* output_fail_destroy_attribute() */
1540
1541	0	if(instance->_Id)
1542		{
1543	0	xsd_ID_destroy(
1544		instance->_Id);
1545	0	instance->_Id = NULL;
1546		}
1547	0	xsd_any_destroy_contents(
1548		&instance->any);
1549
1550		any_destroy:
1551
1552		exit:
1553
1554	0	GlobusSoapMessageDebugExit();
1555	0	return result;
1556		}
1557
1558
1559		globus_result_t
1560		wsse_SecurityTokenReferenceType_array_init_contents(
1561		wsse_SecurityTokenReferenceType_array * array)
1562	0	{
1563	0	return globus_xsd_generic_array_init_contents(
1564		(globus_xsd_generic_array_t *) array,
1565		&wsse_SecurityTokenReferenceType_info);
1566		}
1567		/* wsse_SecurityTokenReferenceType_array_init_contents() */
1568
1569		globus_result_t
1570		wsse_SecurityTokenReferenceType_array_init(
1571		wsse_SecurityTokenReferenceType_array ** arr)
1572	0	{
1573	0	return globus_xsd_generic_array_init(
1574		(globus_xsd_generic_array_t **) arr,
1575		&wsse_SecurityTokenReferenceType_info);
1576		}
1577		/* wsse_SecurityTokenReferenceType_array_init() */
1578
1579		void
1580		wsse_SecurityTokenReferenceType_array_destroy_contents(
1581		wsse_SecurityTokenReferenceType_array * array)
1582	0	{
1583	0	globus_xsd_generic_array_destroy_contents(
1584		(globus_xsd_generic_array_t *) array);
1585		}
1586		/* wsse_SecurityTokenReferenceType_array_destroy_contents() */
1587
1588		void
1589		wsse_SecurityTokenReferenceType_array_destroy(
1590		wsse_SecurityTokenReferenceType_array * array)
1591	0	{
1592	0	globus_xsd_generic_array_destroy(
1593		(globus_xsd_generic_array_t *) array);
1594		}
1595		/* wsse_SecurityTokenReferenceType_array_destroy() */
1596
1597		globus_result_t
1598		wsse_SecurityTokenReferenceType_array_copy(
1599		wsse_SecurityTokenReferenceType_array ** dest_arr,
1600		const wsse_SecurityTokenReferenceType_array * src_arr)
1601	0	{
1602	0	return globus_xsd_generic_array_copy(
1603		(globus_xsd_generic_array_t **) dest_arr,
1604		(globus_xsd_generic_array_t *) src_arr);
1605		}
1606		/* wsse_SecurityTokenReferenceType_array_copy() */
1607
1608		globus_result_t
1609		wsse_SecurityTokenReferenceType_array_copy_contents(
1610		wsse_SecurityTokenReferenceType_array * dest_arr,
1611		const wsse_SecurityTokenReferenceType_array * src_arr)
1612	0	{
1613	0	return globus_xsd_generic_array_copy_contents(
1614		(globus_xsd_generic_array_t *) dest_arr,
1615		(globus_xsd_generic_array_t *) src_arr);
1616		}
1617		/* wsse_SecurityTokenReferenceType_array_copy_contents() */
1618
1619		wsse_SecurityTokenReferenceType *
1620		wsse_SecurityTokenReferenceType_array_push(
1621		wsse_SecurityTokenReferenceType_array * array)
1622	0	{
1623		/* Some contents initializers don't initialize subelments but to set their
1624		* values to be NULL
1625		*/
1626	0	if (array->type_info == NULL)
1627		{
1628	0	array->type_info = &wsse_SecurityTokenReferenceType_info;
1629		}
1630
1631	0	return globus_xsd_generic_array_push(
1632		(globus_xsd_generic_array_t *) array);
1633		}
1634		/* wsse_SecurityTokenReferenceType_array_push() */
1635
1636		void *
1637		wsse_SecurityTokenReferenceType_array_push_wrapper(
1638		void * array)
1639	0	{
1640	0	return (void *) wsse_SecurityTokenReferenceType_array_push((wsse_SecurityTokenReferenceType_array *) array);
1641		}
1642
1643		globus_result_t
1644		wsse_SecurityTokenReferenceType_array_serialize(
1645		const xsd_QName *                   element_qname,
1646		const wsse_SecurityTokenReferenceType_array *        array,
1647		globus_soap_message_handle_t        message,
1648		globus_xsd_element_options_t        options)
1649	0	{
1650	0	return globus_xsd_generic_array_serialize(
1651		element_qname,
1652		(const globus_xsd_generic_array_t *) array,
1653		message,
1654		options);
1655		}
1656		/* wsse_SecurityTokenReferenceType_array_serialize() */
1657
1658		globus_result_t
1659		wsse_SecurityTokenReferenceType_array_deserialize(
1660		const xsd_QName *                   element_qname,
1661		wsse_SecurityTokenReferenceType_array * array,
1662		globus_soap_message_handle_t        message,
1663		globus_xsd_element_options_t        options)
1664	0	{
1665		/* Some initializers set the array's contents to NULL */
1666	0	if (array->type_info == NULL)
1667		{
1668	0	array->type_info = &wsse_SecurityTokenReferenceType_info;
1669		}
1670	0	return globus_xsd_generic_array_deserialize(
1671		element_qname,
1672		(globus_xsd_generic_array_t *) array,
1673		message,
1674		options);