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		#include "globus_soap_message.h"
18		#include "globus_i_soap_message.h"
19		#include "globus_xml_buffer.h"
20		#include "xsd_QName.h"
21
22		globus_result_t
23		globus_xml_buffer_copy_contents(
24		globus_xml_buffer * dest,
25		const globus_xml_buffer * src)
26	38302	{
27	38302	globus_result_t result = GLOBUS_SUCCESS;
28		GlobusFuncName(globus_xml_buffer_copy_contents);
29	38302	GlobusSoapMessageDebugEnter();
30
31	38302	if(dest && src)
32		{
33	38302	dest->length = src->length;
34	38302	dest->buffer = globus_malloc(src->length + 1);
35	38302	if(!dest->buffer)
36		{
37	0	result = GlobusSoapMessageErrorOutOfMemory;
38	0	goto exit;
39		}
40	38302	memcpy(dest->buffer, src->buffer, src->length);
41	38302	dest->buffer[src->length] = 0;
42		}
43
44	38302	GlobusSoapMessageDebugExit();
45
46	38302	exit:
47	38302	return result;
48		}
49
50		void
51		globus_xml_buffer_destroy_contents(
52		globus_xml_buffer * instance)
53	71668	{
54		GlobusFuncName(globus_xml_buffer_destroy_contents);
55	71668	GlobusSoapMessageDebugEnter();
56
57	71668	if (instance->buffer != NULL)
58		{
59	71668	free(instance->buffer);
60	71668	instance->buffer = NULL;
61	71668	instance->length = 0;
62		}
63
64	71668	GlobusSoapMessageDebugExit();
65	71668	}
66
67
68		globus_result_t
69		globus_xml_buffer_deserialize_contents(
70		const xsd_QName * eqn,
71		globus_xml_buffer * buffer_handle,
72		globus_soap_message_handle_t message_handle,
73		globus_xsd_element_options_t options)
74	32875	{
75	32875	globus_result_t result = GLOBUS_SUCCESS;
76		GlobusFuncName(globus_xml_buffer_deserialize_contents);
77	32875	GlobusSoapMessageDebugEnter();
78
79	32875	if(xmlTextReaderNodeType(message_handle->reader) ==
80		XML_READER_TYPE_TEXT)
81		{
82	174	if(xmlTextReaderHasValue(message_handle->reader))
83		{
84	174	message_handle->doc_to_free =
85		xmlTextReaderCurrentDoc(message_handle->reader);
86	174	buffer_handle->buffer =
87		(char *) xmlEncodeEntitiesReentrant(
88		message_handle->doc_to_free,
89		xmlTextReaderConstValue(message_handle->reader));
90	174	buffer_handle->length = strlen(buffer_handle->buffer);
91
92		}
93
94	174	if(message_handle->next_ready)
95		{
96	174	message_handle->next_ready--;
97		}
98	174	goto exit;
99		}
100
101	32701	if(message_handle->next_ready)
102		{
103		/* The element was pushed back, so we apparently want to include
104		* it in the xml buffer
105		*/
106	30747	if(!xmlTextReaderIsEmptyElement(message_handle->reader))
107		{
108	30711	message_handle->next_ready--;
109		}
110
111	30747	buffer_handle->buffer = (char *) xmlTextReaderReadOuterXml(
112		message_handle->reader);
113	30747	if(!buffer_handle->buffer)
114		{
115	0	result = GlobusSoapMessageErrorDeserializeFailed(
116		message_handle->result,
117		&globus_xml_buffer_qname);
118	0	goto exit;
119		}
120	30747	xmlTextReaderSkip(message_handle->reader, 0);
121		}
122		else
123		{
124	1954	buffer_handle->buffer = (char *) xmlTextReaderReadInnerXml(
125		message_handle->reader);
126	1954	if(!buffer_handle->buffer)
127		{
128	0	result = GlobusSoapMessageErrorDeserializeFailed(
129		message_handle->result,
130		&globus_xml_buffer_qname);
131	0	goto exit;
132		}
133	1954	xmlTextReaderSkip(message_handle->reader, 0);
134		/* Push the element end back */
135	1954	globus_soap_message_deserialize_push_element(message_handle);
136		}
137
138	32701	buffer_handle->length = strlen(buffer_handle->buffer);
139
140	32875	exit:
141
142	32875	GlobusSoapMessageDebugExit();
143	32875	return result;
144		}
145
146		globus_result_t
147		globus_xml_buffer_serialize(
148		const xsd_QName * element_qname,
149		const globus_xml_buffer * instance,
150		globus_soap_message_handle_t message_handle,
151		globus_xsd_element_options_t options)
152	169	{
153	169	globus_result_t result = GLOBUS_SUCCESS;
154	169	xsd_QName * type_attr = NULL;
155	169	char * type_value = NULL;
156	169	char * prefix = NULL;
157	169	char * type_attr_prefix = NULL;
158
159		GlobusFuncName(globus_xml_buffer_serialize);
160	169	GlobusSoapMessageDebugEnter();
161
162	169	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
163		{
164		/* serialize globus_xml_buffer element */
165	0	result = globus_soap_message_element_ns_set(
166		message_handle,
167		element_qname,
168		element_qname->Namespace,
169		&options);
170	0	if(result != GLOBUS_SUCCESS)
171		{
172	0	result = GlobusSoapMessageErrorSerializeFailed(
173		result, NULL, element_qname);
174	0	goto exit;
175		}
176
177	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
178		!globus_soap_message_serialize_is_c14n_subset(message_handle))
179		{
180	0	result = globus_soap_message_attribute_ns_set(
181		message_handle,
182		element_qname,
183		"http://www.w3.org/2001/XMLSchema-instance",
184		&options);
185	0	if(result != GLOBUS_SUCCESS)
186		{
187	0	result = GlobusSoapMessageErrorSerializeFailed(
188		result, NULL, element_qname);
189	0	goto exit;
190		}
191
192	0	result = globus_soap_message_attribute_ns_set(
193		message_handle,
194		element_qname,
195		globus_xml_buffer_qname.Namespace,
196		&options);
197	0	if(result != GLOBUS_SUCCESS)
198		{
199	0	result = GlobusSoapMessageErrorSerializeFailed(
200		result, NULL, element_qname);
201	0	goto exit;
202		}
203		}
204
205	0	result = globus_soap_message_serialize_element(
206		message_handle,
207		element_qname,
208		options,
209		&globus_xml_buffer_qname);
210	0	if(result != GLOBUS_SUCCESS)
211		{
212	0	result = GlobusSoapMessageErrorSerializeFailed(
213		result, NULL, element_qname);
214	0	goto exit;
215		}
216
217	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
218		!globus_soap_message_serialize_is_c14n_subset(message_handle))
219		{
220	0	xsd_QName_init(&type_attr);
221
222	0	type_attr->local = globus_libc_strdup("type");
223	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
224
225	0	if(prefix)
226		{
227	0	type_value = globus_common_create_string(
228		"%s:%s", type_attr_prefix,
229		globus_xml_buffer_qname.local);
230		}
231		else
232		{
233	0	type_value = globus_libc_strdup(globus_xml_buffer_qname.local);
234		}
235		}
236
237		/* serialize namespaces */
238	0	result = globus_soap_message_element_ns_add(
239		message_handle,
240		element_qname,
241		element_qname->Namespace,
242		&options);
243	0	if(result != GLOBUS_SUCCESS)
244		{
245	0	result = GlobusSoapMessageErrorSerializeFailed(
246		result, NULL, element_qname);
247	0	goto exit;
248		}
249
250	0	if(options & GLOBUS_XSD_ELEMENT_TYPE_ATTR &&
251		!globus_soap_message_serialize_is_c14n_subset(message_handle))
252		{
253		xsd_QName type_attr;
254	0	type_attr.local = "type";
255	0	type_attr.Namespace = "http://www.w3.org/2001/XMLSchema-instance";
256
257	0	result = globus_soap_message_attribute_ns_add(
258		message_handle,
259		element_qname,
260		type_attr.Namespace,
261		&options);
262	0	if(result != GLOBUS_SUCCESS)
263		{
264	0	result = GlobusSoapMessageErrorSerializeFailed(
265		result, NULL, element_qname);
266	0	goto exit;
267		}
268
269	0	result = globus_soap_message_attribute_ns_add(
270		message_handle,
271		element_qname,
272		globus_xml_buffer_qname.Namespace,
273		&options);
274	0	if(result != GLOBUS_SUCCESS)
275		{
276	0	result = GlobusSoapMessageErrorSerializeFailed(
277		result, NULL, element_qname);
278	0	goto exit;
279		}
280
281	0	result = globus_soap_message_serialize_QName_attribute(
282		message_handle,
283		&type_attr,
284		&globus_xml_buffer_qname);
285	0	if(result != GLOBUS_SUCCESS)
286		{
287	0	result = GlobusSoapMessageErrorSerializeFailed(
288		result, NULL, element_qname);
289	0	goto exit;
290		}
291		}
292
293	0	result = globus_soap_message_serialize_element_begin_close(
294		message_handle, element_qname);
295	0	if(result != GLOBUS_SUCCESS)
296		{
297	0	result = GlobusSoapMessageErrorSerializeFailed(
298		result, NULL, element_qname);
299	0	goto exit;
300		}
301		}
302
303	169	result = globus_xml_buffer_serialize_contents(
304		element_qname,
305		instance,
306		message_handle,
307		options);
308
309	169	if(result != GLOBUS_SUCCESS)
310		{
311	0	result = GlobusSoapMessageErrorSerializeFailed(
312		result, NULL, element_qname);
313	0	goto exit;
314		}
315	169	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
316		{
317		/* add end element */
318	0	result = globus_soap_message_serialize_element_end(
319		message_handle,
320		element_qname,
321		options,
322		&globus_xml_buffer_qname);
323	0	if(result != GLOBUS_SUCCESS)
324		{
325	0	result = GlobusSoapMessageErrorSerializeFailed(
326		result, NULL, element_qname);
327	0	goto exit;
328		}
329
330	0	globus_soap_message_element_ns_remove(
331		message_handle,
332		element_qname->Namespace,
333		&options);
334
335
336
337	0	if(options & GLOBUS_XSD_ELEMENT_TYPE_ATTR &&
338		!globus_soap_message_serialize_is_c14n_subset(message_handle))
339		{
340	0	globus_soap_message_attribute_ns_remove(
341		message_handle,
342		"http://www.w3.org/2001/XMLSchema-instance",
343		&options);
344
345	0	globus_soap_message_attribute_ns_remove(
346		message_handle, globus_xml_buffer_qname.Namespace, &options);
347		}
348
349	0	globus_soap_message_element_ns_remove(
350		message_handle, element_qname->Namespace, &options);
351		}
352	169	exit:
353
354	169	GlobusSoapMessageDebugExit();
355	169	return result;
356		}
357		/* globus_xml_buffer_serialize() */
358
359		globus_result_t
360		globus_xml_buffer_serialize_contents(
361		const xsd_QName * element,
362		const globus_xml_buffer * buffer_handle,
363		globus_soap_message_handle_t message_handle,
364		globus_xsd_element_options_t options)
365	23243	{
366	23243	int res = 0;
367	23243	globus_result_t result = GLOBUS_SUCCESS;
368		GlobusFuncName(globus_xml_buffer_serialize_contents);
369	23243	GlobusSoapMessageDebugEnter();
370
371	23243	res = xmlTextWriterWriteRawLen(message_handle->writer,
372		(const xmlChar *)buffer_handle->buffer,
373		buffer_handle->length);
374	23243	if(res < 0)
375		{
376	0	result = GlobusSoapMessageErrorSerializeFailed(
377		message_handle->result,
378		"Failed to serialize xml buffer",
379		&globus_xml_buffer_qname);
380	0	goto exit;
381		}
382
383	23243	exit:
384
385	23243	GlobusSoapMessageDebugExit();
386	23243	return result;
387		}
388		/* globus_xml_buffer_serialize_contents() */
389
390		globus_result_t
391		globus_xml_buffer_deserialize(
392		const xsd_QName * element_qname,
393		globus_xml_buffer * instance,
394		globus_soap_message_handle_t message_handle,
395		globus_xsd_element_options_t options)
396	0	{
397	0	globus_result_t result = GLOBUS_SUCCESS;
398		GlobusFuncName(globus_xml_buffer_deserialize);
399	0	GlobusSoapMessageDebugEnter();
400
401	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
402		{
403	0	result = globus_soap_message_deserialize_element(
404		message_handle, element_qname);
405	0	if(result != GLOBUS_SUCCESS)
406		{
407	0	result = GlobusSoapMessageErrorDeserializeFailed(
408		result, element_qname);
409	0	goto exit;
410		}
411	0	result = globus_soap_message_deserialize_element_begin_close(
412		message_handle);
413	0	if(result != GLOBUS_SUCCESS)
414		{
415	0	result = GlobusSoapMessageErrorDeserializeFailed(
416		result, element_qname);
417	0	goto exit;
418		}
419		}
420	0	result = globus_xml_buffer_deserialize_contents(
421		element_qname,
422		instance,
423		message_handle,
424		options);
425	0	if (result != GLOBUS_SUCCESS)
426		{
427	0	goto exit;
428		}
429
430	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
431		{
432	0	result = globus_soap_message_deserialize_element_end(
433		message_handle,
434		element_qname);
435	0	if(result != GLOBUS_SUCCESS)
436		{
437	0	result = GlobusSoapMessageErrorDeserializeFailed(
438		result, element_qname);
439	0	goto exit;
440		}
441		}
442
443	0	exit:
444
445	0	GlobusSoapMessageDebugExit();
446	0	return result;
447		}