Changeset 170

Show
Ignore:
Timestamp:
05/24/06 16:46:47 (2 years ago)
Author:
abauer
Message:

Merged the dev branch into the 6230 branch

svn merge -r 159:169 dev-branch/ 6230-branch/

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/6230-branch/libsyncml/objects/sml_auth.c

    r127 r170  
    6060                smlTrace(TRACE_INTERNAL, "Auth is required"); 
    6161                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); 
    6266        } else if ((!cred && auth->enabled && auth->state == SML_AUTH_ACCEPTED) || \ 
    6367                (cred && !auth->enabled)) { 
     
    8690                                        auth->state = SML_ERROR_AUTH_REJECTED; 
    8791                                } 
     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                                 
    8899                                g_strfreev(arr); 
    89100         
     
    97108        } 
    98109         
    99         if (auth->state == SML_ERROR_AUTH_REJECTED || auth->state == SML_ERROR_AUTH_REQUIRED) 
     110        if (auth->state == SML_ERROR_AUTH_REJECTED || auth->state == SML_ERROR_AUTH_REQUIRED) { 
     111                smlTrace(TRACE_INTERNAL, "Ending session due to wrong / missing creds"); 
    100112                session->end = TRUE; 
     113        } 
    101114         
    102115        reply = smlAuthHeaderReply(session, auth->state, &error); 
     
    115128 
    116129error: 
    117         smlSessionSetError(session, &error); 
     130        smlSessionDispatchEvent(session, SML_SESSION_EVENT_ERROR, NULL, NULL, NULL, error); 
    118131        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(&error)); 
    119132        smlErrorDeref(&error); 
  • branches/6230-branch/libsyncml/objects/sml_devinf_obj.c

    r127 r170  
    3636/*@{*/ 
    3737 
     38static 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 
     67error: 
     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 
    3873static void _devinf_reply(SmlSession *session, SmlStatus *status, void *userdata) 
    3974{ 
     
    5792{ 
    5893        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, agent, session, get, error); 
    59         SmlStatus *result = NULL; 
     94        SmlCommand *result = NULL; 
    6095        SmlCommand *cmd = NULL; 
    6196         
     
    70105                                goto error; 
    71106                         
    72                         if (!smlSessionSendResult(session, result, _devinf_reply, agent, error)) { 
    73                                 smlStatusUnref(result); 
     107                        if (!smlSessionSendCommand(session, result, NULL, _devinf_reply, agent, error)) { 
     108                                smlCommandUnref(result); 
    74109                                goto error; 
    75110                        } 
    76111                         
    77                         smlStatusUnref(result); 
     112                        smlCommandUnref(result); 
    78113                         
    79114                        SmlStatus *reply = smlCommandNewReply(get, SML_NO_ERROR, error); 
     
    134169        SmlDevInfAgent *agent = userdata; 
    135170        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); 
    141182        if (!reply) 
    142183                goto error; 
     
    205246 
    206247/* 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; 
     248SmlDevInf *smlDevInfAgentGetDevInf(SmlDevInfAgent *agent) 
     249
     250        smlAssert(agent); 
     251        return agent->recvDevInf; 
    235252} 
    236253 
     
    257274        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, agent, session, error); 
    258275        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                         
    262298        smlTrace(TRACE_EXIT, "%s", __func__); 
    263299        return TRUE; 
    264300         
    265 /*error: 
    266         smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    267         return FALSE;*/ 
     301error: 
     302        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
     303        return FALSE; 
    268304} 
    269305 
  • branches/6230-branch/libsyncml/objects/sml_devinf_obj.h

    r127 r170  
    2626SmlDevInfAgent *smlDevInfAgentNew(SmlDevInf *devinf, SmlError **error); 
    2727void smlDevInfAgentFree(SmlDevInfAgent *agent); 
    28 SmlDevInf *smlDevInfAgentGetDevInf(SmlDevInfAgent *agent, SmlError **error); 
     28SmlDevInf *smlDevInfAgentGetDevInf(SmlDevInfAgent *agent); 
    2929SmlBool smlDevInfAgentRegister(SmlDevInfAgent *agent, SmlManager *manager, SmlError **error); 
    3030SmlBool smlDevInfAgentSendDevInf(SmlDevInfAgent *agent, SmlSession *session, SmlError **error); 
  • branches/6230-branch/libsyncml/objects/sml_devinf_obj_internals.h

    r127 r170  
    2626        SmlBool devinfSent; 
    2727         
    28         SmlCommand *recvDevInf; 
     28        SmlDevInf *recvDevInf; 
    2929}; 
    3030 
  • branches/6230-branch/libsyncml/objects/sml_ds_server.c

    r152 r170  
    171171/*@{*/ 
    172172 
    173 SmlDsServer *smlDsServerNew(SmlContentType type, SmlLocation *location, SmlError **error) 
    174 { 
    175         smlTrace(TRACE_ENTRY, "%s(%i, %p, %p)", __func__, type, location, error); 
     173SmlDsServer *smlDsServerNew(const char *type, SmlLocation *location, SmlError **error) 
     174{ 
     175        smlTrace(TRACE_ENTRY, "%s(%s, %p, %p)", __func__, type, location, error); 
    176176        smlAssert(location); 
    177177         
     
    183183        smlLocationRef(location); 
    184184 
    185         server->contenttype = type
     185        server->contenttype = g_strdup(type)
    186186        server->servertype = SML_DS_SERVER; 
    187187         
     
    194194} 
    195195 
    196 SmlDsServer *smlDsClientNew(SmlContentType type, SmlLocation *location, SmlLocation *target, SmlError **error) 
    197 { 
    198         smlTrace(TRACE_ENTRY, "%s(%i, %p, %p, %p)", __func__, type, location, target, error); 
     196SmlDsServer *smlDsClientNew(const char *type, SmlLocation *location, SmlLocation *target, SmlError **error) 
     197{ 
     198        smlTrace(TRACE_ENTRY, "%s(%s, %p, %p, %p)", __func__, type, location, target, error); 
    199199        smlAssert(location); 
    200200        smlAssert(target); 
     
    210210        smlLocationRef(target); 
    211211 
    212         server->contenttype = type
     212        server->contenttype = g_strdup(type)
    213213        server->servertype = SML_DS_CLIENT; 
    214214         
     
    231231        if (server->target) 
    232232                smlLocationUnref(server->target); 
     233         
     234        if (server->contenttype) 
     235                g_free(server->contenttype); 
    233236         
    234237        g_free(server); 
     
    265268} 
    266269 
    267 SmlContentType smlDsServerGetContentType(SmlDsServer *server) 
     270const char *smlDsServerGetContentType(SmlDsServer *server) 
    268271{ 
    269272        smlAssert(server); 
     
    756759        smlAssert(dsession); 
    757760         
    758         SmlCommand *alert = smlCommandNewAlert(type, dsession->target, dsession->location, next, last, SML_CONTENT_TYPE_UNKNOWN, error); 
     761        SmlCommand *alert = smlCommandNewAlert(type, dsession->target, dsession->location, next, last, NULL, error); 
    759762        if (!alert) 
    760763                goto error; 
     
    858861 
    859862//Send a change to the remote side 
    860 SmlBool smlDsSessionQueueChange(SmlDsSession *dsession, SmlChangeType type, const char *uid, const char *data, unsigned int size, SmlContentType contenttype, SmlDsSessionWriteCb callback, void *userdata, SmlError **error) 
    861 { 
    862         smlTrace(TRACE_ENTRY, "%s(%p, %i, %s, %p, %i, %i, %p, %p, %p)", __func__, dsession, type, uid, data, size, contenttype, callback, userdata, error); 
     863SmlBool smlDsSessionQueueChange(SmlDsSession *dsession, SmlChangeType type, const char *uid, const char *data, unsigned int size, const char *contenttype, SmlDsSessionWriteCb callback, void *userdata, SmlError **error) 
     864{ 
     865        smlTrace(TRACE_ENTRY, "%s(%p, %i, %s, %p, %i, %s, %p, %p, %p)", __func__, dsession, type, uid, data, size, contenttype, callback, userdata, error); 
    863866        smlAssert(dsession); 
    864867         
     
    10101013} 
    10111014 
    1012 SmlContentType smlDsSessionGetContentType(SmlDsSession *dsession) 
     1015const char *smlDsSessionGetContentType(SmlDsSession *dsession) 
    10131016{ 
    10141017        smlAssert(dsession); 
  • branches/6230-branch/libsyncml/objects/sml_ds_server.h

    r127 r170  
    3434typedef SmlBool (* SmlDsSessionAlertCb) (SmlDsSession *dsession, SmlAlertType type, const char *last, const char *next, void *userdata); 
    3535typedef void (* SmlDsSessionSyncCb) (SmlDsSession *dsession, unsigned int numchanges, void *userdata); 
    36 typedef SmlBool (* SmlDsSessionChangesCb) (SmlDsSession *dsession, SmlChangeType type, const char *uid, char *data, unsigned int size, SmlContentType contenttype, void *userdata, SmlError **error); 
     36typedef SmlBool (* SmlDsSessionChangesCb) (SmlDsSession *dsession, SmlChangeType type, const char *uid, char *data, unsigned int size, const char *contenttype, void *userdata, SmlError **error); 
    3737typedef void (* SmlDsSessionWriteCb) (SmlDsSession *dsession, SmlStatus *status, const char *newuid, void *userdata); 
    3838 
    39 SmlDsServer *smlDsServerNew(SmlContentType type, SmlLocation *location, SmlError **error); 
    40 SmlDsServer *smlDsClientNew(SmlContentType type, SmlLocation *location, SmlLocation *target, SmlError **error); 
     39SmlDsServer *smlDsServerNew(const char *type, SmlLocation *location, SmlError **error); 
     40SmlDsServer *smlDsClientNew(const char *type, SmlLocation *location, SmlLocation *target, SmlError **error); 
    4141void smlDsServerFree(SmlDsServer *server); 
    4242SmlBool smlDsServerRegister(SmlDsServer *server, SmlManager *manager, SmlError **error); 
     
    4545void smlDsServerSetConnectCallback(SmlDsServer *server, SmlDsSessionConnectCb callback, void *userdata); 
    4646const char *smlDsServerGetLocation(SmlDsServer *server); 
    47 SmlContentType smlDsServerGetContentType(SmlDsServer *server); 
     47const char *smlDsServerGetContentType(SmlDsServer *server); 
    4848SmlDsSession *smlDsServerSendAlert(SmlDsServer *server, SmlSession *session, SmlAlertType type, const char *last, const char *next, SmlStatusReplyCb callback, void *userdata, SmlError **error); 
    4949 
     
    5757void smlDsSessionGetSync(SmlDsSession *dsession, SmlDsSessionSyncCb chgCallback, void *userdata); 
    5858SmlBool smlDsSessionSendSync(SmlDsSession *dsession, unsigned int num_changes, SmlStatusReplyCb callback, void *userdata, SmlError **error); 
    59 SmlBool smlDsSessionQueueChange(SmlDsSession *dsession, SmlChangeType type, const char *uid, const char *data, unsigned int size, SmlContentType contenttype, SmlDsSessionWriteCb callback, void *userdata, SmlError **error); 
     59SmlBool smlDsSessionQueueChange(SmlDsSession *dsession, SmlChangeType type, const char *uid, const char *data, unsigned int size, const char *contenttype, SmlDsSessionWriteCb callback, void *userdata, SmlError **error); 
    6060SmlBool smlDsSessionCloseSync(SmlDsSession *dsession, SmlError **error); 
    6161SmlBool smlDsSessionQueueMap(SmlDsSession *dsession, const char *uid, const char *newuid, SmlError **error); 
    6262SmlBool smlDsSessionCloseMap(SmlDsSession *dsession, SmlStatusReplyCb callback, void *userdata, SmlError **error); 
    6363const char *smlDsSessionGetLocation(SmlDsSession *dsession); 
    64 SmlContentType smlDsSessionGetContentType(SmlDsSession *dsession); 
     64const char *smlDsSessionGetContentType(SmlDsSession *dsession); 
    6565SmlDsServer *smlDsSessionGetServer(SmlDsSession *dsession); 
    6666 
  • branches/6230-branch/libsyncml/objects/sml_ds_server_internals.h

    r127 r170  
    8181        /** The target if the ds server is in client mode */ 
    8282        SmlLocation *target; 
    83         SmlContentType contenttype; 
     83        char *contenttype; 
    8484        SmlDsServerType servertype; 
    8585        SmlManager *manager; 
  • branches/6230-branch/libsyncml/parser/sml_wbxml.c

    r127 r170  
    7979         
    8080        smlTrace(TRACE_INTERNAL, "Wbxml input: %s", smlPrintBinary(data, size)); 
     81        smlLog("received-%i.wbxml", data, size); 
    8182         
    8283        char *buffer = NULL; 
     
    136137         
    137138        smlTrace(TRACE_INTERNAL, "Wbxml assembled: %s", smlPrintHex(*data, *size)); 
     139        smlLog("sent-%i.wbxml", *data, *size); 
    138140         
    139141        smlTrace(TRACE_EXIT, "%s", __func__); 
  • branches/6230-branch/libsyncml/parser/sml_xml_assm.c

    r153 r170  
    9191        else 
    9292                rc = xmlTextWriterWriteFormatCDATA(assm->writer, "%*s", size, (xmlChar *)value); 
     93                 
    9394        if (rc < 0) { 
    9495                smlErrorSet(error, SML_ERROR_GENERIC, "Unable to add data"); 
     
    197198} 
    198199 
    199 SmlBool smlItemAssemble(SmlItem *item, SmlXmlAssembler *assm, SmlBool raw, unsigned int complete_size, SmlError **error) 
    200 { 
    201         smlTrace(TRACE_ENTRY, "%s(%p, %p, %i, %i, %p)", __func__, item, assm, raw, complete_size, error); 
     200SmlBool smlItemAssemble(SmlItem *item, SmlXmlAssembler *assm, SmlError **error) 
     201{ 
     202        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, item, assm, error); 
    202203        smlAssert(assm); 
    203204        smlAssert(item); 
     
    221222        } 
    222223         
    223         //Meta 
    224         /*if (complete_size) { 
    225                 if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error)) 
    226                         goto error; 
    227                          
    228                 if (!_smlXmlAssemblerAddIDNS(assm, NULL, SML_ELEMENT_SIZE, SML_NAMESPACE_METINF, complete_size, error)) 
    229                         goto error; 
    230          
    231                 //META 
    232                 if (!_smlXmlAssemblerEndNode(assm, error)) 
    233                         goto error; 
    234         }*/ 
    235          
    236224        if (smlItemHasData(item)) { 
    237225                if (item->disabled) { 
    238                         if (!_smlXmlAssemblerAddData(assm, SML_ELEMENT_DATA, "", 0, raw, error)) 
     226                        if (!_smlXmlAssemblerAddData(assm, SML_ELEMENT_DATA, "", 0, item->raw, error)) 
    239227                                goto error; 
    240228                } else { 
     
    244232                                goto error; 
    245233                         
    246                         if (!_smlXmlAssemblerAddData(assm, SML_ELEMENT_DATA, data, size, raw, error)) 
     234                        if (!_smlXmlAssemblerAddData(assm, SML_ELEMENT_DATA, data, size, item->raw, error)) 
    247235                                goto error; 
    248236                } 
     
    339327                goto error; 
    340328         
    341         const char *contenttype = smlContentTypeToString(change->private.access.item->contenttype, error); 
    342         if (!contenttype) 
    343                 goto error; 
    344          
    345         if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, contenttype, error)) 
     329        if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, change->private.access.item->contenttype, error)) 
    346330                goto error; 
    347331         
     
    350334                goto error; 
    351335         
    352         if (!smlItemAssemble(change->private.access.item, assm, FALSE, 0, error)) 
     336        if (!smlItemAssemble(change->private.access.item, assm, error)) 
    353337                goto error; 
    354338         
     
    381365                goto error; 
    382366         
    383         const char *contenttype = smlContentTypeToString(change->private.change.item->contenttype, error); 
    384         if (!contenttype) 
    385                 goto error; 
    386          
    387         if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, contenttype, error)) 
    388                 goto error; 
    389          
    390         if (change->size) { 
     367        if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, change->private.change.item->contenttype, error)) 
     368                goto error; 
     369         
     370        const char *opt = smlAssemblerGetOption(assm->assembler, "USE_LARGEOBJECTS"); 
     371        SmlBool supportsLargeObjects = (opt && !atoi(opt)) ? FALSE : TRUE; 
     372        if (supportsLargeObjects && change->size) { 
    391373                if (!_smlXmlAssemblerAddIDNS(assm, SML_ELEMENT_SIZE, SML_NAMESPACE_METINF, change->size, error)) 
    392374                        goto error; 
     
    397379                goto error; 
    398380         
    399         const char *opt = smlAssemblerGetOption(assm->assembler, "ONLY_REPLACE"); 
     381        opt = smlAssemblerGetOption(assm->assembler, "ONLY_REPLACE"); 
    400382        if (opt && atoi(opt) && change->type == SML_COMMAND_TYPE_ADD) { 
    401383                change->private.change.item->target = change->private.change.item->source; 
     
    403385        } 
    404386         
    405         if (!smlItemAssemble(change->private.change.item, assm, FALSE, change->size, error)) 
     387        if (!smlItemAssemble(change->private.change.item, assm, error)) 
    406388                goto error; 
    407389         
     
    416398SmlBool smlSyncAssemble(SmlXmlAssembler *assm, SmlCommand *cmd, SmlError **error) 
    417399{ 
    418         smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, assm, cmd, error); 
     400        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, assm, cmd, error); 
    419401        smlAssert(cmd); 
    420402        smlAssert(assm); 
     
    425407        } 
    426408         
    427         /*if (assm->session->incomingMaxObjSize && assm->session->version != SML_VERSION_10) { 
     409        const char *opt = smlAssemblerGetOption(assm->assembler, "USE_LARGEOBJECTS"); 
     410        SmlBool supportsLargeObjects = (opt && !atoi(opt)) ? FALSE : TRUE; 
     411        if (supportsLargeObjects && assm->session->incomingMaxObjSize && assm->session->version != SML_VERSION_10) { 
    428412                if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error)) 
    429413                        goto error; 
     
    435419                if (!_smlXmlAssemblerEndNode(assm, error)) 
    436420                        goto error; 
    437         }*/ 
     421        } 
    438422         
    439423        if (!smlLocationAssemble(cmd->target, assm, SML_ELEMENT_TARGET, error)) 
     
    448432                goto error; 
    449433         
    450         /*if (assm->session->version != SML_VERSION_10) { 
     434        opt = smlAssemblerGetOption(assm->assembler, "USE_NUMBEROFCHANGES"); 
     435        SmlBool supportsNumberOfChanges = (opt && !atoi(opt)) ? FALSE : TRUE; 
     436        if (supportsNumberOfChanges && assm->session->version != SML_VERSION_10) { 
    451437                if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_NUMBEROFCHANGES, cmd->private.sync.numChanged, error)) 
    452438                        goto error; 
    453         }*/ 
     439        } 
    454440         
    455441        smlTrace(TRACE_EXIT, "%s", __func__); 
     
    566552        } 
    567553         
    568         if (cmd->private.alert.contentType != SML_CONTENT_TYPE_UNKNOWN) { 
     554        if (cmd->private.alert.contentType) { 
    569555                if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error)) 
    570556                        goto error; 
    571                  
    572                 const char *contenttype = smlContentTypeToString(cmd->private.alert.contentType, error); 
    573                 if (!contenttype) 
    574                         goto error; 
    575557                         
    576                 if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, contenttype, error)) 
     558                if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, cmd->private.alert.contentType, error)) 
    577559                        goto error; 
    578560                 
     
    585567        if (!_smlXmlAssemblerEndNode(assm, error)) 
    586568                goto error; 
     569         
     570        smlTrace(TRACE_EXIT, "%s", __func__); 
     571        return TRUE; 
     572 
     573error: 
     574        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
     575        return FALSE; 
     576} 
     577 
     578SmlBool smlResultsAssemble(SmlXmlAssembler *assm, SmlCommand *cmd, SmlError **error) 
     579{ 
     580        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, assm, cmd, error); 
     581        smlAssert(cmd); 
     582        smlAssert(assm); 
     583         
     584        if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_MSGREF, cmd->private.results.status->msgRef, error)) 
     585                goto error; 
     586                 
     587        if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_CMDREF, cmd->private.results.status->cmdRef, error)) 
     588                goto error; 
     589                 
     590        if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error)) 
     591                goto error; 
     592                 
     593        if (!_smlXmlAssemblerAddStringNS(assm, SML_ELEMENT_TYPE, SML_NAMESPACE_METINF, cmd->private.results.status->item->contenttype, error)) 
     594                goto error; 
     595         
     596        //META 
     597        if (!_smlXmlAssemblerEndNode(assm, error)) 
     598                goto error; 
     599         
     600        if (!smlItemAssemble(cmd->private.results.status->item, assm, error)) 
     601                goto error; 
     602         
     603        if (cmd->private.results.status->sourceRef) { 
     604                if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_SOURCEREF, cmd->private.results.status->sourceRef->locURI, error)) 
     605                        goto error; 
     606        } 
     607         
     608        if (cmd->private.results.status->targetRef) { 
     609                if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_TARGETREF, cmd->private.results.status->targetRef->locURI, error)) 
     610                        goto error; 
     611        } 
    587612         
    588613        smlTrace(TRACE_EXIT, "%s", __func__); 
     
    680705                goto error_free_writer; 
    681706         
    682         if (session->incomingMaxMsgSize || session->incomingMaxObjSize) { 
     707        //const char *opt = smlAssemblerGetOption(assm->assembler, "USE_LARGEOBJECTS"); 
     708        //SmlBool supportsLargeObjects = (opt && !atoi(opt)) ? FALSE : TRUE; 
     709        if (session->incomingMaxMsgSize) { // || (session->incomingMaxObjSize && supportsLargeObjects)) { 
    683710                if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_META, error)) 
    684711                        goto error_free_writer; 
     
    689716                } 
    690717                 
    691                 if (session->incomingMaxObjSize) { 
     718                /*if (supportsLargeObjects && session->incomingMaxObjSize) { 
    692719                        if (!_smlXmlAssemblerAddIDNS(assm, SML_ELEMENT_MAXOBJSIZE, SML_NAMESPACE_METINF, session->incomingMaxObjSize, error)) 
    693720                                goto error_free_writer; 
    694                 } 
     721                }*/ 
    695722                 
    696723                //META 
     
    798825                        break; 
    799826                case SML_COMMAND_TYPE_PUT: 
     827                case SML_COMMAND_TYPE_GET: 
    800828                        if (!smlAccessAssemble(assm, cmd, error)) 
    801829                                goto error_free_writer; 
     
    805833                                goto error_free_writer; 
    806834                        break; 
     835                case SML_COMMAND_TYPE_RESULTS: 
     836                        if (!smlResultsAssemble(assm, cmd, error)) 
     837                                goto error_free_writer; 
    807838                default: 
    808839                        smlErrorSet(error, SML_ERROR_GENERIC, "Unknown command type"); 
     
    10021033        } 
    10031034         
    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                 } 
     1035        /* Get the reserved buffer */ 
     1036        GList *s = NULL; 
     1037        for (s = assm->statuses; s; s = s->next) { 
     1038                res = s->data; 
     1039                if (res->cmdRef == status->cmdRef && res->msgRef == status->msgRef) 
     1040                        break; 
     1041                res = NULL; 
    10181042        } 
    10191043         
     
    10461070        } 
    10471071         
    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         } 
     1072        if (!_smlXmlAssemblerStartNode(assm, SML_ELEMENT_STATUS, error)) 
     1073                goto error; 
    10551074         
    10561075        if (!_smlXmlAssemblerAddID(assm, SML_ELEMENT_CMDID, res->cmdID, error)) 
     
    10631082                goto error; 
    10641083         
    1065         if (status->type != SML_COMMAND_TYPE_RESULTS) { 
    1066                 const char *cmdname = smlCommandTypeToString(status->type, error); 
    1067                 if (!cmdname) 
    1068                         goto error; 
    1069                          
    1070                 if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_CMD, cmdname, error)) 
    1071                         goto error; 
    1072         } 
     1084        const char *cmdname = smlCommandTypeToString(status->type, error); 
     1085        if (!cmdname) 
     1086                goto error; 
     1087                 
     1088        if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_CMD, cmdname, error)) 
     1089                goto error; 
    10731090         
    10741091        switch (status->type) { 
     
    11271144                        } 
    11281145                        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; 
    11471146                default: 
    11481147                ; 
     
    11591158        } 
    11601159         
    1161         if (status->type != SML_COMMAND_TYPE_RESULTS && status->data) { 
     1160        if (status->data) { 
    11621161                if (!_smlXmlAssemblerAddString(assm, SML_ELEMENT_DATA, status->data, error)) 
    11631162                        goto error; 
     
    13341333                                /* Add the corresponding command opener */ 
    13351334                                 
    1336                                 if (onlyReplace) 
     1335                                if (cmd->cmdType == SML_COMMAND_TYPE_ADD && onlyReplace) 
    13371336                                        cmdname = SML_ELEMENT_REPLACE; 
    13381337                                else { 
     
    14561455                SmlXmlAssemblerStatus *status = b->data; 
    14571456                if (!status->buffer) { 
     1457                        if (status->cmdRef == 0 && check) { 
     1458                                smlErrorSet(error, SML_ERROR_GENERIC, "Reserved status 0 has not been added"); 
     1459                                goto error_free_writer; 
     1460                        } 
    14581461                        smlTrace(TRACE_INTERNAL, "Reserved status %i is missing", status->cmdRef); 
    14591462                        missingstatus = TRUE; 
     
    15481551SmlBool smlXmlAssemblerRun(SmlXmlAssembler *assm, char **data, unsigned int *size, SmlBool *end, SmlBool final, unsigned int maxsize, SmlError **error) 
    15491552{ 
    1550         return smlXmlAssemblerRunFull(assm, data, size, end, final, TRUE, maxsize, error); 
     1553        SmlBool ans = smlXmlAssemblerRunFull(assm, data, size, end, final, TRUE, maxsize, error); 
     1554                 
     1555        smlLog("sent-%i.xml", *data, *size); 
     1556        return ans; 
    15511557} 
    15521558 
     
    15841590SmlBool smlXmlAssemblerNextCmdRef(SmlXmlAssembler *assm, unsigned int *cmdRef, unsigned int *msgRef) 
    15851591{ 
    1586         smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, assm, cmdRef, msgRef); 
    15871592        smlAssert(assm); 
    15881593        smlAssert(cmdRef); 
     
    15961601                        *cmdRef = status->cmdRef; 
    15971602                        *msgRef = status->msgRef; 
    1598                          
    1599                         smlTrace(TRACE_EXIT, "%s: Found one", __func__); 
    16001603                        return TRUE; 
    16011604                } 
    16021605        } 
    16031606         
    1604         smlTrace(TRACE_EXIT, "%s: None found", __func__); 
    16051607        return FALSE; 
    16061608} <