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