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