22 #include <libsyncml/syncml.h> 24 #include <libsyncml/syncml_internals.h> 25 #include <libsyncml/sml_elements_internals.h> 26 #include <libsyncml/sml_command_internals.h> 27 #include <libsyncml/sml_devinf_internals.h> 28 #include <libsyncml/sml_session_internals.h> 29 #include "libsyncml/sml_error_internals.h" 31 #include "sml_xml_parse.h" 32 #include "sml_xml_parse_internals.h" 34 #define BUFFER_SIZE 500 40 ret = (xmlTextReaderRead(parser->reader) == 1) ? TRUE : FALSE;
41 }
while (ret && (xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_DOCUMENT_TYPE || \
42 xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_WHITESPACE || \
43 xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_SIGNIFICANT_WHITESPACE));
48 static SmlBool _smlXmlParserStepData(
SmlXmlParser *parser)
52 ret = (xmlTextReaderRead(parser->reader) == 1) ? TRUE : FALSE;
53 }
while (ret && (xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_DOCUMENT_TYPE || \
54 xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_WHITESPACE));
63 if (xmlTextReaderNext(parser->reader) != 1)
66 node_type = xmlTextReaderNodeType(parser->reader);
67 while (xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_DOCUMENT_TYPE ||
68 xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_WHITESPACE ||
69 xmlTextReaderNodeType(parser->reader) == XML_READER_TYPE_SIGNIFICANT_WHITESPACE)
71 if (!_smlXmlParserStep (parser))
78 static SmlBool _smlXmlParserExpectNode(
SmlXmlParser *parser,
int type, SmlBool empty,
const char *name,
SmlError **error)
81 if (!_smlXmlParserStep(parser)) {
82 smlErrorSet(error, SML_ERROR_GENERIC,
"No node at all");
86 if (xmlTextReaderNodeType(parser->reader) != type) {
87 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong node type");
96 if (!xmlTextReaderConstName(parser->reader)) {
101 if (strcmp((
char *)xmlTextReaderConstName(parser->reader), name)) {
102 smlErrorSet(error, SML_ERROR_GENERIC,
"Wrong name");
108 if (!empty && !xmlTextReaderConstName(parser->reader)) {
114 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown node type");
121 static SmlBool _smlXmlParserGetID(
SmlXmlParser *parser,
unsigned int *
id,
const char *name,
SmlError **error)
128 smlErrorSet(error, SML_ERROR_GENERIC,
"Id already set");
132 if (!_smlXmlParserExpectNode(parser, XML_NODE_TEXT, FALSE, NULL, error))
135 *
id = atoi(g_strstrip((
char *)xmlTextReaderConstValue(parser->reader)));
137 if (!_smlXmlParserExpectNode(parser, XML_NODE_CLOSE, FALSE, name, error))
146 static SmlBool _smlXmlParserGetString(
SmlXmlParser *parser,
char **
string,
const char *name,
SmlError **error)
153 smlErrorSet(error, SML_ERROR_GENERIC,
"string already set");
158 if (xmlTextReaderIsEmptyElement(parser->reader)) {
159 *
string = g_strdup(
"");
163 if (!_smlXmlParserStep(parser)) {
164 smlErrorSet(error, SML_ERROR_GENERIC,
"No node at all");
168 if (xmlTextReaderNodeType(parser->reader) == XML_NODE_TEXT) {
169 *
string = g_strstrip(g_strdup((
char *)xmlTextReaderConstValue(parser->reader)));
171 if (!_smlXmlParserExpectNode(parser, XML_NODE_CLOSE, FALSE, name, error))
173 }
else if (xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
174 *
string = g_strdup(
"");
176 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong node type");
188 static SmlBool _smlXmlParserGetData(
SmlXmlParser *parser,
char **
string,
unsigned int *size,
const char *name,
SmlError **error)
196 smlErrorSet(error, SML_ERROR_GENERIC,
"string already set");
201 xmlBuffer *buffer = xmlBufferCreateSize(BUFFER_SIZE);
203 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to create new buffer");
207 xmlTextWriter *writer = xmlNewTextWriterMemory(buffer, 0);
209 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to create new writer");
210 goto error_free_buffer;
214 if (xmlTextReaderIsEmptyElement(parser->reader))
218 if (!_smlXmlParserStepData(parser)) {
219 smlErrorSet(error, SML_ERROR_GENERIC,
"There is a missing node during the data parsing of %s.", name);
220 goto error_free_writer;
223 switch (xmlTextReaderNodeType(parser->reader)) {
225 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), name))
228 if (!xmlTextReaderIsEmptyElement(parser->reader))
229 rc = xmlTextWriterEndElement(writer);
232 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to end node");
233 goto error_free_writer;
237 if (!xmlTextReaderIsEmptyElement(parser->reader))
238 rc = xmlTextWriterStartElementNS(writer, NULL, xmlTextReaderConstName(parser->reader), NULL);
240 rc = xmlTextWriterWriteElementNS(writer, NULL, xmlTextReaderConstName(parser->reader), NULL, (
const xmlChar*)
"");
243 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to start node");
244 goto error_free_writer;
249 rc = xmlTextWriterWriteRaw(writer, xmlTextReaderConstValue(parser->reader));
251 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to add string");
252 goto error_free_writer;
255 case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
256 rc = xmlTextWriterWriteRaw(writer, xmlTextReaderConstValue(parser->reader));
258 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to add string");
259 goto error_free_writer;
263 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown node type");
264 goto error_free_writer;
276 xmlFreeTextWriter(writer);
277 *
string = g_strndup((
const char *) xmlBufferContent(buffer), xmlBufferLength(buffer));
279 *size = xmlBufferLength(buffer);
281 xmlBufferFree(buffer);
286 xmlFreeTextWriter(writer);
288 xmlBufferFree(buffer);
295 static SmlBool _smlSyncHeaderParseDTD(SmlProtocolVersion *version,
SmlXmlParser *parser,
SmlError **error)
297 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, version, parser, error);
303 smlErrorSet(error, SML_ERROR_GENERIC,
"dtd already set");
309 if (!_smlXmlParserGetString(parser, &dtd, SML_ELEMENT_VERDTD, error))
312 if (!strcmp(dtd,
"1.0"))
313 *version = SML_VERSION_10;
314 else if (!strcmp(dtd,
"1.1"))
315 *version = SML_VERSION_11;
316 else if (!strcmp(dtd,
"1.2"))
317 *version = SML_VERSION_12;
320 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown VerDTD");
325 smlTrace(TRACE_EXIT,
"%s", __func__);
329 *version = SML_VERSION_UNKNOWN;
334 static SmlBool _smlSyncHeaderParseProto(SmlProtocolType *type,
SmlXmlParser *parser,
SmlError **error)
336 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, type, parser, error);
342 smlErrorSet(error, SML_ERROR_GENERIC,
"protocol already set");
348 if (!_smlXmlParserGetString(parser, &proto, SML_ELEMENT_VERPROTO, error))
351 if (!strcmp(proto, SML_VERSION_STRING_10) || !strcmp(proto, SML_VERSION_STRING_11) || !strcmp(proto, SML_VERSION_STRING_12))
352 *type = SML_PROTOCOL_SYNCML;
354 smlSafeCFree(&proto);
355 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown VerProto");
358 smlSafeCFree(&proto);
360 smlTrace(TRACE_EXIT,
"%s", __func__);
364 *type = SML_PROTOCOL_UNKNOWN;
372 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, location, parser, error);
378 smlErrorSet(error, SML_ERROR_GENERIC,
"Location already set");
389 if (!_smlXmlParserStep(parser)) {
390 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
391 goto error_free_location;
394 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET) && \
395 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
397 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE) && \
398 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
400 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE_PARENT) && \
401 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
403 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET_PARENT) && \
404 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
406 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
408 "The element %s is not a start node in locations (Target, Source, SourceParent or TargetParent).",
409 xmlTextReaderConstName(parser->reader));
410 goto error_free_location;
413 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_LOCURI)) {
414 if (!_smlXmlParserGetString(parser, &((*location)->locURI), SML_ELEMENT_LOCURI, error))
415 goto error_free_location;
416 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_LOCNAME)) {
417 if (!_smlXmlParserGetString(parser, &((*location)->locName), SML_ELEMENT_LOCNAME, error))
418 goto error_free_location;
420 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node. expected SyncHdr");
421 goto error_free_location;
425 if (!(*location)->locURI) {
426 smlErrorSet(error, SML_ERROR_GENERIC,
"No locURI set");
427 goto error_free_location;
430 smlTrace(TRACE_EXIT,
"%s", __func__);
434 smlLocationUnref(*location);
443 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, anchor, parser, error);
449 smlErrorSet(error, SML_ERROR_GENERIC,
"anchor already set");
459 if (!_smlXmlParserStep(parser)) {
460 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
461 goto error_free_anchor;
464 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ANCHOR) && \
465 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
467 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
469 "The element %s is not a start node in Anchor.",
470 xmlTextReaderConstName(parser->reader));
471 goto error_free_anchor;
474 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NEXT)) {
475 if (!_smlXmlParserGetString(parser, &((*anchor)->next), SML_ELEMENT_NEXT, error))
476 goto error_free_anchor;
477 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_LAST)) {
478 if (!_smlXmlParserGetString(parser, &((*anchor)->last), SML_ELEMENT_LAST, error))
479 goto error_free_anchor;
481 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
482 goto error_free_anchor;
486 if (!(*anchor)->next) {
487 smlErrorSet(error, SML_ERROR_GENERIC,
"No next set");
488 goto error_free_anchor;
491 smlTrace(TRACE_EXIT,
"%s", __func__);
495 smlAnchorFree(*anchor);
502 static SmlBool _smlChalMetaParse(
SmlXmlParser *parser,
char **format,
char **type,
char **nonce,
SmlError **error)
504 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p, %p, %p, %p)", __func__, parser, format, type, nonce, error);
509 if (!_smlXmlParserStep(parser)) {
510 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
514 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META) && \
515 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
517 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
519 "The element %s is not a start node in Chal/Meta.",
520 xmlTextReaderConstName(parser->reader));
524 if (type && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TYPE)) {
525 if (!_smlXmlParserGetString(parser, type, SML_ELEMENT_TYPE, error))
527 }
else if (format && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FORMAT)) {
528 if (!_smlXmlParserGetString(parser, format, SML_ELEMENT_FORMAT, error))
530 }
else if (format && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NEXTNONCE)) {
531 if (!_smlXmlParserGetString(parser, nonce, SML_ELEMENT_NEXTNONCE, error))
534 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node: %s", xmlTextReaderConstName(parser->reader));
539 smlTrace(TRACE_EXIT,
"%s", __func__);
554 static SmlBool _smlCommandMetaParse(
SmlXmlParser *parser,
char **format,
char **type,
SmlAnchor **anchor,
unsigned int *size,
int *maxobjsize,
SmlError **error)
556 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p, %p, %p, %p)", __func__, parser, format, type, anchor, size, maxobjsize, error);
563 if (xmlTextReaderIsEmptyElement(parser->reader))
566 smlTrace(TRACE_EXIT,
"%s - empty meta element", __func__);
571 if (!_smlXmlParserStep(parser)) {
572 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
576 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MEM)) {
578 smlTrace(TRACE_INTERNAL,
"%s: Skipping mem node");
579 if (!_smlXmlSkipNode(parser)) {
580 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to skip mem node");
585 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META) && \
586 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
588 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
590 "The element %s is not a start node in Command/Meta.",
591 xmlTextReaderConstName(parser->reader));
595 if (type && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TYPE)) {
596 if (!_smlXmlParserGetString(parser, type, SML_ELEMENT_TYPE, error))
598 }
else if (anchor && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ANCHOR)) {
599 if (!_smlAnchorParse(anchor, parser, error))
601 }
else if (format && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FORMAT)) {
602 if (!_smlXmlParserGetString(parser, format, SML_ELEMENT_FORMAT, error))
604 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MARK)) {
607 if (!_smlXmlParserGetString(parser, &mark, SML_ELEMENT_MARK, error))
610 }
else if (size && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SIZE)) {
611 if (!_smlXmlParserGetID(parser, size, SML_ELEMENT_SIZE, error))
613 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXOBJSIZE)) {
615 unsigned int loc_maxobjsize = 0;
616 if (!_smlXmlParserGetID(parser, &loc_maxobjsize, SML_ELEMENT_MAXOBJSIZE, error))
619 *maxobjsize = loc_maxobjsize;
620 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_VERSION)) {
622 char *version = NULL;
623 if (!_smlXmlParserGetString(parser, &version, SML_ELEMENT_VERSION, error))
625 smlSafeCFree(&version);
627 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node for meta information: %s", xmlTextReaderConstName(parser->reader));
632 smlTrace(TRACE_EXIT,
"%s", __func__);
648 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %i, %p)", __func__, parser, cmd, type, error);
652 if (parser->gotMoreData) {
653 smlErrorSet(error, SML_ERROR_GENERIC,
"Last item already had more data set");
657 SmlItem *item = smlItemNew(0, error);
662 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM) &&
663 xmlTextReaderIsEmptyElement(parser->reader)) {
664 smlTrace(TRACE_EXIT,
"%s - empty item", __func__);
668 if (!_smlXmlParserStep(parser)) {
669 smlErrorSet(error, SML_ERROR_GENERIC,
"The first element inside of an Item structure cannot be parsed.");
670 goto error_free_item;
674 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM) && \
675 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
677 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
679 "The element %s is not a start node in Item.",
680 xmlTextReaderConstName(parser->reader));
681 goto error_free_item;
684 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) {
686 if (!_smlLocationParse(&source, parser, error))
687 goto error_free_item;
689 smlItemSetSource(item, source);
690 smlLocationUnref(source);
691 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) {
693 if (!_smlLocationParse(&target, parser, error))
694 goto error_free_item;
696 smlItemSetTarget(item, target);
697 smlLocationUnref(target);
698 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE_PARENT)) {
700 if (!_smlLocationParse(&source, parser, error))
701 goto error_free_item;
703 smlItemSetSourceParent(item, source);
704 smlLocationUnref(source);
705 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET_PARENT)) {
707 if (!_smlLocationParse(&target, parser, error))
708 goto error_free_item;
710 smlItemSetTargetParent(item, target);
711 smlLocationUnref(target);
712 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
714 case SML_COMMAND_TYPE_ALERT:
721 if (!_smlCommandMetaParse(parser, NULL, NULL, NULL, NULL, NULL, error))
722 goto error_free_item;
725 if (!_smlCommandMetaParse(parser, NULL, &(cmd->private.alert.contentType), &cmd->private.alert.anchor, NULL, &(cmd->private.alert.maxObjSize), error))
726 goto error_free_item;
729 case SML_COMMAND_TYPE_ADD:
730 case SML_COMMAND_TYPE_DELETE:
731 case SML_COMMAND_TYPE_REPLACE:
732 if (!_smlCommandMetaParse(parser, NULL, &(item->contenttype), NULL, &cmd->size, NULL, error))
733 goto error_free_item;
735 case SML_COMMAND_TYPE_RESULTS:
736 case SML_COMMAND_TYPE_PUT:;
739 if (!_smlCommandMetaParse(parser, NULL, &(item->contenttype), NULL, NULL, NULL, error))
740 goto error_free_item;
742 if (!item->contenttype)
743 goto error_free_item;
746 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown command type");
747 goto error_free_item;
749 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA)) {
755 if (!xmlTextReaderIsEmptyElement(parser->reader)) {
757 case SML_COMMAND_TYPE_ALERT:
758 if (!_smlXmlParserStep(parser)) {
759 smlErrorSet(error, SML_ERROR_GENERIC,
"The next element after the starting Data element in an Item is missing.");
760 goto error_free_item;
763 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA) &&
764 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
770 smlTrace(TRACE_INTERNAL,
"%s: detected empty data element", __func__);
775 if (xmlTextReaderNodeType(parser->reader) == XML_NODE_TEXT) {
781 goto error_free_item;
782 anchor->next = g_strdup((
char *)xmlTextReaderConstValue(parser->reader));
785 if (!_smlAnchorParse(&anchor, parser, error))
786 goto error_free_item;
788 item->anchor = anchor;
790 if (!_smlXmlParserStep(parser)) {
791 smlErrorSet(error, SML_ERROR_GENERIC,
"The closing Data element in an Item is missing.");
792 goto error_free_item;
797 unsigned int size = 0;
798 if (!_smlXmlParserGetData(parser, &data, &size, SML_ELEMENT_DATA, error))
799 goto error_free_item;
801 if (!smlItemAddData(item, data, size, error)) {
803 goto error_free_item;
809 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MOREDATA)) {
810 if (parser->
version == SML_VERSION_10) {
811 smlErrorSet(error, SML_ERROR_GENERIC,
"SyncML 1.0 does not allow MoreData");
812 goto error_free_item;
815 item->moreData = TRUE;
816 parser->gotMoreData = TRUE;
817 if (!_smlXmlParserStep(parser)) {
818 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes2");
819 goto error_free_item;
822 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MOREDATA) && \
823 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
824 if (!_smlXmlParserStep(parser)) {
825 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes3");
826 goto error_free_item;
831 smlErrorSet(error, SML_ERROR_GENERIC,
"The element Item does not support the child element %s.", xmlTextReaderConstName(parser->reader));
832 goto error_free_item;
835 if (!_smlXmlParserStep(parser)) {
836 smlErrorSet(error, SML_ERROR_GENERIC,
"The next element in an Item structure is missing.");
837 goto error_free_item;
841 smlTrace(TRACE_EXIT,
"%s", __func__);
853 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, parser, error);
862 if (!_smlXmlParserStep(parser)) {
863 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
867 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CRED) && \
868 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
870 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
872 "The element %s is not a start node in Cred.",
873 xmlTextReaderConstName(parser->reader));
877 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
878 if (!_smlCommandMetaParse(parser, &format, &type, NULL, NULL, NULL, error))
880 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA)) {
881 if (!_smlXmlParserGetString(parser, &data, SML_ELEMENT_DATA, error))
884 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node %s", xmlTextReaderConstName(parser->reader));
889 cred = smlCredNewFromString(type, format, data, error);
896 smlSafeCFree(&format);
903 smlTrace(TRACE_EXIT,
"%s: %p", __func__, cred);
915 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, parser, error);
923 if (!_smlXmlParserStep(parser)) {
924 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
928 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CHAL) && \
929 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
931 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
933 "The element %s is not a start node in Chal.",
934 xmlTextReaderConstName(parser->reader));
938 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
939 if (!_smlChalMetaParse(parser, &format, &type, &nonce, error))
942 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node %s", xmlTextReaderConstName(parser->reader));
947 if (format && strcmp(format, SML_BASE64)) {
948 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown format");
953 if (!type || !strcmp(type, SML_AUTH_BASIC)) {
954 auth = SML_AUTH_TYPE_BASIC;
955 }
else if (!strcmp(type, SML_AUTH_MD5)) {
956 auth = SML_AUTH_TYPE_MD5;
958 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown type");
963 smlSafeCFree(&format);
968 if (nonce || auth == SML_AUTH_TYPE_MD5)
969 chal = smlChalNewFromBase64(auth, nonce, error);
971 chal = smlChalNew(auth, error);
976 smlSafeCFree(&nonce);
978 smlTrace(TRACE_EXIT,
"%s: %p", __func__, chal);
983 smlSafeCFree(&format);
987 smlSafeCFree(&nonce);
994 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %s, %p)", __func__, parser, type, VA_STRING(name), error);
998 char *contenttype = NULL;
1000 *cmd = smlCommandNew(type, error);
1006 if (!_smlXmlParserStep(parser)) {
1007 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1008 goto error_free_cmd;
1011 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), name) && \
1012 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1014 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1016 "The element %s is not a start node in %s.",
1017 xmlTextReaderConstName(parser->reader), name);
1018 goto error_free_cmd;
1021 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
1022 if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error))
1023 goto error_free_cmd;
1024 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) {
1025 SmlItem *item = _smlItemParse(parser, *cmd, type, error);
1027 goto error_free_cmd;
1028 (*cmd)->private.change.items = g_list_append((*cmd)->private.change.items, item);
1029 if (!(*cmd)->private.change.items)
1032 smlErrorSet(error, SML_ERROR_GENERIC,
"g_list_append for item list of change command failed.");
1033 goto error_free_cmd;
1035 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
1036 if (!_smlCommandMetaParse(parser, NULL, &contenttype, NULL, &(*cmd)->size, NULL, error))
1037 goto error_free_cmd;
1039 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
1040 goto error_free_cmd;
1044 if (!(*cmd)->cmdID) {
1045 smlErrorSet(error, SML_ERROR_GENERIC,
"No cmdid set");
1046 goto error_free_cmd;
1049 if (!(*cmd)->private.change.items ||
1050 !g_list_length((*cmd)->private.change.items)) {
1051 smlErrorSet(error, SML_ERROR_GENERIC,
"No items set");
1052 goto error_free_cmd;
1057 for (i=0; i < g_list_length((*cmd)->private.change.items); i++)
1059 SmlItem *item = g_list_nth_data((*cmd)->private.change.items, i);
1060 if (item->contenttype == NULL && contenttype) {
1061 item->contenttype = g_strdup(contenttype);
1065 smlSafeCFree(&contenttype);
1067 for (i=0; i < g_list_length((*cmd)->private.change.items); i++)
1069 SmlItem *item = g_list_nth_data((*cmd)->private.change.items, i);
1070 if ((*cmd)->size && !item->size)
1071 item->size = (*cmd)->size;
1075 case SML_COMMAND_TYPE_ADD:
1076 (*cmd)->private.change.type = SML_CHANGE_ADD;
1078 case SML_COMMAND_TYPE_REPLACE:
1079 (*cmd)->private.change.type = SML_CHANGE_REPLACE;
1081 case SML_COMMAND_TYPE_DELETE:
1082 (*cmd)->private.change.type = SML_CHANGE_DELETE;
1085 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown change type set");
1086 goto error_free_cmd;
1089 if (!(*cmd)->source)
1091 SmlItem *item = g_list_nth_data((*cmd)->private.change.items, 0);
1093 (*cmd)->source = smlLocationClone(item->source, error);
1094 if (!(*cmd)->source)
1095 goto error_free_cmd;
1099 if (!(*cmd)->target)
1101 SmlItem *item = g_list_nth_data((*cmd)->private.change.items, 0);
1103 (*cmd)->target = smlLocationClone(item->target, error);
1104 if (!(*cmd)->target)
1105 goto error_free_cmd;
1110 if (!_smlXmlParserStep(parser)) {
1111 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1112 goto error_free_cmd;
1115 smlTrace(TRACE_EXIT,
"%s: %p", __func__, *cmd);
1119 smlCommandUnref(*cmd);
1122 smlSafeCFree(&contenttype);
1128 static SmlBool _smlMessageParseSynchdrMeta(
SmlXmlParser *parser,
unsigned int *maxmsgsize,
unsigned int *maxobjsize,
char **emi,
SmlError **error)
1130 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, parser, maxmsgsize, maxobjsize, error);
1133 smlAssert(maxmsgsize);
1134 smlAssert(maxobjsize);
1139 if (!_smlXmlParserStep(parser)) {
1140 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1144 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META) && \
1145 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1147 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1149 "The element %s is not a start node in SyncHdr/Meta.",
1150 xmlTextReaderConstName(parser->reader));
1154 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXMSGSIZE)) {
1155 if (!_smlXmlParserGetID(parser, maxmsgsize, SML_ELEMENT_MAXMSGSIZE, error))
1157 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXOBJSIZE)) {
1158 if (!_smlXmlParserGetID(parser, maxobjsize, SML_ELEMENT_MAXOBJSIZE, error))
1160 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_EMI)) {
1161 if (!_smlXmlParserGetString(parser, emi, SML_ELEMENT_EMI, error))
1164 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node. expected MaxMsgSize, MaxObjSize or EMI. Instead of that: %s", xmlTextReaderConstName(parser->reader));
1169 if (!(*maxmsgsize) && !(*maxobjsize)) {
1170 smlErrorSet(error, SML_ERROR_GENERIC,
"No maxmsgsize set");
1174 smlTrace(TRACE_EXIT,
"%s", __func__);
1186 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, cmd, error);
1191 *cmd = smlCommandNew(SML_COMMAND_TYPE_ALERT, error);
1195 (*cmd)->private.alert.maxObjSize = -1;
1198 if (!_smlXmlParserStep(parser)) {
1199 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1200 goto error_free_cmd;
1203 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ALERT) && \
1204 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1206 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1208 "The element %s is not a start node in Alert.",
1209 xmlTextReaderConstName(parser->reader));
1210 goto error_free_cmd;
1213 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
1214 if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error))
1215 goto error_free_cmd;
1216 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) {
1217 SmlItem *item = _smlItemParse(parser, (*cmd), SML_COMMAND_TYPE_ALERT, error);
1219 goto error_free_cmd;
1221 (*cmd)->target = item->target;
1222 item->target = NULL;
1223 (*cmd)->source = item->source;
1224 item->source = NULL;
1227 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA)) {
1228 unsigned int id = 0;
1229 if (!_smlXmlParserGetID(parser, &
id, SML_ELEMENT_DATA, error))
1230 goto error_free_cmd;
1231 (*cmd)->private.alert.type = smlAlertTypeConvert(
id, error);
1232 if ((*cmd)->private.alert.type == SML_ALERT_UNKNOWN &&
1234 goto error_free_cmd;
1236 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node %s", xmlTextReaderConstName(parser->reader));
1237 goto error_free_cmd;
1241 if (!(*cmd)->private.alert.type) {
1242 smlErrorSet(error, SML_ERROR_GENERIC,
"No alert type set");
1243 goto error_free_cmd;
1247 if (!_smlXmlParserStep(parser)) {
1248 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1249 goto error_free_cmd;
1252 smlTrace(TRACE_EXIT,
"%s", __func__);
1256 smlCommandUnref(*cmd);
1265 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, cmd, error);
1270 *cmd = smlCommandNew(SML_COMMAND_TYPE_SYNC, error);
1273 (*cmd)->private.sync.maxObjSize = -1;
1276 if (!_smlXmlParserStep(parser)) {
1277 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1278 goto error_free_cmd;
1281 if (xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE && !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNC))
1283 else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1285 "The element %s is not a start node in Sync.",
1286 xmlTextReaderConstName(parser->reader));
1287 goto error_free_cmd;
1290 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ADD) || \
1291 !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_REPLACE) || \
1292 !strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DELETE))
1295 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
1296 if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error))
1297 goto error_free_cmd;
1298 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) {
1299 SmlItem *item = _smlItemParse(parser, (*cmd), SML_COMMAND_TYPE_SYNC, error);
1301 goto error_free_cmd;
1302 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
1303 if (!_smlCommandMetaParse(parser, NULL, NULL, NULL, NULL, &((*cmd)->private.sync.maxObjSize), error))
1305 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) {
1306 if (!_smlLocationParse(&(*cmd)->target, parser, error))
1307 goto error_free_cmd;
1308 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) {
1309 if (!_smlLocationParse(&(*cmd)->source, parser, error))
1310 goto error_free_cmd;
1311 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NUMBEROFCHANGES)) {
1312 (*cmd)->private.sync.hasNumChanged = TRUE;
1313 if (!_smlXmlParserGetID(parser, &((*cmd)->private.sync.numChanged), SML_ELEMENT_NUMBEROFCHANGES, error))
1314 goto error_free_cmd;
1316 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node: %s", xmlTextReaderConstName(parser->reader));
1317 goto error_free_cmd;
1321 smlTrace(TRACE_EXIT,
"%s", __func__);
1325 smlCommandUnref(*cmd);
1334 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, parser, error);
1344 if (!_smlXmlParserStep(parser)) {
1345 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1346 goto error_free_item;
1349 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAPITEM) && \
1350 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1352 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1354 "The element %s is not a start node in MapItem.",
1355 xmlTextReaderConstName(parser->reader));
1356 goto error_free_item;
1359 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) {
1360 if (!_smlLocationParse(&item->source, parser, error))
1361 goto error_free_item;
1362 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) {
1363 if (!_smlLocationParse(&item->target, parser, error))
1364 goto error_free_item;
1366 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node %s", xmlTextReaderConstName(parser->reader));
1367 goto error_free_item;
1371 smlTrace(TRACE_EXIT,
"%s", __func__);
1375 smlMapItemUnref(item);
1383 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, cmd, error);
1388 *cmd = smlCommandNew(SML_COMMAND_TYPE_MAP, error);
1394 if (!_smlXmlParserStep(parser)) {
1395 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1396 goto error_free_cmd;
1399 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAP) && \
1400 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1402 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1404 "The element %s is not a start node in Map.",
1405 xmlTextReaderConstName(parser->reader));
1406 goto error_free_cmd;
1409 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
1410 if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error))
1411 goto error_free_cmd;
1412 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAPITEM)) {
1413 SmlMapItem *item = _smlMapItemParse(parser, error);
1415 goto error_free_cmd;
1416 (*cmd)->private.map.items = g_list_append((*cmd)->private.map.items, item);
1417 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) {
1418 if (!_smlLocationParse(&(*cmd)->target, parser, error))
1419 goto error_free_cmd;
1420 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) {
1421 if (!_smlLocationParse(&(*cmd)->source, parser, error))
1422 goto error_free_cmd;
1424 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
1425 goto error_free_cmd;
1430 if (!_smlXmlParserStep(parser)) {
1431 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1432 goto error_free_cmd;
1435 smlTrace(TRACE_EXIT,
"%s", __func__);
1439 smlCommandUnref(*cmd);
1448 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %i, %p)", __func__, parser, cmd, type, error);
1452 char *contenttype = NULL;
1454 *cmd = smlCommandNew(type, error);
1460 if (!_smlXmlParserStep(parser)) {
1461 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1462 goto error_free_cmd;
1465 if ((*cmd)->type == SML_COMMAND_TYPE_PUT &&!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_PUT) && \
1466 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1468 }
else if ((*cmd)->type == SML_COMMAND_TYPE_GET &&!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_GET) && \
1469 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1471 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1473 "The element %s is not a start node in Put or Get.",
1474 xmlTextReaderConstName(parser->reader));
1475 goto error_free_cmd;
1478 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
1479 if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error))
1480 goto error_free_cmd;
1481 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) {
1482 (*cmd)->private.access.item = _smlItemParse(parser, (*cmd), (*cmd)->type, error);
1483 if (!(*cmd)->private.access.item)
1484 goto error_free_cmd;
1486 (*cmd)->target = (*cmd)->private.access.item->target;
1487 (*cmd)->private.access.item->target = NULL;
1488 (*cmd)->source = (*cmd)->private.access.item->source;
1489 (*cmd)->private.access.item->source = NULL;
1490 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
1491 char *format = NULL;
1492 if (!_smlCommandMetaParse(parser, &format, &contenttype, NULL, NULL, NULL, error))
1493 goto error_free_cmd;
1494 if (format) smlSafeCFree(&format);
1496 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
1497 goto error_free_cmd;
1501 if (!(*cmd)->private.access.item) {
1502 smlErrorSet(error, SML_ERROR_GENERIC,
"Put/Get is missing item");
1503 goto error_free_cmd;
1508 if (!(*cmd)->private.access.item->contenttype && contenttype)
1509 (*cmd)->private.access.item->contenttype = g_strdup(contenttype);
1512 smlSafeCFree(&contenttype);
1515 if (!_smlXmlParserStep(parser)) {
1516 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1517 goto error_free_cmd;
1520 smlTrace(TRACE_EXIT,
"%s", __func__);
1524 smlCommandUnref(*cmd);
1528 smlSafeCFree(&contenttype);
1535 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, cmd, error);
1539 char *contenttype = NULL;
1540 char *locURI = NULL;
1542 *cmd = smlCommandNew(SML_COMMAND_TYPE_RESULTS, error);
1548 if (!(*cmd)->private.results.status)
1550 (*cmd)->private.results.status->
refCount = 1;
1551 (*cmd)->private.results.status->result = (*cmd);
1552 (*cmd)->private.results.status->type = SML_COMMAND_TYPE_RESULTS;
1555 if (!_smlXmlParserStep(parser)) {
1556 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1557 goto error_free_cmd;
1560 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_RESULTS) && \
1561 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1563 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
1565 "The element %s is not a start node in Results.",
1566 xmlTextReaderConstName(parser->reader));
1567 goto error_free_cmd;
1571 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
1572 if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error))
1573 goto error_free_cmd;
1574 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MSGREF)) {
1575 if (!_smlXmlParserGetID(parser, &((*cmd)->private.results.status->msgRef), SML_ELEMENT_MSGREF, error))
1576 goto error_free_cmd;
1577 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDREF)) {
1578 if (!_smlXmlParserGetID(parser, &((*cmd)->private.results.status->cmdRef), SML_ELEMENT_CMDREF, error))
1579 goto error_free_cmd;
1580 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCEREF)) {
1581 if (!_smlXmlParserGetString(parser, &locURI, SML_ELEMENT_SOURCEREF, error))
1582 goto error_free_cmd;
1584 (*cmd)->private.results.status->sourceRef = smlLocationNew(locURI, NULL, error);
1585 smlSafeCFree(&locURI);
1586 if (!(*cmd)->private.results.status->sourceRef)
1587 goto error_free_cmd;
1588 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGETREF)) {
1589 if (!_smlXmlParserGetString(parser, &locURI, SML_ELEMENT_TARGETREF, error))
1590 goto error_free_cmd;
1592 (*cmd)->private.results.status->targetRef = smlLocationNew(locURI, NULL, error);
1593 smlSafeCFree(&locURI);
1594 if (!(*cmd)->private.results.status->targetRef)
1595 goto error_free_cmd;
1596 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) {
1597 (*cmd)->private.results.status->item = _smlItemParse(parser, (*cmd), (*cmd)->type, error);
1598 if (!(*cmd)->private.results.status->item)
1599 goto error_free_cmd;
1601 (*cmd)->target = (*cmd)->private.results.status->item->target;
1602 (*cmd)->private.results.status->item->target = NULL;
1603 (*cmd)->source = (*cmd)->private.results.status->item->source;
1604 (*cmd)->private.results.status->item->source = NULL;
1605 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
1607 char *format = NULL;
1608 if (!_smlCommandMetaParse(parser, &format, &contenttype, NULL, NULL, NULL, error))
1609 goto error_free_cmd;
1610 if (format) smlSafeCFree(&format);
1612 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
1613 goto error_free_cmd;
1617 if (!(*cmd)->private.results.status->item) {
1618 smlErrorSet(error, SML_ERROR_GENERIC,
"Result is missing item");
1619 goto error_free_cmd;
1624 if (!(*cmd)->private.results.status->item->contenttype) {
1626 smlErrorSet(error, SML_ERROR_GENERIC,
"Result is missing content type");
1627 goto error_free_cmd;
1630 (*cmd)->private.results.status->item->contenttype = g_strdup(contenttype);
1634 smlSafeCFree(&contenttype);
1637 if (!_smlXmlParserStep(parser)) {
1638 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1639 goto error_free_cmd;
1642 smlTrace(TRACE_EXIT,
"%s", __func__);
1646 smlCommandUnref(*cmd);
1650 smlSafeCFree(&contenttype);
1655 static SmlBool _smlXmlParserFixBrokenItemData(
1656 const char *data,
unsigned int size,
1657 char **fixed_data,
unsigned int *fixed_size,
1660 smlTrace(TRACE_ENTRY,
"%s(%p, %d, %p, %p, %p)", __func__, data, size, fixed_data, fixed_size, error);
1664 smlAssert(fixed_data);
1665 smlAssert(fixed_size);
1685 memcpy(*fixed_data, data, size);
1686 const char *position = *fixed_data;
1688 while (position + 1 < *fixed_data + *fixed_size)
1691 const char *byte = position + 1;
1697 smlTrace(TRACE_INTERNAL,
"%s: Found NULL byte in XML document at %p.", __func__, position);
1702 const char *last_utf16 = position;
1703 while (last_utf16 + 1 < *fixed_data + *fixed_size &&
1704 *((
char *)(last_utf16 + 1)) == 0)
1713 smlTrace(TRACE_INTERNAL,
"%s: Converting %d bytes ...", __func__, last_utf16 - position + 1);
1714 GError *gerror = NULL;
1715 size_t read_bytes = 0;
1716 size_t written_bytes = 0;
1717 gchar *conv_string = g_convert(
1718 position, (last_utf16 - position + 1),
1720 &read_bytes, &written_bytes,
1725 error, SML_ERROR_GENERIC,
1726 "Character conversion from UTF-16 to UTF-8 failed. %s",
1728 g_error_free(gerror);
1732 smlTrace(TRACE_INTERNAL,
"%s: read %d --> written %d --> %d ::= %s", __func__, read_bytes, written_bytes, strlen(conv_string), conv_string);
1735 char *new_data =
smlTryMalloc0(*fixed_size - read_bytes + written_bytes + 1, error);
1741 memcpy(new_data, *fixed_data, (
size_t) position - (
size_t) *fixed_data);
1742 memcpy(new_data + (
size_t) position - (
size_t) *fixed_data, conv_string, written_bytes);
1743 memcpy(new_data + (
size_t) position - (
size_t) *fixed_data + written_bytes,
1744 position + read_bytes, *fixed_size - ( (
size_t) position - (
size_t) *fixed_data ) - read_bytes );
1747 *fixed_size = *fixed_size - read_bytes + written_bytes;
1748 position = new_data + (position - *fixed_data) + written_bytes;
1749 smlSafeCFree(fixed_data);
1750 *fixed_data = new_data;
1752 smlSafeCFree(&conv_string);
1754 smlTrace(TRACE_INTERNAL,
"%s: Converted UTF-16 string to UTF-8", __func__);
1756 smlTrace(TRACE_INTERNAL,
"%s: Correctly encoded: %s", __func__, *fixed_data);
1763 position = *fixed_data;
1765 while (position + 1 < *fixed_data + *fixed_size)
1768 const char *limit_item_start = strstr(position,
"<Item>");
1769 if (! limit_item_start)
1771 smlTrace(TRACE_EXIT,
"%s - no (more) Item found", __func__);
1774 smlTrace(TRACE_INTERNAL,
"%s - Item found", __func__);
1776 const char *limit_item_end = strstr(limit_item_start,
"</Item>");
1777 if (! limit_item_end)
1779 g_warning(
"%s - no end of Item found.", __func__);
1780 smlTrace(TRACE_EXIT,
"%s - no end of Item found", __func__);
1783 smlTrace(TRACE_INTERNAL,
"%s - end of Item found", __func__);
1785 if (limit_item_start >= limit_item_end)
1788 position = limit_item_end + strlen(
"</Item>");
1793 const char *limit_data_start = strstr(limit_item_start,
"<Data>");
1794 if (! limit_data_start)
1796 smlTrace(TRACE_EXIT,
"%s - no Data found", __func__);
1799 smlTrace(TRACE_INTERNAL,
"%s - Data found", __func__);
1801 const char *limit_data_end = strstr(limit_data_start,
"</Data>");
1802 if (! limit_data_end)
1804 g_warning(
"%s - no end of Data found.", __func__);
1805 smlTrace(TRACE_EXIT,
"%s - no end of Data found", __func__);
1808 smlTrace(TRACE_INTERNAL,
"%s - end of Data found", __func__);
1810 if (limit_data_start >= limit_data_end)
1813 position = limit_data_end + strlen(
"</Data>");
1818 if (limit_item_start >= limit_data_start ||
1819 limit_data_start >= limit_data_end ||
1820 limit_data_end >= limit_item_end)
1825 position = limit_item_end + strlen(
"</Item>");
1830 const char *cdata_start = strstr(limit_data_start,
"<![CDATA[");
1831 const char *cdata_end = NULL;
1833 cdata_end = strstr(cdata_start,
"]]");
1834 if (cdata_start && cdata_end &&
1835 limit_data_start < cdata_start &&
1836 cdata_start < cdata_end &&
1837 cdata_end < limit_data_end)
1840 position = limit_item_end + strlen(
"</Item>");
1846 limit_data_start + strlen(
"<Data>"),
1847 limit_data_end - limit_data_start - strlen(
"<Data>"),
1851 position = limit_item_end + strlen(
"</Item>");
1866 smlTrace(TRACE_INTERNAL,
"%s: There is data which is not CDATA.", __func__);
1872 char *new_data =
smlTryMalloc0(*fixed_size + strlen(
"<![CDATA[]]>") + 1, error);
1878 size_t before_size = limit_data_start + strlen(
"<Data>") - *fixed_data;
1879 size_t data_size = limit_data_end - limit_data_start - strlen(
"<Data>");
1880 size_t after_size = *fixed_size - before_size - data_size;
1882 smlTrace(TRACE_INTERNAL,
"%s: %i = %i + %i +%i", __func__,
1883 *fixed_size, before_size, data_size, after_size);
1885 memcpy(new_data, *fixed_data, before_size);
1886 memcpy(new_data + before_size,
"<![CDATA[", strlen (
"<![CDATA["));
1887 memcpy(new_data + before_size + strlen (
"<![CDATA["),
1888 limit_data_start + strlen(
"<Data>"),
1890 memcpy(new_data + before_size + strlen (
"<![CDATA[") + data_size,
1891 "]]>", strlen(
"]]>"));
1892 memcpy(new_data + before_size + strlen (
"<![CDATA[]]>") + data_size,
1895 smlSafeCFree(fixed_data);
1896 *fixed_data = new_data;
1898 *fixed_size += strlen(
"<![CDATA[]]>");
1900 position = *fixed_data +
1901 before_size + strlen (
"<![CDATA[]]>") +
1902 data_size + strlen(
"</Data></Item>");
1903 smlTrace(TRACE_INTERNAL,
"%s: CDATA inserted", __func__);
1906 smlTrace(TRACE_EXIT,
"%s", __func__);
1917 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %i, %p)", __func__, parser, data, size, error);
1930 parser->data = NULL;
1932 if (! _smlXmlParserFixBrokenItemData(
1933 data, size, &(parser->data), &(parser->size), error))
1940 smlTrace(TRACE_INTERNAL,
"Xml input: %s", debugstr);
1941 smlLog(
"received-%i.xml", parser->data, parser->size);
1942 smlSafeCFree(&debugstr);
1944 parser->got_command = FALSE;
1947 parser->reader = xmlReaderForMemory(parser->data, parser->size,
"/", NULL, XML_PARSE_NONET | XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOCDATA);
1948 if (!parser->reader) {
1949 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to create new reader");
1952 xmlSubstituteEntitiesDefault(1);
1955 if (!_smlXmlParserExpectNode(parser, XML_NODE_START, FALSE, SML_ELEMENT_SYNCML, error))
1956 goto error_free_reader;
1959 if (!_smlXmlParserExpectNode(parser, XML_NODE_START, FALSE, SML_ELEMENT_SYNCHDR, error))
1960 goto error_free_reader;
1962 smlTrace(TRACE_EXIT,
"%s", __func__);
1966 xmlFreeTextReader(parser->reader);
1968 parser->reader = NULL;
1970 smlSafeCFree(&(parser->data));
1977 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, parser,
final, end, error);
1980 SmlBool got_final = FALSE;
1983 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FINAL)) {
1985 if (!_smlXmlParserStep(parser)) {
1986 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
1990 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FINAL) && \
1991 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
1992 if (!_smlXmlParserStep(parser)) {
1993 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2006 *end = parser->got_command ? FALSE : TRUE;
2012 if (strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCBODY) ||
2013 (!xmlTextReaderIsEmptyElement(parser->reader) &&
2014 xmlTextReaderNodeType(parser->reader) != XML_NODE_CLOSE
2017 smlErrorSet(error, SML_ERROR_GENERIC,
"Wrong closing syncbody node");
2022 if (!_smlXmlParserExpectNode(parser, XML_NODE_CLOSE, FALSE, SML_ELEMENT_SYNCML, error))
2025 xmlFreeTextReader(parser->reader);
2026 parser->reader = NULL;
2028 smlSafeCFree(&(parser->data));
2030 smlTrace(TRACE_EXIT,
"%s", __func__);
2040 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, parser);
2043 if (parser->reader) {
2044 xmlFreeTextReader(parser->reader);
2047 smlSafeCFree(&(parser->data));
2049 smlSafeFree((gpointer *)&parser);
2051 smlTrace(TRACE_EXIT,
"%s", __func__);
2056 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, header, cred, error);
2062 if (!xmlTextReaderConstName(parser->reader) || strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCHDR) || \
2063 xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
2065 smlErrorSet(error, SML_ERROR_GENERIC,
"Wrong starting node for a header");
2069 parser->
version = SML_VERSION_UNKNOWN;
2076 if (!_smlXmlParserStep(parser)) {
2077 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2078 goto error_free_header;
2081 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCHDR) && \
2082 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2084 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
2086 "The element %s is not a start node in SyncHdr.",
2087 xmlTextReaderConstName(parser->reader));
2088 goto error_free_header;
2091 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_VERDTD)) {
2092 if (!_smlSyncHeaderParseDTD(&((*header)->version), parser, error))
2093 goto error_free_header;
2094 parser->
version = (*header)->version;
2095 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_VERPROTO)) {
2096 if (!_smlSyncHeaderParseProto(&((*header)->protocol), parser, error))
2097 goto error_free_header;
2098 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SESSIONID)) {
2099 if (!_smlXmlParserGetString(parser, &((*header)->sessionID), SML_ELEMENT_SESSIONID, error))
2100 goto error_free_header;
2101 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MSGID)) {
2102 if (!_smlXmlParserGetID(parser, &((*header)->messageID), SML_ELEMENT_MSGID, error))
2103 goto error_free_header;
2104 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) {
2105 if (!_smlLocationParse(&((*header)->target), parser, error))
2106 goto error_free_header;
2107 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) {
2108 if (!_smlLocationParse(&((*header)->source), parser, error))
2109 goto error_free_header;
2110 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_RESPURI)) {
2115 if ((*header)->responseURI) {
2116 smlTrace(TRACE_ERROR,
"%s: There is more than on RespURI.", __func__);
2117 smlSafeCFree(&((*header)->responseURI));
2119 if (!_smlXmlParserGetString(parser, &((*header)->responseURI), SML_ELEMENT_RESPURI, error))
2120 goto error_free_header;
2121 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NORESP)) {
2123 (*header)->noResponse = TRUE;
2124 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
2125 if (!_smlMessageParseSynchdrMeta(parser, &((*header)->maxmsgsize), &((*header)->maxobjsize), &((*header)->emi), error))
2126 goto error_free_header;
2127 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CRED)) {
2128 *cred = _smlCredParse(parser, error);
2130 goto error_free_header;
2134 smlErrorSet(error, SML_ERROR_GENERIC,
"Element %s not supported for SyncHdr.",
2135 (
char *)xmlTextReaderConstName(parser->reader));
2136 goto error_free_header;
2140 if (!(*header)->protocol) {
2141 smlErrorSet(error, SML_ERROR_GENERIC,
"No protocol set");
2142 goto error_free_header;
2145 if (!(*header)->version) {
2146 smlErrorSet(error, SML_ERROR_GENERIC,
"No dtd version set");
2147 goto error_free_header;
2150 if (!(*header)->sessionID) {
2151 smlErrorSet(error, SML_ERROR_GENERIC,
"No sessionID set");
2152 goto error_free_header;
2155 if (!(*header)->target) {
2156 smlErrorSet(error, SML_ERROR_GENERIC,
"No target set");
2157 goto error_free_header;
2160 if (!(*header)->source) {
2161 smlErrorSet(error, SML_ERROR_GENERIC,
"No source set");
2162 goto error_free_header;
2165 if (!(*header)->messageID) {
2166 smlErrorSet(error, SML_ERROR_GENERIC,
"No msgid set");
2167 goto error_free_header;
2171 if (!_smlXmlParserExpectNode(parser, XML_NODE_START, FALSE, SML_ELEMENT_SYNCBODY, error))
2172 goto error_free_header;
2175 if (!xmlTextReaderIsEmptyElement(parser->reader) && !_smlXmlParserStep(parser)) {
2176 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2177 goto error_free_header;
2180 smlTrace(TRACE_EXIT,
"%s", __func__);
2184 smlHeaderFree(*header);
2188 smlCredUnref(*cred);
2196 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, status, error);
2201 char *locURI = NULL;
2205 if (smlCommandTypeFromString((
char *)xmlTextReaderConstName(parser->reader), error) != SML_COMMAND_TYPE_UNKNOWN && xmlTextReaderNodeType(parser->reader) == XML_NODE_START) {
2207 smlTrace(TRACE_EXIT,
"%s: Next is command", __func__);
2210 smlErrorDeref(error);
2214 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FINAL) && (xmlTextReaderNodeType(parser->reader) == XML_NODE_START || xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE)) {
2216 smlTrace(TRACE_EXIT,
"%s: Next is final", __func__);
2221 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCBODY) &&
2222 (xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE ||
2223 xmlTextReaderIsEmptyElement(parser->reader)
2227 smlTrace(TRACE_EXIT,
"%s: Next is closing syncbody", __func__);
2231 if (strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_STATUS)) {
2232 smlErrorSet(error, SML_ERROR_GENERIC,
"Unexpected element <%s>.",
2233 (
char *)xmlTextReaderConstName(parser->reader));
2237 if (xmlTextReaderIsEmptyElement(parser->reader))
2245 _smlXmlParserStep(parser);
2246 smlErrorSet(error, SML_ERROR_GENERIC,
"Empty status element");
2250 if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
2252 "The element %s is not the start node of Status.",
2253 xmlTextReaderConstName(parser->reader));
2257 *status = smlStatusNew(SML_ERROR_UNKNOWN, 0, 0, NULL, NULL, SML_COMMAND_TYPE_UNKNOWN, error);
2262 if (!_smlXmlParserStep(parser)) {
2263 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2264 goto error_free_status;
2267 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_STATUS) && \
2268 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2270 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
2272 "The element %s is not a start node in Status.",
2273 xmlTextReaderConstName(parser->reader));
2274 goto error_free_status;
2277 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
2279 if (!_smlXmlParserExpectNode(parser, XML_NODE_TEXT, FALSE, NULL, error))
2280 goto error_free_status;
2281 if (!_smlXmlParserExpectNode(parser, XML_NODE_CLOSE, FALSE, SML_ELEMENT_CMDID, error))
2282 goto error_free_status;
2283 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MSGREF)) {
2292 if (!_smlXmlParserGetID(parser, &((*status)->msgRef), SML_ELEMENT_MSGREF, error))
2293 goto error_free_status;
2294 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDREF)) {
2295 if (!_smlXmlParserGetID(parser, &((*status)->cmdRef), SML_ELEMENT_CMDREF, error))
2296 goto error_free_status;
2297 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMD)) {
2298 char *cmdname = NULL;
2299 if (!_smlXmlParserGetString(parser, &cmdname, SML_ELEMENT_CMD, error))
2300 goto error_free_status;
2301 (*status)->type = smlCommandTypeFromString(cmdname, error);
2302 smlSafeCFree(&cmdname);
2303 if ((*status)->type == SML_COMMAND_TYPE_UNKNOWN)
2304 goto error_free_status;
2305 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA)) {
2306 if (!_smlXmlParserGetString(parser, &((*status)->data), SML_ELEMENT_DATA, error))
2307 goto error_free_status;
2308 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCEREF)) {
2309 if (!_smlXmlParserGetString(parser, &locURI, SML_ELEMENT_SOURCEREF, error))
2310 goto error_free_status;
2312 (*status)->sourceRef = smlLocationNew(locURI, NULL, error);
2313 smlSafeCFree(&locURI);
2314 if (!(*status)->sourceRef)
2315 goto error_free_status;
2316 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGETREF)) {
2317 if (!_smlXmlParserGetString(parser, &locURI, SML_ELEMENT_TARGETREF, error))
2318 goto error_free_status;
2320 (*status)->targetRef = smlLocationNew(locURI, NULL, error);
2321 smlSafeCFree(&locURI);
2322 if (!(*status)->targetRef)
2323 goto error_free_status;
2324 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) {
2329 item = _smlItemParse(parser, NULL, (*status)->type, error);
2331 goto error_free_status;
2332 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CHAL)) {
2333 (*status)->chal = _smlChalParse(parser, error);
2334 if (!(*status)->chal)
2335 goto error_free_status;
2337 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
2343 if (!_smlXmlParserStep(parser)) {
2344 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2345 goto error_free_status;
2350 if ((*status)->type == SML_COMMAND_TYPE_ALERT) {
2351 (*status)->anchor = item->anchor;
2352 item->anchor = NULL;
2353 }
else if ((*status)->type == SML_COMMAND_TYPE_ADD ||
2354 (*status)->type == SML_COMMAND_TYPE_REPLACE ||
2355 (*status)->type == SML_COMMAND_TYPE_DELETE) {
2360 g_warning(
"Received explicit status for add, delete or replace (%s).", xmlBufferContent(item->buffer));
2362 smlErrorSet(error, SML_ERROR_GENERIC,
"Got wrong item");
2364 goto error_free_status;
2380 if ((*status)->type == SML_COMMAND_TYPE_UNKNOWN) {
2381 smlErrorSet(error, SML_ERROR_GENERIC,
"No cmd set");
2382 goto error_free_status;
2385 smlTrace(TRACE_INTERNAL,
"Got status %p with: cmdRef %i, msgRef %i, type %i, data %s", *status, (*status)->cmdRef, (*status)->msgRef, (*status)->type, VA_STRING((*status)->data));
2387 smlTrace(TRACE_EXIT,
"%s", __func__);
2391 smlStatusUnref(*status);
2400 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, cmd, error);
2407 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FINAL) && (xmlTextReaderNodeType(parser->reader) == XML_NODE_START || xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE)) {
2409 smlTrace(TRACE_EXIT,
"%s: Next is final", __func__);
2410 return SML_PARSER_RESULT_OTHER;
2414 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCBODY) &&
2415 (xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE ||
2416 xmlTextReaderIsEmptyElement(parser->reader)
2420 smlTrace(TRACE_EXIT,
"%s: Next is closing syncbody", __func__);
2421 return SML_PARSER_RESULT_OTHER;
2425 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_STATUS) && xmlTextReaderNodeType(parser->reader) == XML_NODE_START) {
2427 smlTrace(TRACE_EXIT,
"%s: Next is status", __func__);
2428 return SML_PARSER_RESULT_STATUS;
2431 SmlCommandType type = smlCommandTypeFromString((
char *)xmlTextReaderConstName(parser->reader), error);
2435 SmlParserResult result = SML_PARSER_RESULT_NORMAL;
2438 case SML_COMMAND_TYPE_ALERT:
2439 if (!_smlAlertParse(parser, cmd, error))
2442 case SML_COMMAND_TYPE_PUT:
2443 case SML_COMMAND_TYPE_GET:
2444 if (!_smlCommandAccessParse(parser, cmd, type, error))
2447 case SML_COMMAND_TYPE_SYNC:
2448 if (xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2449 if (!_smlXmlParserStep(parser)) {
2450 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2451 goto error_free_cmd;
2454 smlTrace(TRACE_EXIT,
"%s: SML_PARSER_RESULT_CLOSE", __func__);
2455 return SML_PARSER_RESULT_CLOSE;
2457 if (!_smlCommandSyncParse(parser, cmd, error))
2460 result = SML_PARSER_RESULT_OPEN;
2463 case SML_COMMAND_TYPE_MAP:
2464 if (!_smlCommandMapParse(parser, cmd, error))
2467 case SML_COMMAND_TYPE_ADD:
2468 if (!_smlChangeParse(parser, cmd, SML_COMMAND_TYPE_ADD, SML_ELEMENT_ADD, error))
2471 case SML_COMMAND_TYPE_REPLACE:
2472 if (!_smlChangeParse(parser, cmd, SML_COMMAND_TYPE_REPLACE, SML_ELEMENT_REPLACE, error))
2475 case SML_COMMAND_TYPE_DELETE:
2476 if (!_smlChangeParse(parser, cmd, SML_COMMAND_TYPE_DELETE, SML_ELEMENT_DELETE, error))
2479 case SML_COMMAND_TYPE_RESULTS:
2480 if (!_smlResultsParse(parser, cmd, error))
2484 smlErrorSet(error, SML_ERROR_GENERIC,
"Unsupported command type");
2488 if (!(*cmd)->cmdID) {
2489 smlErrorSet(error, SML_ERROR_GENERIC,
"No cmdid set");
2490 goto error_free_cmd;
2493 parser->got_command = TRUE;
2495 smlTrace(TRACE_EXIT,
"%s: %i", __func__, result);
2500 smlCommandUnref(*cmd);
2504 return SML_PARSER_RESULT_ERROR;
2509 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, functions,error);
2511 smlAssert(functions);
2518 functions->free = (SmlParserFreeFunction)smlXmlParserFree;
2519 functions->end = (SmlParserEndFunction)smlXmlParserEnd;
2520 functions->get_header = (SmlParserHeaderFunction)smlXmlParserGetHeader;
2521 functions->get_cmd = (SmlParserCommandFunction)smlXmlParserGetCommand;
2522 functions->get_status = (SmlParserStatusFunction)smlXmlParserGetStatus;
2524 smlTrace(TRACE_EXIT,
"%s: %p", __func__, parser);
2534 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, datastore, error);
2537 smlAssert(datastore);
2539 if (xmlTextReaderIsEmptyElement(parser->reader)) {
2541 smlTrace(TRACE_EXIT,
"%s - empty DSMem", __func__);
2546 if (!_smlXmlParserStep(parser)) {
2547 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2551 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DSMEM) && \
2552 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2554 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
2556 "The element %s is not a start node in DSMem.",
2557 xmlTextReaderConstName(parser->reader));
2561 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXID)) {
2562 if (!_smlXmlParserGetID(parser, &(datastore->maxid), SML_ELEMENT_MAXID, error))
2564 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SHAREDMEM)) {
2565 datastore->sharedMem = TRUE;
2566 if (!_smlXmlParserStep(parser)) {
2567 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2571 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SHAREDMEM) && \
2572 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2573 if (!_smlXmlParserStep(parser)) {
2574 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes2");
2579 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXMEM)) {
2580 if (!_smlXmlParserGetID(parser, &(datastore->maxmem), SML_ELEMENT_MAXMEM, error))
2583 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
2588 smlTrace(TRACE_EXIT,
"%s", __func__);
2598 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, datastore, error);
2601 smlAssert(datastore);
2604 if (!_smlXmlParserStep(parser)) {
2605 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2609 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCCAP) && \
2610 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2612 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
2614 "The element %s is not a start node in SyncCap.",
2615 xmlTextReaderConstName(parser->reader));
2619 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCTYPE)) {
2620 unsigned int id = 0;
2621 if (!_smlXmlParserGetID(parser, &
id, SML_ELEMENT_SYNCTYPE, error))
2624 SmlDevInfSyncCap synccap = smlDevInfSyncCapConvert(
id, error);
2625 if (synccap == SML_DEVINF_SYNCTYPE_UNKNOWN &&
2629 if (synccap != SML_DEVINF_SYNCTYPE_UNKNOWN)
2630 smlDevInfDataStoreSetSyncCap(datastore, synccap, TRUE);
2632 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
2637 smlTrace(TRACE_EXIT,
"%s", __func__);
2647 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, devinf, error);
2655 if (!_smlXmlParserStep(parser)) {
2656 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2666 const char *elem_name;
2667 elem_name = (
const char*)xmlTextReaderConstName(parser->reader);
2669 smlTrace(TRACE_INTERNAL,
"read: %s\n", elem_name);
2670 if (!strcmp(elem_name, SML_ELEMENT_CTCAP) &&
2671 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2676 if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START)
2679 "The element %s is not a start node in CTCap.",
2680 xmlTextReaderConstName(parser->reader));
2685 SmlDevInfCTCapType type;
2686 type = smlDevInfCTCapTypeFromString(elem_name, error);
2688 if (type != SML_DEVINF_CTCAP_UNKNOWN)
2690 _smlXmlParserGetString(parser, &value, elem_name, error);
2696 case SML_DEVINF_CTCAP_CTTYPE:
2700 if (property != NULL)
2704 smlDevInfPropertyAddPropParam(property, param);
2707 smlDevInfCTCapAddProperty(ctcap, property);
2710 smlDevInfAppendCTCap(devinf, ctcap);
2713 ctcap = smlDevInfNewCTCap(error);
2716 smlDevInfCTCapSetCTType(ctcap, value);
2718 case SML_DEVINF_CTCAP_VERCT:
2721 smlDevInfCTCapSetVerCT(ctcap, value);
2723 case SML_DEVINF_CTCAP_PROPNAME:
2727 if (property != NULL)
2731 smlDevInfPropertyAddPropParam(property, param);
2734 smlDevInfCTCapAddProperty(ctcap, property);
2737 property = smlDevInfNewProperty(error);
2740 smlDevInfPropertySetPropName(property, value);
2742 case SML_DEVINF_CTCAP_DATATYPE:
2743 if (property == NULL)
2746 smlDevInfPropParamSetDataType(param, value);
2748 smlDevInfPropertySetDataType(property, value);
2750 case SML_DEVINF_CTCAP_MAXOCCUR:
2751 if (property == NULL)
2753 smlDevInfPropertySetMaxOccur(property, atoi(value));
2755 case SML_DEVINF_CTCAP_MAXSIZE:
2756 if (property == NULL)
2758 smlDevInfPropertySetMaxSize(property, atoi(value));
2760 case SML_DEVINF_CTCAP_NOTRUNCATE:
2761 if (property == NULL)
2763 smlDevInfPropertySetNoTruncate(property);
2765 case SML_DEVINF_CTCAP_DISPLAYNAME:
2766 if (property == NULL)
2769 smlDevInfPropParamSetDisplayName(param, value);
2771 smlDevInfPropertySetDisplayName(property, value);
2773 case SML_DEVINF_CTCAP_VALENUM:
2774 if (property == NULL)
2777 smlDevInfPropParamAddValEnum(param, value);
2779 smlDevInfPropertyAddValEnum(property, value);
2781 case SML_DEVINF_CTCAP_PARAMNAME:
2782 if (property == NULL)
2786 smlDevInfPropertyAddPropParam(property, param);
2789 param = smlDevInfNewPropParam(error);
2792 smlDevInfPropParamSetParamName(param, value);
2794 case SML_DEVINF_CTCAP_SIZE:
2795 smlDevInfPropertySetPropSize(property, atoi(value));
2798 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown CTCapType: %s", elem_name);
2801 smlSafeCFree(&value);
2803 if (!_smlXmlParserStep(parser)) {
2804 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2809 smlDevInfPropertyAddPropParam(property, param);
2810 if (property != NULL)
2811 smlDevInfCTCapAddProperty(ctcap, property);
2813 smlDevInfAppendCTCap(devinf, ctcap);
2815 smlTrace(TRACE_EXIT,
"%s", __func__);
2821 smlSafeCFree(&value);
2827 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, error);
2831 if (!_smlXmlParserStep(parser)) {
2832 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2843 const char *elem_name;
2844 elem_name = (
const char*)xmlTextReaderConstName(parser->reader);
2846 smlTrace(TRACE_INTERNAL,
"read: %s\n", elem_name);
2847 if (!strcmp(elem_name, SML_ELEMENT_PROPPARAM) &&
2848 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2853 if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START)
2856 "The element %s is not a start node in PropParam.",
2857 xmlTextReaderConstName(parser->reader));
2862 SmlDevInfCTCapType type;
2863 type = smlDevInfCTCapTypeFromString(elem_name, error);
2865 if (type != SML_DEVINF_CTCAP_UNKNOWN)
2867 _smlXmlParserGetString(parser, &value, elem_name, error);
2873 case SML_DEVINF_CTCAP_PARAMNAME:
2874 smlDevInfPropParamSetParamName(param, value);
2876 case SML_DEVINF_CTCAP_DATATYPE:
2877 smlDevInfPropParamSetDataType(param, value);
2879 case SML_DEVINF_CTCAP_DISPLAYNAME:
2880 smlDevInfPropParamSetDisplayName(param, value);
2882 case SML_DEVINF_CTCAP_VALENUM:
2883 smlDevInfPropParamAddValEnum(param, value);
2886 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown CTCapType for PropParam: %s", elem_name);
2889 smlSafeCFree(&value);
2891 if (!_smlXmlParserStep(parser)) {
2892 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2897 smlTrace(TRACE_EXIT,
"%s", __func__);
2903 smlSafeCFree(&value);
2909 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, error);
2913 if (!_smlXmlParserStep(parser)) {
2914 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2926 const char *elem_name;
2927 elem_name = (
const char*)xmlTextReaderConstName(parser->reader);
2929 smlTrace(TRACE_INTERNAL,
"read: %s\n", elem_name);
2930 if (!strcmp(elem_name, SML_ELEMENT_PROPERTY) &&
2931 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
2936 if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START)
2939 "The element %s is not a start node in Property.",
2940 xmlTextReaderConstName(parser->reader));
2945 SmlDevInfCTCapType type;
2946 type = smlDevInfCTCapTypeFromString(elem_name, error);
2948 if (type != SML_DEVINF_CTCAP_UNKNOWN &&
2949 type != SML_DEVINF_CTCAP_PROPPARAM)
2951 _smlXmlParserGetString(parser, &value, elem_name, error);
2957 case SML_DEVINF_CTCAP_PROPNAME:
2958 smlDevInfPropertySetPropName(property, value);
2960 case SML_DEVINF_CTCAP_DATATYPE:
2961 smlDevInfPropertySetDataType(property, value);
2963 case SML_DEVINF_CTCAP_MAXOCCUR:
2964 smlDevInfPropertySetMaxOccur(property, atoi(value));
2966 case SML_DEVINF_CTCAP_MAXSIZE:
2967 smlDevInfPropertySetMaxSize(property, atoi(value));
2969 case SML_DEVINF_CTCAP_NOTRUNCATE:
2970 smlDevInfPropertySetNoTruncate(property);
2972 case SML_DEVINF_CTCAP_DISPLAYNAME:
2973 smlDevInfPropertySetDisplayName(property, value);
2975 case SML_DEVINF_CTCAP_VALENUM:
2976 smlDevInfPropertyAddValEnum(property, value);
2978 case SML_DEVINF_CTCAP_PROPPARAM:
2979 param = _smlXmlDevInfDataStoreParseCTCap12PropParam(parser, error);
2982 smlDevInfPropertyAddPropParam(property, param);
2984 case SML_DEVINF_CTCAP_SIZE:
2985 smlDevInfPropertySetPropSize(property, atoi(value));
2988 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown CTCapType for Property: %s", elem_name);
2991 if (value) smlSafeCFree(&value);
2993 if (!_smlXmlParserStep(parser)) {
2994 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
2999 smlTrace(TRACE_EXIT,
"%s", __func__);
3005 smlSafeCFree(&value);
3011 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, devinf, error);
3019 if (!_smlXmlParserStep(parser)) {
3020 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3032 const char *elem_name;
3033 elem_name = (
const char*)xmlTextReaderConstName(parser->reader);
3035 smlTrace(TRACE_INTERNAL,
"read: %s\n", elem_name);
3036 if (!strcmp(elem_name, SML_ELEMENT_CTCAP) &&
3037 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3042 if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START)
3045 "The element %s is not a start node in CtCap.",
3046 xmlTextReaderConstName(parser->reader));
3051 SmlDevInfCTCapType type;
3052 type = smlDevInfCTCapTypeFromString(elem_name, error);
3054 if (type != SML_DEVINF_CTCAP_UNKNOWN &&
3055 type != SML_DEVINF_CTCAP_PROPERTY)
3057 _smlXmlParserGetString(parser, &value, elem_name, error);
3063 case SML_DEVINF_CTCAP_CTTYPE:
3064 smlDevInfCTCapSetCTType(ctcap, value);
3066 case SML_DEVINF_CTCAP_VERCT:
3067 smlDevInfCTCapSetVerCT(ctcap, value);
3069 case SML_DEVINF_CTCAP_PROPERTY:
3070 property = _smlXmlDevInfDataStoreParseCTCap12Property(parser, error);
3073 smlDevInfCTCapAddProperty(ctcap, property);
3076 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown CTCapType for CTCap: %s", elem_name);
3079 if (value) smlSafeCFree(&value);
3081 if (!_smlXmlParserStep(parser)) {
3082 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3086 smlDevInfAppendCTCap(devinf, ctcap);
3088 smlTrace(TRACE_EXIT,
"%s", __func__);
3094 smlSafeCFree(&value);
3100 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, devinf, error);
3112 if (devinf->version == SML_DEVINF_VERSION_12)
3113 ret = _smlXmlDevInfDataStoreParseCTCap12(parser, devinf, error);
3115 ret = _smlXmlDevInfDataStoreParseCTCap11(parser, devinf, error);
3117 smlTrace(TRACE_EXIT,
"%s (%d)", __func__, ret);
3121 static SmlBool _smlXmlDevInfDataStoreParseRxTx(
SmlXmlParser *parser,
const char *element,
char **cttype,
char **version,
SmlError **error)
3123 smlTrace(TRACE_ENTRY,
"%s(%p, %s, %p, %p, %p)", __func__, parser, VA_STRING(element), cttype, version, error);
3129 if (!_smlXmlParserStep(parser)) {
3130 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3135 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), element) && \
3136 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3138 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
3140 "The element %s is not a start node in %s.",
3141 xmlTextReaderConstName(parser->reader), element);
3145 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CTTYPE)) {
3146 if (!_smlXmlParserGetString(parser, cttype, SML_ELEMENT_CTTYPE, error))
3148 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_VERCT)) {
3151 if (!_smlXmlParserStep(parser)) {
3152 smlErrorSet(error, SML_ERROR_GENERIC,
"No node at all");
3156 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_VERCT) && \
3157 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3158 *version = g_strdup(
"");
3159 }
else if (xmlTextReaderNodeType(parser->reader) == XML_NODE_TEXT) {
3160 *version = g_strstrip(g_strdup((
char *)xmlTextReaderConstValue(parser->reader)));
3162 if (!_smlXmlParserExpectNode(parser, XML_NODE_CLOSE, FALSE, SML_ELEMENT_VERCT, error))
3165 *version = g_strdup(
"");
3169 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node");
3173 if (!_smlXmlParserStep(parser)) {
3174 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3179 smlTrace(TRACE_EXIT,
"%s", __func__);
3189 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, devinf, error);
3197 datastore->refCount = 1;
3198 datastore->rxPrefContentType = NULL;
3199 datastore->txPrefContentType = NULL;
3201 if (!_smlXmlParserStep(parser)) {
3202 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3203 goto error_free_datastore;
3208 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATASTORE) && \
3209 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3211 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
3213 "The element %s is not a start node in Datastore.",
3214 xmlTextReaderConstName(parser->reader));
3215 goto error_free_datastore;
3218 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCEREF)) {
3219 if (!_smlXmlParserGetString(parser, &(datastore->sourceref), SML_ELEMENT_SOURCEREF, error))
3220 goto error_free_datastore;
3221 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DISPLAYNAME)) {
3222 if (!_smlXmlParserGetString(parser, &(datastore->displayname), SML_ELEMENT_DISPLAYNAME, error))
3223 goto error_free_datastore;
3224 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXGUIDSIZE)) {
3225 if (!_smlXmlParserGetID(parser, &(datastore->maxGUIDSize), SML_ELEMENT_MAXGUIDSIZE, error))
3226 goto error_free_datastore;
3227 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_RXPREF)) {
3228 if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_RXPREF, &(datastore->rxPrefContentType), &(datastore->rxPrefVersion), error))
3229 goto error_free_datastore;
3230 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_RX)) {
3231 char *cttype = NULL;
3233 if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_RX, &cttype, &verct, error))
3234 goto error_free_datastore;
3236 smlSafeCFree(&cttype);
3238 smlSafeCFree(&verct);
3240 goto error_free_datastore;
3241 smlDevInfDataStoreAddRx(datastore, ct);
3242 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TXPREF)) {
3243 if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_TXPREF, &(datastore->txPrefContentType), &(datastore->txPrefVersion), error))
3244 goto error_free_datastore;
3245 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TX)) {
3246 char *cttype = NULL;
3248 if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_TX, &cttype, &verct, error))
3249 goto error_free_datastore;
3251 smlSafeCFree(&cttype);
3253 smlSafeCFree(&verct);
3255 goto error_free_datastore;
3256 smlDevInfDataStoreAddTx(datastore, ct);
3257 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CTCAP)) {
3258 if (!_smlXmlDevInfDataStoreParseCTCap(parser, devinf, error))
3259 goto error_free_datastore;
3260 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCCAP)) {
3261 if (!_smlXmlDevInfDataStoreParseSyncCap(parser, datastore, error))
3262 goto error_free_datastore;
3263 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DSMEM)) {
3264 if (!_smlXmlDevInfDataStoreParseDSMem(parser, datastore, error))
3265 goto error_free_datastore;
3266 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SUPPORT_HIERARCHICAL_SYNC)) {
3267 if (devinf->version < SML_DEVINF_VERSION_12) {
3268 smlErrorSet(error, SML_ERROR_GENERIC,
"SupportHierarchicalSync is only supported in OMA DS 1.2 DevInf and later.");
3271 datastore->supportsHierarchicalSync = TRUE;
3272 if (!xmlTextReaderIsEmptyElement(parser->reader)) {
3273 if (!_smlXmlParserStep(parser)) {
3274 smlErrorSet(error, SML_ERROR_GENERIC,
"The closing element of %s is missing.", SML_ELEMENT_SUPPORT_HIERARCHICAL_SYNC);
3279 smlErrorSet(error, SML_ERROR_GENERIC,
"A DataStore within DevInf includes the unsupported element %s.", (
char *)xmlTextReaderConstName(parser->reader));
3280 goto error_free_datastore;
3283 if (!_smlXmlParserStep(parser)) {
3284 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3285 goto error_free_datastore;
3289 smlDevInfAddDataStore(devinf, datastore);
3291 smlTrace(TRACE_EXIT,
"%s", __func__);
3294 error_free_datastore:
3295 smlDevInfDataStoreUnref(datastore);
3301 SmlDevInf *smlXmlDevInfParse(
const char *data,
unsigned int size,
SmlError **error)
3303 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, data, size, error);
3311 smlTrace(TRACE_INTERNAL,
"Xml devinf input: %s", debugstr);
3312 smlSafeCFree(&debugstr);
3319 parser->reader = xmlReaderForMemory(data, size,
"/", NULL, XML_PARSE_NONET | XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOCDATA | XML_PARSER_SUBST_ENTITIES);
3320 if (!parser->reader) {
3321 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to create new reader");
3324 xmlSubstituteEntitiesDefault(1);
3327 if (!_smlXmlParserExpectNode(parser, XML_NODE_START, FALSE, SML_ELEMENT_DEVINF, error))
3334 smlDevInfRef(devinf);
3336 if (!_smlXmlParserStep(parser)) {
3337 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3342 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DEVINF) && \
3343 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3345 }
else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
3347 "The element %s is not a start node in DevInf.",
3348 xmlTextReaderConstName(parser->reader));
3353 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_VERDTD)) {
3354 char *verdtd = NULL;
3355 if (!_smlXmlParserGetString(parser, &verdtd, SML_ELEMENT_VERDTD, error))
3358 if (verdtd && !strcmp(verdtd,
"1.1"))
3359 devinf->version = SML_DEVINF_VERSION_11;
3360 else if (verdtd && !strcmp(verdtd,
"1.0"))
3361 devinf->version = SML_DEVINF_VERSION_10;
3362 else if (verdtd && !strcmp(verdtd,
"1.2"))
3363 devinf->version = SML_DEVINF_VERSION_12;
3365 smlSafeCFree(&verdtd);
3366 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown devinf version");
3369 smlSafeCFree(&verdtd);
3370 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAN)) {
3371 if (!_smlXmlParserGetString(parser, &(devinf->manufacturer), SML_ELEMENT_MAN, error))
3373 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MOD)) {
3374 if (!_smlXmlParserGetString(parser, &(devinf->model), SML_ELEMENT_MOD, error))
3376 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_OEM)) {
3377 if (!_smlXmlParserGetString(parser, &(devinf->oem), SML_ELEMENT_OEM, error))
3379 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FWV)) {
3380 if (!_smlXmlParserGetString(parser, &(devinf->firmwareVersion), SML_ELEMENT_FWV, error))
3382 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SWV)) {
3383 if (!_smlXmlParserGetString(parser, &(devinf->softwareVersion), SML_ELEMENT_SWV, error))
3385 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_HWV)) {
3386 if (!_smlXmlParserGetString(parser, &(devinf->hardwareVersion), SML_ELEMENT_HWV, error))
3388 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DEVID)) {
3389 if (!_smlXmlParserGetString(parser, &(devinf->devid), SML_ELEMENT_DEVID, error))
3391 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DEVTYPE)) {
3392 char *devtype = NULL;
3393 if (!_smlXmlParserGetString(parser, &devtype, SML_ELEMENT_DEVTYPE, error))
3396 devinf->devtyp = smlDevInfDevTypeFromString(devtype, error);
3397 smlSafeCFree(&devtype);
3399 if (devinf->devtyp == SML_DEVINF_DEVTYPE_UNKNOWN)
3401 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_UTC)) {
3402 if (devinf->version == SML_DEVINF_VERSION_10) {
3403 smlErrorSet(error, SML_ERROR_GENERIC,
"Devinf 1.0 does not allow UTC");
3407 devinf->supportsUTC = TRUE;
3408 if (!_smlXmlParserStep(parser)) {
3409 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3413 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_UTC) && \
3414 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3415 if (!_smlXmlParserStep(parser)) {
3416 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes2");
3421 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SUPPORTLARGEOBJS)) {
3422 if (devinf->version == SML_DEVINF_VERSION_10) {
3423 smlErrorSet(error, SML_ERROR_GENERIC,
"Devinf 1.0 does not allow large objects");
3427 devinf->supportsLargeObjs = TRUE;
3428 if (!_smlXmlParserStep(parser)) {
3429 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3433 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SUPPORTLARGEOBJS) && \
3434 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3435 if (!_smlXmlParserStep(parser)) {
3436 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes2");
3441 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SUPPORTNUMBEROFCHANGES)) {
3442 if (devinf->version == SML_DEVINF_VERSION_10) {
3443 smlErrorSet(error, SML_ERROR_GENERIC,
"Devinf 1.0 does not allow number of changes");
3447 devinf->supportsNumberOfChanges = TRUE;
3448 if (!_smlXmlParserStep(parser)) {
3449 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3453 if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SUPPORTNUMBEROFCHANGES) && \
3454 xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
3455 if (!_smlXmlParserStep(parser)) {
3456 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes2");
3461 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATASTORE)) {
3462 if (!_smlXmlDevInfDataStoreParse(parser, devinf, error))
3464 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CTCAP)) {
3468 if (!_smlXmlDevInfDataStoreParseCTCap(parser, devinf, error))
3470 }
else if (!strcmp((
char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_EXT)) {
3472 smlTrace(TRACE_INTERNAL,
"%s: Skipping ext node");
3473 if (!_smlXmlSkipNode(parser)) {
3474 smlErrorSet(error, SML_ERROR_GENERIC,
"Unable to skip ext node");
3479 smlErrorSet(error, SML_ERROR_GENERIC,
"wrong initial node: %s", (
char *)xmlTextReaderConstName(parser->reader));
3483 if (!_smlXmlParserStep(parser)) {
3484 smlErrorSet(error, SML_ERROR_GENERIC,
"Missing nodes");
3489 xmlFreeTextReader(parser->reader);
3490 parser->reader = NULL;
3491 smlSafeFree((gpointer *)&parser);
3493 smlTrace(TRACE_EXIT,
"%s", __func__);
3497 if (parser && parser->reader) {
3498 xmlFreeTextReader(parser->reader);
3499 parser->reader = NULL;
3502 smlSafeFree((gpointer *)&parser);
3504 smlDevInfUnref(devinf);
SmlBool smlXmlParserStart(SmlXmlParser *parser, const char *data, unsigned int size, SmlError **error)
Start the parsing.
const char * smlErrorPrint(SmlError **error)
Returns the message of the error.
char * smlPrintBinary(const char *data, int len)
Used for printing binary data.
SmlBool smlErrorIsSet(SmlError **error)
Checks if the error is set.
void smlTrace(SmlTraceType type, const char *message,...)
Used for tracing the application.
void * smlTryMalloc0(long n_bytes, SmlError **error)
Safely mallocs.
void smlErrorSet(SmlError **error, SmlErrorType type, const char *format,...)
Sets the error.
SmlProtocolVersion version