Navigation

← Previous Changeset
Next Changeset →

Changeset 160

Timestamp:

05/03/06 22:33:24 (3 years ago)

Author:

abauer

Message:

Added support for parsing and displaying devinf objs

Added support for requesting devinf objs

Added support to dump devinf

Files:

branches/dev-branch/libsyncml/objects/sml_auth.c (modified) (3 diffs)
branches/dev-branch/libsyncml/objects/sml_devinf_obj.c (modified) (6 diffs)
branches/dev-branch/libsyncml/objects/sml_devinf_obj.h (modified) (1 diff)
branches/dev-branch/libsyncml/objects/sml_devinf_obj_internals.h (modified) (1 diff)
branches/dev-branch/libsyncml/parser/sml_xml_assm.c (modified) (14 diffs)
branches/dev-branch/libsyncml/parser/sml_xml_parse.c (modified) (5 diffs)
branches/dev-branch/libsyncml/parser/sml_xml_parse.h (modified) (1 diff)
branches/dev-branch/libsyncml/sml_command.c (modified) (6 diffs)
branches/dev-branch/libsyncml/sml_command.h (modified) (2 diffs)
branches/dev-branch/libsyncml/sml_command_internals.h (modified) (3 diffs)
branches/dev-branch/libsyncml/sml_devinf.c (modified) (6 diffs)
branches/dev-branch/libsyncml/sml_devinf.h (modified) (2 diffs)
branches/dev-branch/libsyncml/sml_devinf_internals.h (modified) (1 diff)
branches/dev-branch/libsyncml/sml_manager.c (modified) (1 diff)
branches/dev-branch/libsyncml/sml_parse.c (modified) (2 diffs)
branches/dev-branch/libsyncml/sml_session.c (modified) (17 diffs)
branches/dev-branch/libsyncml/sml_session.h (modified) (3 diffs)
branches/dev-branch/libsyncml/sml_session_internals.h (modified) (1 diff)
branches/dev-branch/tests/check_devinf.c (modified) (1 diff)
branches/dev-branch/tools/syncml-http-server.c (modified) (1 diff)
branches/dev-branch/tools/syncml-obex-client.c (modified) (10 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

branches/dev-branch/libsyncml/objects/sml_auth.c

r127	r160
60	60	smlTrace(TRACE_INTERNAL, "Auth is required");
61	61	auth->state = SML_ERROR_AUTH_REQUIRED;
	62
	63	smlErrorSet(&error, SML_ERROR_AUTH_REQUIRED, "Auth required but not given");
	64	smlSessionDispatchEvent(session, SML_SESSION_EVENT_ERROR, NULL, NULL, NULL, error);
	65	smlErrorDeref(&error);
62	66	} else if ((!cred && auth->enabled && auth->state == SML_AUTH_ACCEPTED) \|\| \
63	67	(cred && !auth->enabled)) {
…	…
86	90	auth->state = SML_ERROR_AUTH_REJECTED;
87	91	}
	92
	93	if (auth->state == SML_ERROR_AUTH_REJECTED) {
	94	smlErrorSet(&error, SML_ERROR_AUTH_REJECTED, "Auth rejected for username %s", arr[0]);
	95	smlSessionDispatchEvent(session, SML_SESSION_EVENT_ERROR, NULL, NULL, NULL, error);
	96	smlErrorDeref(&error);
	97	}
	98
88	99	g_strfreev(arr);
89	100
…	…
115	126
116	127	error:
117		smlSession~~SetError(session, &~~error);
	128	smlSessionDispatchEvent(session, SML_SESSION_EVENT_ERROR, NULL, NULL, NULL, error);
118	129	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(&error));
119	130	smlErrorDeref(&error);

branches/dev-branch/libsyncml/objects/sml_devinf_obj.c

r127	r160
36	36	/@{/
37	37
	38	static void _get_devinf_reply(SmlSession session, SmlStatus status, void *userdata)
	39	{
	40	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, session, status, userdata);
	41	SmlError *error = NULL;
	42	SmlDevInfAgent *agent = userdata;
	43
	44	if (smlStatusIsResult(status)) {
	45	SmlCommand *result = smlStatusGetResult(status);
	46	printf("result: %p\n", result);
	47
	48	agent->recvDevInf = smlDevInfFromResult(result, &error);
	49	if (!agent->recvDevInf)
	50	goto error;
	51
	52	SmlStatus *reply = smlCommandNewReply(result, SML_NO_ERROR, &error);
	53	if (!reply)
	54	goto error;
	55
	56	if (!smlSessionSendReply(session, reply, &error)) {
	57	smlStatusUnref(reply);
	58	goto error;
	59	}
	60
	61	smlStatusUnref(reply);
	62	}
	63
	64	smlTrace(TRACE_EXIT, "%s", __func__);
	65	return;
	66
	67	error:
	68	smlSessionDispatchEvent(session, SML_SESSION_EVENT_ERROR, NULL, NULL, NULL, error);
	69	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(&error));
	70	smlErrorDeref(&error);
	71	}
	72
38	73	static void _devinf_reply(SmlSession session, SmlStatus status, void *userdata)
39	74	{
…	…
57	92	{
58	93	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, agent, session, get, error);
59		Sml~~Status~~ *result = NULL;
	94	SmlCommand *result = NULL;
60	95	SmlCommand *cmd = NULL;
61	96
…	…
70	105	goto error;
71	106
72		if (!smlSessionSend~~Result(session, result~~, _devinf_reply, agent, error)) {
73		sml~~Status~~Unref(result);
	107	if (!smlSessionSendCommand(session, result, NULL, _devinf_reply, agent, error)) {
	108	smlCommandUnref(result);
74	109	goto error;
75	110	}
76	111
77		sml~~Status~~Unref(result);
	112	smlCommandUnref(result);
78	113
79	114	SmlStatus *reply = smlCommandNewReply(get, SML_NO_ERROR, error);
…	…
134	169	SmlDevInfAgent *agent = userdata;
135	170	SmlError *error = NULL;
136
137		agent->recvDevInf = cmd;
138		smlCommandRef(cmd);
139
140		SmlStatus *reply = smlCommandNewReply(agent->recvDevInf, SML_NO_ERROR, &error);
	171	char *data = NULL;
	172	unsigned int size = 0;
	173
	174	if (!smlItemGetData(cmd->private.access.item, &data, &size, &error))
	175	goto error;
	176
	177	agent->recvDevInf = smlDevInfParse(data, size, &error);
	178	if (!agent->recvDevInf)
	179	goto error;
	180
	181	SmlStatus *reply = smlCommandNewReply(cmd, SML_NO_ERROR, &error);
141	182	if (!reply)
142	183	goto error;
…	…
205	246
206	247	/* Get the devinf that was sent in the session. Returns FALSE if no devinf was received yet. */
207		SmlDevInf smlDevInfAgentGetDevInf(SmlDevInfAgent agent, SmlError **error)
208		{
209		smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, agent, error);
210		smlAssert(agent);
211
212		if (agent->recvDevInf) {
213		char *data = NULL;
214		unsigned int size = 0;
215		if (!smlItemGetData(agent->recvDevInf->private.access.item, &data, &size, error))
216		goto error;
217
218		SmlDevInf *devinf = smlDevInfParse(data, size, error);
219		if (!devinf)
220		goto error;
221
222		smlCommandUnref(agent->recvDevInf);
223		agent->recvDevInf = NULL;
224
225		smlTrace(TRACE_EXIT, "%s: %p", __func__, devinf);
226		return devinf;
227		}
228
229		smlTrace(TRACE_EXIT, "%s: No devinf yet", __func__);
230		return NULL;
231
232		error:
233		smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
234		return NULL;
	248	SmlDevInf smlDevInfAgentGetDevInf(SmlDevInfAgent agent)
	249	{
	250	smlAssert(agent);
	251	return agent->recvDevInf;
235	252	}
236	253
…	…
257	274	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, agent, session, error);
258	275	smlAssert(agent);
259
260		//TODO
261
	276	SmlCommand *get = NULL;
	277
	278	if (agent->recvDevInf) {
	279	smlTrace(TRACE_EXIT, "%s: Already have the devinf", __func__);
	280	return TRUE;
	281	}
	282
	283	if (smlSessionGetVersion(session) == SML_VERSION_10)
	284	get = smlDevInfNewGet(SML_DEVINF_VERSION_10, error);
	285	else
	286	get = smlDevInfNewGet(SML_DEVINF_VERSION_11, error);
	287
	288	if (!get)
	289	goto error;
	290
	291	if (!smlSessionSendCommand(session, get, NULL, _get_devinf_reply, agent, error)) {
	292	smlCommandUnref(get);
	293	goto error;
	294	}
	295
	296	smlCommandUnref(get);
	297
262	298	smlTrace(TRACE_EXIT, "%s", __func__);
263	299	return TRUE;
264	300
265		/*error:
266		smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
267		return FALSE;*/
	301	error:
	302	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
	303	return FALSE;
268	304	}
269	305

branches/dev-branch/libsyncml/objects/sml_devinf_obj.h

r127	r160
26	26	SmlDevInfAgent smlDevInfAgentNew(SmlDevInf devinf, SmlError **error);
27	27	void smlDevInfAgentFree(SmlDevInfAgent *agent);
28		SmlDevInf smlDevInfAgentGetDevInf(SmlDevInfAgent agent~~, SmlError **error~~);
	28	SmlDevInf smlDevInfAgentGetDevInf(SmlDevInfAgent agent);
29	29	SmlBool smlDevInfAgentRegister(SmlDevInfAgent agent, SmlManager manager, SmlError **error);
30	30	SmlBool smlDevInfAgentSendDevInf(SmlDevInfAgent agent, SmlSession session, SmlError **error);

branches/dev-branch/libsyncml/objects/sml_devinf_obj_internals.h

r127 r160

26 26 SmlBool devinfSent;
27 27
28 Sml~~Command~~ *recvDevInf;
28 SmlDevInf *recvDevInf;
29 29 };
30 30

branches/dev-branch/libsyncml/parser/sml_xml_assm.c

r153	r160
425	425	}
426	426
427		~~/*if (~~assm->session->incomingMaxObjSize && assm->session->version != SML_VERSION_10) {
	427	if (assm->session->supportsLargeObjects && assm->session->incomingMaxObjSize && assm->session->version != SML_VERSION_10) {
428	428	if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error))
429	429	goto error;
…	…
435	435	if (!_smlXmlAssemblerEndNode(assm, error))
436	436	goto error;
437		}*/
	437	}
438	438
439	439	if (!smlLocationAssemble(cmd->target, assm, SML_ELEMENT_TARGET, error))
…	…
448	448	goto error;
449	449
450		~~/*if (~~assm->session->version != SML_VERSION_10) {
	450	if (assm->session->supportsNumberOfChanges && assm->session->version != SML_VERSION_10) {
451	451	if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_NUMBEROFCHANGES, cmd->private.sync.numChanged, error))
452	452	goto error;
453		}*/
	453	}
454	454
455	455	smlTrace(TRACE_EXIT, "%s", __func__);
…	…
585	585	if (!_smlXmlAssemblerEndNode(assm, error))
586	586	goto error;
	587
	588	smlTrace(TRACE_EXIT, "%s", __func__);
	589	return TRUE;
	590
	591	error:
	592	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
	593	return FALSE;
	594	}
	595
	596	SmlBool smlResultsAssemble(SmlXmlAssembler assm, SmlCommand cmd, SmlError **error)
	597	{
	598	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, assm, cmd, error);
	599	smlAssert(cmd);
	600	smlAssert(assm);
	601
	602	if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_MSGREF, cmd->private.results.status->msgRef, error))
	603	goto error;
	604
	605	if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_CMDREF, cmd->private.results.status->cmdRef, error))
	606	goto error;
	607
	608	if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error))
	609	goto error;
	610
	611	const char *contenttype = smlContentTypeToString(cmd->private.results.status->item->contenttype, error);
	612	if (!contenttype)
	613	goto error;
	614
	615	if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, contenttype, error))
	616	goto error;
	617
	618	//META
	619	if (!_smlXmlAssemblerEndNode(assm, error))
	620	goto error;
	621
	622	if (!smlItemAssemble(cmd->private.results.status->item, assm, TRUE, 0, error))
	623	goto error;
	624
	625	if (cmd->private.results.status->sourceRef) {
	626	if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_SOURCEREF, cmd->private.results.status->sourceRef->locURI, error))
	627	goto error;
	628	}
	629
	630	if (cmd->private.results.status->targetRef) {
	631	if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_TARGETREF, cmd->private.results.status->targetRef->locURI, error))
	632	goto error;
	633	}
587	634
588	635	smlTrace(TRACE_EXIT, "%s", __func__);
…	…
798	845	break;
799	846	case SML_COMMAND_TYPE_PUT:
	847	case SML_COMMAND_TYPE_GET:
800	848	if (!smlAccessAssemble(assm, cmd, error))
801	849	goto error_free_writer;
…	…
805	853	goto error_free_writer;
806	854	break;
	855	case SML_COMMAND_TYPE_RESULTS:
	856	if (!smlResultsAssemble(assm, cmd, error))
	857	goto error_free_writer;
807	858	default:
808	859	smlErrorSet(error, SML_ERROR_GENERIC, "Unknown command type");
…	…
1002	1053	}
1003	1054
1004		/* If the status is a result, we create a new buffer here
1005		* since it was not reserved before */
1006		if (status->type == SML_COMMAND_TYPE_RESULTS) {
1007		if (!smlXmlAssemblerReserveStatus(assm, status->cmdRef, status->msgRef, status->cmdID, error))
1008		goto error;
1009		res = g_list_last(assm->statuses)->data;
1010		} else {
1011		GList *s = NULL;
1012		for (s = assm->statuses; s; s = s->next) {
1013		res = s->data;
1014		if (res->cmdRef == status->cmdRef && res->msgRef == status->msgRef)
1015		break;
1016		res = NULL;
1017		}
	1055	/* Get the reserved buffer */
	1056	GList *s = NULL;
	1057	for (s = assm->statuses; s; s = s->next) {
	1058	res = s->data;
	1059	if (res->cmdRef == status->cmdRef && res->msgRef == status->msgRef)
	1060	break;
	1061	res = NULL;
1018	1062	}
1019	1063
…	…
1046	1090	}
1047	1091
1048		if (status->type != SML_COMMAND_TYPE_RESULTS) {
1049		if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_STATUS, error))
1050		goto error;
1051		} else {
1052		if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_RESULTS, error))
1053		goto error;
1054		}
	1092	if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_STATUS, error))
	1093	goto error;
1055	1094
1056	1095	if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_CMDID, res->cmdID, error))
…	…
1127	1166	}
1128	1167	break;
1129		~~case SML_COMMAND_TYPE_RESULTS:~~
1130		~~if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error))~~
1131		~~goto error;~~
1132
1133		~~const char *contenttype = smlContentTypeToString(status->item->contenttype, error);~~
1134		~~if (!contenttype)~~
1135		~~goto error;~~
1136
1137		~~if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, contenttype, error))~~
1138		~~goto error;~~
1139
1140		~~//META~~
1141		~~if (!_smlXmlAssemblerEndNode(assm, error))~~
1142		~~goto error;~~
1143
1144		~~if (!smlItemAssemble(status->item, assm, TRUE, 0, error))~~
1145		~~goto error;~~
1146		~~break;~~
1147	1168	default:
1148	1169	;
…	…
1159	1180	}
1160	1181
1161		if (status->~~type != SML_COMMAND_TYPE_RESULTS && status->~~data) {
	1182	if (status->data) {
1162	1183	if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DATA, status->data, error))
1163	1184	goto error;
…	…
1334	1355	/* Add the corresponding command opener */
1335	1356
1336		if (onlyReplace)
	1357	if (cmd->cmdType == SML_COMMAND_TYPE_ADD && onlyReplace)
1337	1358	cmdname = SML_ELEMENT_REPLACE;
1338	1359	else {
…	…
1584	1605	SmlBool smlXmlAssemblerNextCmdRef(SmlXmlAssembler assm, unsigned int cmdRef, unsigned int *msgRef)
1585	1606	{
1586		~~smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, assm, cmdRef, msgRef);~~
1587	1607	smlAssert(assm);
1588	1608	smlAssert(cmdRef);
…	…
1596	1616	*cmdRef = status->cmdRef;
1597	1617	*msgRef = status->msgRef;
1598
1599		~~smlTrace(TRACE_EXIT, "%s: Found one", __func__);~~
1600	1618	return TRUE;
1601	1619	}
1602	1620	}
1603	1621
1604		~~smlTrace(TRACE_EXIT, "%s: None found", __func__);~~
1605	1622	return FALSE;
1606	1623	}
…	…
1895	1912
1896	1913	//Devtyp
1897		switch (devinf->devtyp) {
1898		case SML_DEVINF_DEVTYPE_PAGER:
1899		if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, SML_ELEMENT_DEVTYP_PAGER, error))
1900		goto error_free_writer;
1901		break;
1902		case SML_DEVINF_DEVTYPE_HANDHELD:
1903		if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, SML_ELEMENT_DEVTYP_HANDHELD, error))
1904		goto error_free_writer;
1905		break;
1906		case SML_DEVINF_DEVTYPE_PDA:
1907		if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, SML_ELEMENT_DEVTYP_PDA, error))
1908		goto error_free_writer;
1909		break;
1910		case SML_DEVINF_DEVTYPE_PHONE:
1911		if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, SML_ELEMENT_DEVTYP_PHONE, error))
1912		goto error_free_writer;
1913		break;
1914		case SML_DEVINF_DEVTYPE_SMARTPHONE:
1915		if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, SML_ELEMENT_DEVTYP_SMARTPHONE, error))
1916		goto error_free_writer;
1917		break;
1918		case SML_DEVINF_DEVTYPE_SERVER:
1919		if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, SML_ELEMENT_DEVTYP_SERVER, error))
1920		goto error_free_writer;
1921		break;
1922		case SML_DEVINF_DEVTYPE_WORKSTATION:
1923		if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, SML_ELEMENT_DEVTYP_WORKSTATION, error))
1924		goto error_free_writer;
1925		break;
1926		case SML_DEVINF_DEVTYPE_UNKNOWN:
1927		smlErrorSet(error, SML_ERROR_GENERIC, "Unknown devtype");
1928		goto error_free_writer;
1929		break;
1930		}
	1914	const char *devtype = smlDevInfDevTypeToString(devinf->devtyp, error);
	1915	if (!devtype)
	1916	goto error_free_writer;
	1917
	1918	if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DEVTYPE, devtype, error))
	1919	goto error_free_writer;
1931	1920
1932	1921	//UTC (>= 1.1)

branches/dev-branch/libsyncml/parser/sml_xml_parse.c

r152	r160
24	24	#include <libsyncml/sml_elements_internals.h>
25	25	#include <libsyncml/sml_command_internals.h>
	26	#include <libsyncml/sml_devinf_internals.h>
26	27	#include <libsyncml/sml_session_internals.h>
27	28
…	…
1151	1152	}
1152	1153
1153
1154	1154	static SmlBool _smlCommandAccessParse(SmlXmlParser parser, SmlCommand cmd, SmlCommandType type, SmlError *error)
1155	1155	{
…	…
1219	1219	(*cmd)->private.access.item->contenttype = smlContentTypeFromString(contenttype, error);
1220	1220	if (!(*cmd)->private.access.item->contenttype)
	1221	goto error_free_cmd;
	1222	}
	1223
	1224	if (contenttype)
	1225	g_free(contenttype);
	1226
	1227	/* Step once more */
	1228	if (!_smlXmlParserStep(parser)) {
	1229	smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
	1230	goto error_free_cmd;
	1231	}
	1232
	1233	smlTrace(TRACE_EXIT, "%s", __func__);
	1234	return TRUE;
	1235
	1236	error_free_cmd:
	1237	smlCommandUnref(*cmd);
	1238	error:
	1239	*cmd = NULL;
	1240	if (contenttype)
	1241	g_free(contenttype);
	1242	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
	1243	return FALSE;
	1244	}
	1245
	1246	static SmlBool _smlResultsParse(SmlXmlParser parser, SmlCommand cmd, SmlError *error)
	1247	{
	1248	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, parser, cmd, error);
	1249	smlAssert(parser);
	1250	smlAssert(cmd);
	1251	char *contenttype = NULL;
	1252	char *locURI = NULL;
	1253
	1254	*cmd = smlCommandNew(SML_COMMAND_TYPE_RESULTS, error);
	1255	if (!*cmd)
	1256	goto error;
	1257	(*cmd)->refCount = 1;
	1258
	1259	(*cmd)->private.results.status = smlTryMalloc0(sizeof(SmlStatus), error);
	1260	if (!(*cmd)->private.results.status)
	1261	goto error;
	1262	(*cmd)->private.results.status->refCount = 1;
	1263	(cmd)->private.results.status->result = (cmd);
	1264	(*cmd)->private.results.status->type = SML_COMMAND_TYPE_RESULTS;
	1265
	1266	while (1) {
	1267	if (!_smlXmlParserStep(parser)) {
	1268	smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
	1269	goto error_free_cmd;
	1270	}
	1271
	1272	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_RESULTS) && \
	1273	xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
	1274	break;
	1275	} else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
	1276	smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node");
	1277	goto error_free_cmd;
	1278	}
	1279
	1280
	1281	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) {
	1282	if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error))
	1283	goto error_free_cmd;
	1284	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MSGREF)) {
	1285	if (!_smlXmlParserGetID(parser, &((*cmd)->private.results.status->msgRef), SML_ELEMENT_MSGREF, error))
	1286	goto error_free_cmd;
	1287	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDREF)) {
	1288	if (!_smlXmlParserGetID(parser, &((*cmd)->private.results.status->cmdRef), SML_ELEMENT_CMDREF, error))
	1289	goto error_free_cmd;
	1290	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCEREF)) {
	1291	if (!_smlXmlParserGetString(parser, &locURI, SML_ELEMENT_SOURCEREF, error))
	1292	goto error_free_cmd;
	1293
	1294	(*cmd)->private.results.status->sourceRef = smlLocationNew(locURI, NULL, error);
	1295	g_free(locURI);
	1296	locURI = NULL;
	1297	if (!(*cmd)->private.results.status->sourceRef)
	1298	goto error_free_cmd;
	1299	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGETREF)) {
	1300	if (!_smlXmlParserGetString(parser, &locURI, SML_ELEMENT_TARGETREF, error))
	1301	goto error_free_cmd;
	1302
	1303	(*cmd)->private.results.status->targetRef = smlLocationNew(locURI, NULL, error);
	1304	g_free(locURI);
	1305	locURI = NULL;
	1306	if (!(*cmd)->private.results.status->targetRef)
	1307	goto error_free_cmd;
	1308	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) {
	1309	(cmd)->private.results.status->item = _smlItemParse(parser, (cmd), (*cmd)->type, error);
	1310	if (!(*cmd)->private.results.status->item)
	1311	goto error_free_cmd;
	1312
	1313	(cmd)->target = (cmd)->private.results.status->item->target;
	1314	(*cmd)->private.results.status->item->target = NULL;
	1315	(cmd)->source = (cmd)->private.results.status->item->source;
	1316	(*cmd)->private.results.status->item->source = NULL;
	1317	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) {
	1318	char *format = NULL;
	1319	if (!_smlCommandMetaParse(parser, &format, &contenttype, NULL, NULL, error))
	1320	goto error_free_cmd;
	1321	g_free(format);
	1322	} else {
	1323	smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node");
	1324	goto error_free_cmd;
	1325	}
	1326	}
	1327
	1328	if (!(*cmd)->private.results.status->item) {
	1329	smlErrorSet(error, SML_ERROR_GENERIC, "Result is missing item");
	1330	goto error_free_cmd;
	1331	}
	1332
	1333	/* We only use the content type of the put command if the item itself did not have
	1334	* a content type set */
	1335	if ((*cmd)->private.results.status->item->contenttype == SML_CONTENT_TYPE_UNKNOWN) {
	1336	if (!contenttype) {
	1337	smlErrorSet(error, SML_ERROR_GENERIC, "Put is missing content type");
	1338	goto error_free_cmd;
	1339	}
	1340
	1341	(*cmd)->private.results.status->item->contenttype = smlContentTypeFromString(contenttype, error);
	1342	if (!(*cmd)->private.results.status->item->contenttype)
1221	1343	goto error_free_cmd;
1222	1344	}
…	…
1704	1826	goto error;
1705	1827	break;
	1828	case SML_COMMAND_TYPE_RESULTS:
	1829	if (!_smlResultsParse(parser, cmd, error))
	1830	goto error;
	1831	break;
1706	1832	default:
1707	1833	smlErrorSet(error, SML_ERROR_GENERIC, "Unsupported command type");
…	…
1751	1877	}
1752	1878
	1879	static SmlBool _smlXmlDevInfDataStoreParseSyncCap(SmlXmlParser parser, SmlDevInfDataStore datastore, SmlError **error)
	1880	{
	1881	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, parser, datastore, error);
	1882	smlAssert(parser);
	1883	smlAssert(datastore);
	1884
	1885	while (1) {
	1886	if (!_smlXmlParserStep(parser)) {
	1887	smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
	1888	goto error;
	1889	}
	1890
	1891	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCCAP) && \
	1892	xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
	1893	break;
	1894	} else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
	1895	smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node");
	1896	goto error;
	1897	}
	1898
	1899	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNCTYPE)) {
	1900	SmlDevInfSyncCap synccap = SML_DEVINF_SYNCTYPE_UNKNOWN;
	1901	if (!_smlXmlParserGetID(parser, &synccap, SML_ELEMENT_SYNCTYPE, error))
	1902	goto error;
	1903
	1904	if (synccap != SML_DEVINF_SYNCTYPE_UNKNOWN)
	1905	smlDevInfDataStoreSetSyncCap(datastore, synccap, TRUE);
	1906	} else {
	1907	smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node");
	1908	goto error;
	1909	}
	1910	}
	1911
	1912	smlTrace(TRACE_EXIT, "%s", __func__);
	1913	return TRUE;
	1914
	1915	error:
	1916	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
	1917	return FALSE;
	1918	}
	1919
	1920	static SmlBool _smlXmlDevInfDataStoreParseRxTx(SmlXmlParser parser, const char element, char cttype, char version, SmlError **error)
	1921	{
	1922	smlTrace(TRACE_ENTRY, "%s(%p, %s, %p, %p, %p)", __func__, parser, element, cttype, version, error);
	1923	smlAssert(parser);
	1924	smlAssert(element);
	1925	smlAssert(cttype);
	1926
	1927	while (1) {
	1928	if (!_smlXmlParserStep(parser)) {
	1929	smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
	1930	goto error;
	1931	}
	1932
	1933	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), element) && \
	1934	xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
	1935	break;
	1936	} else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
	1937	smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node");
	1938	goto error;
	1939	}
	1940
	1941	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CTTYPE)) {
	1942	if (!_smlXmlParserGetString(parser, cttype, SML_ELEMENT_CTTYPE, error))
	1943	goto error;
	1944	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_VERCT)) {
	1945	if (!_smlXmlParserGetString(parser, version, SML_ELEMENT_VERCT, error))
	1946	goto error;
	1947	} else {
	1948	smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node");
	1949	goto error;
	1950	}
	1951	}
	1952
	1953	smlTrace(TRACE_EXIT, "%s", __func__);
	1954	return TRUE;
	1955
	1956	error:
	1957	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
	1958	return FALSE;
	1959	}
	1960
	1961	static SmlBool _smlXmlDevInfDataStoreParse(SmlXmlParser parser, SmlDevInf devinf, SmlError **error)
	1962	{
	1963	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, parser, devinf, error);
	1964	smlAssert(devinf);
	1965	smlAssert(parser);
	1966
	1967	SmlDevInfDataStore *datastore = smlTryMalloc0(sizeof(SmlDevInfDataStore), error);
	1968	if (!datastore)
	1969	goto error;
	1970	datastore->refCount = 1;
	1971
	1972	if (!_smlXmlParserStep(parser)) {
	1973	smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
	1974	goto error_free_datastore;
	1975	}
	1976
	1977	while (1) {
	1978
	1979	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATASTORE) && \
	1980	xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
	1981	break;
	1982	} else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
	1983	smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node");
	1984	goto error_free_datastore;
	1985	}
	1986
	1987	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCEREF)) {
	1988	if (!_smlXmlParserGetString(parser, &(datastore->sourceref), SML_ELEMENT_SOURCEREF, error))
	1989	goto error_free_datastore;
	1990	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DISPLAYNAME)) {
	1991	if (!_smlXmlParserGetString(parser, &(datastore->displayname), SML_ELEMENT_DISPLAYNAME, error))
	1992	goto error_free_datastore;
	1993	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXGUIDSIZE)) {
	1994	if (!_smlXmlParserGetID(parser, &(datastore->maxGUIDSize), SML_ELEMENT_MAXGUIDSIZE, error))
	1995	goto error_free_datastore;
	1996	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_RXPREF)) {
	1997	if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_RXPREF, &(datastore->rxPrefContentType), &(datastore->rxPrefVersion), error))
	1998	goto error_free_datastore;
	1999	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_RX)) {
	2000	if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_RX, &(datastore->rxContentType), &(datastore->rxVersion), error))
	2001	goto error_free_datastore;
	2002	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TXPREF)) {
	2003	if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_TXPREF, &(datastore->txPrefContentType), &(datastore->txPrefVersion), error))
	2004	goto error_free_datastore;
	2005	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TX)) {
	2006	if (!_smlXmlDevInfDataStoreParseRxTx(parser, SML_ELEMENT_TX, &(datastore->txContentType), &(datastore->txVersion), error))
	2007	goto error_free_datastore;
	2008	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SHAREDMEM)) {
	2009	datastore->sharedMem = TRUE;
	2010	if (!_smlXmlParserStep(parser)) {
	2011	smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
	2012	goto error_free_datastore;
	2013	}
	2014
	2015	if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SHAREDMEM) && \
	2016	xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
	2017	if (!_smlXmlParserStep(parser)) {
	2018	smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes2");
	2019	goto error_free_datastore;
	2020	}
	2021	}
	2022	continue;
	2023	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXID)) {
	2024	if (!_smlXmlParserGetID(parser, &(datastore->maxid), SML_ELEMENT_MAXID, error))
	2025	goto error_free_datastore;
	2026	} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXMEM)) {
	2027	if (!_smlXmlParserGetID(parser, &(datastore->maxmem), SML_ELEMENT_MAXMEM, error))
	2028	goto error_free_datastore;
	2029	} else if (!strcmp((char *)xmlTextReaderC

r127	r160
26	26	SmlBool devinfSent;
27	27
28		Sml~~Command~~ *recvDevInf;
	28	SmlDevInf *recvDevInf;
29	29	};
30	30