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 "ds_SignedInfoType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName ds_SignedInfoType_qname =
29		{
30		DS_SIGNEDINFOTYPE_NS,
31		DS_SIGNEDINFOTYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		ds_SignedInfoType_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 ds_SignedInfoType_serialize(
43		element_qname,
44		(const ds_SignedInfoType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		ds_SignedInfoType_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 ds_SignedInfoType_deserialize_pointer(
56		element_qname,
57		(ds_SignedInfoType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		ds_SignedInfoType_init_wrapper(void **object)
63	0	{
64	0	return ds_SignedInfoType_init(
65		(ds_SignedInfoType **) object);
66		}
67
68		void
69		ds_SignedInfoType_destroy_wrapper(
70		void *                          object)
71	0	{
72	0	ds_SignedInfoType_destroy(
73		(ds_SignedInfoType *) object);
74		}
75
76		globus_result_t
77		ds_SignedInfoType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	0	{
81	0	return ds_SignedInfoType_copy(
82		(ds_SignedInfoType **) dest_obj,
83		(ds_SignedInfoType *) src_obj);
84		}
85
86		globus_result_t
87		ds_SignedInfoType_init_contents_wrapper(void *object)
88	0	{
89	0	return ds_SignedInfoType_init_contents(
90		(ds_SignedInfoType *) object);
91		}
92
93		void
94		ds_SignedInfoType_destroy_contents_wrapper(
95		void *                          object)
96	0	{
97	0	ds_SignedInfoType_destroy_contents(
98		(ds_SignedInfoType *) object);
99		}
100
101		globus_result_t
102		ds_SignedInfoType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	0	{
106	0	return ds_SignedInfoType_copy_contents(
107		(ds_SignedInfoType *) dest_obj,
108		(const ds_SignedInfoType *) src_obj);
109		}
110
111		globus_result_t
112		ds_SignedInfoType_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 ds_SignedInfoType_serialize_contents(
119		element_qname,
120		(ds_SignedInfoType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		ds_SignedInfoType_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(ds_SignedInfoType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = ds_SignedInfoType_init(
138		(ds_SignedInfoType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = ds_SignedInfoType_deserialize_contents(
146		element_qname,
147		*(ds_SignedInfoType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		ds_SignedInfoType_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 ds_SignedInfoType_array_serialize(
162		element,
163		(ds_SignedInfoType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		ds_SignedInfoType_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 = ds_SignedInfoType_array_init(
179		(ds_SignedInfoType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return ds_SignedInfoType_array_deserialize(
187		element_qname,
188		*(ds_SignedInfoType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		ds_SignedInfoType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return ds_SignedInfoType_array_init(
197		(ds_SignedInfoType_array **) arr);
198		}
199
200		void
201		ds_SignedInfoType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	ds_SignedInfoType_array_destroy(
205		(ds_SignedInfoType_array *) arr);
206		}
207
208		globus_result_t
209		ds_SignedInfoType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return ds_SignedInfoType_array_copy(
214		(ds_SignedInfoType_array **) dest_arr,
215		(const ds_SignedInfoType_array *) src_arr);
216		}
217
218		globus_result_t
219		ds_SignedInfoType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return ds_SignedInfoType_array_init_contents(
223		(ds_SignedInfoType_array *) arr);
224		}
225
226		void
227		ds_SignedInfoType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	ds_SignedInfoType_array_destroy_contents(
231		(ds_SignedInfoType_array *) arr);
232		}
233
234		globus_result_t
235		ds_SignedInfoType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return ds_SignedInfoType_array_copy_contents(
240		(ds_SignedInfoType_array *) dest_arr,
241		(const ds_SignedInfoType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s ds_SignedInfoType_contents_info =
245		{
246		&ds_SignedInfoType_qname,
247		ds_SignedInfoType_serialize_contents_wrapper,
248		ds_SignedInfoType_deserialize_contents_wrapper,
249		ds_SignedInfoType_init_wrapper,
250		ds_SignedInfoType_destroy_wrapper,
251		ds_SignedInfoType_copy_wrapper,
252		ds_SignedInfoType_init_contents_wrapper,
253		ds_SignedInfoType_destroy_contents_wrapper,
254		ds_SignedInfoType_copy_contents_wrapper,
255		sizeof(ds_SignedInfoType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s ds_SignedInfoType_array_info =
262		{
263		&ds_SignedInfoType_qname,
264		ds_SignedInfoType_array_serialize_wrapper,
265		ds_SignedInfoType_array_deserialize_wrapper,
266		ds_SignedInfoType_array_init_wrapper,
267		ds_SignedInfoType_array_destroy_wrapper,
268		ds_SignedInfoType_array_copy_wrapper,
269		ds_SignedInfoType_array_init_contents_wrapper,
270		ds_SignedInfoType_array_destroy_contents_wrapper,
271		ds_SignedInfoType_array_copy_contents_wrapper,
272		sizeof(ds_SignedInfoType),
273		ds_SignedInfoType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s ds_SignedInfoType_info =
279		{
280		&ds_SignedInfoType_qname,
281		ds_SignedInfoType_serialize_wrapper,
282		ds_SignedInfoType_deserialize_pointer_wrapper,
283		ds_SignedInfoType_init_wrapper,
284		ds_SignedInfoType_destroy_wrapper,
285		ds_SignedInfoType_copy_wrapper,
286		ds_SignedInfoType_init_contents_wrapper,
287		ds_SignedInfoType_destroy_contents_wrapper,
288		ds_SignedInfoType_copy_contents_wrapper,
289		sizeof(ds_SignedInfoType),
290		NULL,
291		&ds_SignedInfoType_contents_info,
292		&ds_SignedInfoType_array_info
293		};
294
295		globus_result_t
296		ds_SignedInfoType_init_contents(
297		ds_SignedInfoType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(ds_SignedInfoType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(ds_SignedInfoType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		ds_SignedInfoType_init(
311		ds_SignedInfoType ** object)
312	0	{
313	0	ds_SignedInfoType * instance;
314	0	globus_result_t                     result = GLOBUS_SUCCESS;
315	0	GlobusFuncName(ds_SignedInfoType_init);
316	0	GlobusSoapMessageDebugEnter();
317
318	0	instance = globus_malloc(sizeof(ds_SignedInfoType));
319	0	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	0	memset(instance, 0, sizeof(ds_SignedInfoType));
326
327	0	*object = instance;
328
329		exit:
330	0	GlobusSoapMessageDebugExit();
331	0	return result;
332		}
333
334		void
335		ds_SignedInfoType_destroy(
336		ds_SignedInfoType * instance)
337	0	{
338	0	GlobusFuncName(ds_SignedInfoType_destroy);
339	0	GlobusSoapMessageDebugEnter();
340
341	0	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	0	ds_SignedInfoType_destroy_contents(instance);
347	0	globus_free(instance);
348
349		exit:
350
351	0	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		ds_SignedInfoType_destroy_contents(
357		ds_SignedInfoType * instance)
358	0	{
359	0	GlobusFuncName(ds_SignedInfoType_destroy_contents);
360	0	GlobusSoapMessageDebugEnter();
361
362	0	if(instance)
363		{
364
365
366	0	ds_CanonicalizationMethodType_destroy_contents(
367		&instance->CanonicalizationMethod);
368
369	0	ds_SignatureMethodType_destroy_contents(
370		&instance->SignatureMethod);
371
372	0	ds_ReferenceType_array_destroy_contents(&instance->Reference);
373
374	0	if(instance->_Id)
375		{
376	0	xsd_ID_destroy(
377		instance->_Id);
378	0	instance->_Id = NULL;
379		}
380
381		}
382
383	0	GlobusSoapMessageDebugExit();
384		}
385
386
387		globus_result_t
388		ds_SignedInfoType_copy(
389		ds_SignedInfoType ** dest_obj,
390		const ds_SignedInfoType * src_obj)
391	0	{
392	0	globus_result_t                     result = GLOBUS_SUCCESS;
393	0	ds_SignedInfoType * instance;
394	0	GlobusFuncName(ds_SignedInfoType_copy);
395
396	0	GlobusSoapMessageDebugEnter();
397
398	0	instance = calloc(1, sizeof(ds_SignedInfoType));
399	0	if (instance == NULL)
400		{
401	0	GlobusSoapMessageDebugExit();
402	0	return GlobusSoapMessageErrorOutOfMemory;
403		}
404
405	0	result = ds_SignedInfoType_copy_contents(instance, src_obj);
406	0	if(result != GLOBUS_SUCCESS)
407		{
408	0	globus_free(instance);
409	0	GlobusSoapMessageDebugExit();
410	0	return GlobusSoapMessageErrorOutOfMemory;
411		}
412
413	0	*dest_obj = instance;
414	0	GlobusSoapMessageDebugExit();
415	0	return result;
416		}
417
418		globus_result_t
419		ds_SignedInfoType_copy_contents(
420		ds_SignedInfoType * instance,
421		const ds_SignedInfoType * src_obj)
422	0	{
423	0	globus_result_t                     result = GLOBUS_SUCCESS;
424	0	GlobusFuncName(ds_SignedInfoType_copy_contents);
425
426	0	GlobusSoapMessageDebugEnter();
427
428	0	if(src_obj->_Id)
429		{
430	0	result = xsd_ID_copy(
431		&instance->_Id,
432		src_obj->_Id);
433	0	if(result != GLOBUS_SUCCESS)
434		{
435	0	result = GlobusSoapMessageErrorCopyFailed(
436		result, NULL, &xsd_ID_qname);
437	0	goto _Id_destroy;
438		}
439		}
440		else
441		{
442	0	instance->_Id = NULL;
443		}
444
445	0	result = ds_CanonicalizationMethodType_copy_contents(
446		&instance->CanonicalizationMethod,
447		&src_obj->CanonicalizationMethod);
448	0	if(result != GLOBUS_SUCCESS)
449		{
450	0	result = GlobusSoapMessageErrorCopyFailed(
451		result, NULL, &ds_CanonicalizationMethodType_qname);
452	0	goto CanonicalizationMethod_destroy;
453		}
454
455	0	result = ds_SignatureMethodType_copy_contents(
456		&instance->SignatureMethod,
457		&src_obj->SignatureMethod);
458	0	if(result != GLOBUS_SUCCESS)
459		{
460	0	result = GlobusSoapMessageErrorCopyFailed(
461		result, NULL, &ds_SignatureMethodType_qname);
462	0	goto SignatureMethod_destroy;
463		}
464
465	0	result = ds_ReferenceType_array_copy_contents(
466		&instance->Reference,
467		&src_obj->Reference);
468	0	if(result != GLOBUS_SUCCESS)
469		{
470	0	result = GlobusSoapMessageErrorCopyFailed(
471		result, NULL, &ds_ReferenceType_qname);
472	0	goto Reference_destroy_array;
473		}
474
475	0	goto exit;
476
477		fail_deserialize:
478
479		_Id_destroy:
480
481	0	if(instance->_Id)
482		{
483	0	xsd_ID_destroy(
484		instance->_Id);
485	0	instance->_Id = NULL;
486		}
487	0	ds_ReferenceType_array_destroy_contents(
488		&instance->Reference);
489
490		Reference_destroy_array:
491	0	ds_SignatureMethodType_destroy_contents(
492		&instance->SignatureMethod);
493
494		SignatureMethod_destroy:
495	0	ds_CanonicalizationMethodType_destroy_contents(
496		&instance->CanonicalizationMethod);
497
498		CanonicalizationMethod_destroy:
499
500
501		exit:
502
503	0	GlobusSoapMessageDebugExit();
504	0	return result;
505		}
506
507
508
509		globus_result_t
510		ds_SignedInfoType_serialize_contents(
511		const xsd_QName *                   element_qname, /* ignored */
512		const ds_SignedInfoType *              inst,
513		globus_soap_message_handle_t        message_handle,
514		globus_xsd_element_options_t        options)
515	0	{
516	0	globus_result_t                     result = GLOBUS_SUCCESS;
517	0	GlobusFuncName(ds_SignedInfoType_serialize_contents);
518	0	GlobusSoapMessageDebugEnter();
519
520	0	result = ds_SignedInfoType_serialize(
521		NULL,
522		inst,
523		message_handle,
524		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
525	0	if(result != GLOBUS_SUCCESS)
526		{
527	0	result = GlobusSoapMessageErrorSerializeFailed(
528		result, NULL, element_qname);
529		goto exit;
530		}
531
532		exit:
533
534	0	GlobusSoapMessageDebugExit();
535	0	return result;
536		}
537
538
539
540		globus_result_t
541		ds_SignedInfoType_serialize(
542		const xsd_QName *                   element_qname,
543		const ds_SignedInfoType *              instance,
544		globus_soap_message_handle_t        message_handle,
545		globus_xsd_element_options_t        options)
546	0	{
547	0	globus_result_t                     result = GLOBUS_SUCCESS;
548	0	xsd_QName                           subelement;
549	0	globus_list_t *                     any_attr_keys = NULL;
550	0	globus_list_t *                     any_attr_keys_iterator = NULL;
551	0	xsd_QName *                         type_attr = NULL;
552
553	0	char *                              prefix = NULL;
554	0	int                                 prefix_created;
555	0	int                                 define_prefix = 0;
556	0	int                                 save_options = options;
557
558	0	GlobusFuncName(ds_SignedInfoType_serialize);
559	0	GlobusSoapMessageDebugEnter();
560
561
562	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
563		{
564		/* serialize ds_SignedInfoType element */
565	0	result = globus_soap_message_element_ns_set(
566		message_handle,
567		element_qname,
568		element_qname->Namespace,
569		&options);
570	0	if(result != GLOBUS_SUCCESS)
571		{
572	0	result = GlobusSoapMessageErrorSerializeFailed(
573		result, NULL, element_qname);
574	0	goto exit;
575		}
576
577	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
578		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
579		{
580	0	result = globus_soap_message_attribute_ns_set(
581		message_handle,
582		element_qname,
583		"http://www.w3.org/2001/XMLSchema-instance",
584		&options);
585	0	if(result != GLOBUS_SUCCESS)
586		{
587	0	result = GlobusSoapMessageErrorSerializeFailed(
588		result, NULL, element_qname);
589	0	goto exit;
590		}
591		}
592
593	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
594		!globus_soap_message_serialize_is_c14n_subset(message_handle))
595		{
596
597	0	result = globus_soap_message_attribute_ns_set(
598		message_handle,
599		element_qname,
600		ds_SignedInfoType_qname.Namespace,
601		&options);
602	0	if(result != GLOBUS_SUCCESS)
603		{
604	0	result = GlobusSoapMessageErrorSerializeFailed(
605		result, NULL, element_qname);
606	0	goto exit;
607		}
608		}
609
610	0	if(instance->_Id)
611		{
612
613	0	result = globus_soap_message_attribute_ns_set(
614		message_handle,
615		element_qname,
616		NULL,
617		&options);
618
619	0	if(result != GLOBUS_SUCCESS)
620		{
621	0	xsd_QName               error_qname;
622	0	error_qname.local = prefix;
623	0	error_qname.Namespace = "";
624	0	result = GlobusSoapMessageErrorSerializeFailed(result,
625		NULL,
626		&error_qname);
627	0	goto exit;
628		}
629
630
631		}
632
633	0	result = globus_soap_message_serialize_element(
634		message_handle,
635		element_qname,
636		options,
637		&ds_SignedInfoType_qname);
638	0	if(result != GLOBUS_SUCCESS)
639		{
640	0	result = GlobusSoapMessageErrorSerializeFailed(
641		result, NULL, element_qname);
642	0	goto exit;
643		}
644
645	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
646		!globus_soap_message_serialize_is_c14n_subset(message_handle))
647		{
648	0	xsd_QName_init(&type_attr);
649
650	0	type_attr->local = globus_libc_strdup("type");
651	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
652		}
653
654
655		/* serialize namespaces */
656	0	result = globus_soap_message_element_ns_add(
657		message_handle,
658		element_qname,
659		element_qname->Namespace,
660		&options);
661	0	if(result != GLOBUS_SUCCESS)
662		{
663	0	result = GlobusSoapMessageErrorSerializeFailed(
664		result, NULL, element_qname);
665	0	goto exit;
666		}
667
668	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
669		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
670		{
671	0	result = globus_soap_message_attribute_ns_add(
672		message_handle,
673		element_qname,
674		"http://www.w3.org/2001/XMLSchema-instance",
675		&options);
676	0	if(result != GLOBUS_SUCCESS)
677		{
678	0	result = GlobusSoapMessageErrorSerializeFailed(
679		result, NULL, element_qname);
680	0	goto exit;
681		}
682		}
683	0	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
684		!globus_soap_message_serialize_is_c14n_subset(message_handle))
685		{
686
687	0	result = globus_soap_message_attribute_ns_add(
688		message_handle,
689		element_qname,
690		ds_SignedInfoType_qname.Namespace,
691		&options);
692	0	if(result != GLOBUS_SUCCESS)
693		{
694	0	result = GlobusSoapMessageErrorSerializeFailed(
695		result, NULL, element_qname);
696	0	goto exit;
697		}
698		}
699
700	0	if(instance->_Id)
701		{
702
703	0	result = globus_soap_message_attribute_ns_add(
704		message_handle,
705		element_qname,
706		NULL,
707		&options);
708
709	0	if(result != GLOBUS_SUCCESS)
710		{
711	0	xsd_QName               error_qname;
712	0	error_qname.local = prefix;
713	0	error_qname.Namespace = "";
714	0	result = GlobusSoapMessageErrorSerializeFailed(result,
715		NULL,
716		&error_qname);
717	0	goto exit;
718		}
719
720
721		}
722
723		/* serialize attributes */
724
725	0	subelement.Namespace = "";
726	0	subelement.local = "Id";
727
728	0	if(instance->_Id)
729		{
730
731	0	result = xsd_ID_serialize_attribute(
732		&subelement,
733		instance->_Id,
734		message_handle,
735		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
736	0	if(result != GLOBUS_SUCCESS)
737		{
738	0	result = GlobusSoapMessageErrorSerializeFailed(result,
739		NULL,
740		element_qname);
741	0	goto exit;
742		}
743
744		}
745
746	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
747		!globus_soap_message_serialize_is_c14n_subset(message_handle))
748		{
749	0	result = globus_soap_message_serialize_QName_attribute(
750		message_handle,
751		type_attr,
752		&ds_SignedInfoType_qname);
753	0	if(result != GLOBUS_SUCCESS)
754		{
755	0	result = GlobusSoapMessageErrorSerializeFailed(
756		result, NULL, element_qname);
757	0	goto exit;
758		}
759		}
760
761
762		}
763
764	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
765		{
766	0	result = globus_soap_message_serialize_element_begin_close(
767		message_handle, element_qname);
768	0	if(result != GLOBUS_SUCCESS)
769		{
770	0	result = GlobusSoapMessageErrorSerializeFailed(
771		result, NULL, element_qname);
772	0	goto exit;
773		}
774		}
775	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
776
777
778		/* serialize contents of type */
779
780	0	subelement.local = "CanonicalizationMethod";
781	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
782
783	0	result = ds_CanonicalizationMethodType_serialize(
784		&subelement,
785		&instance->CanonicalizationMethod,
786		message_handle,
787		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
788	0	if(result != GLOBUS_SUCCESS)
789		{
790	0	result = GlobusSoapMessageErrorSerializeFailed(
791		result, NULL, &ds_CanonicalizationMethodType_qname);
792	0	goto exit;
793		}
794
795	0	subelement.local = "SignatureMethod";
796	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
797
798	0	result = ds_SignatureMethodType_serialize(
799		&subelement,
800		&instance->SignatureMethod,
801		message_handle,
802		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
803	0	if(result != GLOBUS_SUCCESS)
804		{
805	0	result = GlobusSoapMessageErrorSerializeFailed(
806		result, NULL, &ds_SignatureMethodType_qname);
807	0	goto exit;
808		}
809
810	0	subelement.local = "Reference";
811	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
812
813	0	result = GlobusXSDArrayCheckLowerBounds(
814		1,
815		instance->Reference.length,
816		"Reference");
817	0	if(result != GLOBUS_SUCCESS)
818		{
819	0	result = GlobusSoapMessageErrorSerializeFailed(
820		result, NULL, &ds_ReferenceType_qname);
821	0	goto exit;
822		}
823
824	0	result = ds_ReferenceType_array_serialize(
825		&subelement,
826		&instance->Reference,
827		message_handle,
828		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
829	0	if(result != GLOBUS_SUCCESS)
830		{
831	0	result = GlobusSoapMessageErrorSerializeFailed(
832		result, NULL, &ds_ReferenceType_qname);
833	0	goto exit;
834		}
835
836	0	options = save_options;
837
838	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
839		{
840		/* add end element */
841	0	result = globus_soap_message_serialize_element_end(
842		message_handle,
843		element_qname,
844		options,
845		&ds_SignedInfoType_qname);
846	0	if(result != GLOBUS_SUCCESS)
847		{
848	0	result = GlobusSoapMessageErrorSerializeFailed(
849		result, NULL, element_qname);
850	0	goto exit;
851		}
852
853	0	globus_soap_message_element_ns_remove(
854		message_handle,
855		element_qname->Namespace,
856		&options);
857
858		/* remove namespace/prefix mappings for these types */
859
860	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
861		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
862		{
863	0	globus_soap_message_attribute_ns_remove(
864		message_handle,
865		"http://www.w3.org/2001/XMLSchema-instance",
866		&options);
867		}
868	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
869		!globus_soap_message_serialize_is_c14n_subset(message_handle))
870		{
871	0	globus_soap_message_attribute_ns_remove(
872		message_handle,
873		ds_SignedInfoType_qname.Namespace,
874		&options);
875		}
876
877	0	if(instance->_Id)
878		{
879
880	0	globus_soap_message_attribute_ns_remove(
881		message_handle,
882		NULL,
883		&options);
884
885		}
886
887		}
888
889		exit:
890	0	if (type_attr)
891		{
892	0	xsd_QName_destroy(type_attr);
893		}
894
895
896	0	if(any_attr_keys)
897		{
898	0	globus_list_free(any_attr_keys);
899		}
900
901	0	GlobusSoapMessageDebugExit();
902	0	return result;
903		}
904
905
906
907		globus_result_t
908		ds_SignedInfoType_deserialize_contents(
909		const xsd_QName *                   element_qname, /* ignored */
910		ds_SignedInfoType *                    inst,
911		globus_soap_message_handle_t        message_handle,
912		globus_xsd_element_options_t        options)
913	0	{
914	0	globus_result_t                     result = GLOBUS_SUCCESS;
915	0	GlobusFuncName(ds_SignedInfoType_deserialize_contents);
916	0	GlobusSoapMessageDebugEnter();
917
918	0	result = ds_SignedInfoType_deserialize(
919		NULL,
920		inst,
921		message_handle,
922		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
923	0	if(result != GLOBUS_SUCCESS)
924		{
925	0	result = GlobusSoapMessageErrorDeserializeFailed(
926		result, element_qname);
927		goto exit;
928		}
929
930		exit:
931
932	0	GlobusSoapMessageDebugExit();
933	0	return result;
934		}
935
936
937
938		globus_result_t
939		ds_SignedInfoType_deserialize(
940		const xsd_QName *                   element_qname,
941		ds_SignedInfoType *                    instance,
942		globus_soap_message_handle_t        message_handle,
943		globus_xsd_element_options_t        options)
944	0	{
945	0	globus_result_t                     result = GLOBUS_SUCCESS;
946	0	xsd_QName                           subelement;
947	0	GlobusFuncName(ds_SignedInfoType_deserialize);
948	0	GlobusSoapMessageDebugEnter();
949
950
951	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
952		{
953	0	result = globus_soap_message_deserialize_element(
954		message_handle, element_qname);
955	0	if(result != GLOBUS_SUCCESS)
956		{
957	0	result = GlobusSoapMessageErrorDeserializeFailed(
958		result, element_qname);
959	0	goto exit;
960		}
961
962	0	subelement.Namespace = "";
963	0	subelement.local = "Id";
964
965	0	result = xsd_ID_deserialize_attribute_pointer(
966		&subelement,
967		&instance->_Id,
968		message_handle,
969		0);
970	0	if(result != GLOBUS_SUCCESS)
971		{
972	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
973	0	goto _Id_destroy;
974		}
975
976
977
978	0	result = globus_soap_message_deserialize_element_begin_close(
979		message_handle);
980	0	if(result != GLOBUS_SUCCESS)
981		{
982	0	result = GlobusSoapMessageErrorDeserializeFailed(
983		result, element_qname);
984	0	goto fail_deserialize;
985		}
986		}
987
988	0	subelement.local = "CanonicalizationMethod";
989	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
990
991	0	result = ds_CanonicalizationMethodType_deserialize(
992		&subelement,
993		&instance->CanonicalizationMethod,
994		message_handle,
995		0);
996	0	if(result != GLOBUS_SUCCESS)
997		{
998	0	result = GlobusSoapMessageErrorDeserializeFailed(
999		result,
1000		&ds_CanonicalizationMethodType_qname);
1001	0	goto CanonicalizationMethod_destroy;
1002		}
1003
1004	0	subelement.local = "SignatureMethod";
1005	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1006
1007	0	result = ds_SignatureMethodType_deserialize(
1008		&subelement,
1009		&instance->SignatureMethod,
1010		message_handle,
1011		0);
1012	0	if(result != GLOBUS_SUCCESS)
1013		{
1014	0	result = GlobusSoapMessageErrorDeserializeFailed(
1015		result,
1016		&ds_SignatureMethodType_qname);
1017	0	goto SignatureMethod_destroy;
1018		}
1019
1020	0	subelement.local = "Reference";
1021	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1022
1023	0	result = ds_ReferenceType_array_deserialize(
1024		&subelement,
1025		&instance->Reference,
1026		message_handle,
1027		0);
1028	0	if(result != GLOBUS_SUCCESS)
1029		{
1030	0	result = GlobusSoapMessageErrorDeserializeFailed(
1031		result,
1032		(&subelement));
1033	0	goto Reference_destroy_array;
1034		}
1035
1036	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1037		{
1038	0	result = globus_soap_message_deserialize_element_end(
1039		message_handle,
1040		element_qname);
1041	0	if(result != GLOBUS_SUCCESS)
1042		{
1043	0	result = GlobusSoapMessageErrorDeserializeFailed(
1044		result, element_qname);
1045		goto fail_deserialize;
1046		}
1047		}
1048
1049	0	goto exit;
1050
1051		fail_deserialize:
1052
1053		_Id_destroy:
1054		/* output_fail_destroy_attribute() */
1055
1056	0	if(instance->_Id)
1057		{
1058	0	xsd_ID_destroy(
1059		instance->_Id);
1060	0	instance->_Id = NULL;
1061		}
1062	0	ds_ReferenceType_array_destroy_contents(
1063		&instance->Reference);
1064
1065		Reference_destroy_array:
1066	0	ds_SignatureMethodType_destroy_contents(
1067		&instance->SignatureMethod);
1068
1069		SignatureMethod_destroy:
1070	0	ds_CanonicalizationMethodType_destroy_contents(
1071		&instance->CanonicalizationMethod);
1072
1073		CanonicalizationMethod_destroy:
1074
1075
1076		exit:
1077
1078	0	GlobusSoapMessageDebugExit();
1079	0	return result;
1080		}
1081
1082
1083
1084		globus_result_t
1085		ds_SignedInfoType_deserialize_pointer(
1086		const xsd_QName *                   element_qname,
1087		ds_SignedInfoType **                   ip,
1088		globus_soap_message_handle_t        message_handle,
1089		globus_xsd_element_options_t        options)
1090	0	{
1091	0	ds_SignedInfoType * instance = NULL;
1092	0	globus_result_t                     result = GLOBUS_SUCCESS;
1093	0	xsd_QName                           subelement;
1094	0	int                                 found_attrs = 0;
1095	0	int                                 empty_element = 0;
1096	0	GlobusFuncName(ds_SignedInfoType_deserialize_pointer);
1097	0	GlobusSoapMessageDebugEnter();
1098
1099	0	*ip = NULL;
1100
1101	0	result = globus_soap_message_deserialize_element(
1102		message_handle, element_qname);
1103	0	if(result != GLOBUS_SUCCESS &&
1104		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1105		GlobusSoapMessageStatusFailedElementCheck(result) ||
1106		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1107		{
1108	0	result = GLOBUS_SUCCESS;
1109	0	goto exit;
1110		}
1111
1112	0	if(result != GLOBUS_SUCCESS)
1113		{
1114	0	result = GlobusSoapMessageErrorDeserializeFailed(
1115		result, element_qname);
1116	0	goto exit;
1117		}
1118
1119	0	if(globus_soap_message_deserialize_element_is_empty(
1120		message_handle))
1121		{
1122	0	empty_element = 1;
1123		}
1124
1125	0	result = ds_SignedInfoType_init(&instance);
1126	0	if(result != GLOBUS_SUCCESS)
1127		{
1128	0	result = GlobusSoapMessageErrorDeserializeFailed(
1129		result, element_qname);
1130	0	goto exit;
1131		}
1132
1133
1134	0	subelement.Namespace = "";
1135	0	subelement.local = "Id";
1136
1137	0	result = xsd_ID_deserialize_attribute_pointer(
1138		&subelement,
1139		&instance->_Id,
1140		message_handle,
1141		0);
1142	0	if(result != GLOBUS_SUCCESS)
1143		{
1144	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1145	0	goto _Id_destroy;
1146		}
1147
1148
1149	0	if(instance->_Id)
1150		{
1151	0	found_attrs++;
1152		}
1153
1154	0	if(found_attrs == 0 &&
1155		globus_soap_message_deserialize_element_is_nil(message_handle))
1156		{
1157	0	ds_SignedInfoType_destroy(instance);
1158
1159	0	result = globus_soap_message_deserialize_element_end(
1160		message_handle,
1161		element_qname);
1162	0	if(result != GLOBUS_SUCCESS)
1163		{
1164	0	result = GlobusSoapMessageErrorDeserializeFailed(
1165		result, element_qname);
1166	0	goto exit;
1167		}
1168
1169	0	*ip = NULL;
1170	0	globus_object_free(globus_error_get(result));
1171	0	result = GLOBUS_SUCCESS;
1172	0	goto exit;
1173		}
1174
1175
1176	0	if(empty_element)
1177		{
1178	0	result = globus_soap_message_deserialize_element_end(
1179		message_handle,
1180		element_qname);
1181	0	if(result != GLOBUS_SUCCESS)
1182		{
1183	0	result = GlobusSoapMessageErrorDeserializeFailed(
1184		result, element_qname);
1185	0	goto fail_deserialize;
1186		}
1187
1188	0	*ip = instance;
1189	0	goto exit;
1190		}
1191
1192	0	result = globus_soap_message_deserialize_element_begin_close(
1193		message_handle);
1194	0	if(result != GLOBUS_SUCCESS)
1195		{
1196	0	result = GlobusSoapMessageErrorDeserializeFailed(
1197		result, element_qname);
1198	0	goto exit;
1199		}
1200
1201	0	result = ds_SignedInfoType_deserialize(
1202		element_qname,
1203		instance,
1204		message_handle,
1205		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1206
1207	0	result = globus_soap_message_deserialize_element_end(
1208		message_handle,
1209		element_qname);
1210	0	if(result != GLOBUS_SUCCESS)
1211		{
1212	0	result = GlobusSoapMessageErrorDeserializeFailed(
1213		result, element_qname);
1214	0	goto fail_deserialize;
1215		}
1216
1217	0	*ip = instance;
1218
1219	0	goto exit;
1220
1221		fail_deserialize:
1222
1223		_Id_destroy:
1224		/* output_fail_destroy_attribute() */
1225
1226	0	if(instance->_Id)
1227		{
1228	0	xsd_ID_destroy(
1229		instance->_Id);
1230	0	instance->_Id = NULL;
1231		}
1232	0	ds_ReferenceType_array_destroy_contents(
1233		&instance->Reference);
1234
1235		Reference_destroy_array:
1236	0	ds_SignatureMethodType_destroy_contents(
1237		&instance->SignatureMethod);
1238
1239		SignatureMethod_destroy:
1240	0	ds_CanonicalizationMethodType_destroy_contents(
1241		&instance->CanonicalizationMethod);
1242
1243		CanonicalizationMethod_destroy:
1244
1245		exit:
1246
1247	0	GlobusSoapMessageDebugExit();
1248	0	return result;
1249		}
1250
1251
1252		globus_result_t
1253		ds_SignedInfoType_array_init_contents(
1254		ds_SignedInfoType_array * array)
1255	0	{
1256	0	return globus_xsd_generic_array_init_contents(
1257		(globus_xsd_generic_array_t *) array,
1258		&ds_SignedInfoType_info);
1259		}
1260		/* ds_SignedInfoType_array_init_contents() */
1261
1262		globus_result_t
1263		ds_SignedInfoType_array_init(
1264		ds_SignedInfoType_array ** arr)
1265	0	{
1266	0	return globus_xsd_generic_array_init(
1267		(globus_xsd_generic_array_t **) arr,
1268		&ds_SignedInfoType_info);
1269		}
1270		/* ds_SignedInfoType_array_init() */
1271
1272		void
1273		ds_SignedInfoType_array_destroy_contents(
1274		ds_SignedInfoType_array * array)
1275	0	{
1276	0	globus_xsd_generic_array_destroy_contents(
1277		(globus_xsd_generic_array_t *) array);
1278		}
1279		/* ds_SignedInfoType_array_destroy_contents() */
1280
1281		void
1282		ds_SignedInfoType_array_destroy(
1283		ds_SignedInfoType_array * array)
1284	0	{
1285	0	globus_xsd_generic_array_destroy(
1286		(globus_xsd_generic_array_t *) array);
1287		}
1288		/* ds_SignedInfoType_array_destroy() */
1289
1290		globus_result_t
1291		ds_SignedInfoType_array_copy(
1292		ds_SignedInfoType_array ** dest_arr,
1293		const ds_SignedInfoType_array * src_arr)
1294	0	{
1295	0	return globus_xsd_generic_array_copy(
1296		(globus_xsd_generic_array_t **) dest_arr,
1297		(globus_xsd_generic_array_t *) src_arr);
1298		}
1299		/* ds_SignedInfoType_array_copy() */
1300
1301		globus_result_t
1302		ds_SignedInfoType_array_copy_contents(
1303		ds_SignedInfoType_array * dest_arr,
1304		const ds_SignedInfoType_array * src_arr)
1305	0	{
1306	0	return globus_xsd_generic_array_copy_contents(
1307		(globus_xsd_generic_array_t *) dest_arr,
1308		(globus_xsd_generic_array_t *) src_arr);
1309		}
1310		/* ds_SignedInfoType_array_copy_contents() */
1311
1312		ds_SignedInfoType *
1313		ds_SignedInfoType_array_push(
1314		ds_SignedInfoType_array * array)
1315	0	{
1316		/* Some contents initializers don't initialize subelments but to set their
1317		* values to be NULL
1318		*/
1319	0	if (array->type_info == NULL)
1320		{
1321	0	array->type_info = &ds_SignedInfoType_info;
1322		}
1323
1324	0	return globus_xsd_generic_array_push(
1325		(globus_xsd_generic_array_t *) array);
1326		}
1327		/* ds_SignedInfoType_array_push() */
1328
1329		void *
1330		ds_SignedInfoType_array_push_wrapper(
1331		void * array)
1332	0	{
1333	0	return (void *) ds_SignedInfoType_array_push((ds_SignedInfoType_array *) array);
1334		}
1335
1336		globus_result_t
1337		ds_SignedInfoType_array_serialize(
1338		const xsd_QName *                   element_qname,
1339		const ds_SignedInfoType_array *        array,
1340		globus_soap_message_handle_t        message,
1341		globus_xsd_element_options_t        options)
1342	0	{
1343	0	return globus_xsd_generic_array_serialize(
1344		element_qname,
1345		(const globus_xsd_generic_array_t *) array,
1346		message,
1347		options);
1348		}
1349		/* ds_SignedInfoType_array_serialize() */
1350
1351		globus_result_t
1352		ds_SignedInfoType_array_deserialize(
1353		const xsd_QName *                   element_qname,
1354		ds_SignedInfoType_array * array,
1355		globus_soap_message_handle_t        message,
1356		globus_xsd_element_options_t        options)
1357	0	{
1358		/* Some initializers set the array's contents to NULL */
1359	0	if (array->type_info == NULL)
1360		{
1361	0	array->type_info = &ds_SignedInfoType_info;
1362		}
1363	0	return globus_xsd_generic_array_deserialize(
1364		element_qname,
1365		(globus_xsd_generic_array_t *) array,
1366		message,
1367		options);