Changeset 2442

Show
Ignore:
Timestamp:
08/13/07 15:17:41 (1 year ago)
Author:
paule
Message:

Remove old uid mapping code and change to rely upon OpenSync?'s internal mapping logic; fix segfault when committing deletions; fix endless looping in get_changes

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • plugins/opie-sync/src/opie_format.c

    r2439 r2442  
    278278                                        osync_xmlfield_set_key_value(out_xmlfield, "Content", iprop->children->content); 
    279279                                } 
    280                                 else if(!strcasecmp(iprop->name, "Uid")) 
    281                                 { 
    282                                         out_xmlfield = osync_xmlfield_new(out_xmlformat, "Uid", error); 
    283                                         osync_xmlfield_set_key_value(out_xmlfield, "Content", iprop->children->content); 
    284                                 } 
    285280                                else if(!strcasecmp(iprop->name, "rid")) 
    286281                                { 
     
    512507                else if(!strcmp("FormattedName", fieldname)) { 
    513508                        xmlfield_key_to_attr(in_xmlfield, "Content", on_contact, "FileAs"); 
    514                 } 
    515                 else if(!strcmp("Uid", fieldname)) { 
    516                         xmlfield_key_to_attr(in_xmlfield, "Content", on_contact, "Uid"); 
    517509                } 
    518510                else if(!strcmp("Categories", fieldname)) { 
     
    649641                                        osync_xmlfield_set_key_value(out_xmlfield, "Content", iprop->children->content); 
    650642                                        osync_xmlfield_set_key_value(out_xmlfield, "Value", "DATE"); /* FIXME I doubt this is still valid */ 
    651                                 } 
    652                                 else if(!strcasecmp(iprop->name, "Uid")) 
    653                                 { 
    654                                         out_xmlfield = osync_xmlfield_new(out_xmlformat, "Uid", error); 
    655                                         osync_xmlfield_set_key_value(out_xmlfield, "Content", iprop->children->content); 
    656643                                } 
    657644                                else if(!strcasecmp(iprop->name, "Categories")) 
     
    875862                        } 
    876863                } 
    877                 else if(!strcmp("Uid", fieldname)) { 
    878                         xmlfield_key_to_attr(in_xmlfield, "Content", on_todo, "Uid"); 
    879                 } 
    880864                else if(!strcmp("RecurrenceRule", fieldname)) { 
    881865                        xmlfield_recur_to_attr(in_xmlfield, on_todo); 
     
    10391023                                        g_strfreev(categorytokens); 
    10401024                                } 
    1041                                 else if(!strcasecmp(iprop->name, "uid"))  
    1042                                 { 
    1043                                         out_xmlfield = osync_xmlfield_new(out_xmlformat, "Uid", error); 
    1044                                         osync_xmlfield_set_key_value(out_xmlfield, "Content", iprop->children->content); 
    1045                                 } 
    10461025                        } 
    10471026                        /* FIXME Stuff to handle: 
     
    11601139                else if(!strcmp("DateEnd", fieldname)) { 
    11611140                        xmlfield_vtime_to_attr_time_t(in_xmlfield, on_event, "end"); 
    1162                 } 
    1163                 else if(!strcmp("Uid", fieldname)) { 
    1164                         xmlfield_vtime_to_attr_time_t(in_xmlfield, on_event, "uid"); 
    11651141                } 
    11661142                else if(!strcmp("Categories", fieldname)) { 
  • plugins/opie-sync/src/opie_format.h

    r2438 r2442  
    2727 
    2828void xmlfield_key_to_attr(OSyncXMLField *xmlfield, const char *key, xmlNode *node_to, const char *attrname); 
     29void xmlfield_uid_to_attr(OSyncXMLField *xmlfield, xmlNode *node_to); 
     30void xml_uid_attr_to_xmlfield(const char *uid, const char *nodename, OSyncXMLFormat *out_xmlformat, OSyncError **error); 
    2931time_t xmlfield_vtime_to_attr_time_t(OSyncXMLField *xmlfield, xmlNode *node_to, const char *attrname); 
    3032void xmlfield_categories_to_attr(OSyncXMLField *in_xmlfield, xmlNode *node_to, const char *category_attr); 
  • plugins/opie-sync/src/opie_sync.c

    r2405 r2442  
    3434#include "opie_xml.h" 
    3535 
    36 GTree *uidmap_read(const char *uidmap_file); 
    37 void uidmap_write(GTree *uidmap, const char *uidmap_file); 
    38 void uidmap_free(GTree **uidmap); 
    39 void uidmap_addmapping(GTree *uidmap, const char *opie_uid, const char *ext_uid); 
    40 char *uidmap_set_node_uid(GTree *uidmap, xmlNode *node, xmlDoc *doc,  
    41                                                                                                  const char *listelement, const char *itemelement, const char *ext_uid); 
    42 const char *uidmap_get_mapped_uid(GTree *uidmap, const char *uid); 
    43 void uidmap_removemapping(GTree *uidmap, const char *uid1); 
    44                  
    4536/* sync_cancelled() 
    4637 *  
     
    302293                        opie_xml_category_ids_to_names(env->plugin_env->categories_doc, item_node); 
    303294                 
    304                 char *opie_uid = opie_xml_get_uid(item_node); 
    305                 char *uid = NULL; 
    306                 if(opie_uid) { 
    307                         const char *uidentry = uidmap_get_mapped_uid(env->plugin_env->uidmap, opie_uid); 
    308                         if(uidentry) 
    309                                 uid = g_strdup(uidentry); 
    310                         else if(!strcasecmp(item_node->name, "note")) 
    311                                 uid = g_strdup(opie_uid); 
    312                         else { 
    313                                 uid = opie_xml_get_tagged_uid(item_node); 
    314                                 if(opie_uid) { 
    315                                         uidmap_addmapping(env->plugin_env->uidmap, opie_uid, uid); 
    316                                         uidmap_addmapping(env->plugin_env->uidmap, uid, opie_uid); 
    317                                 } 
    318                         } 
    319                         g_free(opie_uid); 
    320                 } 
     295                char *uid = opie_xml_get_tagged_uid(item_node); 
    321296                 
    322297                char *data = xml_node_to_text(env->doc, item_node); 
     
    337312                OSyncChangeType changetype = osync_hashtable_get_changetype(env->hashtable, uid, hash); 
    338313 
    339                 if (changetype == OSYNC_CHANGE_TYPE_UNMODIFIED) { 
    340                         g_free(hash); 
    341                         g_free(uid); 
    342                         g_free(data); 
    343                         continue; 
    344                 } 
    345  
    346                 //Set the hash of the object (optional, only required if you use hashtabled) 
    347                 osync_hashtable_update_hash(env->hashtable, changetype, uid, hash); 
    348  
    349                 //Make the new change to report 
    350                 OSyncChange *change = osync_change_new(&error); 
    351                 if (!change) { 
    352                         osync_context_report_osyncwarning(ctx, error); 
    353                         osync_error_unref(&error); 
    354                         continue; 
    355                 } 
    356  
    357                 //Now set the uid of the object 
    358                 osync_change_set_uid(change, uid); 
    359                 osync_change_set_hash(change, hash); 
    360                 osync_change_set_changetype(change, changetype); 
    361  
     314                if (changetype != OSYNC_CHANGE_TYPE_UNMODIFIED) { 
     315                        //Set the hash of the object (optional, only required if you use hashtabled) 
     316                        osync_hashtable_update_hash(env->hashtable, changetype, uid, hash); 
     317         
     318                        //Make the new change to report 
     319                        OSyncChange *change = osync_change_new(&error); 
     320                        if (!change) { 
     321                                osync_context_report_osyncwarning(ctx, error); 
     322                                osync_error_unref(&error); 
     323                        } 
     324                        else { 
     325         
     326                                //Now set the uid of the object 
     327                                osync_change_set_uid(change, uid); 
     328                                osync_change_set_hash(change, hash); 
     329                                osync_change_set_changetype(change, changetype); 
     330                 
     331                                OSyncData *odata = osync_data_new(data, strlen(data) + 1, env->objformat, &error); 
     332                                if (!odata) { 
     333                                        osync_change_unref(change); 
     334                                        osync_context_report_osyncwarning(ctx, error); 
     335                                        osync_error_unref(&error); 
     336                                } 
     337                                else { 
     338                                        osync_data_set_objtype(odata, osync_objtype_sink_get_name(sink)); 
     339                         
     340                                        //Now you can set the data for the object 
     341                                        osync_change_set_data(change, odata); 
     342                                        osync_data_unref(odata); 
     343                         
     344                                        // just report the change via 
     345                                        osync_context_report_change(ctx, change); 
     346                         
     347                                        osync_change_unref(change); 
     348                                } 
     349                        } 
     350                } 
     351 
     352                g_free(data); 
    362353                g_free(hash); 
    363  
    364                 OSyncData *odata = osync_data_new(data, strlen(data) + 1, env->objformat, &error); 
    365                 if (!odata) { 
    366                         osync_change_unref(change); 
    367                         osync_context_report_osyncwarning(ctx, error); 
    368                         osync_error_unref(&error); 
    369                         continue; 
    370                 } 
    371  
    372                 osync_data_set_objtype(odata, osync_objtype_sink_get_name(sink)); 
    373  
    374                 //Now you can set the data for the object 
    375                 osync_change_set_data(change, odata); 
    376                 osync_data_unref(odata); 
    377  
    378                 // just report the change via 
    379                 osync_context_report_change(ctx, change); 
    380  
    381                 osync_change_unref(change); 
    382  
    383354                g_free(uid); 
    384355                 
     
    448419                char *change_str = NULL; 
    449420                osync_data_get_data(change_data, &change_str, &change_size); 
    450                 /* Parse the string as XML */ 
    451                 change_doc = opie_xml_change_parse(change_str, &change_node); 
    452                 if(!change_doc) { 
    453                         osync_error_set(&error, OSYNC_ERROR_GENERIC, "Unable to retrieve XML from change"); 
    454                         goto error; 
    455                 } 
    456                 opie_uid = uidmap_set_node_uid(env->plugin_env->uidmap, change_node, env->doc, env->listelement, env->itemelement, ext_uid); 
    457                 /* Convert categories into names that other systems can use */ 
    458                 if(env->plugin_env->categories_doc) 
    459                         opie_xml_category_names_to_ids(env->plugin_env->categories_doc, change_node); 
    460                  
    461                 /* Get hash */ 
    462                 hash = hash_xml_node(env->doc, change_node); 
     421                if(change_str) { 
     422                        /* Parse the string as XML */ 
     423                        change_doc = opie_xml_change_parse(change_str, &change_node); 
     424                        if(!change_doc) { 
     425                                osync_error_set(&error, OSYNC_ERROR_GENERIC, "Unable to retrieve XML from change"); 
     426                                goto error; 
     427                        } 
     428                         
     429                        /* Get UID */ 
     430                        if(!strcmp(env->itemelement,"note")) 
     431                                opie_uid = g_strdup(ext_uid); 
     432                        else 
     433                                opie_uid = opie_xml_set_ext_uid(change_node, env->doc, env->listelement, env->itemelement, ext_uid); 
     434                         
     435                        /* Convert categories into names that other systems can use */ 
     436                        if(env->plugin_env->categories_doc) 
     437                                opie_xml_category_names_to_ids(env->plugin_env->categories_doc, change_node); 
     438                         
     439                        /* Get hash */ 
     440                        hash = hash_xml_node(env->doc, change_node); 
     441                } 
    463442        } 
    464443         
     
    466445                case OSYNC_CHANGE_TYPE_DELETED: 
    467446                        if(!opie_uid) { 
    468                                 const char *uidentry = uidmap_get_mapped_uid(env->plugin_env->uidmap, ext_uid); 
    469                                 if(uidentry) 
    470                                         opie_uid = g_strdup(uidentry); 
    471                                 else if(!strcmp(env->itemelement, "note")) 
     447                                if(!strcmp(env->itemelement, "note")) 
    472448                                        opie_uid = g_strdup(ext_uid); 
    473449                                else 
    474                                         opie_uid = opie_xml_strip_uid(ext_uid, env->itemelement); 
    475                         } 
    476                         opie_xml_remove_by_uid(env->doc, env->listelement, env->itemelement, opie_uid); 
    477                         uidmap_removemapping(env->plugin_env->uidmap, ext_uid); 
     450                                        opie_uid = opie_xml_strip_uid(ext_uid); 
     451                        } 
     452                        if(opie_uid) 
     453                               opie_xml_remove_by_uid(env->doc, env->listelement, env->itemelement, opie_uid); 
    478454                        break; 
    479455                 
     
    642618        env->connected = FALSE; 
    643619         
    644         const char *configdir = osync_plugin_info_get_configdir(info); 
    645         char *uidmap_path = g_strdup_printf("%s/opie_uidmap.xml", configdir); 
    646         env->uidmap = uidmap_read(uidmap_path); 
    647         g_free(uidmap_path); 
    648          
    649620        comms_init(); 
    650621         
     
    672643 
    673644        comms_shutdown(); 
    674          
    675         uidmap_write(env->uidmap, env->uidmap_file); 
    676         uidmap_free(&env->uidmap); 
    677         g_free(env->uidmap_file); 
    678645         
    679646        g_mutex_free(env->plugin_mutex); 
     
    714681} 
    715682 
    716  
    717 void uidmap_addmapping(GTree *uidmap, const char *uid1, const char *uid2) { 
    718         char *key = g_strdup(uid1); 
    719         char *value = g_strdup(uid2); 
    720         g_tree_insert(uidmap, key, value); 
    721 } 
    722  
    723 void uidmap_removemapping(GTree *uidmap, const char *uid1) { 
    724         const char *uid2 = uidmap_get_mapped_uid(uidmap, uid1); 
    725         if(uid2) { 
    726                 char *uid2_copy = g_strdup(uid2); 
    727                 g_tree_remove(uidmap, uid1); 
    728                 g_tree_remove(uidmap, uid2_copy); 
    729                 g_free(uid2_copy); 
    730         } 
    731 } 
    732  
    733 char *uidmap_set_node_uid(GTree *uidmap, xmlNode *node, xmlDoc *doc,  
    734                                                                                                  const char *listelement, const char *itemelement, const char *ext_uid) { 
    735         const char *uidentry = uidmap_get_mapped_uid(uidmap, ext_uid); 
    736         char *opie_uid; 
    737         if(uidentry) { 
    738                 opie_xml_set_uid(node, uidentry); 
    739                 opie_uid = g_strdup(uidentry); 
    740         } 
    741         else { 
    742                 if(!strcmp(node->name,"note")) { 
    743                         opie_uid = g_strdup(ext_uid); 
    744                 } 
    745                 else { 
    746                         opie_uid = opie_xml_set_ext_uid(node, doc, listelement, itemelement, ext_uid); 
    747                         uidmap_addmapping(uidmap, opie_uid, ext_uid); 
    748                         uidmap_addmapping(uidmap, ext_uid, opie_uid); 
    749                 } 
    750         } 
    751         return opie_uid; 
    752 } 
    753  
    754 const char *uidmap_get_mapped_uid(GTree *uidmap, const char *uid) { 
    755         const char *uidentry = (const char *)g_tree_lookup(uidmap, uid); 
    756         return uidentry; 
    757 } 
    758  
    759 gint uidmap_compare(gconstpointer a, gconstpointer b, gpointer user_data) { 
    760         return strcmp((const char *)a, (const char *)b); 
    761 } 
    762  
    763 GTree *uidmap_read(const char *uidmap_file) { 
    764         GTree *uidmap = g_tree_new_full(uidmap_compare, NULL, g_free, g_free); 
    765         xmlDoc *doc = opie_xml_file_open(uidmap_file); 
    766         if(doc) { 
    767                 xmlNode *node = opie_xml_get_first(doc, "mappinglist", "mapping"); 
    768                 while(node) { 
    769                         char *uid1 = xmlGetProp(node, "uid1"); 
    770                         if(uid1) { 
    771                                 char *uid2 = xmlGetProp(node, "uid2"); 
    772                                 if(uid2) { 
    773                                         uidmap_addmapping(uidmap, uid1, uid2); 
    774                                         xmlFree(uid2); 
    775                                 } 
    776                                 xmlFree(uid1); 
    777                         } 
    778                         node = opie_xml_get_next(node); 
    779                 } 
    780         } 
    781         return uidmap; 
    782 } 
    783  
    784 gboolean uidmap_write_entry(gpointer key, gpointer value, gpointer data) { 
    785         xmlNode *node = xmlNewNode(NULL, "mapping"); 
    786         xmlSetProp(node, "uid1", (const char *)key); 
    787         xmlSetProp(node, "uid2", (const char *)value); 
    788         xmlAddChild((xmlNode *)data, node); 
    789         return FALSE; 
    790 } 
    791  
    792 void uidmap_write(GTree *uidmap, const char *uidmap_file) { 
    793         xmlDoc *doc = xmlNewDoc((xmlChar*)"1.0"); 
    794         if(doc) { 
    795                 xmlNode *root = xmlNewNode(NULL, "uidmap"); 
    796                 xmlDocSetRootElement(doc, root); 
    797                 xmlNode *listnode = xmlNewNode(NULL, "mappinglist"); 
    798                 xmlAddChild(root, listnode); 
    799                  
    800                 g_tree_foreach(uidmap, uidmap_write_entry, listnode);  
    801                  
    802                 xmlSaveFormatFile(uidmap_file, doc, 1); 
    803         } 
    804 } 
    805  
    806 void uidmap_free(GTree **uidmap) { 
    807         g_tree_destroy(*uidmap); 
    808         uidmap = NULL; 
    809 } 
    810  
    811683osync_bool get_sync_info(OSyncPluginEnv *env, OSyncError **error) 
    812684{ 
  • plugins/opie-sync/src/opie_sync.h

    r2405 r2442  
    8080        OpieSinkEnv*      note_env; 
    8181         
    82         GTree*            uidmap; 
    83         char*             uidmap_file; 
    84          
    8582        GMutex*           plugin_mutex; 
    8683}; 
  • plugins/opie-sync/src/opie_xml.c

    r2435 r2442  
    316316} 
    317317 
    318 char *opie_xml_strip_uid(const char *ext_uid, const char *node_name) { 
    319         const char *uidptr = ext_uid; 
    320         GString *uid = g_string_new("-");  
    321         int innum = 0; 
    322         while(*uidptr != 0) { 
    323                 if(g_ascii_isdigit(*uidptr)) { 
    324                         g_string_append_c(uid, *uidptr); 
    325                         innum = 1; 
    326                 } 
    327                 else if(innum) 
    328                         break; 
    329                 uidptr++; 
    330         } 
    331          
    332         char *uidstr = g_strdup(uid->str); 
    333         g_string_free(uid, TRUE); 
    334          
    335         return uidstr; 
     318char *opie_xml_strip_uid(const char *ext_uid) { 
     319        if(g_str_has_prefix(ext_uid, "uid-")) { 
     320                const char *uidptr = ext_uid; 
     321                GString *uid = g_string_new("-");  
     322                int innum = 0; 
     323                while(*uidptr != 0) { 
     324                        if(g_ascii_isdigit(*uidptr)) { 
     325                                g_string_append_c(uid, *uidptr); 
     326                                innum = 1; 
     327                        } 
     328                        else if(innum) 
     329                                break; 
     330                        uidptr++; 
     331                } 
     332                 
     333                char *uidstr = g_strdup(uid->str); 
     334                g_string_free(uid, TRUE); 
     335                 
     336                if(strlen(uidstr) < 6 || atoi(uidstr+1) > 1999999999) { 
     337                        g_free(uidstr); 
     338                        return NULL; 
     339                } 
     340                else 
     341                        return uidstr; 
     342        } 
     343        else 
     344                return NULL; 
    336345} 
    337346 
    338347char *opie_xml_set_ext_uid(xmlNode *node, xmlDoc *doc, const char *listelement, 
    339348                                                                                                                                                                const char *itemelement, const char *tagged_uid) { 
    340         char *uid = opie_xml_strip_uid(tagged_uid, node->name);  
    341         if(strlen(uid) < 6 || atoi(uid+1) > 1999999999) { 
    342                 g_free(uid); 
     349        char *uid = opie_xml_strip_uid(tagged_uid);      
     350        if(!uid) 
    343351                uid = opie_xml_generate_uid(doc, listelement, itemelement); 
    344         } 
    345352        opie_xml_set_uid(node, uid); 
    346353        return uid; 
     
    356363} 
    357364 
     365char *opie_xml_tag_uid(const char *uid, const char *nodename) { 
     366        char *uidtag = "uid-unknown-%32s"; 
     367        if(!strcasecmp(nodename, "Contact")) { 
     368                uidtag = "uid-contact-%s"; 
     369        } 
     370        else if(!strcasecmp(nodename, "Task")) { 
     371                uidtag = "uid-todo-%s"; 
     372        } 
     373        else if(!strcasecmp(nodename, "event")) { 
     374                uidtag = "uid-event-%s"; 
     375        } 
     376        else if(!strcasecmp(nodename, "note")) { 
     377                uidtag = "%s"; 
     378        } 
     379         
     380        return g_strdup_printf(uidtag, uid); 
     381} 
     382 
    358383char *opie_xml_get_tagged_uid(xmlNode *node) { 
    359         char *uidtag = "uid-unknown-%32s"; 
    360         if(!strcasecmp(node->name, "Contact")) { 
    361                 uidtag = "uid-contact-%s"; 
    362         } 
    363         else if(!strcasecmp(node->name, "Task")) { 
    364                 uidtag = "uid-todo-%s"; 
    365         } 
    366         else if(!strcasecmp(node->name, "event")) { 
    367                 uidtag = "uid-event-%s"; 
    368         } 
    369          
    370384        char *uid = opie_xml_get_uid(node); 
    371385        if(uid) { 
    372                 char *tagged_uid = g_strdup_printf(uidtag, uid); 
     386                char *tagged_uid = opie_xml_tag_uid(uid, node->name); 
    373387                xmlFree(uid); 
    374388                return tagged_uid; 
  • plugins/opie-sync/src/opie_xml.h

    r2108 r2442  
    4545char *xml_node_to_text(xmlDoc *doc, xmlNode *node);  
    4646void xml_node_to_attr(xmlNode *node_from, const char *nodename, xmlNode *node_to, const char *attrname); 
    47 char *opie_xml_strip_uid(const char *ext_uid, const char *node_name); 
     47char *opie_xml_strip_uid(const char *ext_uid); 
    4848char *opie_xml_set_ext_uid(xmlNode *node, xmlDoc *doc, const char *listelement, 
    4949                                                                                                                                                                const char *itemelement, const char *tagged_uid); 
    5050char *opie_xml_generate_uid(xmlDoc *doc, const char *listelement, const char *itemelement); 
     51char *opie_xml_tag_uid(const char *uid, const char *nodename); 
    5152char *opie_xml_get_tagged_uid(xmlNode *node); 
    5253char *opie_xml_get_uidattr(xmlNode *node);