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