/* Here we actually tell opensync which sinks are available. */
static osync_bool discover(void *userdata, OSyncPluginInfo *info, OSyncError **error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, userdata, info, error);
// plugin_environment *env = (plugin_environment *)userdata;
// Report avaliable sinks...
OSyncObjTypeSink *sink = osync_plugin_info_find_objtype(info, "<objtype e.g. note>");
if (!sink) {
return FALSE;
}
osync_objtype_sink_set_available(sink, TRUE);
OSyncVersion *version = osync_version_new(error);
osync_version_set_plugin(version, "<your plugin-name>");
//osync_version_set_version(version, "version");
//osync_version_set_modelversion(version, "version");
//osync_version_set_firmwareversion(version, "firmwareversion");
//osync_version_set_softwareversion(version, "softwareversion");
//osync_version_set_hardwareversion(version, "hardwareversion");
osync_plugin_info_set_version(info, version);
osync_version_unref(version);
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
}
END_TEST
START_TEST (version_matches)
{
char *testbed = setup_testbed(NULL);
OSyncError *error = NULL;
OSyncVersion *version = osync_version_new(&error);
fail_unless(version != NULL, NULL);
fail_unless(error == NULL, NULL);
osync_version_set_plugin(version, "SyncML");
osync_version_set_vendor(version, "Nokia");
osync_version_set_modelversion(version, "7650");
osync_version_set_firmwareversion(version, "*");
osync_version_set_softwareversion(version, "*");
osync_version_set_hardwareversion(version, "*");
OSyncVersion *pattern = osync_version_new(&error);
fail_unless(pattern != NULL, NULL);
fail_unless(error == NULL, NULL);
osync_version_set_plugin(pattern, "Sync[A-Z]");
osync_version_set_priority(pattern, "100");
osync_version_set_vendor(pattern, "Nokia");
osync_version_set_modelversion(pattern, "[0-9]");
osync_version_set_firmwareversion(pattern, "");
osync_version_set_softwareversion(pattern, "");
osync_version_set_hardwareversion(pattern, "");
fail_unless(osync_version_matches(pattern, version, &error) > 0, NULL);
fail_unless(error == NULL, NULL);
osync_version_set_firmwareversion(pattern, "[0-9]");
fail_unless(osync_version_matches(pattern, version, &error) == 0, NULL);
fail_unless(error == NULL, NULL);
destroy_testbed(testbed);
}
/* Here we actually tell opensync which sinks are available. For this plugin, we
* go through the list of directories and enable all, since all have been configured */
static osync_bool mock_discover(OSyncPluginInfo *info, void *data, OSyncError **error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, error);
OSyncPluginConfig *config = osync_plugin_info_get_config(info);
osync_assert_msg(config, "No OSyncPluginConfig set for mock_discover!");
/*
OSyncFormatEnv *formatenv = osync_plugin_info_get_format_env(info);
osync_assert_msg(config, "No OSyncFormatEnv set for mock_discover!");
*/
OSyncList *r = osync_plugin_config_get_resources(config);
for (; r; r = r->next) {
OSyncPluginResource *res = r->data;
OSyncObjTypeSink *sink;
const char *objtype = osync_plugin_resource_get_objtype(res);
/* Check for ObjType sink */
if ((sink = osync_plugin_info_find_objtype(info, objtype)))
osync_objtype_sink_set_available(sink, TRUE);
}
OSyncVersion *version = osync_version_new(error);
osync_version_set_plugin(version, "mock-sync");
//osync_version_set_vendor(version, "version");
//osync_version_set_modelversion(version, "version");
//osync_version_set_firmwareversion(version, "firmwareversion");
//osync_version_set_softwareversion(version, "softwareversion");
//osync_version_set_hardwareversion(version, "hardwareversion");
osync_plugin_info_set_version(info, version);
osync_version_unref(version);
/* we can set here the capabilities, but for the file-sync
* plugin they are static and shipped with opensync */
if (mock_get_error(info->memberid, "MOCK_DISCOVER_ERROR")) {
osync_error_set(error, OSYNC_ERROR_EXPECTED, "MOCK_DISCOVER_ERROR on purpose!");
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return FALSE;
}
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
}
static osync_bool discover(OSyncPluginInfo *info, void *data, OSyncError **error)
{
printf("[EXTERNAL-DEMO]: %s\n", __func__);
OSyncList *s, *sinks = osync_plugin_info_get_objtype_sinks(info);
for (s = sinks; s; s = s->next) {
OSyncObjTypeSink *sink = (OSyncObjTypeSink *) s->data;
osync_objtype_sink_set_available(sink, TRUE);
}
osync_list_free(sinks);
OSyncVersion *version = osync_version_new(error);
osync_version_set_plugin(version, "external-demo");
osync_plugin_info_set_version(info, version);
osync_version_unref(version);
return TRUE;
}
OSyncList *osync_version_load_from_descriptions(OSyncError **error, const char *descriptiondir, const char *schemadir)
{
GDir *dir = NULL;
GError *gerror = NULL;
const char *descpath = descriptiondir ? descriptiondir : OPENSYNC_DESCRIPTIONSDIR;
const char *schemapath = schemadir ? schemadir : OPENSYNC_SCHEMASDIR;
char *filename = NULL;
const gchar *de = NULL;
OSyncList *versions = NULL;
OSyncVersion *version = NULL;
xmlDocPtr doc;
xmlNodePtr root;
xmlNodePtr cur;
xmlNodePtr child;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
dir = g_dir_open(descpath, 0, &gerror);
if (!dir) {
/* If description directory doesn't exist (e.g. unittests), just ignore this. */
osync_trace(TRACE_EXIT, "Unable to open directory %s: %s", descpath, gerror->message);
g_error_free(gerror);
return NULL;
}
while ((de = g_dir_read_name(dir))) {
char *schemafilepath = NULL;
osync_bool res;
filename = osync_strdup_printf ("%s%c%s", descpath, G_DIR_SEPARATOR, de);
if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR) || !g_pattern_match_simple("*.xml", filename)) {
osync_free(filename);
continue;
}
doc = xmlReadFile(filename, NULL, XML_PARSE_NOBLANKS);
if(!doc) {
osync_free(filename);
continue;
}
osync_free(filename);
root = xmlDocGetRootElement(doc);
if(!root || !xmlStrEqual(root->name, BAD_CAST "versions")) {
osync_xml_free_doc(doc);
continue;
}
schemafilepath = osync_strdup_printf("%s%c%s", schemapath, G_DIR_SEPARATOR, "descriptions.xsd");
res = osync_xml_validate_document(doc, schemafilepath);
osync_free(schemafilepath);
if(res == FALSE) {
osync_xml_free_doc(doc);
continue;
}
cur = root->children;
for(; cur != NULL; cur = cur->next) {
version = osync_version_new(error);
if(!version) {
OSyncList *cur = NULL;
osync_xml_free_doc(doc);
cur = osync_list_first(versions);
while(cur) {
osync_version_unref(cur->data);
cur = cur->next;
}
goto error;
}
child = cur->children;
osync_version_set_plugin(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_priority(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_vendor(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_modelversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_firmwareversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_softwareversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_hardwareversion(version, (const char *)osync_xml_node_get_content(child));
child = child->next;
osync_version_set_identifier(version, (const char *)osync_xml_node_get_content(child));
versions = osync_list_append(versions, version);
}
osync_xml_free_doc(doc);
}
g_dir_close(dir);
osync_trace(TRACE_EXIT, "%s: %p", __func__, versions);
return versions;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
