Changeset 115

Show
Ignore:
Timestamp:
03/06/06 02:40:15 (3 years ago)
Author:
abauer
Message:

Added refernce counting to a lot of objects.

Fixed a lot of memory leaks and bugs in the assembler and the parser

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/development-branch/libsyncml/objects/sml_auth.c

    r111 r115  
    4343} 
    4444 
    45 void _header_callback(SmlSession *session, SmlHeader *header, void *userdata) 
    46 { 
    47         smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, session, header, userdata); 
     45void _header_callback(SmlSession *session, SmlHeader *header, SmlCred *cred, void *userdata) 
     46{ 
     47        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, session, header, cred, userdata); 
    4848        smlAssert(session); 
    4949        smlAssert(userdata); 
    …… 
    5151        SmlAuthenticator *auth = userdata; 
    5252        SmlError *error = NULL; 
    53         SmlCred *cred = header->cred; 
    5453        char *buffer = NULL; 
    5554        unsigned int buffersize = 0; 
    …… 
    199198 
    200199error_free_reply: 
    201         smlStatusFree(reply); 
     200        smlStatusUnref(reply); 
    202201error: 
    203202        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 

  • branches/development-branch/libsyncml/objects/sml_devinf_obj.c

    r112 r115  
    109109         
    110110error_free_cmd: 
    111         smlCommandFree(cmd); 
     111        smlCommandUnref(cmd); 
    112112error: 
    113113        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    265265                goto error_free_loc; 
    266266         
    267         smlLocationFree(devinf10); 
    268         smlLocationFree(devinf11); 
     267        smlLocationUnref(devinf10); 
     268        smlLocationUnref(devinf11); 
    269269        smlTrace(TRACE_EXIT, "%s", __func__); 
    270270        return TRUE; 
    …… 
    272272error_free_loc: 
    273273        if (devinf10) 
    274                 smlLocationFree(devinf10); 
     274                smlLocationUnref(devinf10); 
    275275        if (devinf11) 
    276                 smlLocationFree(devinf11); 
     276                smlLocationUnref(devinf11); 
    277277error: 
    278278        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 

  • branches/development-branch/libsyncml/objects/sml_ds_server.c

    r101 r115  
    261261        g_free(dsession); 
    262262error_free_target: 
    263         smlLocationFree(server->target); 
     263        smlLocationUnref(server->target); 
    264264error: 
    265265        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(&error)); 
    …… 
    329329 
    330330error_free_location: 
    331         smlLocationFree(server->location); 
     331        smlLocationUnref(server->location); 
    332332error_free_server: 
    333333        g_free(server); 
    …… 
    343343         
    344344        if (server->location) 
    345                 smlLocationFree(server->location); 
     345                smlLocationUnref(server->location); 
    346346         
    347347        g_free(server); 
    …… 
    422422 
    423423error_free_target: 
    424         smlLocationFree(server->target); 
     424        smlLocationUnref(server->target); 
    425425error_free_session: 
    426426        g_free(dsession); 
    …… 
    554554error: 
    555555        if (reply) 
    556                 smlStatusFree(reply); 
     556                smlStatusUnref(reply); 
    557557        smlTrace(TRACE_EXIT_ERROR, "%s: Unable to dispatch: %s", __func__, smlErrorPrint(&error)); 
    558558        smlErrorDeref(&error); 
    …… 
    747747        g_free(ctx); 
    748748error_free_cmd: 
    749         smlCommandFree(cmd); 
     749        smlCommandUnref(cmd); 
    750750error: 
    751751        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    839839 
    840840error_free_cmd: 
    841         smlCommandFree(cmd); 
     841        smlCommandUnref(cmd); 
    842842error: 
    843843        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 

  • branches/development-branch/libsyncml/parser/sml_xml_assm.c

    r114 r115  
    11311131} 
    11321132 
    1133 void smlXmlAssemblerFree(SmlXmlAssembler *assm) 
    1134 { 
    1135         smlTrace(TRACE_ENTRY, "%s(%p)", __func__, assm); 
    1136         smlAssert(assm); 
    1137          
    1138         g_free(assm); 
    1139  
    1140         smlTrace(TRACE_EXIT, "%s", __func__); 
    1141 } 
    1142  
    11431133static void flush_list(GList *list) 
    11441134{ 
    …… 
    11581148        g_list_free(list); 
    11591149         
     1150        smlTrace(TRACE_EXIT, "%s", __func__); 
     1151} 
     1152 
     1153void smlXmlAssemblerFree(SmlXmlAssembler *assm) 
     1154{ 
     1155        smlTrace(TRACE_ENTRY, "%s(%p)", __func__, assm); 
     1156        smlAssert(assm); 
     1157         
     1158        if (assm->header_buffer) 
     1159                xmlBufferFree(assm->header_buffer); 
     1160         
     1161        while (assm->statuses) { 
     1162                SmlXmlAssemblerStatus *status = assm->statuses->data; 
     1163                 
     1164                if (status->buffer) 
     1165                        xmlBufferFree(status->buffer); 
     1166                 
     1167                g_free(status); 
     1168                assm->statuses = g_list_delete_link(assm->statuses, assm->statuses); 
     1169        } 
     1170         
     1171        flush_list(assm->commands); 
     1172         
     1173        g_free(assm); 
     1174 
    11601175        smlTrace(TRACE_EXIT, "%s", __func__); 
    11611176} 
    …… 
    12701285                                if (!smlXmlAssemblerAddChildren(assm, cmd->children, error)) 
    12711286                                        goto error; 
    1272                                 break; 
    1273                         case SML_ASSEMBLER_NODE_CLOSE: 
     1287                                 
    12741288                                smlTrace(TRACE_INTERNAL, "closing node"); 
    12751289                                if (!_smlXmlAssemblerEndNode(assm, error)) 
    12761290                                        goto error; 
     1291                                break; 
     1292                        case SML_ASSEMBLER_NODE_CLOSE: 
     1293                                /*smlTrace(TRACE_INTERNAL, "closing node"); 
     1294                                if (!_smlXmlAssemblerEndNode(assm, error)) 
     1295                                        goto error;*/ 
    12771296                                break; 
    12781297                } 
    …… 
    14141433        assm->writer = NULL; 
    14151434         
    1416         *data = g_strdup((char *)xmlBufferContent(buffer)); 
     1435        //Avoid the memory copy here 
     1436        *data = (char *)xmlBufferContent(buffer); 
    14171437        *size = xmlBufferLength(buffer); 
    14181438        if (end) { 
    …… 
    14231443        } 
    14241444         
    1425         smlTrace(TRACE_INTERNAL, "Message Assembled: %s", smlPrintBinary(*data, *size)); 
     1445        g_free(buffer); 
     1446         
     1447        //FIXME ADD debug ifs 
     1448        char *debugstr = smlPrintBinary(*data, *size); 
     1449        smlTrace(TRACE_INTERNAL, "Message Assembled: %s", debugstr); 
     1450        g_free(debugstr); 
    14261451         
    14271452        smlTrace(TRACE_EXIT, "%s", __func__); 

  • branches/development-branch/libsyncml/parser/sml_xml_parse.c

    r106 r115  
    104104                goto error; 
    105105         
    106         *id = atoi(g_strstrip((char *)xmlTextReaderValue(parser->reader))); 
     106        *id = atoi(g_strstrip((char *)xmlTextReaderConstValue(parser->reader))); 
    107107         
    108108        if (!_smlXmlParserExpectNode(parser, XML_NODE_CLOSE, FALSE, name, error)) 
    …… 
    131131         
    132132        if (xmlTextReaderNodeType(parser->reader) == XML_NODE_TEXT) { 
    133                 *string = g_strstrip(g_strdup((char *)xmlTextReaderValue(parser->reader))); 
     133                *string = g_strstrip(g_strdup((char *)xmlTextReaderConstValue(parser->reader))); 
    134134                 
    135135                if (!_smlXmlParserExpectNode(parser, XML_NODE_CLOSE, FALSE, name, error)) 
    …… 
    197197                        case XML_NODE_CDATA: 
    198198                        case XML_NODE_TEXT: 
    199                                 rc = xmlTextWriterWriteRaw(writer, xmlTextReaderValue(parser->reader)); 
     199                                rc = xmlTextWriterWriteRaw(writer, xmlTextReaderConstValue(parser->reader)); 
    200200                                if (rc < 0) { 
    201201                                        smlErrorSet(error, SML_ERROR_GENERIC, "Unable to add string"); 
    …… 
    217217         
    218218        xmlFreeTextWriter(writer); 
    219         *string = g_strdup((char *)xmlBufferContent(buffer)); 
     219        *string = (char *)xmlBufferContent(buffer); 
    220220        if (size) 
    221221                *size = xmlBufferLength(buffer); 
    222222         
    223223        (*string)[*size - 1] = 0; 
     224         
     225        //Hack to avoid memory copy 
     226        g_free(buffer); 
    224227         
    225228        return TRUE; 
    …… 
    314317        if (!location) 
    315318                goto error; 
     319        (*location)->refCount = 1; 
    316320         
    317321        while (1) { 
    …… 
    321325                } 
    322326                 
    323                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_TARGET) && \ 
     327                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET) && \ 
    324328                        xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    325329                        break; 
    326                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_SOURCE) && \ 
     330                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE) && \ 
    327331                        xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    328332                        break; 
    …… 
    332336                } 
    333337                 
    334                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_LOCURI)) { 
     338                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_LOCURI)) { 
    335339                        if (!_smlXmlParserGetString(parser, &((*location)->locURI), SML_ELEMENT_LOCURI, error)) 
    336340                                goto error_free_location; 
    337                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_LOCNAME)) { 
     341                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_LOCNAME)) { 
    338342                        if (!_smlXmlParserGetString(parser, &((*location)->locName), SML_ELEMENT_LOCNAME, error)) 
    339343                                goto error_free_location; 
    …… 
    353357 
    354358error_free_location: 
    355         g_free(location); 
     359        smlLocationUnref(*location); 
    356360error: 
    357361        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    380384                } 
    381385                 
    382                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ANCHOR) && \ 
     386                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ANCHOR) && \ 
    383387                        xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    384388                        break; 
    …… 
    388392                } 
    389393                 
    390                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_NEXT)) { 
     394                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NEXT)) { 
    391395                        if (!_smlXmlParserGetString(parser, &((*anchor)->next), SML_ELEMENT_NEXT, error)) 
    392396                                goto error_free_anchor; 
    393                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_LAST)) { 
     397                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_LAST)) { 
    394398                        if (!_smlXmlParserGetString(parser, &((*anchor)->last), SML_ELEMENT_LAST, error)) 
    395399                                goto error_free_anchor; 
    …… 
    409413 
    410414error_free_anchor: 
    411         g_free(*anchor); 
     415        smlAnchorFree(*anchor); 
    412416error: 
    413417        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    426430                } 
    427431                 
    428                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_META) && \ 
     432                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META) && \ 
    429433                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    430434                        break; 
    …… 
    434438                } 
    435439                 
    436                 if (type && !strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_TYPE)) { 
     440                if (type && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TYPE)) { 
    437441                        if (!_smlXmlParserGetString(parser, type, SML_ELEMENT_TYPE, error)) 
    438442                                goto error; 
    439                 } else if (anchor && !strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ANCHOR)) { 
     443                } else if (anchor && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ANCHOR)) { 
    440444                        if (!_smlAnchorParse(anchor, parser, error)) 
    441445                                goto error; 
    442                 } else if (format && !strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_FORMAT)) { 
     446                } else if (format && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_FORMAT)) { 
    443447                        if (!_smlXmlParserGetString(parser, format, SML_ELEMENT_FORMAT, error)) 
    444448                                goto error; 
    445449                } else { 
    446                         smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderName(parser->reader)); 
     450                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderConstName(parser->reader)); 
    447451                        goto error; 
    448452                } 
    …… 
    468472                } 
    469473                 
    470                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_META) && \ 
     474                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META) && \ 
    471475                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    472476                        break; 
    …… 
    476480                } 
    477481                 
    478                 if (maxobjsize && !strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_MAXOBJSIZE)) { 
     482                if (maxobjsize && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXOBJSIZE)) { 
    479483                        if (!_smlXmlParserGetID(parser, maxobjsize, SML_ELEMENT_MAXOBJSIZE, error)) 
    480484                                goto error; 
    481485                } else { 
    482                         smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderName(parser->reader)); 
     486                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderConstName(parser->reader)); 
    483487                        goto error; 
    484488                } 
    …… 
    505509                if (!_smlXmlParserStep(parser)) { 
    506510                        smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes"); 
    507                         goto error; 
    508                 } 
    509                  
    510                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ITEM) && \ 
     511                        goto error_free_item; 
     512                } 
     513                 
     514                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM) && \ 
    511515                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    512516                        break; 
    …… 
    516520                } 
    517521                 
    518                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_SOURCE)) { 
     522                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) { 
    519523                        if (!_smlLocationParse(&item->source, parser, error)) 
    520                                 goto error; 
    521                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_TARGET)) { 
     524                                goto error_free_item; 
     525                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) { 
    522526                        if (!_smlLocationParse(&item->target, parser, error)) 
    523                                 goto error; 
    524                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_META)) { 
     527                                goto error_free_item; 
     528                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) { 
    525529                        switch (type) { 
    526530                                case SML_COMMAND_TYPE_ALERT: 
    527531                                        if (!_smlCommandMetaParse(parser, NULL, NULL, &cmd->private.alert.anchor, error)) 
    528                                                 goto error; 
     532                                                goto error_free_item; 
    529533                                        break; 
    530534                                default: 
    531535                                        smlErrorSet(error, SML_ERROR_GENERIC, "Unknown command type"); 
    532                                         goto error; 
     536                                        goto error_free_item; 
    533537                        } 
    534                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_DATA)) { 
     538                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA)) { 
    535539                        switch (type) { 
    536540                                case SML_COMMAND_TYPE_ALERT: 
    537541                                        if (!_smlXmlParserStep(parser)) { 
    538542                                                smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes"); 
    539                                                 goto error; 
     543                                                goto error_free_item; 
    540544                                        } 
    541545                                         
    542546                                        if (!_smlAnchorParse(&(item->anchor), parser, error)) 
    543                                                 goto error; 
     547                                                goto error_free_item; 
    544548                                         
    545549                                        if (!_smlXmlParserStep(parser)) { 
    546550                                                smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes"); 
    547                                                 goto error; 
     551                                                goto error_free_item; 
    548552                                        } 
    549553                                        break; 
    550554                                default: 
    551555                                        if (!_smlXmlParserGetData(parser, &item->data, &item->size, SML_ELEMENT_DATA, error)) 
    552                                                 goto error; 
     556                                                goto error_free_item; 
    553557                        } 
    554558                } else { 
    555                         smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderName(parser->reader)); 
    556                         goto error; 
     559                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderConstName(parser->reader)); 
     560                        goto error_free_item; 
    557561                } 
    558562        } 
    …… 
    561565        return item; 
    562566 
     567error_free_item: 
     568        smlItemFree(item); 
    563569error: 
    564570        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    583589                } 
    584590                 
    585                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_CRED) && \ 
     591                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CRED) && \ 
    586592                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    587593                        break; 
    …… 
    591597                } 
    592598                 
    593                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_META)) { 
     599                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) { 
    594600                        if (!_smlCommandMetaParse(parser, &format, &type, NULL, error)) 
    595601                                goto error_free_cred; 
    596                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_DATA)) { 
     602                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA)) { 
    597603                        if (!_smlXmlParserGetString(parser, &cred->data, SML_ELEMENT_DATA, error)) 
    598604                                goto error_free_cred; 
    599605                } else { 
    600                         smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderName(parser->reader)); 
     606                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderConstName(parser->reader)); 
    601607                        goto error_free_cred; 
    602608                } 
    …… 
    633639 
    634640error_free_cred: 
    635         if (cred->data) 
    636                 g_free(cred->data); 
    637         g_free(cred); 
     641        smlCredFree(cred); 
    638642error: 
    639643        if (format) 
    …… 
    656660        if (!*cmd) 
    657661                goto error;      
     662        (*cmd)->refCount = 1; 
    658663         
    659664        while (1) { 
    …… 
    663668                } 
    664669                 
    665                 if (!strcmp((char *)xmlTextReaderName(parser->reader), name) && \ 
     670                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), name) && \ 
    666671                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    667672                        break; 
    …… 
    671676                } 
    672677                 
    673                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_CMDID)) { 
     678                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) { 
    674679                        if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error)) 
    675680                                goto error; 
    676                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ITEM)) { 
     681                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) { 
    677682                        item = _smlItemParse(parser, *cmd, SML_COMMAND_TYPE_SYNC, error); 
    678683                        if (!item) 
    679684                                goto error; 
    680                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_META)) { 
     685                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) { 
    681686                        if (!_smlCommandMetaParse(parser, NULL, &contenttype, NULL, error)) 
    682687                                goto error; 
    …… 
    738743        } 
    739744         
     745        if (contenttype) 
     746                g_free(contenttype); 
     747         
    740748        smlTrace(TRACE_EXIT, "%s: %p", __func__, *cmd); 
    741749        return TRUE; 
    742750 
    743751error_free_cmd: 
    744         smlCommandFree(*cmd); 
    745 error: 
     752        smlCommandUnref(*cmd); 
     753error: 
     754        if (contenttype) 
     755                g_free(contenttype); 
    746756        if (item) 
    747757                smlItemFree(item); 
    …… 
    761771                } 
    762772                 
    763                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_META) && \ 
     773                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META) && \ 
    764774                        xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    765775                        break; 
    …… 
    769779                } 
    770780                 
    771                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_MAXMSGSIZE)) { 
     781                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXMSGSIZE)) { 
    772782                        if (!_smlXmlParserGetID(parser, maxmsgsize, SML_ELEMENT_MAXMSGSIZE, error)) 
    773783                                goto error; 
    774                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_MAXOBJSIZE)) { 
     784                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAXOBJSIZE)) { 
    775785                        if (!_smlXmlParserGetID(parser, maxobjsize, SML_ELEMENT_MAXOBJSIZE, error)) 
    776786                                goto error; 
    …… 
    803813        if (!*cmd) 
    804814                goto error; 
     815        (*cmd)->refCount = 1; 
    805816                 
    806817        while (1) { 
    …… 
    810821                } 
    811822                 
    812                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ALERT) && \ 
     823                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ALERT) && \ 
    813824                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    814825                        break; 
    …… 
    818829                } 
    819830                 
    820                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_CMDID)) { 
     831                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) { 
    821832                        if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error)) 
    822833                                goto error_free_cmd; 
    823                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ITEM)) { 
     834                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) { 
    824835                        SmlItem *item = _smlItemParse(parser, (*cmd), SML_COMMAND_TYPE_ALERT, error); 
    825836                        if (!item) 
    …… 
    830841                        (*cmd)->source = item->source; 
    831842                        item->source = NULL; 
    832                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_DATA)) { 
     843                         
     844                        smlItemFree(item); 
     845                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DATA)) { 
    833846                        if (!_smlXmlParserGetID(parser, &((*cmd)->private.alert.type), SML_ELEMENT_DATA, error)) 
    834847                                goto error_free_cmd; 
    835848                } else { 
    836                         smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderName(parser->reader)); 
     849                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderConstName(parser->reader)); 
    837850                        goto error_free_cmd; 
    838851                } 
    …… 
    854867 
    855868error_free_cmd: 
    856         smlCommandFree(*cmd); 
     869        smlCommandUnref(*cmd); 
    857870error: 
    858871        *cmd = NULL; 
    …… 
    877890                } 
    878891                 
    879                 if (xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE && !strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_SYNC)) 
     892                if (xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SYNC)) 
    880893                        break; 
    881894                else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) { 
    …… 
    884897                } 
    885898                 
    886                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ADD) || \ 
    887                 !strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_REPLACE) || \ 
    888                 !strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_DELETE)) 
    889                         break; 
    890                  
    891                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_CMDID)) { 
     899                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ADD) || \ 
     900                !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_REPLACE) || \ 
     901                !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_DELETE)) 
     902                        break; 
     903                 
     904                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) { 
    892905                        if (!_smlXmlParserGetID(parser, &((*cmd)->cmdID), SML_ELEMENT_CMDID, error)) 
    893906                                goto error_free_cmd; 
    894                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_ITEM)) { 
     907                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_ITEM)) { 
    895908                        SmlItem *item = _smlItemParse(parser, (*cmd), SML_COMMAND_TYPE_SYNC, error); 
    896909                        if (!item) 
    897910                                goto error_free_cmd; 
    898                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_META)) { 
     911                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) { 
    899912                        if (!_smlCommandSyncMetaParse(parser, &((*cmd)->private.sync.maxObjSize), error)) 
    900913                                goto error; 
    901                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_TARGET)) { 
     914                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) { 
    902915                        if (!_smlLocationParse(&(*cmd)->target, parser, error)) 
    903916                                goto error_free_cmd; 
    904                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_SOURCE)) { 
     917                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) { 
    905918                        if (!_smlLocationParse(&(*cmd)->source, parser, error)) 
    906919                                goto error_free_cmd; 
    907                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_NUMBEROFCHANGES)) { 
     920                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_NUMBEROFCHANGES)) { 
    908921                        if (!_smlXmlParserGetID(parser, &((*cmd)->private.sync.numChanged), SML_ELEMENT_NUMBEROFCHANGES, error)) 
    909922                                goto error_free_cmd; 
    910923                } else { 
    911                         smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderName(parser->reader)); 
     924                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderConstName(parser->reader)); 
    912925                        goto error_free_cmd; 
    913926                } 
    …… 
    918931 
    919932error_free_cmd: 
    920         smlCommandFree(*cmd); 
     933        smlCommandUnref(*cmd); 
    921934error: 
    922935        *cmd = NULL; 
    …… 
    937950                if (!_smlXmlParserStep(parser)) { 
    938951                        smlErrorSet(error, SML_ERROR_GENERIC, "Missing nodes"); 
    939                         goto error; 
    940                 } 
    941                  
    942                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_MAPITEM) && \ 
     952                        goto error_free_item; 
     953                } 
     954                 
     955                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAPITEM) && \ 
    943956                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    944957                        break; 
    945958                } else if (xmlTextReaderNodeType(parser->reader) != XML_NODE_START) { 
    946959                        smlErrorSet(error, SML_ERROR_GENERIC, "Not a start node"); 
    947                         goto error; 
    948                 } 
    949                  
    950                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_SOURCE)) { 
     960                        goto error_free_item; 
     961                } 
     962                 
     963                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SOURCE)) { 
    951964                        if (!_smlLocationParse(&item->source, parser, error)) 
    952                                 goto error; 
    953                 } else if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_TARGET)) { 
     965                                goto error_free_item; 
     966                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_TARGET)) { 
    954967                        if (!_smlLocationParse(&item->target, parser, error)) 
    955                                 goto error; 
     968                                goto error_free_item; 
    956969                } else { 
    957                         smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderName(parser->reader)); 
    958                         goto error; 
     970                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node %s", xmlTextReaderConstName(parser->reader)); 
     971                        goto error_free_item; 
    959972                } 
    960973        } 
    …… 
    963976        return item; 
    964977 
     978error_free_item: 
     979        smlMapItemFree(item); 
    965980error: 
    966981        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    977992        if (!*cmd) 
    978993                goto error; 
     994        (*cmd)->refCount = 1; 
    979995         
    980996        while (1) { 
    …… 
    9841000                } 
    9851001                 
    986                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_MAP) && \ 
     1002                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAP) && \ 
    9871003                xmlTextReaderNodeType(parser->reader) == XML_NODE_CLOSE) { 
    9881004                        break; 
    …… 
    9921008                } 
    9931009                 
    994                 if (!strcmp((char *)xmlTextReaderName(parser->reader), SML_ELEMENT_CMDID)) { 
     1010                if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_CMDID)) { 
    9951011