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