File libsyncml0-SVN246.diff of Package libsyncml0

Overview Repositories Revisions Requests Users Attributes Meta

File libsyncml0-SVN246.diff of Package libsyncml0 (Revision 58d3b369634d7ddca652f98795ca3ef1)

Currently displaying revision 58d3b369634d7ddca652f98795ca3ef1 , Show latest

Index: Doxyfile.in
===================================================================
--- Doxyfile.in	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ Doxyfile.in	(.../trunk)	(Revision 246)
@@ -99,7 +99,7 @@
 # ordinary class members. Constructors, destructors and assignment operators of 
 # the base classes will not be shown.
 
-INLINE_INHERITED_MEMB = NO
+INLINE_INHERITED_MEMB = YES 
 
 # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
 # path before files name in the file list and in the header files. If set 
@@ -1033,7 +1033,7 @@
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section 
 # have no effect if this option is set to NO (the default)
 
-HAVE_DOT = NO
+HAVE_DOT = YES 
 
 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
 # will generate a graph for each documented class showing the direct and 
@@ -1053,7 +1053,7 @@
 # collaboration diagrams in a style similar to the OMG's Unified Modeling 
 # Language.
 
-UML_LOOK = NO
+UML_LOOK = YES
 
 # If set to YES, the inheritance and collaboration graphs will show the 
 # relations between templates and their instances.
@@ -1080,7 +1080,7 @@
 # So in most cases it will be better to enable call graphs for selected 
 # functions only using the \callgraph command.
 
-CALL_GRAPH = NO
+CALL_GRAPH = YES
 
 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
 # will graphical hierarchy of all classes instead of a textual one.
Index: libsyncml/sml_error.c
===================================================================
--- libsyncml/sml_error.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_error.c	(.../trunk)	(Revision 246)
@@ -63,12 +63,14 @@
  */
 /*@{*/
 
-void smlErrorRef(SmlError **error)
+SmlError **smlErrorRef(SmlError **error)
 {
 	if (!smlErrorIsSet(error))
-		return;
+		return error;
 	
 	g_atomic_int_inc(&(*error)->refCount);
+
+	return error;
 }
 
 void smlErrorDeref(SmlError **error)
Index: libsyncml/objects/sml_devinf_obj.c
===================================================================
--- libsyncml/objects/sml_devinf_obj.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/objects/sml_devinf_obj.c	(.../trunk)	(Revision 246)
@@ -346,8 +346,16 @@
 
 	SmlBool retval = smlDevInfAgentRegisterSession(agent, manager, NULL, error);
 
+	
+	if (!retval)
+		goto error;
+	
+	smlTrace(TRACE_EXIT, "%s", __func__);
+	return TRUE;
+
+error:
 	smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
-	return retval;
+	return FALSE;
 }
 
 /*@}*/
Index: libsyncml/objects/sml_ds_server.c
===================================================================
--- libsyncml/objects/sml_ds_server.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/objects/sml_ds_server.c	(.../trunk)	(Revision 246)
@@ -393,7 +393,7 @@
 	return NULL;
 }
 
-void smlDsSessionRef(SmlDsSession *dsession)
+SmlDsSession *smlDsSessionRef(SmlDsSession *dsession)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, dsession);
 	smlAssert(dsession);
@@ -401,6 +401,7 @@
 	g_atomic_int_inc(&(dsession->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, dsession->refCount);
+	return dsession;
 }
 
 void smlDsSessionUnref(SmlDsSession *dsession)
@@ -510,11 +511,18 @@
 		
 		dsession->syncReply = SML_NO_ERROR;
 		
+		// Now there are no more changes... do some fancy callback. Some applications will love it ;)
+		if (!dsession->recvChanges && dsession->recvEventCallback) {
+			dsession->recvEventCallback(dsession, SML_DS_EVENT_GOTCHANGES, dsession->recvEventCallbackUserdata);
+			smlTrace(TRACE_INTERNAL, "recvEventCallback no changes in recvSync callback");
+		}
+
 		smlTrace(TRACE_EXIT, "%s", __func__);
 	} else if (dsession->recvChanges && dsession->changesCallback) {
 		smlTrace(TRACE_ENTRY, "%s(%p): Dispatching changes", __func__, dsession);
 		
 		while (dsession->recvChanges) {
+
 			SmlCommand *cmd = dsession->recvChanges->data;
 			
 			if (cmd) {
@@ -527,7 +535,7 @@
 				/* We'd rather use the target of the change since it already the mapped
 				 * uid (if we are a client for example). If it is not given we use the
 				 * source uri. This has then to be translated by the sync engine of course */
-				
+
 				char *data = NULL;
 				unsigned int size = 0;
 				if (!smlItemStealData(item, &data, &size, &error))
@@ -555,8 +563,21 @@
 			
 			dsession->recvChanges = g_list_delete_link(dsession->recvChanges, dsession->recvChanges);
 		}
+
+		// Now there are no more changes... do some fancy callback. Some applications will love it ;)
+		if (dsession->recvEventCallback) {
+			dsession->recvEventCallback(dsession, SML_DS_EVENT_GOTCHANGES, dsession->recvEventCallbackUserdata);
+			smlTrace(TRACE_INTERNAL, "recvEventCallback all changes sent in recvChanges callback");
+		}
+
+		smlTrace(TRACE_EXIT, "%s", __func__);
+	} else {
+		smlTrace(TRACE_ENTRY, "%s()", __func__);
 		
-		smlTrace(TRACE_EXIT, "%s", __func__);
+		smlTrace(TRACE_INTERNAL, "recvChanges: %p changesCallback: %p", dsession->recvChanges, dsession->changesCallback); 
+
+		smlTrace(TRACE_EXIT, "%s()", __func__);
+
 	}
 
 	g_mutex_unlock(dsession->lock);
@@ -830,6 +851,21 @@
 	smlTrace(TRACE_EXIT, "%s", __func__);
 }
 
+void smlDsSessionGetEvent(SmlDsSession *dsession, SmlDsSessionEventCb eventCallback, void *userdata)
+{
+	smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, dsession, eventCallback, userdata);
+	smlAssert(dsession);
+	smlAssert(eventCallback);
+	
+	dsession->recvEventCallback = eventCallback;
+	dsession->recvEventCallbackUserdata = userdata;
+	
+	//smlDsSessionDispatch(dsession);
+	
+	smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
+
 /** @brief Start the sync command to send to the other side
  * 
  * This function will start the sync command with which the changes will be sent to the other side.
Index: libsyncml/objects/sml_ds_server_internals.h
===================================================================
--- libsyncml/objects/sml_ds_server_internals.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/objects/sml_ds_server_internals.h	(.../trunk)	(Revision 246)
@@ -66,6 +66,10 @@
 	SmlStatusReplyCb sentSyncCallback;
 	void *sentSyncCallbackUserdata;
 	
+	/** Callback that will infomration about the Ds Session events */
+	SmlDsSessionEventCb recvEventCallback;
+	void *recvEventCallbackUserdata;
+
 	/** The temporary storage for the sync command to send */
 	SmlCommand *syncCommand;
 	
Index: libsyncml/objects/sml_ds_server.h
===================================================================
--- libsyncml/objects/sml_ds_server.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/objects/sml_ds_server.h	(.../trunk)	(Revision 246)
@@ -30,11 +30,17 @@
 	SML_DS_CLIENT = 2
 } SmlDsServerType;
 
+typedef enum {
+	SML_DS_EVENT_GOTCHANGES = 0,
+	SML_DS_EVENT_COMMITEDCHANGES = 1
+} SmlDsEvent;
+
 typedef SmlErrorType (* SmlDsServerSanCb) (SmlDsServer *dsserver, SmlAlertType type, void *userdata);
 
 typedef void (* SmlDsSessionConnectCb) (SmlDsSession *dsession, void *userdata);
 typedef SmlBool (* SmlDsSessionAlertCb) (SmlDsSession *dsession, SmlAlertType type, const char *last, const char *next, void *userdata);
 typedef void (* SmlDsSessionSyncCb) (SmlDsSession *dsession, unsigned int numchanges, void *userdata);
+typedef void (* SmlDsSessionEventCb) (SmlDsSession *dsession, SmlDsEvent event, void *userdata);
 typedef SmlBool (* SmlDsSessionChangesCb) (SmlDsSession *dsession, SmlChangeType type, const char *uid, char *data, unsigned int size, const char *contenttype, void *userdata, SmlError **error);
 typedef void (* SmlDsSessionWriteCb) (SmlDsSession *dsession, SmlStatus *status, const char *newuid, void *userdata);
 
@@ -50,7 +56,7 @@
 const char *smlDsServerGetContentType(SmlDsServer *server);
 SmlDsSession *smlDsServerSendAlert(SmlDsServer *server, SmlSession *session, SmlAlertType type, const char *last, const char *next, SmlStatusReplyCb callback, void *userdata, SmlError **error);
 
-void smlDsSessionRef(SmlDsSession *dsession);
+SmlDsSession *smlDsSessionRef(SmlDsSession *dsession);
 void smlDsSessionUnref(SmlDsSession *dsession);
 void smlDsSessionDispatch(SmlDsSession *dsession);
 SmlBool smlDsSessionCheck(SmlDsSession *dsession);
@@ -58,6 +64,7 @@
 SmlBool smlDsSessionSendAlert(SmlDsSession *dsession, SmlAlertType type, const char *last, const char *next, SmlStatusReplyCb callback, void *userdata, SmlError **error);
 void smlDsSessionGetChanges(SmlDsSession *dsession, SmlDsSessionChangesCb chgCallback, void *userdata);
 void smlDsSessionGetSync(SmlDsSession *dsession, SmlDsSessionSyncCb chgCallback, void *userdata);
+void smlDsSessionGetEvent(SmlDsSession *dsession, SmlDsSessionEventCb eventCallback, void *userdata);
 SmlBool smlDsSessionSendSync(SmlDsSession *dsession, unsigned int num_changes, SmlStatusReplyCb callback, void *userdata, SmlError **error);
 SmlBool smlDsSessionQueueChange(SmlDsSession *dsession, SmlChangeType type, const char *uid, const char *data, unsigned int size, const char *contenttype, SmlDsSessionWriteCb callback, void *userdata, SmlError **error);
 SmlBool smlDsSessionCloseSync(SmlDsSession *dsession, SmlError **error);
Index: libsyncml/sml_error.h
===================================================================
--- libsyncml/sml_error.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_error.h	(.../trunk)	(Revision 246)
@@ -105,7 +105,7 @@
 	SML_ERROR_NO_MEMORY = 512
 } SmlErrorType;
 
-void smlErrorRef(SmlError **error);
+SmlError **smlErrorRef(SmlError **error);
 void smlErrorDeref(SmlError **error);
 SmlBool smlErrorIsSet(SmlError **error);
 void smlErrorSet(SmlError **error, SmlErrorType type, const char *format, ...);
Index: libsyncml/sml_devinf_internals.h
===================================================================
--- libsyncml/sml_devinf_internals.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_devinf_internals.h	(.../trunk)	(Revision 246)
@@ -39,6 +39,8 @@
 	SmlBool supportsNumberOfChanges;
 
 	GList *datastores;
+
+	GList *ctcaps;
 };
 
 struct SmlDevInfDataStore {
@@ -67,4 +69,9 @@
 	unsigned int synccap;
 };
 
+typedef struct SmlDevInfCTCap {
+	SmlDevInfCTCapType type;
+	char *value;
+} SmlDevInfCTCap;
+
 #endif //_SML_DEVINF_INTERNALS_H_
Index: libsyncml/sml_parse.c
===================================================================
--- libsyncml/sml_parse.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_parse.c	(.../trunk)	(Revision 246)
@@ -864,7 +864,7 @@
  * returns the lower one of the 2 */
 int smlAssemblerGetSendingMaxObjSize(SmlAssembler *assm)
 {
-	smlTrace(TRACE_ENTRY, "%s(%p, %u)", __func__, assm);
+	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, assm);
 	smlAssert(assm);
 	int ret = 0;
 	
Index: libsyncml/sml_devinf.c
===================================================================
--- libsyncml/sml_devinf.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_devinf.c	(.../trunk)	(Revision 246)
@@ -114,7 +114,7 @@
 	return NULL;	
 }
 
-void smlDevInfRef(SmlDevInf *devinf)
+SmlDevInf *smlDevInfRef(SmlDevInf *devinf)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, devinf);
 	smlAssert(devinf);
@@ -122,6 +122,7 @@
 	g_atomic_int_inc(&(devinf->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, devinf->refCount);
+	return devinf;
 }
 
 void smlDevInfUnref(SmlDevInf *devinf)
@@ -147,6 +148,13 @@
 		}
 		g_list_free(devinf->datastores);
 		
+		for (d = devinf->ctcaps; d; d = d->next) {
+			SmlDevInfCTCap *ctcap = d->data;
+			g_free(ctcap->value);
+			g_free(ctcap);
+		}
+		g_list_free(devinf->ctcaps);
+		
 		g_free(devinf);
 	}
 	
@@ -323,7 +331,7 @@
 }
 
 
-void smlDevInfDataStoreRef(SmlDevInfDataStore *datastore)
+SmlDevInfDataStore *smlDevInfDataStoreRef(SmlDevInfDataStore *datastore)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, datastore);
 	smlAssert(datastore);
@@ -331,6 +339,7 @@
 	g_atomic_int_inc(&(datastore->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, datastore->refCount);
+	return datastore;
 }
 
 void smlDevInfDataStoreUnref(SmlDevInfDataStore *datastore)
@@ -694,4 +703,94 @@
 	return NULL;
 }
 
+void smlDevInfAddCTCap(SmlDevInf *devinf, SmlDevInfCTCapType type, const char *value)
+{
+	smlTrace(TRACE_ENTRY, "%s(%p, %i, %s)", __func__, devinf, type, value);
+	smlAssert(devinf);
+	smlAssert(value);
+
+	SmlDevInfCTCap *ctcap = smlTryMalloc0(sizeof(SmlDevInfCTCap), NULL);
+	if (!ctcap) {
+		return;
+	}
+
+	ctcap->type = type;
+	ctcap->value = g_strdup (value);
+
+	devinf->ctcaps = g_list_append (devinf->ctcaps, ctcap);
+
+	smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
+unsigned int smlDevInfNumCTCaps(SmlDevInf *devinf)
+{
+	smlAssert(devinf);
+
+	return g_list_length(devinf->ctcaps);
+}
+
+SmlDevInfCTCapType smlDevInfGetNthCTCapType(SmlDevInf *devinf, unsigned int nth)
+{
+	smlAssert(devinf);
+
+	SmlDevInfCTCap *ctcap = g_list_nth_data(devinf->ctcaps, nth);
+	return ctcap->type;
+}
+
+const char *smlDevInfGetNthCTCapValue(SmlDevInf *devinf, unsigned int nth)
+{
+	smlAssert(devinf);
+
+	SmlDevInfCTCap *ctcap = g_list_nth_data(devinf->ctcaps, nth);
+	return ctcap->value;
+}
+
+SmlDevInfCTCapType smlDevInfCTCapTypeFromString(const char *name, SmlError **error)
+{
+	if (!strcmp(name, SML_ELEMENT_CTTYPE)) {
+		return SML_DEVINF_CTCAP_CTTYPE;
+	} else if (!strcmp(name, SML_ELEMENT_PROPNAME)) {
+		return SML_DEVINF_CTCAP_PROPNAME;
+	} else if (!strcmp(name, SML_ELEMENT_VALENUM)) {
+		return SML_DEVINF_CTCAP_VALENUM;
+	} else if (!strcmp(name, SML_ELEMENT_DATATYPE)) {
+		return SML_DEVINF_CTCAP_DATATYPE;
+	} else if (!strcmp(name, SML_ELEMENT_SIZE)) {
+		return SML_DEVINF_CTCAP_SIZE;
+	} else if (!strcmp(name, SML_ELEMENT_DISPLAYNAME)) {
+		return SML_DEVINF_CTCAP_DISPLAYNAME;
+	} else if (!strcmp(name, SML_ELEMENT_PARAMNAME)) {
+		return SML_DEVINF_CTCAP_PARAMNAME;
+	}
+	
+	smlErrorSet(error, SML_ERROR_GENERIC, "Unknown ctcap type name \"%s\"", name);
+	return SML_DEVINF_CTCAP_UNKNOWN;
+}
+
+
+const char *smlDevInfCTCapTypeToString(SmlDevInfCTCapType type, SmlError **error)
+{
+	switch (type) {
+		case SML_DEVINF_CTCAP_CTTYPE:
+			return SML_ELEMENT_CTTYPE;
+		case SML_DEVINF_CTCAP_PROPNAME:
+			return SML_ELEMENT_PROPNAME;
+		case SML_DEVINF_CTCAP_VALENUM:
+			return SML_ELEMENT_VALENUM;
+		case SML_DEVINF_CTCAP_DATATYPE:
+			return SML_ELEMENT_DATATYPE;
+		case SML_DEVINF_CTCAP_SIZE:
+			return SML_ELEMENT_SIZE;
+		case SML_DEVINF_CTCAP_DISPLAYNAME:
+			return SML_ELEMENT_DISPLAYNAME;
+		case SML_DEVINF_CTCAP_PARAMNAME:
+			return SML_ELEMENT_PARAMNAME;
+		default:
+			;
+	}
+	
+	smlErrorSet(error, SML_ERROR_GENERIC, "Unknown ctcap type \"%i\"", type);
+	return NULL;
+}
+
 /*@}*/
Index: libsyncml/sml_elements.c
===================================================================
--- libsyncml/sml_elements.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_elements.c	(.../trunk)	(Revision 246)
@@ -68,7 +68,7 @@
 	return NULL;	
 }
 
-void smlLocationRef(SmlLocation *loc)
+SmlLocation *smlLocationRef(SmlLocation *loc)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, loc);
 	smlAssert(loc);
@@ -76,6 +76,7 @@
 	g_atomic_int_inc(&(loc->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, loc->refCount);
+	return loc;
 }
 
 void smlLocationUnref(SmlLocation *loc)
@@ -342,7 +343,7 @@
 	return NULL;
 }
 
-void smlItemRef(SmlItem *item)
+SmlItem *smlItemRef(SmlItem *item)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, item);
 	smlAssert(item);
@@ -350,6 +351,7 @@
 	g_atomic_int_inc(&(item->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, item->refCount);
+	return item;
 }
 
 void smlItemUnref(SmlItem *item)
@@ -575,7 +577,7 @@
 	return NULL;	
 }
 
-void smlMapItemRef(SmlMapItem *item)
+SmlMapItem *smlMapItemRef(SmlMapItem *item)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, item);
 	smlAssert(item);
@@ -583,6 +585,7 @@
 	g_atomic_int_inc(&(item->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, item->refCount);
+	return item;
 }
 
 void smlMapItemUnref(SmlMapItem *item)
Index: libsyncml/sml_command.c
===================================================================
--- libsyncml/sml_command.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_command.c	(.../trunk)	(Revision 246)
@@ -138,7 +138,7 @@
 	return NULL;
 }
 
-void smlStatusRef(SmlStatus *status)
+SmlStatus *smlStatusRef(SmlStatus *status)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, status);
 	smlAssert(status);
@@ -146,6 +146,7 @@
 	g_atomic_int_inc(&(status->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, status->refCount);
+	return status;
 }
 
 void smlStatusUnref(SmlStatus *status)
@@ -280,7 +281,7 @@
 	return NULL;
 }
 
-void smlCommandRef(SmlCommand *cmd)
+SmlCommand *smlCommandRef(SmlCommand *cmd)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, cmd);
 	smlAssert(cmd);
@@ -288,6 +289,7 @@
 	g_atomic_int_inc(&(cmd->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, cmd->refCount);
+	return cmd;
 }
 
 void smlCommandUnref(SmlCommand *cmd)
Index: libsyncml/sml_devinf.h
===================================================================
--- libsyncml/sml_devinf.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_devinf.h	(.../trunk)	(Revision 246)
@@ -25,7 +25,7 @@
 const char *smlDevInfDevTypeToString(SmlDevInfDevTyp type, SmlError **error);
 
 SmlDevInf *smlDevInfNew(const char *devid, SmlDevInfDevTyp devtyp, SmlError **error);
-void smlDevInfRef(SmlDevInf *devinf);
+SmlDevInf *smlDevInfRef(SmlDevInf *devinf);
 void smlDevInfUnref(SmlDevInf *devinf);
 
 const char *smlDevInfGetManufacturer(SmlDevInf *devinf);
@@ -56,7 +56,7 @@
 SmlDevInfDataStore *smlDevInfGetNthDataStore(SmlDevInf *devinf, unsigned int nth);
 
 SmlDevInfDataStore *smlDevInfDataStoreNew(const char *sourceRef, SmlError **error);
-void smlDevInfDataStoreRef(SmlDevInfDataStore *datastore);
+SmlDevInfDataStore *smlDevInfDataStoreRef(SmlDevInfDataStore *datastore);
 void smlDevInfDataStoreUnref(SmlDevInfDataStore *datastore);
 
 const char *smlDevInfDataStoreGetSourceRef(SmlDevInfDataStore *datastore);
@@ -88,4 +88,12 @@
 SmlDevInf *smlDevInfParse(const char *data, unsigned int length, SmlError **error);
 SmlDevInf *smlDevInfFromResult(SmlCommand *result, SmlError **error);
 
+void smlDevInfAddCTCap(SmlDevInf *devinf, SmlDevInfCTCapType type, const char *value);
+unsigned int smlDevInfNumCTCaps(SmlDevInf *devinf);
+SmlDevInfCTCapType smlDevInfGetNthCTCapType(SmlDevInf *devinf, unsigned int nth);
+const char *smlDevInfGetNthCTCapValue(SmlDevInf *devinf, unsigned int nth);
+
+SmlDevInfCTCapType smlDevInfCTCapTypeFromString(const char *name, SmlError **error);
+const char *smlDevInfCTCapTypeToString(SmlDevInfCTCapType type, SmlError **error);
+
 #endif //_SML_DEVINF_H_
Index: libsyncml/sml_elements.h
===================================================================
--- libsyncml/sml_elements.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_elements.h	(.../trunk)	(Revision 246)
@@ -22,7 +22,7 @@
 #define _SML_ELEMENTS_H_
 
 SmlLocation *smlLocationNew			(const char *locURI, const char *locName, SmlError **error);
-void 		smlLocationRef			(SmlLocation *loc);
+SmlLocation *smlLocationRef			(SmlLocation *loc);
 void 		smlLocationUnref		(SmlLocation *loc);
 
 const char	*smlLocationGetURI		(SmlLocation *loc);
@@ -37,7 +37,7 @@
 
 SmlItem *smlItemNew(unsigned int size, SmlError **error);
 SmlItem *smlItemNewForData(const char *data, unsigned int size, SmlError **error);
-void smlItemRef(SmlItem *item);
+SmlItem *smlItemRef(SmlItem *item);
 void smlItemUnref(SmlItem *item);
 SmlBool smlItemAddData(SmlItem *item, const char *data, unsigned int size, SmlError **error);
 SmlBool smlItemCheck(SmlItem *item);
@@ -57,7 +57,7 @@
 void smlChalFree(SmlChal *chal);
 
 SmlMapItem *smlMapItemNew(const char *uid, const char *newuid, SmlError **error);
-void smlMapItemRef(SmlMapItem *item);
+SmlMapItem *smlMapItemRef(SmlMapItem *item);
 void smlMapItemUnref(SmlMapItem *item);
 
 #endif //_SML_ELEMENTS_H_
Index: libsyncml/sml_session.c
===================================================================
--- libsyncml/sml_session.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_session.c	(.../trunk)	(Revision 246)
@@ -1154,7 +1154,7 @@
 	return NULL;
 }
 
-void smlSessionRef(SmlSession *session)
+SmlSession *smlSessionRef(SmlSession *session)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, session);
 	smlAssert(session);
@@ -1162,6 +1162,7 @@
 	g_atomic_int_inc(&(session->refCount));
 	
 	smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, session->refCount);
+	return session;
 }
 
 void smlSessionUnref(SmlSession *session)
Index: libsyncml/sml_command.h
===================================================================
--- libsyncml/sml_command.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_command.h	(.../trunk)	(Revision 246)
@@ -22,7 +22,7 @@
 #define _SML_COMMAND_H_
 
 SmlStatus *smlStatusNew(SmlErrorType data, unsigned int cmdref, unsigned int msgref, SmlLocation *sourceref, SmlLocation *targeref, SmlCommandType type, SmlError **error);
-void smlStatusRef(SmlStatus *status);
+SmlStatus *smlStatusRef(SmlStatus *status);
 void smlStatusUnref(SmlStatus *status);
 SmlErrorType smlStatusGetCode(SmlStatus *status);
 SmlErrorClass smlStatusGetClass(SmlStatus *status);
@@ -31,7 +31,7 @@
 
 SmlCommand *smlCommandNew(SmlCommandType type, SmlError **error);
 SmlStatus *smlCommandNewReply(SmlCommand *cmd, SmlErrorType code, SmlError **error);
-void smlCommandRef(SmlCommand *cmd);
+SmlCommand *smlCommandRef(SmlCommand *cmd);
 void smlCommandUnref(SmlCommand *cmd);
 
 SmlCommand *smlCommandNewAlert(SmlAlertType type, SmlLocation *target, SmlLocation *source, const char *next, const char *last, const char *contenttype, SmlError **error);
Index: libsyncml/sml_session.h
===================================================================
--- libsyncml/sml_session.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_session.h	(.../trunk)	(Revision 246)
@@ -41,7 +41,7 @@
 
 /* Session Management */
 SmlSession *smlSessionNew(SmlSessionType sessionType, SmlMimeType mimetype, SmlProtocolVersion version, SmlProtocolType protocol, SmlLocation *target, SmlLocation *source, const char *sessionID, unsigned int messageID, SmlError **error);
-void smlSessionRef(SmlSession *session);
+SmlSession *smlSessionRef(SmlSession *session);
 void smlSessionUnref(SmlSession *session);
 void smlSessionSetEventCallback(SmlSession *session, SmlSessionEventCallback callback, void *userdata);
 void smlSessionSetDataCallback(SmlSession *session, SmlSessionDataCallback callback, void *userdata);
Index: libsyncml/sml_transport.c
===================================================================
--- libsyncml/sml_transport.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_transport.c	(.../trunk)	(Revision 246)
@@ -135,7 +135,7 @@
 /** @brief Asynchronously runs the transport
  * 
  * This function will spawn a new thread in which the transport is
- * dispatched. The transport must be in the state "Initialized".
+ * dispatched. The transport must be in the state "Uninitialized".
  * 
  * @param tsp The transport
  * @param error Return location if an error occured
@@ -269,7 +269,7 @@
 	return NULL;
 }
 
-void smlTransportDataRef(SmlTransportData *data)
+SmlTransportData *smlTransportDataRef(SmlTransportData *data)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, data);
 	smlAssert(data);
@@ -277,6 +277,7 @@
 	g_atomic_int_inc(&data->refCount);
 	
 	smlTrace(TRACE_EXIT, "%s", __func__);
+	return data;
 }
 
 void smlTransportDataDeref(SmlTransportData *data)
@@ -368,7 +369,7 @@
 	return NULL;
 }
 
-void smlLinkRef(SmlLink *link)
+SmlLink *smlLinkRef(SmlLink *link)
 {
 	smlTrace(TRACE_ENTRY, "%s(%p)", __func__, link);
 	smlAssert(link);
@@ -376,6 +377,7 @@
 	g_atomic_int_inc(&link->refCount);
 	
 	smlTrace(TRACE_EXIT, "%s", __func__);
+	return link;
 }
 
 void smlLinkDeref(SmlLink *link)
Index: libsyncml/parser/sml_xml_assm.c
===================================================================
--- libsyncml/parser/sml_xml_assm.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/parser/sml_xml_assm.c	(.../trunk)	(Revision 246)
@@ -1959,6 +1959,24 @@
 			goto error_free_buffer;
 	}
 
+	// CTCap
+	if (devinf->ctcaps) {
+		if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_CTCAP, error))
+			goto error;
+		
+		for (d = devinf->ctcaps; d; d = d->next) {
+			SmlDevInfCTCap *ctcap = d->data;
+			const char *element_name;
+			if (!(element_name = smlDevInfCTCapTypeToString(ctcap->type, error)))
+				goto error;
+			if (!_smlXmlAssemblerAddString(assm, element_name, ctcap->value, error))
+				goto error;
+		}
+		
+		if (!_smlXmlAssemblerEndNode(assm, error))
+			goto error;
+	}
+
 	//Devinf
 	if (!_smlXmlAssemblerEndNode(assm, error))
 		goto error;
Index: libsyncml/parser/sml_xml_parse.c
===================================================================
--- libsyncml/parser/sml_xml_parse.c	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/parser/sml_xml_parse.c	(.../trunk)	(Revision 246)
@@ -1602,7 +1602,7 @@
 	if (parser->reader)
 		xmlFreeTextReader(parser->reader);
 	
-	xmlCleanupParser();
+	//xmlCleanupParser();
 	
 	g_free(parser);
 
@@ -2400,13 +2400,37 @@
 			if (!_smlXmlDevInfDataStoreParse(parser, devinf, error))
 				goto error_free_devinf;
 		} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CTCAP)) {
-			/* Ignored for now */
-			smlTrace(TRACE_INTERNAL, "Skipping ctcap node");
-			if (xmlTextReaderNext(parser->reader) != 1) {
-				smlErrorSet(error, SML_ERROR_GENERIC, "Unable to skip ctcap node");
-				goto error_free_parser;
+			if (!_smlXmlParserStep(parser)) {
+				smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
+				goto error_free_devinf;
 			}
-			continue;
+			
+			while (1) {
+				if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CTCAP) &&
+				    xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) {
+					break;
+				} else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) {
+					smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node");
+					goto error_free_devinf;
+				}
+				
+				const char *elem_name;
+				char *value = NULL;
+				SmlDevInfCTCapType type;
+				
+				elem_name = (const char*)xmlTextReaderConstName(parser->reader);
+				type = smlDevInfCTCapTypeFromString(elem_name, NULL);
+				if (type != SML_DEVINF_CTCAP_UNKNOWN) {
+					_smlXmlParserGetString(parser, &value, elem_name, error);
+					smlDevInfAddCTCap(devinf, type, value);
+					g_free(value);
+				}
+
+				if (!_smlXmlParserStep(parser)) {
+					smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes");
+					goto error_free_devinf;
+				}
+			}
 		} else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_EXT)) {
 			/* Ignored for now */
 			smlTrace(TRACE_INTERNAL, "Skipping ext node");
Index: libsyncml/sml_transport.h
===================================================================
--- libsyncml/sml_transport.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_transport.h	(.../trunk)	(Revision 246)
@@ -39,11 +39,11 @@
 SmlBool smlTransportDisconnect(SmlTransport *tsp, SmlLink *link, SmlError **error);
 SmlBool smlTransportSend(SmlTransport *tsp, SmlLink *link, SmlTransportData *data, SmlError **error);
 SmlTransportData *smlTransportDataNew(char *data, unsigned long size, SmlMimeType mimetype, SmlBool ownsData, SmlError **error);
-void smlTransportDataRef(SmlTransportData *data);
+SmlTransportData *smlTransportDataRef(SmlTransportData *data);
 void smlTransportDataDeref(SmlTransportData *data);
 SmlLink *smlLinkNew(SmlTransport *tsp, void *link_data, SmlError **error);
 SmlLink *smlLinkFind(SmlTransport *tsp, void *link_data);
-void smlLinkRef(SmlLink *link);
+SmlLink *smlLinkRef(SmlLink *link);
 void smlLinkDeref(SmlLink *link);
 void smlTransportSetError(SmlTransport *tsp, SmlLink *link, SmlError **error);
 SmlTransportType smlTransportGetType(SmlTransport *tsp);
Index: libsyncml/sml_defines.h
===================================================================
--- libsyncml/sml_defines.h	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ libsyncml/sml_defines.h	(.../trunk)	(Revision 246)
@@ -160,6 +160,17 @@
 	SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC = 1 << 6
 } SmlDevInfSyncCap;
 
+typedef enum {
+	SML_DEVINF_CTCAP_UNKNOWN,
+	SML_DEVINF_CTCAP_CTTYPE,
+	SML_DEVINF_CTCAP_PROPNAME,
+	SML_DEVINF_CTCAP_VALENUM,
+	SML_DEVINF_CTCAP_DATATYPE,
+	SML_DEVINF_CTCAP_SIZE,
+	SML_DEVINF_CTCAP_DISPLAYNAME,
+	SML_DEVINF_CTCAP_PARAMNAME
+} SmlDevInfCTCapType;
+
 #define SML_ELEMENT_TEXT_VCARD "text/x-vcard"
 #define SML_ELEMENT_TEXT_VCAL "text/x-vcalendar"
 #define SML_ELEMENT_TEXT_PLAIN "text/plain"
Index: TODO
===================================================================
--- TODO	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ TODO	(.../trunk)	(Revision 246)
@@ -1 +0,0 @@
-
Index: NEWS
===================================================================
--- NEWS	(.../tags/libsyncml-0.4.4)	(Revision 246)
+++ NEWS	(.../trunk)	(Revision 246)
@@ -1 +0,0 @@
-

Places

File libsyncml0-SVN246.diff of Package libsyncml0 (Revision 58d3b369634d7ddca652f98795ca3ef1)

Places