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