Changeset 169

Timestamp:

05/24/06 16:43:46 (2 years ago)

Author:

abauer

Message:

Fixed some bugs

ds server can now configure things like largeObject handling,
support for number of changes etc without needing a devinf

Files:

• branches/dev-branch/libsyncml/objects/sml_auth.c (modified) (1 diff)
• branches/dev-branch/libsyncml/parser/sml_xml_assm.c (modified) (13 diffs)
• branches/dev-branch/libsyncml/parser/sml_xml_parse.c (modified) (6 diffs)
• branches/dev-branch/libsyncml/sml_command_internals.h (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_devinf.c (modified) (2 diffs)
• branches/dev-branch/libsyncml/sml_devinf.h (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_elements.c (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_elements.h (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_elements_internals.h (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_parse.c (modified) (2 diffs)
• branches/dev-branch/libsyncml/sml_parse.h (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_session.c (modified) (7 diffs)
• branches/dev-branch/libsyncml/sml_session.h (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_session_internals.h (modified) (1 diff)
• branches/dev-branch/libsyncml/sml_support.c (modified) (1 diff)
• branches/dev-branch/tests/check_obex.c (modified) (4 diffs)
• branches/dev-branch/tests/check_sync.c (modified) (4 diffs)
• branches/dev-branch/tools/syncml-obex-client.c (modified) (5 diffs)

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

@@ -108 +108 @@
-        }
-        
-
+
+
-                session->end = TRUE;
+        }
-        
-        reply = smlAuthHeaderReply(session, auth->state, &error);

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

@@ -198 +198 @@
-}
-
-Bool raw, unsigned int complete_size, Sml
-
-i, %i, %p)", __func__, item, assm, raw, complete_size
+
+
+p)", __func__, item, assm
-        smlAssert(assm);
-        smlAssert(item);
@@ -222 +222 @@
-        }
-        
-        //Meta
-        /*if (complete_size) {
-                if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error))
-                        goto error;
-                        
-                if (!_smlXmlAssemblerAddIDNS(assm, NULL, SML_ELEMENT_SIZE, SML_NAMESPACE_METINF, complete_size, error))
-                        goto error;
-        
-                //META
-                if (!_smlXmlAssemblerEndNode(assm, error))
-                        goto error;
-        }*/
-        
-        if (smlItemHasData(item)) {
-                if (item->disabled) {
-
+item->
-                                goto error;
-                } else {
@@ -245 +232 @@
-                                goto error;
-                        
-
+item->
-                                goto error;
-                }
@@ -347 +334 @@
-                goto error;
-        
-FALSE, 0, 
+
-                goto error;
-        
@@ -381 +368 @@
-                goto error;
-        
-
+
+
+
-                if (!_smlXmlAssemblerAddIDNS(assm, SML_ELEMENT_SIZE, SML_NAMESPACE_METINF, change->size, error))
-                        goto error;
@@ -390 +379 @@
-                goto error;
-        
-const char *
+
-        if (opt && atoi(opt) && change->type == SML_COMMAND_TYPE_ADD) {
-                change->private.change.item->target = change->private.change.item->source;
@@ -396 +385 @@
-        }
-        
-FALSE, change->size, 
+
-                goto error;
-        
@@ -418 +407 @@
-        }
-        
-
+
+
+
-                if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error))
-                        goto error;
@@ -441 +432 @@
-                goto error;
-        
-
+
+
+
-                if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_NUMBEROFCHANGES, cmd->private.sync.numChanged, error))
-                        goto error;
-*/
+
-        
-        smlTrace(TRACE_EXIT, "%s", __func__);
@@ -605 +598 @@
-                goto error;
-        
-TRUE, 0, 
+
-                goto error;
-        
@@ -712 +705 @@
-                goto error_free_writer;
-        
-
+
+
+
-                if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error))
-                        goto error_free_writer;
@@ -721 +716 @@
-                }
-                
-if (
+/*if (supportsLargeObjects && 
-                        if (!_smlXmlAssemblerAddIDNS(assm, SML_ELEMENT_MAXOBJSIZE, SML_NAMESPACE_METINF, session->incomingMaxObjSize, error))
-                                goto error_free_writer;
-
+*/
-                
-                //META
@@ -1556 +1551 @@
-SmlBool smlXmlAssemblerRun(SmlXmlAssembler *assm, char **data, unsigned int *size, SmlBool *end, SmlBool final, unsigned int maxsize, SmlError **error)
-{
-
+
+
+
+
-}
-

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

@@ -492 +492 @@
-}
-
-unsigned 
+
-{
-        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, parser, maxobjsize, error);
@@ -519 +519 @@
-                        goto error;
-                } else if (maxobjsize && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXOBJSIZE)) {
-
+
+
-                                goto error;
+                        *maxobjsize = loc_maxobjsize;
-                } else {
-                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderConstName(parser->reader));
@@ -985 +987 @@
-        if (!*cmd)
-                goto error;
+        (*cmd)->private.sync.maxObjSize = -1;
-        
-        while (1) {
@@ -1021 +1024 @@
-                                goto error_free_cmd;
-                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NUMBEROFCHANGES)) {
+                        (*cmd)->private.sync.hasNumChanged = TRUE;
-                        if (!_smlXmlParserGetID(parser, &((*cmd)->private.sync.numChanged), SML_ELEMENT_NUMBEROFCHANGES, error))
-                                goto error_free_cmd;
@@ -1367 +1371 @@
-        char *debugstr = smlPrintBinary(data, size);
-        smlTrace(TRACE_INTERNAL, "Xml input: %s", debugstr);
+        smlLog("received-%i.xml", data, size);
-        g_free(debugstr);
-        
@@ -2049 +2054 @@
-        }
-        
+        smlDevInfAddDataStore(devinf, datastore);
+        
-        smlTrace(TRACE_EXIT, "%s", __func__);
-        return TRUE;

branches/dev-branch/libsyncml/sml_command_internals.h

@@ -29 +29 @@
-
-typedef struct SmlCommandSyncPrivate {
-unsigned 
+
-        unsigned int maxObjSize;
+        SmlBool hasNumChanged;
-} SmlCommandSyncPrivate;
-

branches/dev-branch/libsyncml/sml_devinf.c

@@ -513 +513 @@
-}
-
+void smlDevInfConfigureSession(SmlDevInf *devinf, SmlSession *session)
+{
+        smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, devinf, session);
+        smlAssert(devinf);
+        smlAssert(session);
+        
+        if (!devinf->supportsNumberOfChanges)
+                smlSessionUseNumberOfChanges(session, FALSE);
+                
+        if (!devinf->supportsLargeObjs)
+                smlSessionUseLargeObjects(session, FALSE);
+                
+        smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
-SmlCommand *smlDevInfNewResult(SmlCommand *cmd, SmlDevInf *devinf, SmlDevInfVersion version, SmlError **error)
-{
@@ -579 +594 @@
-                goto error_free_cmd;
-        }
+        smlItemSetRaw(cmd->private.access.item, TRUE);
-        
-        smlTrace(TRACE_EXIT, "%s: %p", __func__, cmd);

branches/dev-branch/libsyncml/sml_devinf.h

@@ -83 +83 @@
-SmlCommand *smlDevInfNewGet(SmlDevInfVersion version, SmlError **error);
-
+void smlDevInfConfigureSession(SmlDevInf *devinf, SmlSession *session);
+
-SmlDevInf *smlDevInfParse(const char *data, unsigned int length, SmlError **error);
-SmlDevInf *smlDevInfFromResult(SmlCommand *result, SmlError **error);

branches/dev-branch/libsyncml/sml_elements.c

@@ -507 +507 @@
-}
-
+void smlItemSetRaw(SmlItem *item, SmlBool raw)
+{
+        smlAssert(item);
+        
+        item->raw = raw;
+}
+
-void smlCredFree(SmlCred *cred)
-{

branches/dev-branch/libsyncml/sml_elements.h

@@ -50 +50 @@
-void smlItemSetTarget(SmlItem *item, SmlLocation *target);
-SmlLocation *smlItemGetTarget(SmlItem *item);
+void smlItemSetRaw(SmlItem *item, SmlBool raw);
-
-void smlHeaderFree(SmlHeader *header);

branches/dev-branch/libsyncml/sml_elements_internals.h

@@ -50 +50 @@
-        
-        SmlBool disabled;
+        /** If set to true, libsyncml will omit the cdata tags */
+        SmlBool raw;
-};
-

branches/dev-branch/libsyncml/sml_parse.c

@@ -121 +121 @@
-        smlAssert(size);
-        smlAssert(parser->functions.start);
-        
-        smlLog("received-%i.xml", data, size);
-                
-        if (parser->limit && size > parser->limit) {
@@ -399 +397 @@
-        if (!assm->functions.run(assm->assm_userdata, data, size, end, final, smlAssemblerGetLimit(assm), error))
-                goto error;
-                
-        smlLog("sent-%i.xml", *data, *size);
-        
-        smlTrace(TRACE_EXIT, "%s", __func__);

branches/dev-branch/libsyncml/sml_parse.h

@@ -111 +111 @@
-void smlAssemblerSetRequestedLimit(SmlAssembler *assm, unsigned int limit);
-void smlAssemblerSetLimit(SmlAssembler *assm, unsigned int limit);
+unsigned int smlSessionGetSendingLimit(SmlSession *session);
-SmlBool smlAssemblerGetSpace(SmlAssembler *assm, int *space, SmlCommand *parent, SmlCommand *cmd, SmlError **error);
-unsigned int smlAssemblerGetMaxObjSize(SmlAssembler *assm);

branches/dev-branch/libsyncml/sml_session.c

@@ -481 +481 @@
-        switch (sesscmd->type) {
-                case SML_SESSION_FLUSH:
-
+ {
-                                session->end = TRUE;
+                                smlTrace(TRACE_INTERNAL, "End on flush was set");
+                        }
-                        if (!_smlSessionFlushInternal(session, sesscmd->final, &error))
-                                goto error;
@@ -571 +573 @@
-        
-        smlAssemblerSetRequestedLimit(session->assembler, header->maxmsgsize);
-
+//
-        
-        /* Reserve the status for header reply. It will always be cmdRef 0
@@ -703 +705 @@
-                                        goto error_free_cmd;
-                                }
+                                
+                                /* If we are a server, we just mimick the behaviour of the client regarding
+                                 * large object handling and support of number of changes. This way we dont
+                                 * need to parse the devinf */
+                                if (cmd->type == SML_COMMAND_TYPE_SYNC) {
+                                        smlTrace(TRACE_INTERNAL, "maxObjSize: %i, numbOfChanges: %i, %i", cmd->private.sync.maxObjSize, cmd->private.sync.hasNumChanged, cmd->private.sync.numChanged);
+                                        if (cmd->private.sync.maxObjSize != -1)
+                                                smlAssemblerSetRequestedMaxObjSize(session->assembler, cmd->private.sync.maxObjSize);
+                                
+                                        if (session->sessionType == SML_SESSION_TYPE_SERVER) {
+                                                if (cmd->private.sync.maxObjSize == -1)
+                                                        smlSessionUseLargeObjects(session, FALSE);
+                                                        
+                                                if (cmd->private.sync.hasNumChanged == FALSE)
+                                                        smlSessionUseNumberOfChanges(session, FALSE);
+                                        }
+                                }
+                                
-                                
-                                session->parentCommand = cmd;
@@ -1073 +1093 @@
-        else
-                session->lastMessageID = 1;
-       
+
-        session->end = FALSE;
-        session->sessionType = sessionType;
-        session->lastCommandID = 0;
-        session->supportsNumberOfChanges = TRUE;
-        session->supportsLargeObjects = TRUE;
-        
-        if (sessionType == SML_SESSION_TYPE_CLIENT)
@@ -1269 +1287 @@
-}
-
+void smlSessionUseNumberOfChanges(SmlSession *session, SmlBool support)
+{
+        smlTrace(TRACE_ENTRY, "%s(%p, %i)", __func__, session, support);
+        smlAssert(session);
+        
+        smlAssemblerSetOption(session->assembler, "USE_NUMBEROFCHANGES", support ? "1" : "0");
+        
+        smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
+void smlSessionUseLargeObjects(SmlSession *session, SmlBool support)
+{
+        smlTrace(TRACE_ENTRY, "%s(%p, %i)", __func__, session, support);
+        smlAssert(session);
+        
+        smlAssemblerSetOption(session->assembler, "USE_LARGEOBJECTS", support ? "1" : "0");
+        
+        smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
-void smlSessionUseOnlyReplace(SmlSession *session, SmlBool onlyReplace)
-{
@@ -1290 +1328 @@
-}
-
+unsigned int smlSessionGetSendingLimit(SmlSession *session)
+{
+        smlAssert(session);
+        return smlAssemblerGetLimit(session->assembler);
+}
+
-void smlSessionSetReceivingLimit(SmlSession *session, unsigned int limit)
-{
@@ -1308 +1352 @@
-        
-        smlTrace(TRACE_EXIT, "%s", __func__);
+}
+
+unsigned int smlSessionGetMaxObjSize(SmlSession *session)
+{
+        smlAssert(session);
+        return smlAssemblerGetMaxObjSize(session->assembler);
-}
-

branches/dev-branch/libsyncml/sml_session.h

@@ -52 +52 @@
-void smlSessionUseStringTable(SmlSession *session, SmlBool useStringtable);
-void smlSessionUseOnlyReplace(SmlSession *session, SmlBool onlyReplace);
+void smlSessionUseNumberOfChanges(SmlSession *session, SmlBool support);
+void smlSessionUseLargeObjects(SmlSession *session, SmlBool support);
-void smlSessionSetSendingLimit(SmlSession *session, unsigned int limit);
-void smlSessionSetReceivingLimit(SmlSession *session, unsigned int limit);
-void smlSessionSetSendingMaxObjSize(SmlSession *session, unsigned int limit);
+unsigned int smlSessionGetMaxObjSize(SmlSession *session);
-void smlSessionSetReceivingMaxObjSize(SmlSession *session, unsigned int limit);
-const char *smlSessionGetSessionID(SmlSession *session);

branches/dev-branch/libsyncml/sml_session_internals.h

@@ -31 +31 @@
-        SmlAssembler *assembler;
-        SmlBool onlyReplace;
-        
-        SmlBool supportsNumberOfChanges;
-        SmlBool supportsLargeObjects;
-        
-        SmlSessionEventCallback eventCallback;

branches/dev-branch/libsyncml/sml_support.c

@@ -73 +73 @@
-        char *logfile = NULL;
-        for (;;i = i + 1) {
-
+
+
+
-                if (!g_file_test(logfile, G_FILE_TEST_EXISTS))
-                        break;

branches/dev-branch/tests/check_obex.c

@@ -307 +307 @@
-        smlTransportDataDeref(data);
-
+        while (server_receives < 1) { usleep(50); };
+
-        fail_unless(smlTransportDisconnect(client, NULL, &error), NULL);
-        fail_unless(error == NULL, NULL);
-        
-1 && client_errors < 2
+2 && client_errors < 1
-        
-        fail_unless(client_receives == 0, NULL);
-        fail_unless(server_receives == 1, NULL);
-        fail_unless(client_connect_done == 2, NULL);
-1
-2
+2
+1
-        
-        smlTransportStop(client);
@@ -566 +568 @@
-        fail_unless(error == NULL, NULL);
-        
-2
+6
-        
-        fail_unless(client_receives == 3, NULL);
@@ -805 +807 @@
-        fail_unless(error == NULL, NULL);
-        
-2
+1
-        
-        fail_unless(client_receives == 0, NULL);
@@ -811 +813 @@
-        fail_unless(client_connect_done == 1, NULL);
-        fail_unless(client_disconnect_done == 1, NULL);
-2
+1
-        
-        smlTransportStop(client);

branches/dev-branch/tests/check_sync.c

@@ -26 +26 @@
-#include <libsyncml/transports/http_client.h>
-#include <libsyncml/transports/http_server.h>
+
+#include <libsyncml/objects/sml_devinf_obj.h>
-
-#define NUM_SESSIONS 30
@@ -224 +226 @@
-        smlTrace(TRACE_ENTRY, "%s()", __func__);
-        
+        fail_unless(numChanges != 87, NULL);
-        syncs_received++;
-                
@@ -1038 +1041 @@
-END_TEST
-
+/* client -- 3 * alert ---> server
+ * server -- statuses, 3 * alert ---> client
+ * client -- statuses, num * add, num * replace, num * delete ---> server
+ * server -- statuses ---> client
+ */
+START_TEST (sync_multi_conf_from_devinf)
+{
+        int num_items = 1;
+        
+        init_alerts_received = 0;
+        alerts_received = 0;
+        syncs_received = 0;
+        sync_ends_received = 0;
+        changes_received = 0;
+        replies_received = 0;
+        adds_received = 0;
+        add_replies_received = 0;
+        deletes_received = 0;
+        delete_replies_received = 0;
+        modifies_received = 0;
+        modify_replies_received = 0;
+        session_ends = 0;
+        
+        transport_errors = 0;
+        num_sessions = 0;
+        num_finals = 0;
+        num_end = 0;
+        session_errors = 0;
+
+        setup_testbed(NULL);
+        
+        SmlError *error = NULL;
+        SmlTransport *server = smlTransportNew(SML_TRANSPORT_HTTP_SERVER, &error);
+        SmlTransport *client = smlTransportNew(SML_TRANSPORT_HTTP_CLIENT, &error);
+        
+        SmlTransportHttpClientConfig clientConfig;
+        clientConfig.port = 12004;
+        clientConfig.url = "http://127.0.0.1:12004";
+        clientConfig.proxy = NULL;
+        
+        SmlTransportHttpServerConfig serverConfig;
+        serverConfig.port = 12004;
+        serverConfig.url = NULL;
+        serverConfig.interface = NULL;
+        
+        managerTracker *clienttracker = g_malloc0(sizeof(managerTracker));
+        SmlManager *clientmanager = clienttracker->manager = smlManagerNew(client, &error);
+        smlManagerSetEventCallback(clienttracker->manager, _manager_event, clienttracker);
+        managerTracker *servertracker = g_malloc0(sizeof(managerTracker));
+        SmlManager *servermanager = servertracker->manager = smlManagerNew(server, &error);
+        smlManagerSetEventCallback(servertracker->manager, _manager_event, servertracker);
+        
+        fail_unless(smlTransportInitialize(client, &clientConfig, &error), NULL);
+        fail_unless(smlTransportInitialize(server, &serverConfig, &error), NULL);
+
+        fail_unless(smlManagerStart(clientmanager, &error), NULL);
+        fail_unless(error == NULL, NULL);
+        fail_unless(smlManagerStart(servermanager, &error), NULL);
+        fail_unless(error == NULL, NULL);
+
+        SmlLocation *loc = smlLocationNew("test", NULL, &error);
+        fail_unless(loc != NULL, NULL);
+        fail_unless(error == NULL, NULL);
+        
+        SmlLocation *loc1 = smlLocationNew("test1", NULL, &error);
+        fail_unless(loc1 != NULL, NULL);
+        fail_unless(error == NULL, NULL);
+        
+        SmlLocation *loc2 = smlLocationNew("test2", NULL, &error);
+        fail_unless(loc2 != NULL, NULL);
+        fail_unless(error == NULL, NULL);
+        
+        SmlLocation *loc3 = smlLocationNew("test3", NULL, &error);
+        fail_unless(loc3 != NULL, NULL);
+        fail_unless(error == NULL, NULL);
+        
+        clienttracker->ds[0] = smlDsClientNew(SML_ELEMENT_TEXT_VCARD, loc1, loc1, &error);
+        clienttracker->ds[1] = smlDsClientNew(SML_ELEMENT_TEXT_VCAL, loc2, loc2, &error);
+        clienttracker->ds[2] = smlDsClientNew(SML_ELEMENT_TEXT_PLAIN, loc3, loc3, &error);
+        smlDsServerRegister(clienttracker->ds[0], clientmanager, &error);
+        smlDsServerRegister(clienttracker->ds[1], clientmanager, &error);
+        smlDsServerRegister(clienttracker->ds[2], clientmanager, &error);
+                                
+        servertracker->ds[0] = smlDsServerNew(SML_ELEMENT_TEXT_VCARD, loc1, &error);
+        servertracker->ds[1] = smlDsServerNew(SML_ELEMENT_TEXT_VCAL, loc2, &error);
+        servertracker->ds[2] = smlDsServerNew(SML_ELEMENT_TEXT_PLAIN, loc3, &error);
+        smlDsServerSetConnectCallback(servertracker->ds[0], _recv_init_alert, servertracker);
+        smlDsServerSetConnectCallback(servertracker->ds[1], _recv_init_alert, servertracker);
+        smlDsServerSetConnectCallback(servertracker->ds[2], _recv_init_alert, servertracker);
+        smlDsServerRegister(servertracker->ds[0], servermanager, &error);
+        smlDsServerRegister(servertracker->ds[1], servermanager, &error);
+        smlDsServerRegister(servertracker->ds[2], servermanager, &error);
+        
+        /* The devinf obj */
+        SmlDevInf *devinf = smlDevInfNew("LibSyncmML", SML_DEVINF_DEVTYPE_WORKSTATION, &error);
+        smlDevInfSetSupportsNumberOfChanges(devinf, FALSE);
+        smlDevInfSetSupportsLargeObjs(devinf, FALSE);
+        smlDevInfSetSupportsUTC(devinf, FALSE);
+        SmlDevInfAgent *clientagent = smlDevInfAgentNew(devinf, &error);
+        smlDevInfAgentRegister(clientagent, clientmanager, &error);
+
+        /* And we also add the devinfo to the devinf agent */
+        SmlDevInfDataStore *datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc1), &error);
+        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1");
+        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1");
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE);
+        smlDevInfAddDataStore(devinf, datastore);
+        
+        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc2), &error);
+        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0");
+        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0");
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE);
+        smlDevInfAddDataStore(devinf, datastore);
+        
+        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc3), &error);
+        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0");
+        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0");
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE);
+        smlDevInfAddDataStore(devinf, datastore);
+        
+        devinf = smlDevInfNew("LibSyncmML", SML_DEVINF_DEVTYPE_SERVER, &error);
+        smlDevInfSetSupportsNumberOfChanges(devinf, FALSE);
+        smlDevInfSetSupportsLargeObjs(devinf, FALSE);
+        smlDevInfSetSupportsUTC(devinf, FALSE);
+        SmlDevInfAgent *serveragent = smlDevInfAgentNew(devinf, &error);
+        smlDevInfAgentRegister(serveragent, servermanager, &error);
+        
+        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc1), &error);
+        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1");
+        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1");
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE);
+        smlDevInfAddDataStore(devinf, datastore);
+        
+        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc2), &error);
+        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0");
+        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0");
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE);
+        smlDevInfAddDataStore(devinf, datastore);
+        
+        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc3), &error);
+        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0");
+        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0");
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE);
+        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE);
+        smlDevInfAddDataStore(devinf, datastore);
+        
+        smlLocationUnref(loc1);
+        smlLocationUnref(loc2);
+        smlLocationUnref(loc3);
+        
+        /* The authenticator */
+        SmlAuthenticator *auth = smlAuthNew(&error);
+        smlAuthSetEnable(auth, FALSE);
+        smlAuthRegister(auth, clientmanager, &error);
+        
+        /* The authenticator */
+        SmlAuthenticator *auth2 = smlAuthNew(&error);
+        smlAuthSetEnable(auth2, FALSE);
+        smlAuthRegister(auth2, servermanager, &error);
+        
+        clienttracker->session = smlSessionNew(SML_SESSION_TYPE_CLIENT, SML_MIMETYPE_XML, SML_VERSION_12, SML_PROTOCOL_SYNCML, loc, loc, NULL, 0, &error);
+        smlSessionSetReceivingLimit(clienttracker->session, 76400);
+        smlSessionSetReceivingMaxObjSize(clienttracker->session, 76500);
+        
+        smlDevInfConfigureSession(devinf, clienttracker->session);
+        
+        fail_unless(smlManagerSessionAdd(clientmanager, clienttracker->session, NULL, &error), NULL);
+        fail_unless(error == NULL, NULL);
+        
+        smlLocationUnref(loc);
+        
+        clienttracker->dssessions[0] = smlDsServerSendAlert(clienttracker->ds[0], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error);
+        clienttracker->dssessions[1] = smlDsServerSendAlert(clienttracker->ds[1], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error);
+        clienttracker->dssessions[2] = smlDsServerSendAlert(clienttracker->ds[2], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error);
+        
+        fail_unless(smlDevInfAgentSendDevInf(clientagent, clienttracker->session, &error), NULL);
+        fail_unless(error == NULL, NULL);
+        
+        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL);
+        fail_unless(error == NULL, NULL);
+        
+        while (init_alerts_received != 3 || num_sessions != 2) {
+                smlManagerDispatch(servermanager);
+                smlManagerDispatch(clientmanager);
+                usleep(100);
+        }
+        
+        fail_unless(smlSessionGetSendingLimit(servertracker->session) == 76400, NULL);
+        fail_unless(smlSessionGetMaxObjSize(servertracker->session) != 76500, NULL);
+        smlSessionSetReceivingLimit(servertracker->session, 76400);
+        smlSessionSetReceivingMaxObjSize(servertracker->session, 76500);
+        
+        smlDsSessionGetAlert(servertracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1));
+        smlDsSessionGetAlert(servertracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1));
+        smlDsSessionGetAlert(servertracker->dssessions[2], _recv_alert, GINT_TO_POINTER(1));
+        
+        SmlDevInf *recvClientDevInf = smlDevInfAgentGetDevInf(serveragent);
+        fail_unless(smlDevInfNumDataStores(recvClientDevInf) == 3, NULL);
+        fail_unless(smlDevInfSupportsNumberOfChanges(recvClientDevInf) == FALSE, NULL);
+        fail_unless(smlDevInfSupportsLargeObjs(recvClientDevInf) == FALSE, NULL);
+        fail_unless(smlDevInfSupportsUTC(recvClientDevInf) == FALSE, NULL);
+        
+        fail_unless(smlDevInfAgentSendDevInf(serveragent, servertracker->session, &error), NULL);
+        fail_unless(error == NULL, NULL);
+        
+        smlDsSessionSendAlert(servertracker->dssessions[0], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error);
+        smlDsSessionSendAlert(servertracker->dssessions[1], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error);
+        smlDsSessionSendAlert(servertracker->dssessions[2], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error);
+        
+        fail_unless(servertracker->session != NULL, NULL);
+        fail_unless(smlSessionFlush(servertracker->session, TRUE, &error), NULL);
+        
+        smlDsSessionGetAlert(clienttracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1));
+        smlDsSessionGetAlert(clienttracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1));
+        smlDsSessionGetAlert(clienttracker->dssessions[2], _recv_alert, GINT_TO_POINTER(1));
+        
+        while (alerts_received != 6) {
+                smlDsSessionDispatch(servertracker->dssessions[0]);
+                smlDsSessionDispatch(servertracker->dssessions[1]);
+                smlDsSessionDispatch(servertracker->dssessions[2]);
+                
+                smlDsSessionDispatch(clienttracker->dssessions[0]);
+                smlDsSessionDispatch(clienttracker->dssessions[1]);
+                smlDsSessionDispatch(clienttracker->dssessions[2]);
+                
+                smlManagerDispatch(servermanager);
+                smlManagerDispatch(clientmanager);
+                usleep(100);
+        }
+        
+        fail_unless(smlSessionGetSendingLimit(clienttracker->session) == 76400, NULL);
+        fail_unless(smlSessionGetMaxObjSize(clienttracker->session) == 0, NULL);
+        
+        SmlDevInf *recvServerDevInf = smlDevInfAgentGetDevInf(clientagent);
+        fail_unless(smlDevInfNumDataStores(recvServerDevInf) == 3, NULL);
+        fail_unless(smlDevInfSupportsNumberOfChanges(recvServerDevInf) == FALSE, NULL);
+        fail_unless(smlDevInfSupportsLargeObjs(recvServerDevInf) == FALSE, NULL);
+        fail_unless(smlDevInfSupportsUTC(recvServerDevInf) == FALSE, NULL);
+        
+        smlDsSessionSendSync(clienttracker->dssessions[0], 87, _sync_reply, GINT_TO_POINTER(1), &error);
+        smlDsSessionSendSync(clienttracker->dssessions[1], 87, _sync_reply, GINT_TO_POINTER(1), &error);
+        smlDsSessionSendSync(clienttracker->dssessions[2], 87, _sync_reply, GINT_TO_POINTER(1), &error);
+        
+        int i = 0;
+        for (i = 0; i < num_items; i++) {
+                fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[0], SML_CHANGE_ADD, "uid", "data", 4, SML_ELEMENT_TEXT_VCARD, _add_reply, GINT_TO_POINTER(2), &error), NULL);
+                fail_unless(error == NULL, NULL);
+                fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[0], SML_CHANGE_REPLACE, "uid", "newdata", 7, SML_ELEMENT_TEXT_VCARD, _modify_reply, GINT_TO_POINTER(1), &error), NULL);
+                fail_unless(error == NULL, NULL);
+                fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[0], SML_CHANGE_DELETE, "uid", NULL, 0, SML_ELEMENT_TEXT_VCARD, _delete_reply, GINT_TO_POINTER(1), &error), NULL);
+                fail_unless(error == NULL, NULL);
+                fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[1], SML_CHANGE_ADD, "uid", "data", 4, SML_ELEMENT_TEXT_VCAL, _add_reply, GINT_TO_POINTER(2), &error), NULL);
+                fail_unless(error == NULL, NULL);
+                fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[1], SML_CHANGE_REPLACE, "uid", "newdata", 7, SML_ELEMENT_TEXT_VCAL, _modify_reply, GINT_TO_POINTER(1), &error), NULL);
+                fail_unless(error == NULL, NULL);
+                fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[1], SML_CHANGE_DELETE, "uid", NULL, 0, SML_ELEMENT_TEXT_VCAL, _delete_reply, GINT_TO_POINTER(1), &error), NULL);