Changeset 351

Show
Ignore:
Timestamp:
02/01/08 17:22:10 (10 months ago)
Author:
bellmich
Message:

- introduced smlSafe(C)Free in XML parser
- fixed some free calls on NULL pointer

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libsyncml/parser/sml_xml_parse.c

    r348 r351  
    299299                *version = SML_VERSION_12; 
    300300        else { 
    301                 g_free(dtd); 
     301                smlSafeCFree(&dtd); 
    302302                smlErrorSet(error, SML_ERROR_GENERIC, "Unknown VerDTD"); 
    303303                goto error; 
    304304        } 
    305         g_free(dtd); 
     305        smlSafeCFree(&dtd); 
    306306         
    307307        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    333333                *type = SML_PROTOCOL_SYNCML; 
    334334        else { 
    335                 g_free(proto); 
     335                smlSafeCFree(&proto); 
    336336                smlErrorSet(error, SML_ERROR_GENERIC, "Unknown VerProto"); 
    337337                goto error; 
    338338        } 
    339         g_free(proto); 
     339        smlSafeCFree(&proto); 
    340340         
    341341        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    562562                        if (!_smlXmlParserGetString(parser, &mark, SML_ELEMENT_MARK, error)) 
    563563                                goto error; 
    564                         g_free(mark); 
     564                        smlSafeCFree(&mark); 
    565565                } else if (size && !strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_SIZE)) { 
    566566                        if (!_smlXmlParserGetID(parser, size, SML_ELEMENT_SIZE, error)) 
    …… 
    576576                        if (!_smlXmlParserGetString(parser, &version, SML_ELEMENT_VERSION, error)) 
    577577                                goto error; 
    578                         g_free(version); 
     578                        smlSafeCFree(&version); 
    579579                } else { 
    580580                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node: %s", xmlTextReaderConstName(parser->reader)); 
    …… 
    692692                                         
    693693                                        if (!smlItemAddData(item, data, size, error)) { 
    694                                                 g_free(data); 
     694                                                smlSafeCFree(&data); 
    695695                                                goto error_free_item; 
    696696                                        } 
    697697                                         
    698                                         g_free(data); 
     698                                        smlSafeCFree(&data); 
    699699                        } 
    700700                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MOREDATA)) { 
    …… 
    778778cleanup: 
    779779        if (data) 
    780                 g_free(data); 
     780                smlSafeCFree(&data); 
    781781        if (format) 
    782                 g_free(format); 
     782                smlSafeCFree(&format); 
    783783        if (type) 
    784                 g_free(type); 
     784                smlSafeCFree(&type); 
    785785        return cred; 
    786786error:           
    …… 
    843843         
    844844        if (format) 
    845                 g_free(format); 
     845                smlSafeCFree(&format); 
    846846        if (type) 
    847                 g_free(type); 
     847                smlSafeCFree(&type); 
    848848         
    849849        smlTrace(TRACE_EXIT, "%s: %p", __func__, chal); 
    …… 
    854854error: 
    855855        if (format) 
    856                 g_free(format); 
     856                smlSafeCFree(&format); 
    857857        if (type) 
    858                 g_free(type); 
     858                smlSafeCFree(&type); 
    859859        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    860860        return NULL; 
    …… 
    964964error: 
    965965        if (contenttype) 
    966                 g_free(contenttype); 
     966                smlSafeCFree(&contenttype); 
    967967        *cmd = NULL; 
    968968        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    13131313                        if (!_smlCommandMetaParse(parser, &format, &contenttype, NULL, NULL, NULL, error)) 
    13141314                                goto error_free_cmd; 
    1315                         g_free(format); 
     1315                        smlSafeCFree(&format); 
    13161316                } else { 
    13171317                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node"); 
    …… 
    13311331         
    13321332        if (contenttype) 
    1333                 g_free(contenttype); 
     1333                smlSafeCFree(&contenttype); 
    13341334         
    13351335        /* Step once more */ 
    …… 
    13471347        *cmd = NULL; 
    13481348        if (contenttype) 
    1349                 g_free(contenttype); 
     1349                smlSafeCFree(&contenttype); 
    13501350        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    13511351        return FALSE; 
    …… 
    14011401                         
    14021402                        (*cmd)->private.results.status->sourceRef = smlLocationNew(locURI, NULL, error); 
    1403                         g_free(locURI); 
    1404                         locURI = NULL; 
     1403                        smlSafeCFree(&locURI); 
    14051404                        if (!(*cmd)->private.results.status->sourceRef) 
    14061405                                goto error_free_cmd; 
    …… 
    14101409                                 
    14111410                        (*cmd)->private.results.status->targetRef = smlLocationNew(locURI, NULL, error); 
    1412                         g_free(locURI); 
    1413                         locURI = NULL; 
     1411                        smlSafeCFree(&locURI); 
    14141412                        if (!(*cmd)->private.results.status->targetRef) 
    14151413                                goto error_free_cmd; 
    …… 
    14241422                        (*cmd)->private.results.status->item->source = NULL; 
    14251423                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_META)) { 
     1424                        /* ignore format */ 
    14261425                        char *format = NULL; 
    14271426                        if (!_smlCommandMetaParse(parser, &format, &contenttype, NULL, NULL, NULL, error)) 
    14281427                                goto error_free_cmd; 
    1429                         g_free(format); 
     1428                        if (format) smlSafeCFree(&format); 
    14301429                } else { 
    14311430                        smlErrorSet(error, SML_ERROR_GENERIC, "wrong initial node"); 
    …… 
    14511450         
    14521451        if (contenttype) 
    1453                 g_free(contenttype); 
     1452                smlSafeCFree(&contenttype); 
    14541453         
    14551454        /* Step once more */ 
    …… 
    14671466        *cmd = NULL; 
    14681467        if (contenttype) 
    1469                 g_free(contenttype); 
     1468                smlSafeCFree(&contenttype); 
    14701469        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    14711470        return FALSE; 
    …… 
    14881487        smlTrace(TRACE_INTERNAL, "Xml input: %s", debugstr); 
    14891488        smlLog("received-%i.xml", data, size); 
    1490         g_free(debugstr); 
     1489        smlSafeCFree(&debugstr); 
    14911490         
    14921491        parser->got_command = FALSE; 
    …… 
    15861585        //xmlCleanupParser(); 
    15871586         
    1588         g_free(parser); 
     1587        smlSafeFree((gpointer *)&parser); 
    15891588 
    15901589        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    17911790                                goto error_free_status; 
    17921791                        (*status)->type = smlCommandTypeFromString(cmdname, error); 
    1793                         g_free(cmdname); 
     1792                        smlSafeCFree(&cmdname); 
    17941793                        if ((*status)->type == SML_COMMAND_TYPE_UNKNOWN) 
    17951794                                goto error_free_status; 
    …… 
    18021801                         
    18031802                        (*status)->sourceRef = smlLocationNew(locURI, NULL, error); 
    1804                         g_free(locURI); 
    1805                         locURI = NULL; 
     1803                        smlSafeCFree(&locURI); 
    18061804                        if (!(*status)->sourceRef) 
    18071805                                goto error_free_status; 
    …… 
    18111809                                 
    18121810                        (*status)->targetRef = smlLocationNew(locURI, NULL, error); 
    1813                         g_free(locURI); 
    1814                         locURI = NULL; 
     1811                        smlSafeCFree(&locURI); 
    18151812                        if (!(*status)->targetRef) 
    18161813                                goto error_free_status; 
    …… 
    19941991        functions->get_cmd = (SmlParserCommandFunction)smlXmlParserGetCommand; 
    19951992        functions->get_status = (SmlParserStatusFunction)smlXmlParserGetStatus; 
    1996          
     1993 
    19971994        smlTrace(TRACE_EXIT, "%s: %p", __func__, parser); 
    19981995        return parser; 
    …… 
    22532250                                goto error; 
    22542251                } 
    2255                 g_free(value); 
     2252                smlSafeCFree(&value); 
    22562253 
    22572254                if (!_smlXmlParserStep(parser)) { 
    …… 
    22732270        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    22742271        if (value != NULL) 
    2275                 g_free(value); 
     2272                smlSafeCFree(&value); 
    22762273        return FALSE; 
    22772274} 
    …… 
    23392336                                goto error; 
    23402337                } 
    2341                 g_free(value); 
     2338                smlSafeCFree(&value); 
    23422339 
    23432340                if (!_smlXmlParserStep(parser)) { 
    …… 
    23532350        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    23542351        if (value != NULL) 
    2355                 g_free(value); 
     2352                smlSafeCFree(&value); 
    23562353        return NULL; 
    23572354} 
    …… 
    24392436                                goto error; 
    24402437                } 
    2441                 g_free(value); 
     2438                if (value) smlSafeCFree(&value); 
    24422439 
    24432440                if (!_smlXmlParserStep(parser)) { 
    …… 
    24532450        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    24542451        if (value != NULL) 
    2455                 g_free(value); 
     2452                smlSafeCFree(&value); 
    24562453        return NULL; 
    24572454} 
    …… 
    25252522                                goto error; 
    25262523                } 
    2527                 g_free(value); 
     2524                if (value) smlSafeCFree(&value); 
    25282525 
    25292526                if (!_smlXmlParserStep(parser)) { 
    …… 
    25402537        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    25412538        if (value != NULL) 
    2542                 g_free(value); 
     2539                smlSafeCFree(&value); 
    25432540        return FALSE; 
    25442541} 
    …… 
    27192716        char *debugstr = smlPrintBinary(data, size); 
    27202717        smlTrace(TRACE_INTERNAL, "Xml devinf input: %s", debugstr); 
    2721         g_free(debugstr); 
     2718        smlSafeCFree(&debugstr); 
    27222719         
    27232720        SmlXmlParser *parser = smlTryMalloc0(sizeof(SmlXmlParser), error); 
    …… 
    27702767                                devinf->version = SML_DEVINF_VERSION_12; 
    27712768                        else { 
    2772                                 g_free(verdtd); 
     2769                                smlSafeCFree(&verdtd); 
    27732770                                smlErrorSet(error, SML_ERROR_GENERIC, "Unknown devinf version"); 
    27742771                                goto error_free_devinf; 
    27752772                        } 
    2776                         g_free(verdtd); 
     2773                        smlSafeCFree(&verdtd); 
    27772774                } else if (!strcmp((char *)xmlTextReaderConstName(parser->reader), SML_ELEMENT_MAN)) { 
    27782775                        if (!_smlXmlParserGetString(parser, &(devinf->manufacturer), SML_ELEMENT_MAN, error)) 
    …… 
    28022799                         
    28032800                        devinf->devtyp = smlDevInfDevTypeFromString(devtype, error); 
    2804                         g_free(devtype); 
     2801                        smlSafeCFree(&devtype); 
    28052802                         
    28062803                        if (devinf->devtyp == SML_DEVINF_DEVTYPE_UNKNOWN) 
    …… 
    28932890        xmlFreeTextReader(parser->reader); 
    28942891        parser->reader = NULL; 
    2895         g_free(parser); 
     2892        smlSafeFree((gpointer *)&parser); 
    28962893         
    28972894        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    29042901error_free_parser: 
    29052902        parser->reader = NULL; 
    2906         g_free(parser); 
     2903        smlSafeFree((gpointer *)&parser); 
    29072904error: 
    29082905        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));