1		/*
2		* Portions of this file Copyright 1999-2005 University of Chicago
3		* Portions of this file Copyright 1999-2005 The University of Southern California.
4		*
5		* This file or a portion of this file is licensed under the
6		* terms of the Globus Toolkit Public License, found at
7		* http://www.globus.org/toolkit/download/license.html.
8		* If you redistribute this file, with or without
9		* modifications, you must include this notice in the file.
10		*/
11
12
13		/*
14		* This file is automatically generated by the Globus WSDLtoC converter
15		*/
16
17		#include "xsd_QName.h"
18		#include "globus_soap_message.h"
19		#include "globus_xsd_type_info.h"
20		#include "ds_X509DataType.h"
21
22		xsd_QName ds_X509DataType_choice_qname =
23		{
24		"http://www.w3.org/2000/09/xmldsig#",
25		"X509DataType_choice"
26		};
27
28		globus_result_t
29		ds_X509DataType_choice_serialize_wrapper(
30		xsd_QName *                         element_qname,
31		void *                              instance,
32		globus_soap_message_handle_t        message_handle,
33		globus_xsd_element_options_t        options)
34	0	{
35	0	return ds_X509DataType_choice_serialize(
36		element_qname,
37		(ds_X509DataType_choice *) instance,
38		message_handle, options);
39		}
40
41		globus_result_t
42		ds_X509DataType_choice_deserialize_pointer_wrapper(
43		xsd_QName *                         element_qname,
44		void **                             ip,
45		globus_soap_message_handle_t        message_handle,
46		globus_xsd_element_options_t        options)
47	0	{
48	0	return ds_X509DataType_choice_deserialize_pointer(
49		element_qname,
50		(ds_X509DataType_choice **) ip,
51		message_handle, options);
52		}
53
54		globus_result_t
55		ds_X509DataType_choice_init_wrapper(void **object)
56	0	{
57	0	return ds_X509DataType_choice_init(
58		(ds_X509DataType_choice **) object);
59		}
60
61		void
62		ds_X509DataType_choice_destroy_wrapper(
63		void *                          object)
64	0	{
65	0	ds_X509DataType_choice_destroy(
66		(ds_X509DataType_choice *) object);
67		}
68
69		globus_result_t
70		ds_X509DataType_choice_copy_wrapper(
71		void **                         dest_obj,
72		void *                          src_obj)
73	0	{
74	0	return ds_X509DataType_choice_copy(
75		(ds_X509DataType_choice **) dest_obj,
76		(ds_X509DataType_choice *) src_obj);
77		}
78
79		globus_result_t
80		ds_X509DataType_choice_init_contents_wrapper(void *object)
81	0	{
82	0	return ds_X509DataType_choice_init_contents(
83		(ds_X509DataType_choice *) object);
84		}
85
86		void
87		ds_X509DataType_choice_destroy_contents_wrapper(
88		void *                          object)
89	0	{
90	0	ds_X509DataType_choice_destroy_contents(
91		(ds_X509DataType_choice *) object);
92		}
93
94		globus_result_t
95		ds_X509DataType_choice_copy_contents_wrapper(
96		void *                          dest_obj,
97		void *                          src_obj)
98	0	{
99	0	return ds_X509DataType_choice_copy_contents(
100		(ds_X509DataType_choice *) dest_obj,
101		(ds_X509DataType_choice *) src_obj);
102		}
103
104		globus_result_t
105		ds_X509DataType_choice_serialize_contents_wrapper(
106		xsd_QName *                         element_qname,
107		void *                              instance,
108		globus_soap_message_handle_t        message_handle,
109		globus_xsd_element_options_t        options)
110	0	{
111	0	return ds_X509DataType_choice_serialize_contents(
112		element_qname,
113		(ds_X509DataType_choice *) instance,
114		message_handle, options);
115		}
116
117		globus_result_t
118		ds_X509DataType_choice_deserialize_contents_wrapper(
119		xsd_QName *                         element_qname,
120		void **                             instance,
121		globus_soap_message_handle_t        message_handle,
122		globus_xsd_element_options_t        options)
123	0	{
124	0	globus_result_t                     result;
125	0	GlobusFuncName(ds_X509DataType_choice_deserialize_contents_wrapper);
126	0	GlobusSoapMessageDebugEnter();
127
128	0	if(!*instance)
129		{
130	0	result = ds_X509DataType_choice_init(
131		(ds_X509DataType_choice **)instance);
132	0	if(result != GLOBUS_SUCCESS)
133		{
134	0	goto error;
135		}
136		}
137
138	0	result = ds_X509DataType_choice_deserialize_contents(
139		element_qname,
140		*(ds_X509DataType_choice **)instance,
141		message_handle, options);
142		error:
143	0	GlobusSoapMessageDebugExit();
144	0	return result;
145		}
146
147		globus_result_t
148		ds_X509DataType_choice_array_serialize_wrapper(
149		xsd_QName *                     element,
150		void *                          instance,
151		globus_soap_message_handle_t    message,
152		globus_xsd_element_options_t    options)
153	0	{
154	0	return ds_X509DataType_choice_array_serialize(
155		element,
156		(ds_X509DataType_choice_array *) instance,
157		message, options);
158		}
159
160		globus_result_t
161		ds_X509DataType_choice_array_deserialize_wrapper(
162		xsd_QName *                         element_qname,
163		void **                             inst,
164		globus_soap_message_handle_t        message,
165		globus_xsd_element_options_t        options)
166	0	{
167	0	if(!*inst)
168		{
169	0	globus_result_t                 result;
170
171	0	result = ds_X509DataType_choice_array_init(
172		(ds_X509DataType_choice_array **)inst);
173	0	if(result != GLOBUS_SUCCESS)
174		{
175	0	return result;
176		}
177		}
178
179	0	return ds_X509DataType_choice_array_deserialize(
180		element_qname,
181		*(ds_X509DataType_choice_array **) inst,
182		message, options);
183		}
184
185		globus_result_t
186		ds_X509DataType_choice_array_init_wrapper(
187		void **                             arr)
188	0	{
189	0	return ds_X509DataType_choice_array_init(
190		(ds_X509DataType_choice_array **) arr);
191		}
192
193		void
194		ds_X509DataType_choice_array_destroy_wrapper(
195		void *                              arr)
196	0	{
197	0	ds_X509DataType_choice_array_destroy(
198		(ds_X509DataType_choice_array *) arr);
199		}
200
201		globus_result_t
202		ds_X509DataType_choice_array_copy_wrapper(
203		void **                             dest_arr,
204		void *                              src_arr)
205	0	{
206	0	return ds_X509DataType_choice_array_copy(
207		(ds_X509DataType_choice_array **) dest_arr,
208		(ds_X509DataType_choice_array *) src_arr);
209		}
210
211		globus_result_t
212		ds_X509DataType_choice_array_init_contents_wrapper(
213		void *                              arr)
214	0	{
215	0	return ds_X509DataType_choice_array_init_contents(
216		(ds_X509DataType_choice_array *) arr);
217		}
218
219		void
220		ds_X509DataType_choice_array_destroy_contents_wrapper(
221		void *                              arr)
222	0	{
223	0	ds_X509DataType_choice_array_destroy_contents(
224		(ds_X509DataType_choice_array *) arr);
225		}
226
227		globus_result_t
228		ds_X509DataType_choice_array_copy_contents_wrapper(
229		void *                              dest_arr,
230		void *                              src_arr)
231	0	{
232	0	return ds_X509DataType_choice_array_copy_contents(
233		(ds_X509DataType_choice_array *) dest_arr,
234		(ds_X509DataType_choice_array *) src_arr);
235		}
236
237		struct globus_xsd_type_info_s ds_X509DataType_choice_array_info =
238		{
239		&ds_X509DataType_choice_qname,
240		ds_X509DataType_choice_array_serialize_wrapper,
241		ds_X509DataType_choice_array_deserialize_wrapper,
242		ds_X509DataType_choice_array_init_wrapper,
243		ds_X509DataType_choice_array_destroy_wrapper,
244		ds_X509DataType_choice_array_copy_wrapper,
245		ds_X509DataType_choice_array_init_contents_wrapper,
246		ds_X509DataType_choice_array_destroy_contents_wrapper,
247		ds_X509DataType_choice_array_copy_contents_wrapper,
248		sizeof(ds_X509DataType_choice),
249		ds_X509DataType_choice_array_push_wrapper,
250		NULL,
251		NULL
252		};
253
254		struct globus_xsd_type_info_s ds_X509DataType_choice_contents_info =
255		{
256		&ds_X509DataType_choice_qname,
257		ds_X509DataType_choice_serialize_contents_wrapper,
258		ds_X509DataType_choice_deserialize_contents_wrapper,
259		ds_X509DataType_choice_init_wrapper,
260		ds_X509DataType_choice_destroy_wrapper,
261		ds_X509DataType_choice_copy_wrapper,
262		ds_X509DataType_choice_init_contents_wrapper,
263		ds_X509DataType_choice_destroy_contents_wrapper,
264		ds_X509DataType_choice_copy_contents_wrapper,
265		sizeof(ds_X509DataType_choice),
266		NULL,
267		NULL,
268		NULL
269		};
270
271		struct globus_xsd_type_info_s ds_X509DataType_choice_info =
272		{
273		&ds_X509DataType_choice_qname,
274		ds_X509DataType_choice_serialize_wrapper,
275		ds_X509DataType_choice_deserialize_pointer_wrapper,
276		ds_X509DataType_choice_init_wrapper,
277		ds_X509DataType_choice_destroy_wrapper,
278		ds_X509DataType_choice_copy_wrapper,
279		ds_X509DataType_choice_init_contents_wrapper,
280		ds_X509DataType_choice_destroy_contents_wrapper,
281		ds_X509DataType_choice_copy_contents_wrapper,
282		sizeof(ds_X509DataType),
283		NULL,
284		&ds_X509DataType_choice_contents_info,
285		&ds_X509DataType_choice_array_info
286		};
287
288		globus_result_t
289		ds_X509DataType_choice_init_contents(
290		ds_X509DataType_choice *                    instance)
291	0	{
292	0	globus_result_t                     result = GLOBUS_SUCCESS;
293	0	GlobusFuncName(ds_X509DataType_choice_init_contents);
294	0	GlobusSoapMessageDebugEnter();
295
296	0	memset(instance, 0, sizeof(ds_X509DataType));
297
298	0	GlobusSoapMessageDebugExit();
299	0	return result;
300		}
301
302		globus_result_t
303		ds_X509DataType_choice_init(
304		ds_X509DataType_choice ** object)
305	0	{
306	0	ds_X509DataType_choice * instance;
307	0	globus_result_t                     result = GLOBUS_SUCCESS;
308	0	GlobusFuncName(ds_X509DataType_choice_init);
309	0	GlobusSoapMessageDebugEnter();
310
311	0	instance = globus_malloc(sizeof(ds_X509DataType_choice));
312	0	if(!instance)
313		{
314	0	result = GlobusSoapMessageErrorOutOfMemory;
315	0	goto exit;
316		}
317
318	0	memset(instance, 0, sizeof(ds_X509DataType_choice));
319
320	0	*object = instance;
321
322		exit:
323	0	GlobusSoapMessageDebugExit();
324	0	return result;
325		}
326
327		void
328		ds_X509DataType_choice_destroy(
329		ds_X509DataType_choice * instance)
330	0	{
331	0	GlobusFuncName(ds_X509DataType_choice_destroy);
332	0	GlobusSoapMessageDebugEnter();
333
334	0	if(!instance)
335		{
336	0	goto exit;
337		}
338
339	0	ds_X509DataType_choice_destroy_contents(instance);
340	0	free(instance);
341
342		exit:
343
344	0	GlobusSoapMessageDebugExit();
345		}
346
347
348
349		void
350		ds_X509DataType_choice_destroy_contents(
351		ds_X509DataType_choice * instance)
352	0	{
353	0	GlobusFuncName(ds_X509DataType_choice_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	switch(instance->type)
357		{
358
359		case ds_X509DataType_X509IssuerSerial:
360
361	0	ds_X509IssuerSerialType_destroy_contents(
362		&instance->value.X509IssuerSerial);
363	0	break;
364
365		case ds_X509DataType_X509SKI:
366
367	0	xsd_base64Binary_destroy_contents(
368		&instance->value.X509SKI);
369	0	break;
370
371		case ds_X509DataType_X509SubjectName:
372
373	0	xsd_string_destroy_contents(
374		&instance->value.X509SubjectName);
375	0	break;
376
377		case ds_X509DataType_X509Certificate:
378
379	0	xsd_base64Binary_destroy_contents(
380		&instance->value.X509Certificate);
381	0	break;
382
383		case ds_X509DataType_X509CRL:
384
385	0	xsd_base64Binary_destroy_contents(
386		&instance->value.X509CRL);
387	0	break;
388
389		case ds_X509DataType_any:
390
391	0	xsd_any_destroy_contents(
392		&instance->value.any);
393		break;
394
395		default:
396	0	break;
397		}
398
399	0	instance->type = ds_X509DataType_undefined;
400
401	0	GlobusSoapMessageDebugExit();
402		}
403
404		globus_result_t
405		ds_X509DataType_choice_copy(
406		ds_X509DataType_choice ** dest_obj,
407		const ds_X509DataType_choice * src_obj)
408	0	{
409	0	globus_result_t                     result = GLOBUS_SUCCESS;
410	0	ds_X509DataType_choice * instance;
411	0	GlobusFuncName(ds_X509DataType_choice_copy);
412
413	0	GlobusSoapMessageDebugEnter();
414
415	0	instance = malloc(sizeof(ds_X509DataType_choice));
416	0	if (instance == NULL)
417		{
418	0	GlobusSoapMessageDebugExit();
419	0	return GlobusSoapMessageErrorOutOfMemory;
420		}
421
422	0	result = ds_X509DataType_choice_copy_contents(instance, src_obj);
423	0	if(result != GLOBUS_SUCCESS)
424		{
425	0	globus_free(instance);
426	0	GlobusSoapMessageDebugExit();
427	0	return GlobusSoapMessageErrorOutOfMemory;
428		}
429
430	0	*dest_obj = instance;
431	0	GlobusSoapMessageDebugExit();
432	0	return result;
433		}
434
435
436
437		globus_result_t
438		ds_X509DataType_choice_copy_contents(
439		ds_X509DataType_choice * instance,
440		const ds_X509DataType_choice * src_obj)
441	0	{
442	0	xsd_QName                           subelement;
443	0	globus_result_t                     result = GLOBUS_SUCCESS;
444	0	GlobusFuncName(ds_X509DataType_choice_copy_contents);
445
446	0	GlobusSoapMessageDebugEnter();
447
448	0	switch(src_obj->type)
449		{
450
451		case ds_X509DataType_X509IssuerSerial:
452	0	instance->type = ds_X509DataType_X509IssuerSerial;
453	0	result = ds_X509IssuerSerialType_copy_contents(
454		&instance->value.X509IssuerSerial,
455		&src_obj->value.X509IssuerSerial);
456	0	if(result != GLOBUS_SUCCESS)
457		{
458	0	result = GlobusSoapMessageErrorSerializeFailed(
459		result, NULL, &ds_X509DataType_choice_qname);
460	0	goto exit;
461		}
462
463	0	break;
464
465		case ds_X509DataType_X509SKI:
466	0	instance->type = ds_X509DataType_X509SKI;
467	0	result = xsd_base64Binary_copy_contents(
468		&instance->value.X509SKI,
469		&src_obj->value.X509SKI);
470	0	if(result != GLOBUS_SUCCESS)
471		{
472	0	result = GlobusSoapMessageErrorSerializeFailed(
473		result, NULL, &ds_X509DataType_choice_qname);
474	0	goto exit;
475		}
476
477	0	break;
478
479		case ds_X509DataType_X509SubjectName:
480	0	instance->type = ds_X509DataType_X509SubjectName;
481	0	result = xsd_string_copy_contents(
482		&instance->value.X509SubjectName,
483		&src_obj->value.X509SubjectName);
484	0	if(result != GLOBUS_SUCCESS)
485		{
486	0	result = GlobusSoapMessageErrorSerializeFailed(
487		result, NULL, &ds_X509DataType_choice_qname);
488	0	goto exit;
489		}
490
491	0	break;
492
493		case ds_X509DataType_X509Certificate:
494	0	instance->type = ds_X509DataType_X509Certificate;
495	0	result = xsd_base64Binary_copy_contents(
496		&instance->value.X509Certificate,
497		&src_obj->value.X509Certificate);
498	0	if(result != GLOBUS_SUCCESS)
499		{
500	0	result = GlobusSoapMessageErrorSerializeFailed(
501		result, NULL, &ds_X509DataType_choice_qname);
502	0	goto exit;
503		}
504
505	0	break;
506
507		case ds_X509DataType_X509CRL:
508	0	instance->type = ds_X509DataType_X509CRL;
509	0	result = xsd_base64Binary_copy_contents(
510		&instance->value.X509CRL,
511		&src_obj->value.X509CRL);
512	0	if(result != GLOBUS_SUCCESS)
513		{
514	0	result = GlobusSoapMessageErrorSerializeFailed(
515		result, NULL, &ds_X509DataType_choice_qname);
516	0	goto exit;
517		}
518
519	0	break;
520
521		case ds_X509DataType_any:
522	0	instance->type = ds_X509DataType_any;
523	0	result = xsd_any_copy_contents(
524		&instance->value.any,
525		&src_obj->value.any);
526	0	if(result != GLOBUS_SUCCESS)
527		{
528	0	result = GlobusSoapMessageErrorSerializeFailed(
529		result, NULL, &ds_X509DataType_choice_qname);
530		goto exit;
531		}
532
533	0	break;
534
535		default:
536	0	break;
537		}
538
539		exit:
540
541	0	GlobusSoapMessageDebugExit();
542	0	return result;
543		}
544
545
546
547
548
549		globus_result_t
550		ds_X509DataType_choice_serialize_contents(
551		xsd_QName *                         element_qname, /* ignored */
552		ds_X509DataType_choice * instance,
553		globus_soap_message_handle_t        message_handle,
554		globus_xsd_element_options_t        options)
555	0	{
556	0	xsd_QName                           subelement;
557	0	globus_result_t                     result = GLOBUS_SUCCESS;
558	0	GlobusFuncName(ds_X509DataType_choice_serialize_contents);
559	0	GlobusSoapMessageDebugEnter();
560
561	0	switch(instance->type)
562		{
563
564		case ds_X509DataType_X509IssuerSerial:
565
566	0	subelement.local = "X509IssuerSerial";
567	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
568	0	result = ds_X509IssuerSerialType_serialize(
569		&subelement,
570		&instance->value.X509IssuerSerial,
571		message_handle,
572		options);
573	0	if(result != GLOBUS_SUCCESS)
574		{
575	0	result = GlobusSoapMessageErrorSerializeFailed(
576		result, NULL, &ds_X509DataType_choice_qname);
577	0	goto exit;
578		}
579
580	0	break;
581
582		case ds_X509DataType_X509SKI:
583
584	0	subelement.local = "X509SKI";
585	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
586	0	result = xsd_base64Binary_serialize(
587		&subelement,
588		&instance->value.X509SKI,
589		message_handle,
590		options);
591	0	if(result != GLOBUS_SUCCESS)
592		{
593	0	result = GlobusSoapMessageErrorSerializeFailed(
594		result, NULL, &ds_X509DataType_choice_qname);
595	0	goto exit;
596		}
597
598	0	break;
599
600		case ds_X509DataType_X509SubjectName:
601
602	0	subelement.local = "X509SubjectName";
603	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
604	0	result = xsd_string_serialize(
605		&subelement,
606		&instance->value.X509SubjectName,
607		message_handle,
608		options);
609	0	if(result != GLOBUS_SUCCESS)
610		{
611	0	result = GlobusSoapMessageErrorSerializeFailed(
612		result, NULL, &ds_X509DataType_choice_qname);
613	0	goto exit;
614		}
615
616	0	break;
617
618		case ds_X509DataType_X509Certificate:
619
620	0	subelement.local = "X509Certificate";
621	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
622	0	result = xsd_base64Binary_serialize(
623		&subelement,
624		&instance->value.X509Certificate,
625		message_handle,
626		options);
627	0	if(result != GLOBUS_SUCCESS)
628		{
629	0	result = GlobusSoapMessageErrorSerializeFailed(
630		result, NULL, &ds_X509DataType_choice_qname);
631	0	goto exit;
632		}
633
634	0	break;
635
636		case ds_X509DataType_X509CRL:
637
638	0	subelement.local = "X509CRL";
639	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
640	0	result = xsd_base64Binary_serialize(
641		&subelement,
642		&instance->value.X509CRL,
643		message_handle,
644		options);
645	0	if(result != GLOBUS_SUCCESS)
646		{
647	0	result = GlobusSoapMessageErrorSerializeFailed(
648		result, NULL, &ds_X509DataType_choice_qname);
649	0	goto exit;
650		}
651
652	0	break;
653
654		case ds_X509DataType_any:
655
656	0	subelement.local = "any";
657	0	subelement.Namespace = "http://www.w3.org/2001/XMLSchema";
658	0	result = xsd_any_serialize(
659		&subelement,
660		&instance->value.any,
661		message_handle,
662		options);
663	0	if(result != GLOBUS_SUCCESS)
664		{
665	0	result = GlobusSoapMessageErrorSerializeFailed(
666		result, NULL, &ds_X509DataType_choice_qname);
667		goto exit;
668		}
669
670	0	break;
671
672		default:
673	0	break;
674		}
675
676		exit:
677
678	0	GlobusSoapMessageDebugExit();
679	0	return result;
680		}
681
682
683
684		globus_result_t
685		ds_X509DataType_choice_serialize(
686		xsd_QName *                         element_qname,
687		ds_X509DataType_choice *             instance,
688		globus_soap_message_handle_t        message_handle,
689		globus_xsd_element_options_t        options)
690	0	{
691	0	globus_result_t                     result = GLOBUS_SUCCESS;
692	0	GlobusFuncName(ds_X509DataType_choice_serialize);
693	0	GlobusSoapMessageDebugEnter();
694
695	0	result = ds_X509DataType_choice_serialize_contents(
696		element_qname,
697		instance,
698		message_handle,
699		options);
700	0	if(result != GLOBUS_SUCCESS)
701		{
702	0	result = GlobusSoapMessageErrorSerializeFailed(
703		result, NULL, &ds_X509DataType_choice_qname);
704		goto exit;
705		}
706
707		exit:
708	0	GlobusSoapMessageDebugExit();
709	0	return result;
710		}
711
712
713
714
715
716		globus_result_t
717		ds_X509DataType_choice_deserialize_contents(
718		xsd_QName *                         element_qname, /* ignored */
719		ds_X509DataType_choice * instance,
720		globus_soap_message_handle_t        message_handle,
721		globus_xsd_element_options_t        options)
722	0	{
723	0	globus_result_t                     result = GLOBUS_SUCCESS;
724	0	GlobusFuncName(ds_X509DataType_choice_deserialize_contents);
725	0	GlobusSoapMessageDebugEnter();
726
727	0	result = ds_X509DataType_choice_deserialize(
728		NULL,
729		instance,
730		message_handle,
731		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
732	0	if(result != GLOBUS_SUCCESS)
733		{
734	0	result = GlobusSoapMessageErrorDeserializeFailed(
735		result, element_qname);
736		goto exit;
737		}
738
739		exit:
740
741	0	GlobusSoapMessageDebugExit();
742	0	return result;
743		}
744
745
746
747		globus_result_t
748		ds_X509DataType_choice_deserialize(
749		xsd_QName *                         element_qname,
750		ds_X509DataType_choice * instance,
751		globus_soap_message_handle_t        message_handle,
752		globus_xsd_element_options_t        options)
753	0	{
754	0	globus_result_t                     result = GLOBUS_SUCCESS;
755	0	xsd_QName                           subelement;
756	0	xsd_QName                           deselem_qname = { NULL, NULL } ;
757	0	GlobusFuncName(ds_X509DataType_choice_deserialize);
758	0	GlobusSoapMessageDebugEnter();
759
760	0	xsd_QName_init_contents(&deselem_qname);
761
762	0	do
763		{
764	0	result = globus_soap_message_deserialize_element_unknown(
765		message_handle, &deselem_qname);
766	0	if(result != GLOBUS_SUCCESS)
767		{
768	0	result = GlobusSoapMessageErrorDeserializeFailed(
769		result, &ds_X509DataType_choice_qname);
770	0	goto exit;
771		}
772
773	0	if(globus_soap_message_deserialize_element_is_nil(message_handle))
774		{
775	0	xsd_QName_destroy_contents(&deselem_qname);
776	0	result = globus_soap_message_deserialize_element_end(
777		message_handle,
778		element_qname);
779	0	if(result != GLOBUS_SUCCESS)
780		{
781	0	result = GlobusSoapMessageErrorDeserializeFailed(
782		result, &ds_X509DataType_choice_qname);
783	0	goto exit;
784		}
785		}
786		else
787		{
788	0	break;
789		}
790	0	} while(1);
791
792	0	globus_soap_message_deserialize_push_element(message_handle);
793
794	0	subelement.local = "X509IssuerSerial";
795	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
796	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
797		{
798	0	instance->type=ds_X509DataType_X509IssuerSerial;
799	0	result = ds_X509IssuerSerialType_deserialize(
800		&subelement,
801		&instance->value.X509IssuerSerial,
802		message_handle,
803		options);
804	0	if(result != GLOBUS_SUCCESS)
805		{
806	0	result = GlobusSoapMessageErrorDeserializeFailed(
807		result, &ds_X509DataType_choice_qname);
808	0	goto X509IssuerSerial_destroy;
809		}
810
811	0	goto exit;
812		}
813
814	0	subelement.local = "X509SKI";
815	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
816	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
817		{
818	0	instance->type=ds_X509DataType_X509SKI;
819	0	result = xsd_base64Binary_deserialize(
820		&subelement,
821		&instance->value.X509SKI,
822		message_handle,
823		options);
824	0	if(result != GLOBUS_SUCCESS)
825		{
826	0	result = GlobusSoapMessageErrorDeserializeFailed(
827		result, &ds_X509DataType_choice_qname);
828	0	goto X509SKI_destroy;
829		}
830
831	0	goto exit;
832		}
833
834	0	subelement.local = "X509SubjectName";
835	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
836	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
837		{
838	0	instance->type=ds_X509DataType_X509SubjectName;
839	0	result = xsd_string_deserialize(
840		&subelement,
841		&instance->value.X509SubjectName,
842		message_handle,
843		options);
844	0	if(result != GLOBUS_SUCCESS)
845		{
846	0	result = GlobusSoapMessageErrorDeserializeFailed(
847		result, &ds_X509DataType_choice_qname);
848	0	goto X509SubjectName_destroy;
849		}
850
851	0	goto exit;
852		}
853
854	0	subelement.local = "X509Certificate";
855	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
856	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
857		{
858	0	instance->type=ds_X509DataType_X509Certificate;
859	0	result = xsd_base64Binary_deserialize(
860		&subelement,
861		&instance->value.X509Certificate,
862		message_handle,
863		options);
864	0	if(result != GLOBUS_SUCCESS)
865		{
866	0	result = GlobusSoapMessageErrorDeserializeFailed(
867		result, &ds_X509DataType_choice_qname);
868	0	goto X509Certificate_destroy;
869		}
870
871	0	goto exit;
872		}
873
874	0	subelement.local = "X509CRL";
875	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
876	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
877		{
878	0	instance->type=ds_X509DataType_X509CRL;
879	0	result = xsd_base64Binary_deserialize(
880		&subelement,
881		&instance->value.X509CRL,
882		message_handle,
883		options);
884	0	if(result != GLOBUS_SUCCESS)
885		{
886	0	result = GlobusSoapMessageErrorDeserializeFailed(
887		result, &ds_X509DataType_choice_qname);
888	0	goto X509CRL_destroy;
889		}
890
891	0	goto exit;
892		}
893
894		/* try to parse as any element */
895	0	result = xsd_any_deserialize(
896		&subelement,
897		&instance->value.any,
898		message_handle,
899		options);
900	0	if(result != GLOBUS_SUCCESS)
901		{
902	0	result = GlobusSoapMessageErrorDeserializeFailed(
903		result, &ds_X509DataType_choice_qname);
904	0	goto any_destroy;
905		}
906		else
907		{
908	0	instance->type=ds_X509DataType_any;
909		goto exit;
910		}
911
912	0	instance->type = ds_X509DataType_undefined;
913
914	0	goto exit;
915
916		deserialize_failed:
917
918		any_destroy:
919
920		X509CRL_destroy:
921
922		X509Certificate_destroy:
923
924		X509SubjectName_destroy:
925
926		X509SKI_destroy:
927
928		X509IssuerSerial_destroy:
929
930		exit:
931
932	0	xsd_QName_destroy_contents(&deselem_qname);
933
934	0	if(result == GLOBUS_SUCCESS)
935		{
936	0	do
937		{
938	0	result = globus_soap_message_deserialize_element(
939		message_handle, NULL);
940	0	if(result != GLOBUS_SUCCESS &&
941		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
942		GlobusSoapMessageStatusFailedElementCheck(result) ||
943		GlobusSoapMessageStatusFailedWithTextCheck(result)))
944		{
945	0	result = GLOBUS_SUCCESS;
946	0	break;
947		}
948
949	0	if(globus_soap_message_deserialize_element_is_nil(
950		message_handle))
951		{
952	0	result = globus_soap_message_deserialize_element_end(
953		message_handle,
954		element_qname);
955	0	if(result != GLOBUS_SUCCESS)
956		{
957	0	result = GlobusSoapMessageErrorDeserializeFailed(
958		result, &ds_X509DataType_choice_qname);
959		break;
960		}
961		}
962		else
963		{
964	0	break;
965		}
966
967	0	} while(1);
968		}
969
970	0	xsd_QName_destroy_contents(&deselem_qname);
971
972	0	GlobusSoapMessageDebugExit();
973	0	return result;
974		}
975
976
977
978		globus_result_t
979		ds_X509DataType_choice_deserialize_pointer(
980		xsd_QName *                         element_qname,
981		ds_X509DataType_choice ** ip,
982		globus_soap_message_handle_t        message_handle,
983		globus_xsd_element_options_t        options)
984	0	{
985	0	ds_X509DataType_choice * instance = NULL;
986	0	globus_result_t                     result = GLOBUS_SUCCESS;
987	0	xsd_QName                           subelement;
988	0	GlobusFuncName(ds_X509DataType_choice_deserialize_pointer);
989	0	GlobusSoapMessageDebugEnter();
990
991	0	*ip = NULL;
992
993	0	result = ds_X509DataType_choice_init(&instance);
994	0	if(result != GLOBUS_SUCCESS)
995		{
996	0	result = GlobusSoapMessageErrorDeserializeFailed(
997		result, element_qname);
998	0	goto exit;
999		}
1000
1001	0	result = ds_X509DataType_choice_deserialize_contents(
1002		element_qname,
1003		instance,
1004		message_handle,
1005		options);
1006	0	if(result != GLOBUS_SUCCESS)
1007		{
1008	0	goto exit;
1009		}
1010
1011	0	*ip = instance;
1012
1013		exit:
1014
1015	0	GlobusSoapMessageDebugExit();
1016	0	return result;
1017		}
1018
1019
1020
1021		globus_result_t
1022		ds_X509DataType_choice_array_init_contents(
1023		ds_X509DataType_choice_array * array)
1024	0	{
1025	0	GlobusFuncName(ds_X509DataType_choice_array_init_contents);
1026	0	GlobusSoapMessageDebugEnter();
1027
1028	0	memset(array, 0, sizeof(ds_X509DataType_choice_array));
1029
1030	0	GlobusSoapMessageDebugExit();
1031	0	return GLOBUS_SUCCESS;
1032		}
1033
1034		globus_result_t
1035		ds_X509DataType_choice_array_init(
1036		ds_X509DataType_choice_array ** arr)
1037	0	{
1038	0	ds_X509DataType_choice_array * array;
1039	0	globus_result_t                     result;
1040	0	GlobusFuncName(ds_X509DataType_choice_array_init);
1041	0	GlobusSoapMessageDebugEnter();
1042
1043	0	array = (ds_X509DataType_choice_array *)
1044		globus_malloc(sizeof(ds_X509DataType_choice_array));
1045	0	if(!array)
1046		{
1047	0	result = GlobusSoapMessageErrorOutOfMemory;
1048	0	goto exit;
1049		}
1050
1051	0	result = ds_X509DataType_choice_array_init_contents(array);
1052	0	if(result != GLOBUS_SUCCESS)
1053		{
1054	0	globus_free(array);
1055	0	array = NULL;
1056		}
1057
1058	0	*arr = array;
1059
1060		exit:
1061	0	GlobusSoapMessageDebugExit();
1062	0	return result;
1063		}
1064
1065		void
1066		ds_X509DataType_choice_array_destroy_contents(
1067		ds_X509DataType_choice_array * array)
1068	0	{
1069	0	int                                 i = 0;
1070	0	GlobusFuncName(ds_X509DataType_choice_array_destroy_contents);
1071	0	GlobusSoapMessageDebugEnter();
1072
1073	0	for(; i < array->length; ++i)
1074		{
1075	0	ds_X509DataType_choice_destroy_contents(&array->elements[i]);
1076		}
1077
1078	0	if(array->elements)
1079		{
1080	0	globus_free(array->elements);
1081	0	array->elements = NULL;
1082		}
1083	0	array->length = 0;
1084
1085	0	GlobusSoapMessageDebugExit();
1086		}
1087
1088		void
1089		ds_X509DataType_choice_array_destroy(
1090		ds_X509DataType_choice_array * array)
1091	0	{
1092	0	GlobusFuncName(ds_X509DataType_choice_array_destroy);
1093	0	GlobusSoapMessageDebugEnter();
1094
1095	0	ds_X509DataType_choice_array_destroy_contents(array);
1096	0	globus_free(array);
1097
1098	0	GlobusSoapMessageDebugExit();
1099		}
1100
1101		globus_result_t
1102		ds_X509DataType_choice_array_copy(
1103		ds_X509DataType_choice_array ** dest_arr,
1104		const ds_X509DataType_choice_array * src_arr)
1105	0	{
1106	0	ds_X509DataType_choice_array * array;
1107	0	globus_result_t                     result;
1108	0	GlobusFuncName(ds_X509DataType_choice_array_copy);
1109	0	GlobusSoapMessageDebugEnter();
1110
1111	0	array = (ds_X509DataType_choice_array *) malloc(
1112		sizeof(ds_X509DataType_choice_array));
1113	0	if(!array)
1114		{
1115	0	result = GlobusSoapMessageErrorOutOfMemory;
1116	0	GlobusSoapMessageDebugExit();
1117	0	return result;
1118		}
1119
1120	0	result = ds_X509DataType_choice_array_copy_contents(array, src_arr);
1121	0	if(result != GLOBUS_SUCCESS)
1122		{
1123	0	globus_free(array);
1124	0	GlobusSoapMessageDebugExit();
1125	0	return result;
1126		}
1127
1128	0	*dest_arr = array;
1129
1130	0	GlobusSoapMessageDebugExit();
1131	0	return GLOBUS_SUCCESS;
1132		}
1133
1134		globus_result_t
1135		ds_X509DataType_choice_array_copy_contents(
1136		ds_X509DataType_choice_array * dest_arr,
1137		const ds_X509DataType_choice_array * src_arr)
1138	0	{
1139	0	int                                 i;
1140	0	globus_result_t                     result = GLOBUS_SUCCESS;
1141	0	GlobusFuncName(ds_X509DataType_choice_array_copy_contents);
1142	0	GlobusSoapMessageDebugEnter();
1143
1144	0	dest_arr->length = src_arr->length;
1145	0	if(dest_arr->length > 0)
1146		{
1147	0	dest_arr->elements = (ds_X509DataType_choice *) malloc(
1148		sizeof(ds_X509DataType_choice) * dest_arr->length);
1149	0	if(!dest_arr->elements)
1150		{
1151	0	result = GlobusSoapMessageErrorOutOfMemory;
1152	0	goto exit;
1153		}
1154		}
1155		else
1156		{
1157	0	dest_arr->elements = NULL;
1158		}
1159
1160	0	for(i = 0; i < dest_arr->length; i++)
1161		{
1162	0	result = ds_X509DataType_choice_copy_contents(
1163		&dest_arr->elements[i], &src_arr->elements[i]);
1164	0	if(result != GLOBUS_SUCCESS)
1165		{
1166	0	while(i--)
1167		{
1168	0	ds_X509DataType_choice_destroy_contents(&dest_arr->elements[i]);
1169		}
1170
1171	0	globus_free(dest_arr->elements);
1172	0	dest_arr->elements = NULL;
1173	0	dest_arr->length = 0;
1174	0	break;
1175		}
1176		}
1177
1178		exit:
1179	0	GlobusSoapMessageDebugExit();
1180	0	return result;
1181		}
1182
1183		ds_X509DataType_choice *
1184		ds_X509DataType_choice_array_push(
1185		ds_X509DataType_choice_array * array)
1186	0	{
1187	0	ds_X509DataType_choice *             tmp;
1188
1189	0	GlobusFuncName(ds_X509DataType_choice_array_push);
1190	0	GlobusSoapMessageDebugEnter();
1191
1192	0	tmp = realloc(array->elements,
1193		sizeof(ds_X509DataType_choice) *
1194		(array->length + 1));
1195	0	if (tmp == NULL)
1196		{
1197	0	goto error;
1198		}
1199	0	array->elements = tmp;
1200
1201	0	memset(&array->elements[array->length], 0, sizeof(ds_X509DataType_choice));
1202	0	array->length++;
1203
1204	0	GlobusSoapMessageDebugExit();
1205	0	return (&array->elements[array->length - 1]);
1206		error:
1207	0	GlobusSoapMessageDebugExit();
1208	0	return NULL;
1209		}
1210
1211		void *
1212		ds_X509DataType_choice_array_push_wrapper(
1213		void * array)
1214	0	{
1215	0	return (void *) ds_X509DataType_choice_array_push(
1216		(ds_X509DataType_choice_array *) array);
1217		}
1218
1219		globus_result_t
1220		ds_X509DataType_choice_array_serialize(
1221		xsd_QName *                         element_qname,
1222		ds_X509DataType_choice_array * array,
1223		globus_soap_message_handle_t        message,
1224		globus_xsd_element_options_t        options)
1225	0	{
1226	0	globus_result_t                     result = GLOBUS_SUCCESS;
1227	0	int                                 i = 0;
1228	0	GlobusFuncName(ds_X509DataType_choice_array_serialize);
1229	0	GlobusSoapMessageDebugEnter();
1230
1231	0	for(; i < array->length; ++i)
1232		{
1233	0	result = ds_X509DataType_choice_serialize(
1234		element_qname,
1235		&array->elements[i],
1236		message,
1237		options);
1238	0	if(result != GLOBUS_SUCCESS)
1239		{
1240	0	goto exit;
1241		}
1242		}
1243
1244		exit:
1245
1246	0	GlobusSoapMessageDebugExit();
1247	0	return result;
1248		}
1249
1250		globus_result_t
1251		ds_X509DataType_choice_array_deserialize(
1252		xsd_QName *                         element_qname,
1253		ds_X509DataType_choice_array * array,
1254		globus_soap_message_handle_t        message,
1255		globus_xsd_element_options_t        options)
1256	0	{
1257	0	globus_result_t                     result = GLOBUS_SUCCESS;
1258	0	int                                 i = 0;
1259	0	int                                 pre_length;
1260	0	GlobusFuncName(ds_X509DataType_choice_array_deserialize);
1261	0	GlobusSoapMessageDebugEnter();
1262
1263	0	pre_length = array->length;
1264
1265	0	for(i = 0; i < pre_length; ++i)
1266		{
1267	0	result = ds_X509DataType_choice_deserialize(
1268		element_qname,
1269		&array->elements[i],
1270		message,
1271		options);
1272	0	if(result != GLOBUS_SUCCESS)
1273		{
1274	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1275		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1276		GlobusSoapMessageStatusFailedWithTextCheck(result))
1277		{
1278	0	result = GLOBUS_SUCCESS;
1279	0	break;
1280		}
1281
1282	0	result = GlobusSoapMessageErrorDeserializeFailed(
1283		result, element_qname);
1284	0	goto exit;
1285		}
1286		}
1287
1288	0	while(result == GLOBUS_SUCCESS)
1289		{
1290	0	ds_X509DataType_choice next;
1291	0	memset(&next, 0, sizeof(ds_X509DataType_choice));
1292
1293	0	result = ds_X509DataType_choice_deserialize(
1294		element_qname,
1295		&next,
1296		message,
1297		options);
1298	0	if(result != GLOBUS_SUCCESS)
1299		{
1300	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1301		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1302		GlobusSoapMessageStatusFailedWithTextCheck(result))
1303		{
1304	0	result = GLOBUS_SUCCESS;
1305	0	break;
1306		}
1307
1308	0	result = GlobusSoapMessageErrorDeserializeFailed(
1309		result, element_qname);
1310	0	goto exit;
1311		}
1312
1313	0	array->elements = realloc(
1314		array->elements,
1315		(array->length + 1) * sizeof(ds_X509DataType_choice));
1316	0	if(!array->elements)
1317		{
1318	0	result = GlobusSoapMessageErrorOutOfMemory;
1319	0	goto exit;
1320		}
1321	0	array->elements[array->length] = next;
1322	0	array->length++;
1323	0	++i;
1324		}
1325
1326		exit:
1327
1328	0	if(result != GLOBUS_SUCCESS)
1329		{
1330	0	int                             di = 0;
1331	0	for(; di < i; ++di)
1332		{
1333	0	ds_X509DataType_choice_destroy_contents(
1334		&array->elements[di]);
1335	0	memset(&array->elements[di], 0, sizeof(ds_X509DataType_choice));
1336		}
1337		}
1338
1339	0	GlobusSoapMessageDebugExit();
1340	0	return result;