Changeset 360

Show
Ignore:
Timestamp:
02/04/08 10:40:28 (10 months ago)
Author:
bellmich
Message:

introduced smlSafe(C)Free as replacement for g_free

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libsyncml/objects/sml_auth.c

    r320 r360  
    8080                                 
    8181                                char **arr = g_strsplit(buffer, ":", 2); 
    82                                 g_free(buffer); 
     82                                smlSafeCFree(&buffer); 
    8383                                 
    8484                                smlTrace(TRACE_INTERNAL, "Username \"%s\", Password \"%s\"", arr[0], arr[1]); 
    …… 
    168168        smlAssert(auth); 
    169169         
    170         g_free(auth); 
     170        smlSafeFree((gpointer *)&auth); 
    171171         
    172172        smlTrace(TRACE_EXIT, "%s", __func__);    

  • trunk/libsyncml/objects/sml_devinf_obj.c

    r334 r360  
    263263        smlAssert(agent); 
    264264         
    265         g_free(agent); 
     265        smlSafeFree((gpointer *)&agent); 
    266266         
    267267        smlTrace(TRACE_EXIT, "%s", __func__);    

  • trunk/libsyncml/objects/sml_ds_server.c

    r325 r360  
    6161         
    6262        if (ctx->uid) 
    63                 g_free(ctx->uid); 
     63                smlSafeCFree(&(ctx->uid)); 
    6464                 
    6565        if (ctx->newuid) 
    66                 g_free(ctx->newuid); 
    67          
    68         g_free(ctx); 
     66                smlSafeCFree(&(ctx->newuid)); 
     67         
     68        smlSafeFree((gpointer *)&ctx); 
    6969 
    7070        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    239239         
    240240        if (server->contenttype) 
    241                 g_free(server->contenttype); 
    242          
    243         g_free(server); 
     241                smlSafeCFree(&(server->contenttype)); 
     242         
     243        smlSafeFree((gpointer *)&server); 
    244244         
    245245        smlTrace(TRACE_EXIT, "%s", __func__);    
    …… 
    363363 
    364364error_free_dsession: 
    365         g_free(dsession); 
     365        smlSafeFree((gpointer *)&dsession); 
    366366error: 
    367367        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    458458                g_mutex_free(dsession->lock); 
    459459                 
    460                 g_free(dsession); 
     460                smlSafeFree((gpointer *)&dsession); 
    461461        } 
    462462         
    …… 
    944944 
    945945error_free_ctx: 
    946         g_free(ctx->uid); 
    947         g_free(ctx); 
     946        smlSafeCFree(&(ctx->uid)); 
     947        smlSafeFree((gpointer *)&ctx); 
    948948error_free_cmd: 
    949949        smlCommandUnref(cmd); 
    …… 
    10871087 
    10881088error_free_dsession: 
    1089         g_free(dsession); 
     1089        smlSafeFree((gpointer *)&dsession); 
    10901090error: 
    10911091        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(&error)); 

  • trunk/libsyncml/parser/sml_wbxml.c

    r323 r360  
    8585        char *bin = smlPrintBinary(data, size); 
    8686        smlTrace(TRACE_INTERNAL, "Wbxml input: %s", bin); 
    87         g_free(bin); 
     87        smlSafeCFree(&bin); 
    8888        smlLog("received-%i.wbxml", data, size); 
    8989         
    …… 
    146146        char *hex = smlPrintHex(*data, *size); 
    147147        smlTrace(TRACE_INTERNAL, "Wbxml assembled: %s", hex); 
    148         g_free(hex); 
     148        smlSafeCFree(&hex); 
    149149 
    150150        smlLog("sent-%i.wbxml", *data, *size); 
    …… 
    177177                goto error_free_buffer; 
    178178         
    179         g_free(data); 
    180         g_free(buffer); 
     179        smlSafeCFree(&data); 
     180        smlSafeCFree(&buffer); 
    181181         
    182182        smlTrace(TRACE_EXIT, "%s: %i", __func__, size); 
    …… 
    184184 
    185185error_free_buffer: 
    186         g_free(buffer); 
     186        smlSafeCFree(&buffer); 
    187187error: 
    188188        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 

  • trunk/libsyncml/parser/sml_xml_assm.c

    r345 r360  
    910910        xmlBufferFree(assmcmd->buffer); 
    911911error_free_cmd: 
    912         g_free(assmcmd); 
     912        smlSafeFree((gpointer *)&assmcmd); 
    913913error: 
    914914        return FALSE; 
    …… 
    984984         
    985985        xmlBufferFree(cmd->buffer); 
    986         g_free(cmd); 
     986        smlSafeFree((gpointer *)&cmd); 
    987987         
    988988        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    12621262                 
    12631263                xmlBufferFree(cmd->buffer); 
    1264                 g_free(cmd); 
     1264                smlSafeFree((gpointer *)&cmd); 
    12651265        }        
    12661266         
    …… 
    12821282                        xmlBufferFree(status->buffer); 
    12831283                 
    1284                 g_free(status); 
     1284                smlSafeFree((gpointer *)&status); 
    12851285                assm->statuses = g_list_delete_link(assm->statuses, assm->statuses); 
    12861286        } 
    …… 
    12891289 
    12901290        g_mutex_free(assm->mutex); 
    1291         g_free(assm); 
     1291        smlSafeFree((gpointer *)&assm); 
    12921292 
    12931293        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    13201320                        xmlBufferFree(status->buffer); 
    13211321                        assm->statuses = g_list_remove(assm->statuses, status); 
    1322                         g_free(status); 
     1322                        smlSafeFree((gpointer *)&status); 
    13231323                        assm->reserved_statuses--; 
    13241324                        assm->added_statuses--; 
    …… 
    15871587 
    15881588        // the buffer was created with xmlBufferCreateSize 
    1589         // so we must free it via the libxml API and not via g_free 
     1589        // so we must free it via the libxml API and not via smlSafeCFree 
    15901590        *size = xmlBufferLength(buffer); 
    15911591        *data = g_strndup(xmlBufferContent(buffer), *size); 
    …… 
    17291729 
    17301730error_mutex: 
    1731         g_free(assm); 
     1731        smlSafeFree((gpointer *)&assm); 
    17321732        smlErrorSet(error, SML_ERROR_GENERIC, "%s - Cannot create new mutex.", __func__); 
    17331733error: 
    …… 
    22832283        xmlBufferFree(buffer); 
    22842284         
    2285         g_free(assm); 
     2285        smlSafeFree((gpointer *)&assm); 
    22862286         
    22872287        smlTrace(TRACE_INTERNAL, "Message Assembled: %s", *data); 
    …… 
    22962296        xmlBufferFree(buffer); 
    22972297error_free_assm: 
    2298         g_free(assm); 
     2298        smlSafeFree((gpointer *)&assm); 
    22992299error: 
    23002300        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 

  • trunk/libsyncml/sml_command.c

    r240 r360  
    164164                        smlLocationUnref(status->targetRef); 
    165165                 
    166                 g_free(status->data); 
     166                if (status->data) 
     167                        smlSafeCFree(&(status->data)); 
    167168                 
    168169                if (status->anchor) 
    169170                        smlAnchorFree(status->anchor); 
    170171                         
    171                 g_free(status); 
     172                smlSafeFree((gpointer *)&status); 
    172173        } 
    173174         
    …… 
    317318                                        smlAnchorFree(cmd->private.alert.anchor); 
    318319                                if (cmd->private.alert.contentType) 
    319                                         g_free(cmd->private.alert.contentType); 
     320                                        smlSafeCFree(&(cmd->private.alert.contentType)); 
    320321                                break; 
    321322                        case SML_COMMAND_TYPE_PUT: 
    322323                        case SML_COMMAND_TYPE_GET: 
    323324                                if (cmd->private.access.type) 
    324                                         g_free(cmd->private.access.type); 
     325                                        smlSafeCFree(&(cmd->private.access.type)); 
    325326                                         
    326327                                if (cmd->private.access.item) 
    …… 
    352353                        smlLocationUnref(cmd->source); 
    353354                 
    354                 g_free(cmd); 
     355                smlSafeFree((gpointer *)&cmd); 
    355356        } 
    356357         

  • trunk/libsyncml/sml_error.c

    r240 r360  
    8383         
    8484        if ((*error)->message) 
    85                 g_free ((*error)->message); 
    86                  
    87         g_free(*error); 
    88         *error = NULL; 
     85                smlSafeCFree (&((*error)->message)); 
     86                 
     87        smlSafeFree((gpointer *)error); 
    8988} 
    9089 
    …… 
    155154        g_vsnprintf(buffer, 1024, format, args); 
    156155         
    157         g_free((*error)->message); 
     156        smlSafeCFree(&((*error)->message)); 
    158157        (*error)->message = g_strdup(buffer); 
    159158         

  • trunk/libsyncml/sml_manager.c

    r334 r360  
    7171        } 
    7272         
    73         g_free(sess); 
     73        smlSafeFree((gpointer *)&sess); 
    7474} 
    7575 
    …… 
    166166                smlErrorDeref(&event->error); 
    167167         
    168         g_free(event); 
     168        smlSafeFree((gpointer *)&event); 
    169169         
    170170        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    326326 
    327327error_free_manager: 
    328         g_free(manager);       
     328        smlSafeFree((gpointer *)&manager);     
    329329error: 
    330330        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    363363 
    364364        if (manager->functions) 
    365                 g_free(manager->functions); 
     365                smlSafeFree((gpointer *)&(manager->functions)); 
    366366                 
    367367        if (manager->thread) 
    …… 
    376376        g_mutex_free(manager->running_mutex); 
    377377         
    378         g_free(manager); 
     378        smlSafeFree((gpointer *)&manager); 
    379379         
    380380        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    568568                char *lastid = g_strdup_printf("%i", manager->lastSessionID); 
    569569                smlSessionSetSessionID(session, lastid); 
    570                 g_free(lastid); 
     570                smlSafeCFree(&lastid); 
    571571        } 
    572572         
    …… 
    671671                        smlLocationUnref(object->source); 
    672672                if (object->contentType) 
    673                         g_free(object->contentType); 
     673                        smlSafeCFree(&(object->contentType)); 
    674674        } 
    675675        else 
    …… 
    767767         
    768768        if (object->contentType) 
    769                 g_free(object->contentType); 
    770          
    771         g_free(object); 
     769                smlSafeCFree(&(object->contentType)); 
     770         
     771        smlSafeFree((gpointer *)&object); 
    772772         
    773773        smlTrace(TRACE_EXIT, "%s", __func__); 

  • trunk/libsyncml/sml_notification.c

    r307 r360  
    125125                smlLocationUnref(san->target); 
    126126         
    127         g_free(san->identifier); 
     127        smlSafeCFree(&(san->identifier)); 
    128128        if (san->cred) 
    129129                smlCredUnref(san->cred); 
    130         g_free(san); 
     130        smlSafeFree((gpointer *)&san); 
    131131         
    132132        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    161161        smlAssert(alert); 
    162162         
    163         g_free(alert->contenttype); 
    164         g_free(alert->serverURI); 
    165         g_free(alert); 
     163        smlSafeCFree(&(alert->contenttype)); 
     164        smlSafeCFree(&(alert->serverURI)); 
     165        smlSafeFree((gpointer *)&alert); 
    166166         
    167167        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    295295                san->alerts = g_list_delete_link(san->alerts, san->alerts); 
    296296        } 
    297         g_free(san->identifier); 
    298         g_free(san); 
     297        smlSafeCFree(&(san->identifier)); 
     298        smlSafeFree((gpointer *)&san); 
    299299error: 
    300300        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    379379        char *hex = smlPrintHex(*data, *size); 
    380380        smlTrace(TRACE_INTERNAL, "San packet assembled: %s", hex); 
    381         g_free(hex); 
     381        smlSafeCFree(&hex); 
    382382         
    383383        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    474474        char *hex = smlPrintHex(*data, *size); 
    475475        smlTrace(TRACE_INTERNAL, "San packet assembled: %s", hex); 
    476         g_free(hex); 
     476        smlSafeCFree(&hex); 
    477477         
    478478        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    480480 
    481481error_free_data: 
    482         g_free(*data); 
     482        smlSafeCFree(data); 
    483483error: 
    484         *data = NULL; 
    485484        *size = 0; 
    486485        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    536535 
    537536        smlTransportDataDeref(tspdata); 
    538         g_free(data); 
     537        smlSafeCFree(&data); 
    539538 
    540539        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    544543        smlTransportDataDeref(tspdata); 
    545544error_free_data: 
    546         g_free(data); 
     545        smlSafeCFree(&data); 
    547546error: 
    548547        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 

  • trunk/libsyncml/sml_parse.c

    r242 r360  
    7979 
    8080error_free_parser: 
    81         g_free(parser); 
     81        smlSafeFree((gpointer *)&parser); 
    8282error: 
    8383        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    9898                parser->functions.free(parser->parser_userdata); 
    9999         
    100         g_free(parser); 
     100        smlSafeFree((gpointer *)&parser); 
    101101 
    102102        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    325325         
    326326error_free_assm: 
    327         g_free(assm); 
     327        smlSafeFree((gpointer *)&assm); 
    328328error: 
    329329        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    346346        g_hash_table_destroy(assm->options); 
    347347         
    348         g_free(assm); 
     348        smlSafeFree((gpointer *)&assm); 
    349349 
    350350        smlTrace(TRACE_EXIT, "%s", __func__); 

  • trunk/libsyncml/sml_queue.c

    r127 r360  
    9797        g_mutex_free(queue->mutex); 
    9898         
    99         g_free(queue); 
     99        smlSafeFree((gpointer *)&queue); 
    100100} 
    101101 
    …… 
    429429        g_source_unref(queue->source); 
    430430         
    431         g_free(queue->functions); 
     431        smlSafeFree((gpointer *)&(queue->functions)); 
    432432         
    433433        queue->source = NULL; 

  • trunk/libsyncml/sml_session.c

    r346 r360  
    6969{ 
    7070        while (session->pendingReplies) { 
    71                 g_free((SmlPendingStatus *)session->pendingReplies->data); 
     71                smlSafeFree((gpointer *)&(session->pendingReplies->data)); 
    7272                session->pendingReplies = g_list_delete_link(session->pendingReplies, session->pendingReplies); 
    7373        } 
    …… 
    150150 
    151151error_free_data: 
    152         g_free(data); 
     152        smlSafeCFree(&data); 
    153153error: 
    154154        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    476476                smlStatusUnref(sesscmd->status); 
    477477         
    478         g_free(sesscmd); 
     478        smlSafeFree((gpointer *)&sesscmd); 
    479479} 
    480480 
    …… 
    646646                        pending->callback(session, status, pending->userdata); 
    647647                         
    648                         g_free(pending); 
     648                        smlSafeFree((gpointer *)&pending); 
    649649                         
    650650                        goto out; 
    …… 
    912912                                                smlTrace(TRACE_INTERNAL, "%s: Content so far: %s\n", 
    913913                                                        __func__, bin); 
    914                                                 g_free(bin); 
     914                                                smlSafeCFree(&bin); 
    915915                                        } 
    916916                                         
    …… 
    12501250         
    12511251        if (session->sessionID) 
    1252                 g_free(session->sessionID); 
     1252                smlSafeCFree(&(session->sessionID)); 
    12531253        session->sessionID = g_strdup(sessionID); 
    12541254} 
    …… 
    14221422                 
    14231423                if (session->sessionID) 
    1424                         g_free(session->sessionID); 
     1424                        smlSafeCFree(&(session->sessionID)); 
    14251425                 
    14261426                if (session->command_queue) { 
    …… 
    14451445                g_mutex_free(session->dispatch_mutex); 
    14461446                 
    1447                 g_free(session); 
     1447                smlSafeFree((gpointer *)&session); 
    14481448        } 
    14491449         

  • trunk/libsyncml/sml_support.c

    r349 r360  
    7575                char *logfile_tmp = g_strdup_printf("%s/%s", trace, logname); 
    7676                logfile = g_strdup_printf(logfile_tmp, i); 
    77                 g_free(logfile_tmp); 
     77                smlSafeCFree(&logfile_tmp); 
    7878                if (!g_file_test(logfile, G_FILE_TEST_EXISTS)) 
    7979                        break; 
    80                 g_free(logfile); 
     80                smlSafeCFree(&logfile); 
    8181        } 
    8282         
    …… 
    157157                if (!matched) 
    158158                { 
    159                         g_free(buffer); 
     159                        smlSafeCFree(&buffer); 
    160160                        return; 
    161161                } 
    …… 
    195195                        break; 
    196196        } 
    197         g_free(buffer); 
     197        smlSafeCFree(&buffer); 
    198198         
    199199        g_private_set(current_tabs, GINT_TO_POINTER(tabs)); 
    …… 
    205205        if (!chan) { 
    206206                printf("unable to open %s for writing: %s\n", logfile, error->message); 
    207                 g_free(logfile); 
    208                 g_free(logmessage); 
     207                smlSafeCFree(&logfile); 
     208                smlSafeCFree(&logmessage); 
    209209                return; 
    210210        } 
    …… 
    219219        g_io_channel_shutdown(chan, TRUE, NULL); 
    220220        g_io_channel_unref(chan); 
    221         g_free(logmessage); 
    222         g_free(logfile); 
     221        smlSafeCFree(&logmessage); 
     222        smlSafeCFree(&logfile); 
    223223#endif 
    224224} 
    …… 
    374374                g_main_context_unref(thread->context); 
    375375                 
    376         g_free(thread); 
     376        smlSafeFree((gpointer *)&thread); 
    377377        smlTrace(TRACE_EXIT, "%s", __func__); 
    378378} 

  • trunk/libsyncml/sml_transport.c

    r275 r360  
    123123                smlTransportDataDeref(cmd->data); 
    124124         
    125         g_free(cmd); 
     125        smlSafeFree((gpointer *)&cmd); 
    126126         
    127127        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    324324         
    325325        if (data->ownsData && data->data != NULL) 
    326                 g_free(data->data); 
    327          
    328         g_free(data); 
     326                smlSafeCFree(&(data->data)); 
     327         
     328        smlSafeFree((gpointer *)&data); 
    329329                 
    330330        smlTrace(TRACE_EXIT, "%s: Freed", __func__); 
    …… 
    426426                smlQueueFree(link->event_queue); 
    427427         
    428         g_free(link); 
     428        smlSafeFree((gpointer *)&link); 
    429429                 
    430430        smlTrace(TRACE_EXIT, "%s: Freed", __func__); 
    …… 
    531531                g_main_context_unref(tsp->context); 
    532532         
    533         g_free(tsp); 
     533        smlSafeFree((gpointer *)&tsp); 
    534534         
    535535        smlTrace(TRACE_EXIT, "%s", __func__); 

  • trunk/libsyncml/transports/http_client.c

    r359 r360  
    142142         
    143143error_free_data: 
    144         g_free(data); 
     144        smlSafeCFree(&data); 
    145145error: 
    146146        smlTransportReceiveEvent(env->tsp, NULL, SML_TRANSPORT_EVENT_ERROR, NULL, error); 
    …… 
    248248error_free_env: 
    249249        soup_uri_free(env->uri); 
    250         g_free(env); 
     250        smlSafeFree((gpointer *)&env); 
    251251error: 
    252252        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    291291         
    292292        soup_uri_free(env->uri); 
    293         g_free(env->url); 
    294         g_free(env->proxy); 
    295         g_free(env); 
     293        smlSafeCFree(&(env->url)); 
     294        if (env->proxy) smlSafeCFree(&(env->proxy)); 
     295        smlSafeFree((gpointer *)&env); 
    296296         
    297297        smlTrace(TRACE_EXIT, "%s", __func__); 

  • trunk/libsyncml/transports/http_server.c

    r356 r360  
    5151                smlErrorSet(&error, SML_ERROR_FILE_NOT_FOUND, "Not Found"); 
    5252                soup_message_set_status(msg, SOUP_STATUS_NOT_FOUND); 
    53                 free(path); 
    54                 goto error; 
    55         } 
    56         free(path); 
     53                smlSafeCFree(&path); 
     54                goto error; 
     55        } 
     56        smlSafeCFree(&path); 
     57         
    5758 
    5859        if (soup_message_get_http_version(msg) != 1) { 
    …… 
    6768                goto error; 
    6869        } 
    69          
    7070         
    7171        const char *header = soup_message_get_header(msg->request_headers, "Content-Type"); 
    …… 
    192192 
    193193error_free_env: 
    194         g_free(env->url); 
    195         g_free(env->interface); 
    196         g_free(env); 
     194        smlSafeCFree(&(env->url)); 
     195        smlSafeCFree(&(env->interface)); 
     196        smlSafeFree((gpointer *)&env); 
    197197error: 
    198198        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    211211        // g_object_unref(env->server); 
    212212         
    213         g_free(env->url); 
    214         g_free(env->interface); 
    215         g_free(env); 
     213        smlSafeCFree(&(env->url)); 
     214        smlSafeCFree(&(env->interface)); 
     215        smlSafeFree((gpointer *)&env); 
    216216         
    217217        smlTrace(TRACE_EXIT, "%s", __func__); 

  • trunk/libsyncml/transports/obex_client.c

    r356 r360  
    307307                                        if (!env->connection_id) { 
    308308                                                smlErrorSet(&error, SML_ERROR_GENERIC, "Missing connection id"); 
    309                                                 g_free(who); 
     309                                                smlSafeCFree(&who); 
    310310                                                goto error; 
    311311                                        } 
    …… 
    314314                                        if (!who || strcmp(who, "SYNCML-SYNC")) { 
    315315                                                smlErrorSet(&error, SML_ERROR_GENERIC, "Missing or wrong who response"); 
    316                                                 g_free(who); 
     316                                                smlSafeCFree(&who); 
    317317                                                goto error; 
    318318                                        } 
    319                                         g_free(who); 
     319                                        smlSafeCFree(&who); 
    320320                                         
    321321                                        smlTransportReceiveEvent(env->tsp, NULL, SML_TRANSPORT_EVENT_CONNECT_DONE, NULL, NULL); 
    …… 
    475475        OBEX_Cleanup(env->obexhandle); 
    476476error_free_env: 
    477         g_free(env->path); 
    478         g_free(env); 
     477        smlSafeCFree(&(env->path)); 
     478        smlSafeFree((gpointer *)&env); 
    479479error: 
    480480        smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error)); 
    …… 
    490490         
    491491        smlAssert(env->tsp); 
    492         g_free(env->path); 
    493         g_free(env->stream_chunk); 
     492        smlSafeCFree(&(env->path)); 
     493        smlSafeFree((gpointer *)&(env->stream_chunk)); 
    494494         
    495495        OBEX_Cleanup(env->obexhandle); 
    496496         
    497         g_free(env); 
     497        smlSafeFree((gpointer *)&env); 
    498498         
    499499        smlTrace(TRACE_EXIT, "%s", __func__); 

  • trunk/libsyncml/transports/obex_server.c

    r127 r360  
    6464                g_source_unref(linkenv->source); 
    6565                OBEX_Cleanup(linkenv->handle); 
    66                 g_free(linkenv); 
     66                smlSafeFree((gpointer *)&linkenv); 
    6767                return FALSE; 
    6868        } 
    …… 
    151151                                                                /*char *mimetypestr = g_malloc0(len);// / 2 + 1); 
    152152                                                                if (OBEX_UnicodeToChar((unsigned char *)mimetypestr, header.bs, len / 2 + 1) == -1) { 
    153                                                                         g_free(mimetypestr); 
     153                                                                        smlSafeCFree(&mimetypestr); 
    154154                                                                        smlErrorSet(&error, SML_ERROR_GENERIC, "unable to convert from unicode"); 
    155155                                                                        goto error; 
    …… 
    165165                                                                        mimetype = SML_MIMETYPE_SAN; 
    166166                                                                } else { 
    167                                                                         g_free(mimetypestr); 
     167                                                                        smlSafeCFree(&mimetypestr); 
    168168                                                                        smlErrorSet(&error, SML_ERROR_GENERIC, "Unknown mime type"); 
    169169                                                                        goto error; 
    170170                                                                } 
    171171                                                                 
    172                                                                 g_free(mimetypestr); 
     172                                                                smlSafeCFree(&mimetypestr); 
    173173                                                                break; 
    174174                                                        case OBEX_HDR_LENGTH: 
    …… 
    243243                                                                /*char *mimetypestr = g_malloc0(len / 2 + 1); 
    244244                                                                if (OBEX_UnicodeToChar((unsigned char *)mimetypestr, header.bs, len / 2 + 1) == -1) { 
    245                                                                         g_free(mimetypestr); 
     245                                                                        smlSafeCFree(&mimetypestr); 
    246246                                                                        smlErrorSet(&error, SML_ERROR_GENERIC, "unable to convert from unicode"); 
    247247                                                                        goto error; 
    …… 
    257257                                                                        mimetype = SML_MIMETYPE_SAN; 
    258258                                                                } else { 
    259                                                                         g_free(mimetypestr); 
     259                                                                        smlSafeCFree(&mimetypestr); 
    260260                                                                        smlErrorSet(&error, SML_ERROR_GENERIC, "Unknown mime type"); 
    261261                                                                        goto error; 
    262262                                                                } 
    263263                                                                 
    264                                                                 g_free(mimetypestr); 
     264                                                                smlSafeCFree(&mimetypestr); 
    265265                                                                break; 
    266266                                                        default: 
    …… 
    335335                                         
    336336                                        if (!target || strcmp(target, "SYNCML-SYNC")) { 
    337                                                 g_free(target); 
     337                                                smlSafeCFree(&target); 
    338338                                                smlErrorSet(&error, SML_ERROR_GENERIC, "Missing target"); 
    339339                                                goto error; 
    340340                                        } 
    341                                         g_free(target); 
     341                                        smlSafeCFree(&target); 
    342342                                         
    343343                                        header.bq4 = linkenv->conid; 
    …… 
    477477        close(linkenv->fd); 
    478478error_free_env: 
    479         g_free(linkenv); 
     479  &nbs