Changeset 2145

Show
Ignore:
Timestamp:
06/12/07 14:15:09 (1 year ago)
Author:
mjahn
Message:

r1052@semo: mjahn | 2007-06-09 02:57:29 +0200

r1050@semo (orig r2102): dgollub | 2007-06-09 00:32:45 +0200
Added missing osync_context_report() avoids deadlock.
Reporting deleted entries is broken at the moment ...
Fixed an issue with wrong userdata and the gnokii_sinenv.


r1051@semo (orig r2103): dgollub | 2007-06-09 01:12:14 +0200
Fixed memory leaks, invalid read of size, ...



Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • plugins/gnokii-sync/src/gnokii_calendar.c

    r2142 r2145  
    443443        g_free(caldata); 
    444444 
     445        osync_context_report_success(ctx); 
     446 
    445447        osync_trace(TRACE_EXIT, "%s", __func__); 
    446448} 
  • plugins/gnokii-sync/src/gnokii_contact.c

    r2142 r2145  
    359359        gn_phonebook_entry *contact = NULL; 
    360360        gn_memory_status memstat; 
    361         gn_data *data = (gn_data *) malloc(sizeof(gn_data)); 
    362  
    363         memset(data, 0, sizeof(gn_data)); 
     361        gn_data *data = osync_try_malloc0(sizeof(gn_data), &error);  
    364362 
    365363        OSyncObjTypeSink *sink = osync_plugin_info_get_sink(info); 
     
    367365        gnokii_sinkenv *sinkenv = osync_objtype_sink_get_userdata(sink); 
    368366        gnokii_environment *env = (gnokii_environment *) plugindata; 
     367 
     368        osync_trace(TRACE_INTERNAL, "sinkenv: %p", sinkenv); 
    369369 
    370370 
     
    420420                                continue; 
    421421 
    422                         OSyncChange *change = osync_change_new(&error); 
    423  
    424422                        // prepare UID with gnokii-contact-<memory type>-<memory location> 
    425423                        uid = gnokii_contact_uid(contact); 
     424 
     425                        hash = gnokii_contact_hash(contact); 
     426                        OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, uid, hash); 
     427 
     428                        if (type == OSYNC_CHANGE_TYPE_UNMODIFIED) { 
     429                                g_free(hash); 
     430                                g_free(uid); 
     431                                g_free(contact); 
     432                                continue; 
     433                        } 
     434 
     435                        osync_hashtable_update_hash(sinkenv->hashtable, type, uid, hash); 
     436 
     437                        OSyncChange *change = osync_change_new(&error); 
     438 
     439 
    426440                        osync_change_set_uid(change, uid); 
    427                         g_free(uid); 
    428  
    429                         // get hash of contact  
    430                         hash = gnokii_contact_hash(contact); 
    431441                        osync_change_set_hash(change, hash);     
    432                         g_free(hash); 
    433  
     442                        osync_change_set_changetype(change, type); 
    434443 
    435444                        // set data 
    436                         OSyncData *data = osync_data_new((char *) contact, sizeof(gn_calnote), sinkenv->objformat, &error); 
    437                         if (!data) { 
     445                        osync_trace(TRACE_INTERNAL, "objformat: %p", sinkenv->objformat); 
     446                        OSyncData *odata = osync_data_new((char *) contact, sizeof(gn_phonebook_entry), sinkenv->objformat, &error); 
     447                        if (!odata) { 
    438448                                osync_change_unref(change); 
    439449                                osync_context_report_osyncwarning(ctx, error); 
     
    441451                                g_free(hash); 
    442452                                g_free(uid); 
     453                                g_free(contact); 
    443454                                continue; 
    444455                        } 
    445456 
    446                         osync_data_set_objtype(data, osync_objtype_sink_get_name(sink)); 
    447                         osync_change_set_data(change, data); 
    448                         osync_data_unref(data); 
    449                  
    450                         OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, uid, hash); 
    451                         if (type != OSYNC_CHANGE_TYPE_UNMODIFIED) { 
    452                                osync_trace(TRACE_INTERNAL, "Position: %i Needs to be reported (!= hash)", location - 1); 
    453                                osync_context_report_change(ctx, change); 
    454                                 osync_hashtable_update_hash(sinkenv->hashtable, type, uid, hash); 
    455                         }       
     457                        osync_data_set_objtype(odata, osync_objtype_sink_get_name(sink)); 
     458                        osync_change_set_data(change, odata); 
     459                        osync_data_unref(odata); 
     460 
     461                        osync_context_report_change(ctx, change); 
     462 
     463                        osync_trace(TRACE_INTERNAL, "Position: %i Needs to be reported (!= hash)", location - 1); 
     464                        osync_trace(TRACE_INTERNAL, "Change: %p", change); 
     465 
     466                        osync_change_unref(change); 
    456467 
    457468                        g_free(hash); 
    458469                        g_free(uid); 
    459  
    460470                } 
    461471        } 
    462472 
    463         osync_trace(TRACE_INTERNAL, "number of contact notes: %i", location - 1); 
    464  
     473        g_free(data); 
     474 
     475 
     476        /* FIXME: this is really really broken :(  
    465477        int i; 
     478 
    466479        char **uids = osync_hashtable_get_deleted(sinkenv->hashtable); 
    467480        for (i = 0; uids[i]; i++) { 
     
    498511        } 
    499512        g_free(uids); 
    500  
    501  
     513        */ 
     514 
     515        osync_context_report_success(ctx); 
    502516 
    503517        osync_trace(TRACE_EXIT, "%s()", __func__); 
  • plugins/gnokii-sync/src/gnokii_contact_format.c

    r2144 r2145  
    3434static osync_bool conv_gnokii_contact_to_xmlformat(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, OSyncError **error) 
    3535{ 
    36         osync_trace(TRACE_ENTRY, "%s(%p, %p, %i, %p, %p, %p, %s, %p)", __func__, input, inpsize, output, outpsize, free_input, config, error); 
     36        osync_trace(TRACE_ENTRY, "%s(%p, %i, %p, %p, %p, %s, %p)", __func__, input, inpsize, output, outpsize, free_input, config, error); 
    3737 
    3838        OSyncXMLField *xmlfield = NULL; 
  • plugins/gnokii-sync/src/gnokii_sync.c

    r2143 r2145  
    2424        osync_trace(TRACE_ENTRY, "%s()", __func__); 
    2525 
     26        while (env->sinks) { 
     27                gnokii_sinkenv *sinkenv = env->sinks->data; 
     28 
     29                osync_objtype_sink_unref(sinkenv->sink); 
     30                g_free(sinkenv); 
     31 
     32                env->sinks = g_list_remove(env->sinks, sinkenv); 
     33        } 
     34 
    2635        if (env->state) 
    2736                g_free(env->state); 
     
    117126        free_gnokiienv(env); 
    118127 
     128 
    119129        osync_trace(TRACE_EXIT, "%s", __func__); 
    120130} 
     
    131141        GList *s = NULL; 
    132142        for (s = env->sinks; s; s = s->next) { 
    133                 OSyncObjTypeSink *sink = s->data; 
    134                 osync_objtype_sink_set_available(sink, TRUE); 
     143                gnokii_sinkenv *sinkenv = s->data; 
     144                osync_objtype_sink_set_available(sinkenv->sink, TRUE); 
    135145        } 
    136146 
     
    156166        char *configdata = NULL; 
    157167         
     168        OSyncFormatEnv *formatenv = osync_plugin_info_get_format_env(info);  
     169 
    158170        // create gnokii_environment which stores config and statemachine for libgnokii 
    159         gnokii_environment *env = malloc(sizeof(gnokii_environment)); 
    160         g_assert(env != NULL); 
    161         memset(env, 0, sizeof(gnokii_environment))
     171        gnokii_environment *env = osync_try_malloc0(sizeof(gnokii_environment), error); 
     172        if (!env) 
     173               return NULL
    162174 
    163175        env->sinks = NULL; 
    164176 
    165         env->state = (struct gn_statemachine *) malloc(sizeof(struct gn_statemachine)); 
    166         g_assert(env->state != NULL); 
    167         memset(env->state, 0, sizeof(struct gn_statemachine)); 
    168  
     177        env->state = osync_try_malloc0(sizeof(struct gn_statemachine), error); 
     178        if (!env->state) { 
     179                free_gnokiienv(env); 
     180                return NULL; 
     181        } 
     182 
     183        // parse the member configuration 
    169184        if (!gnokii_config_parse(env->state, osync_plugin_info_get_config(info), error)) { 
    170185                free_gnokiienv(env); 
     
    173188         
    174189        // init the contact sink 
    175         OSyncObjTypeSink *contact_sink = NULL;  
    176         contact_sink = osync_objtype_sink_new("contact", error); 
    177         osync_objtype_sink_add_objformat(contact_sink, "gnokii-contact"); 
     190        gnokii_sinkenv *contact_sinkenv = osync_try_malloc0(sizeof(gnokii_sinkenv), error);  
     191        contact_sinkenv->sink = osync_objtype_sink_new("contact", error); 
     192        osync_objtype_sink_add_objformat(contact_sinkenv->sink, "gnokii-contact"); 
    178193 
    179194        OSyncObjTypeSinkFunctions contact_functions; 
     
    187202        contact_functions.sync_done = sync_done; 
    188203 
    189         osync_objtype_sink_set_functions(contact_sink, contact_functions, env); 
    190         osync_plugin_info_add_objtype(info, contact_sink); 
    191  
    192         env->sinks = g_list_append(env->sinks, contact_sink); 
     204        osync_objtype_sink_set_functions(contact_sinkenv->sink, contact_functions, contact_sinkenv); 
     205        osync_plugin_info_add_objtype(info, contact_sinkenv->sink); 
     206 
     207        contact_sinkenv->objformat = osync_format_env_find_objformat(formatenv, "gnokii-contact"); 
     208        osync_trace(TRACE_INTERNAL, "contact_sinkenv->objformat: %p", contact_sinkenv->objformat); 
     209 
     210        env->sinks = g_list_append(env->sinks, contact_sinkenv); 
    193211 
    194212 
    195213        // init the event sink 
    196         OSyncObjTypeSink *event_sink = osync_objtype_sink_new("event", error); 
    197         osync_objtype_sink_add_objformat(event_sink, "gnokii-event"); 
     214        gnokii_sinkenv *event_sinkenv = osync_try_malloc0(sizeof(gnokii_sinkenv), error);  
     215        event_sinkenv->sink = osync_objtype_sink_new("event", error); 
     216        osync_objtype_sink_add_objformat(event_sinkenv->sink, "gnokii-event"); 
    198217 
    199218        OSyncObjTypeSinkFunctions event_functions; 
     
    207226        event_functions.sync_done = sync_done; 
    208227 
    209         osync_objtype_sink_set_functions(event_sink, event_functions, env); 
    210         osync_plugin_info_add_objtype(info, event_sink); 
    211  
    212         env->sinks = g_list_append(env->sinks, event_sink); 
    213  
     228        osync_objtype_sink_set_functions(event_sinkenv->sink, event_functions, event_sinkenv); 
     229        osync_plugin_info_add_objtype(info, event_sinkenv->sink); 
     230 
     231        event_sinkenv->objformat = osync_format_env_find_objformat(formatenv, "gnokii-event"); 
     232 
     233        env->sinks = g_list_append(env->sinks, event_sinkenv); 
    214234         
    215235        //Process the config data here and set the options on your environment