void osync_version_set_hardwareversion(OSyncVersion *version, const char *hardwareversion) { if(version->hardwareversion) osync_free(version->hardwareversion); if(!hardwareversion) version->hardwareversion = osync_strdup(""); else version->hardwareversion = osync_strdup(hardwareversion); }
void osync_version_set_identifier(OSyncVersion *version, const char *identifier) { if(version->identifier) osync_free(version->identifier); if(!identifier) version->identifier = osync_strdup(""); else version->identifier = osync_strdup(identifier); }
void osync_version_set_firmwareversion(OSyncVersion *version, const char *firmwareversion) { if(version->firmwareversion) osync_free(version->firmwareversion); if(!firmwareversion) version->firmwareversion = osync_strdup(""); else version->firmwareversion = osync_strdup(firmwareversion); }
void osync_version_set_vendor(OSyncVersion *version, const char *vendor) { if(version->vendor) osync_free(version->vendor); if(!vendor) version->vendor = osync_strdup(""); else version->vendor = osync_strdup(vendor); }
void osync_version_set_modelversion(OSyncVersion *version, const char *modelversion) { if(version->modelversion) osync_free(version->modelversion); if(!modelversion) version->modelversion = osync_strdup(""); else version->modelversion = osync_strdup(modelversion); }
void osync_version_set_priority(OSyncVersion *version, const char *priority) { if(version->priority) osync_free(version->priority); if(!priority) version->priority = osync_strdup(""); else version->priority = osync_strdup(priority); }
void osync_version_set_plugin(OSyncVersion *version, const char *plugin) { if(version->plugin) osync_free(version->plugin); if(!plugin) version->plugin = osync_strdup(""); else version->plugin = osync_strdup(plugin); }
void osync_version_set_softwareversion(OSyncVersion *version, const char *softwareversion) { if(version->softwareversion) osync_free(version->softwareversion); if(!softwareversion) version->softwareversion = osync_strdup(""); else version->softwareversion = osync_strdup(softwareversion); }
void osync_plugin_info_set_groupname(OSyncPluginInfo *info, const char *groupname) { osync_assert(info); if (info->groupname) osync_free(info->groupname); info->groupname = osync_strdup(groupname); }
osync_bool osync_db_reset_full(OSyncDB *db, OSyncError **error) { sqlite3_stmt *ppStmt = NULL; char *query = NULL; osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, db, error); osync_assert(db); query = osync_strdup("SELECT name FROM (SELECT * FROM sqlite_master) WHERE type='table'"); if (sqlite3_prepare(db->sqlite3db, query, -1, &ppStmt, NULL) != SQLITE_OK) { osync_error_set(error, OSYNC_ERROR_GENERIC, "Query Error: %s", sqlite3_errmsg(db->sqlite3db)); goto error; } while (sqlite3_step(ppStmt) == SQLITE_ROW) { const char *table = (const char *) sqlite3_column_text(ppStmt, 0); if (!osync_db_reset_table(db, table, error)) goto error; } sqlite3_finalize(ppStmt); osync_trace(TRACE_EXIT, "%s: TRUE", __func__); return TRUE; error: sqlite3_finalize(ppStmt); osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return FALSE; }
osync_bool osync_module_load(OSyncModule *module, const char *path, OSyncError **error) { osync_trace(TRACE_ENTRY, "%s(%p, %s, %p)", __func__, module, path, error); osync_assert(module); osync_assert(!module->module); if (!g_module_supported()) { osync_error_set(error, OSYNC_ERROR_GENERIC, "This platform does not support loading of modules"); goto error; } /* Try to open the module or fail if an error occurs. * * Do local bind to avoid symbol-clashing - i.e. plugins having the same * functions name - e.g. finalize(). * * Don't do lazy binding, otherwise symbols of kdepim-sync can't get loaded. * Related to C++ and dlopen? */ module->module = g_module_open(path, G_MODULE_BIND_LOCAL); if (!module->module) { osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to open module %s: %s", path, g_module_error()); goto error; } module->path = osync_strdup(path); osync_trace(TRACE_EXIT, "%s", __func__); return TRUE; error: osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return FALSE; }
void osync_plugin_info_set_configdir(OSyncPluginInfo *info, const char *configdir) { osync_assert(info); if (info->configdir) osync_free(info->configdir); info->configdir = osync_strdup(configdir); }
OSyncMerger *osync_merger_new(const char *objformat, const char *capsformat, OSyncError **error) { OSyncMerger *merger = NULL; osync_trace(TRACE_ENTRY, "%s(%s, %s, %p)", __func__, objformat, capsformat, error); merger = osync_try_malloc0(sizeof(OSyncMerger), error); if (!merger) { osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return NULL; } merger->ref_count = 1; merger->objformat = osync_strdup(objformat); merger->capsformat = osync_strdup(capsformat); osync_trace(TRACE_EXIT, "%s: %p", __func__, merger); return merger; }
void osync_mapping_entry_set_uid(OSyncMappingEntry *entry, const char *uid) { osync_assert(entry); osync_assert(uid); if (entry->uid) osync_free(entry->uid); entry->uid = osync_strdup(uid); }
void osync_objformat_sink_set_config(OSyncObjFormatSink *sink, const char *config) { osync_assert(sink); if (sink->config) osync_free(sink->config); sink->config = osync_strdup(config); }
void osync_capabilities_set_format(OSyncCapabilities *capabilities, const char *capsformat) { osync_assert(capabilities); osync_assert(capsformat); if (capabilities->format) osync_free(capabilities->format); capabilities->format = osync_strdup(capsformat); }
OSyncObjFormatSink *osync_objformat_sink_new(const char *objformat, OSyncError **error) { OSyncObjFormatSink *formatsink = NULL; osync_trace(TRACE_ENTRY, "%s(%s %p, %p)", __func__, __NULLSTR(objformat), objformat, error); formatsink = osync_try_malloc0(sizeof(OSyncObjFormatSink), error); if (!formatsink) return NULL; /*formatsink->objformat = osync_objformat_ref(objformat);*/ formatsink->objformat = osync_strdup(objformat); formatsink->config = NULL; formatsink->ref_count = 1; osync_trace(TRACE_EXIT, "%s: %p", __func__, formatsink); return formatsink; }
OSyncCapabilitiesObjType *osync_capabilities_objtype_new(const char *objtype, OSyncError **error) { OSyncCapabilitiesObjType *capobjtype = NULL; osync_assert(objtype); capobjtype = osync_try_malloc0(sizeof(OSyncCapabilitiesObjType), error); if (!capobjtype) goto error; capobjtype->name = osync_strdup(objtype); capobjtype->ref_count = 1; return capobjtype; error: osync_trace(TRACE_EXIT_ERROR, "%s: %s" , __func__, osync_error_print(error)); return NULL; }
OSyncList *osync_db_query_table(OSyncDB *db, const char *query, OSyncError **error) { OSyncList *table = NULL; int i, j, column_count = 0; int numrows = 0, numcolumns = 0; char **result = NULL; char *errmsg = NULL; osync_trace(TRACE_ENTRY, "%s(%p, %s, %p)", __func__, db, query, error); osync_assert(db); osync_assert(query); if (sqlite3_get_table(db->sqlite3db, query, &result, &numrows, &numcolumns, &errmsg) != SQLITE_OK) { osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to query table: %s", errmsg); sqlite3_free(errmsg); osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return NULL; } /* First row contains only names of columns. So we skip this! We start reading the array with a offset (number of columns) */ column_count = numcolumns; for (j=0; j < numrows; j++) { OSyncList *row = NULL; for (i=0; i < numcolumns; i++) /* speed up - prepend instead of append */ row = osync_list_prepend(row, osync_strdup(result[column_count++])); /* items got prepended, reverse the list again */ row = osync_list_reverse(row); /* speed up - prepend instead of append. */ table = osync_list_prepend(table, row); } /* items got prepended, reverse the list again */ table = osync_list_reverse(table); sqlite3_free_table(result); osync_trace(TRACE_EXIT, "%s: %p", __func__, table); return table; }
char *osync_db_query_single_string(OSyncDB *db, const char *query, OSyncError **error) { char *result = NULL; sqlite3_stmt *ppStmt = NULL; osync_trace(TRACE_ENTRY, "%s(%p, %s, %p)", __func__, db, query, error); osync_assert(db); osync_assert(query); if (sqlite3_prepare(db->sqlite3db, query, -1, &ppStmt, NULL) != SQLITE_OK) { osync_error_set(error, OSYNC_ERROR_GENERIC, "Query Error: %s", sqlite3_errmsg(db->sqlite3db)); goto error; } if (sqlite3_step(ppStmt) != SQLITE_ROW) { sqlite3_finalize(ppStmt); osync_trace(TRACE_EXIT, "%s: no result of query", __func__); return NULL; } result = osync_strdup((const char *)sqlite3_column_text(ppStmt, 0)); if (sqlite3_step(ppStmt) == SQLITE_ROW) { osync_error_set(error, OSYNC_ERROR_GENERIC, "Returned more than one result! This function only handle a single string!"); goto error; } sqlite3_finalize(ppStmt); osync_trace(TRACE_EXIT, "%s: %s", __func__, result); return result; error: osync_free(result); sqlite3_finalize(ppStmt); osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return NULL; }
OSyncVersion *osync_version_new(OSyncError **error) { OSyncVersion *version = NULL; osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error); version = osync_try_malloc0(sizeof(OSyncVersion), error); if(!version) { osync_trace(TRACE_EXIT_ERROR, "%s: %s" , __func__, osync_error_print(error)); return NULL; } version->ref_count = 1; version->plugin = osync_strdup(""); version->priority = osync_strdup(""); version->vendor = osync_strdup(""); version->modelversion = osync_strdup(""); version->firmwareversion = osync_strdup(""); version->softwareversion = osync_strdup(""); version->hardwareversion = osync_strdup(""); version->identifier = osync_strdup(""); osync_trace(TRACE_EXIT, "%s: %p", __func__, version); return version; }
static void get_changes(void *userdata, OSyncPluginInfo *info, OSyncContext *ctx) { osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, userdata, info, ctx); //plugin_environment *env = (plugin_environment *)userdata; OSyncFormatEnv *formatenv = osync_plugin_info_get_format_env(info); OSyncObjTypeSink *sink = osync_plugin_info_get_sink(info); sink_environment *sinkenv = osync_objtype_sink_get_userdata(sink); OSyncError *error = NULL; //If you use opensync hashtables you can detect if you need //to do a slow-sync and set this on the hastable directly //otherwise you have to make 2 function like "get_changes" and //"get_all" and decide which to use using //osync_objtype_sink_get_slow_sync if (osync_objtype_sink_get_slowsync(sinkenv->sink)) { osync_trace(TRACE_INTERNAL, "Slow sync requested"); if (osync_hashtable_slowsync(sinkenv->hashtable, &error)) { osync_context_report_osyncerror(ctx, error); osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&error)); osync_error_unref(&error); return; } } /* * Now you can get the changes. * Loop over all changes you get and do the following: */ do { char *hash = osync_strdup("<the calculated hash of the object>"); char *uid = osync_strdup("<some uid>"); //Now get the data of this change char *data = NULL; //Make the new change to report OSyncChange *change = osync_change_new(&error); if (!change) { osync_context_report_osyncwarning(ctx, error); osync_error_unref(&error); continue; } //Now set the uid of the object osync_change_set_uid(change, uid); osync_change_set_hash(change, hash); OSyncChangeType changetype = osync_hashtable_get_changetype(sinkenv->hashtable, change); osync_change_set_changetype(change, changetype); // Update entry. // Set the hash of the object (optional, only required if you use hashtabled) osync_hashtable_update_change(sinkenv->hashtable, change); if (changetype == OSYNC_CHANGE_TYPE_UNMODIFIED) { osync_free(hash); osync_free(uid); osync_change_unref(change); continue; } osync_free(hash); osync_free(uid); OSyncObjFormat *format = osync_format_env_find_objformat(formatenv, "<objformat>"); OSyncData *odata = osync_data_new(data, 0, format, &error); if (!odata) { osync_change_unref(change); osync_context_report_osyncwarning(ctx, error); osync_error_unref(&error); continue; } osync_data_set_objtype(odata, osync_objtype_sink_get_name(sinkenv->sink)); //Now you can set the data for the object osync_change_set_data(change, odata); osync_data_unref(odata); // just report the change via osync_context_report_change(ctx, change); osync_change_unref(change); osync_free(uid); } while(0); //When you are done looping and if you are using hashtables //check for deleted entries ... via hashtable OSyncList *u, *uids = osync_hashtable_get_deleted(sinkenv->hashtable); for (u = uids; u; u = u->next) { OSyncChange *change = osync_change_new(&error); if (!change) { osync_context_report_osyncwarning(ctx, error); osync_error_unref(&error); continue; } const char *uid = u->data; osync_change_set_uid(change, uid); osync_change_set_changetype(change, OSYNC_CHANGE_TYPE_DELETED); OSyncObjFormat *format = osync_format_env_find_objformat(formatenv, "<objformat>"); OSyncData *odata = osync_data_new(NULL, 0, format, &error); if (!odata) { osync_change_unref(change); osync_context_report_osyncwarning(ctx, error); osync_error_unref(&error); continue; } osync_data_set_objtype(odata, osync_objtype_sink_get_name(sinkenv->sink)); osync_change_set_data(change, odata); osync_data_unref(odata); osync_context_report_change(ctx, change); osync_hashtable_update_change(sinkenv->hashtable, change); osync_change_unref(change); } osync_list_free(uids); //Now we need to answer the call osync_context_report_success(ctx); osync_trace(TRACE_EXIT, "%s", __func__); }