static osync_bool conv_mockformat1_to_mockformat1a(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
{
osync_trace(TRACE_INTERNAL, "Converting file to fileA");
*free_input = FALSE;
char *identifier = " ";
OSyncFileFormat *file = (OSyncFileFormat *)input;
OSyncFileFormat *fileA = osync_try_malloc0(sizeof(OSyncFileFormat), error);
osync_assert(fileA);
char *filedata = osync_try_malloc0(file->size + 2, error);
memcpy(filedata, file->data, file->size);
memcpy(filedata + file->size, identifier , 2);
fileA->path = file->path;
osync_assert(*error == NULL);
fileA->data = filedata;
fileA->size = file->size + 2;
*output = (char *)fileA;
*outpsize = sizeof(OSyncFileFormat);
return TRUE;
}
static int _osync_version_match(char *pattern, char* string, OSyncError **error)
{
osync_assert(pattern);
osync_assert(string);
if(!strlen(pattern))
return 1;
/* Only newer versions of glib support regular expressions */
/* On Windows the glib regular expressions are required */
#if GLIB_MAJOR_VERSION < 3 && GLIB_MINOR_VERSION < 14
regex_t *preg = osync_try_malloc0(sizeof(regex_t), error);
if(!preg)
goto error;
int ret = regcomp(preg, pattern, 0);
char *errbuf;
size_t errbuf_size;
if(ret) {
errbuf_size = regerror(ret, preg, NULL, 0);
errbuf = osync_try_malloc0(errbuf_size, error);
if(!errbuf)
goto error_and_free;
regerror(ret, preg, errbuf, errbuf_size);
osync_error_set(error, OSYNC_ERROR_GENERIC, "%s", errbuf);
osync_free(errbuf);
goto error_and_free;
}
ret = regexec(preg, string, 0, NULL, 0);
regfree(preg);
osync_free(preg);
if(ret != 0) {
if(ret == REG_NOMATCH)
return 0;
errbuf_size = regerror(ret, preg, NULL, 0);
errbuf = osync_try_malloc0(errbuf_size, error);
if(!errbuf)
goto error;
regerror(ret, preg, errbuf, errbuf_size);
osync_error_set(error, OSYNC_ERROR_GENERIC, "%s", errbuf);
osync_free(errbuf);
goto error;
}
return 1;
error_and_free:
regfree(preg);
osync_free(preg);
error:
return -1;
#else /* GLIB_MAJOR_VERSION < 3 && GLIB_MINOR_VERSION < 14 */
return g_regex_match_simple(pattern, string, 0, 0);
#endif
}
osync_bool osync_queue_send_message_with_timeout(OSyncQueue *queue, OSyncQueue *replyqueue, OSyncMessage *message, unsigned int timeout, OSyncError **error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %u, %p)", __func__, queue, replyqueue, message, timeout, error);
if (osync_message_get_handler(message)) {
OSyncPendingMessage *pending = NULL;
GTimeVal current_time;
long long int id = 0;
osync_assert(replyqueue);
pending = osync_try_malloc0(sizeof(OSyncPendingMessage), error);
if (!pending)
goto error;
/* g_sourcet_get_current_time used cached time ... hopefully faster then g_get_.._time() */
g_source_get_current_time(queue->timeout_source, ¤t_time);
id = gen_id(¤t_time);
osync_message_set_id(message, id);
pending->id = id;
osync_trace(TRACE_INTERNAL, "Setting id %lli for pending reply", id);
if (timeout) {
OSyncTimeoutInfo *toinfo = osync_try_malloc0(sizeof(OSyncTimeoutInfo), error);
if (!toinfo)
goto error;
toinfo->expiration = current_time;
toinfo->expiration.tv_sec += timeout;
pending->timeout_info = toinfo;
} else {
osync_trace(TRACE_INTERNAL, "handler message got sent without timeout!: %s", osync_message_get_commandstr(message));
}
pending->callback = osync_message_get_handler(message);
pending->user_data = osync_message_get_handler_data(message);
g_mutex_lock(replyqueue->pendingLock);
replyqueue->pendingReplies = g_list_append(replyqueue->pendingReplies, pending);
g_mutex_unlock(replyqueue->pendingLock);
}
osync_message_ref(message);
g_async_queue_push(queue->outgoing, message);
g_main_context_wakeup(queue->context);
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return FALSE;
}
OSyncQueue *osync_queue_new(const char *name, OSyncError **error)
{
OSyncQueue *queue = NULL;
osync_trace(TRACE_ENTRY, "%s(%s, %p)", __func__, name, error);
queue = osync_try_malloc0(sizeof(OSyncQueue), error);
if (!queue)
goto error;
if (name)
queue->name = g_strdup(name);
queue->fd = -1;
if (!g_thread_supported ())
g_thread_init (NULL);
queue->pendingLock = g_mutex_new();
queue->context = g_main_context_new();
queue->outgoing = g_async_queue_new();
queue->incoming = g_async_queue_new();
queue->disconnectLock = g_mutex_new();
osync_trace(TRACE_EXIT, "%s: %p", __func__, queue);
return queue;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
OSyncXMLField *osync_xmlfield_new_xmlfield(OSyncXMLField *parent, xmlNodePtr node, OSyncError **error)
{
OSyncXMLField *xmlfield = osync_try_malloc0(sizeof(OSyncXMLField), error);
if(!xmlfield) {
osync_trace(TRACE_ERROR, "%s: %s" , __func__, osync_error_print(error));
return NULL;
}
xmlfield->next = NULL;
xmlfield->node = node;
xmlfield->parent = parent;
node->_private = xmlfield;
if (parent) {
xmlfield->prev = osync_xmlfield_get_last_child(parent);
if (xmlfield->prev) {
osync_assert(xmlfield->prev->next == NULL);
xmlfield->prev->next = xmlfield;
}
if (parent->child == NULL)
parent->child = xmlfield;
}
// We don't know if the parsed xmlformat got sorted xmlfield -> unsorted
xmlfield->sorted = FALSE;
return xmlfield;
}
OSyncThread *osync_thread_new(GMainContext *context, OSyncError **error)
{
OSyncThread *thread = NULL;
osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, context, error);
thread = osync_try_malloc0(sizeof(OSyncThread), error);
if (!thread)
goto error;
thread->ref_count = 1;
if (!g_thread_supported ()) g_thread_init (NULL);
thread->started_mutex = g_mutex_new();
thread->started = g_cond_new();
thread->context = context;
if (thread->context)
g_main_context_ref(thread->context);
thread->loop = g_main_loop_new(thread->context, FALSE);
osync_trace(TRACE_EXIT, "%s: %p", __func__, thread);
return thread;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
OSyncThread *osync_thread_create(GThreadFunc func, void *userdata, OSyncError **error)
{
GError *gerror;
OSyncThread *thread;
osync_assert(func);
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, func, userdata, error);
thread = osync_try_malloc0(sizeof(OSyncThread), error);
if (!thread)
goto error;
thread->ref_count = 1;
if (!g_thread_supported ())
g_thread_init (NULL);
thread->thread = g_thread_create(func, userdata, TRUE, &gerror);
if (!thread->thread) {
osync_error_set(error, OSYNC_ERROR_GENERIC, "%s", gerror->message);
g_error_free(gerror);
goto error_free_thread;
}
osync_trace(TRACE_EXIT, "%s", __func__);
return thread;
error_free_thread:
osync_free(thread);
error:
osync_trace(TRACE_EXIT_ERROR, "%s(%s)", __func__, osync_error_print(error));
return NULL;
}
OSyncXMLField *osync_xmlfield_new_node(OSyncXMLFormat *xmlformat, xmlNodePtr node, OSyncError **error)
{
OSyncXMLField *xmlfield = osync_try_malloc0(sizeof(OSyncXMLField), error);
if(!xmlfield) {
osync_trace(TRACE_ERROR, "%s: %s" , __func__, osync_error_print(error));
return NULL;
}
xmlfield->next = NULL;
xmlfield->node = node;
xmlfield->prev = xmlformat->last_child;
node->_private = xmlfield;
if(!xmlformat->first_child)
xmlformat->first_child = xmlfield;
if(xmlformat->last_child)
xmlformat->last_child->next = xmlfield;
xmlformat->last_child = xmlfield;
xmlformat->child_count++;
// We don't know if the parsed xmlformat got sorted xmlfield -> unsorted
xmlfield->sorted = FALSE;
return xmlfield;
}
OSyncSinkEngine *osync_sink_engine_new(int position, OSyncClientProxy *proxy, OSyncObjEngine *objengine, OSyncError **error)
{
OSyncSinkEngine *sinkengine = NULL;
osync_trace(TRACE_ENTRY, "%s(%i, %p, %p, %p)", __func__, position, proxy, objengine, error);
osync_assert(proxy);
osync_assert(objengine);
sinkengine = osync_try_malloc0(sizeof(OSyncSinkEngine), error);
if (!sinkengine)
goto error;
sinkengine->ref_count = 1;
sinkengine->position = position;
/* we dont reference the proxy to avoid circular dependencies. This object is completely
* dependent on the proxy anyways */
sinkengine->proxy = proxy;
sinkengine->engine = objengine;
osync_obj_engine_ref(objengine);
osync_trace(TRACE_EXIT, "%s: %p", __func__, sinkengine);
return sinkengine;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
static osync_bool demarshal_file(OSyncMarshal *marshal, char **output, unsigned int *outpsize, void *user_data, OSyncError **error)
{
OSyncFileFormat *file = NULL;
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, marshal, output, outpsize, error);
file = osync_try_malloc0(sizeof(OSyncFileFormat), error);
if (!file)
goto error;
if (!osync_marshal_read_string(marshal, &(file->path), error))
goto error;
if (!osync_marshal_read_buffer(marshal, (void *)&(file->data), &(file->size), error))
goto error;
*output = (char *)file;
*outpsize = sizeof(OSyncFileFormat);
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return FALSE;
}
osync_bool osync_xmlfield_sort(OSyncXMLField *xmlfield, OSyncError **error)
{
int index, count;
void **list = NULL;
xmlNodePtr cur = NULL;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, xmlfield);
osync_assert(xmlfield);
if (xmlfield->sorted) {
osync_trace(TRACE_INTERNAL, "already sorted");
goto end;
}
count = osync_xmlfield_get_key_count(xmlfield);
if( count <= 1 ) {
osync_trace(TRACE_INTERNAL, "attribute count <= 1 - no need to sort");
goto end;
}
list = osync_try_malloc0(sizeof(xmlNodePtr) * count, error);
if (!list)
goto error;
cur = xmlfield->node->children;
for (index=0; cur != NULL; index++) {
xmlNodePtr tmp = cur;
list[index] = cur;
cur = cur->next;
xmlUnlinkNode(tmp);
}
qsort(list, count, sizeof(xmlNodePtr), osync_xmlfield_key_compare_stdlib);
for(index = 0; index < count; index++) {
cur = (xmlNodePtr)list[index];
xmlAddChild(xmlfield->node, cur);
if(index < count-1)
cur->next = (xmlNodePtr)list[index+1];
else
cur->next = NULL;
if(index)
cur->prev = (xmlNodePtr)list[index-1];
else
cur->prev = NULL;
}
g_free(list);
end:
xmlfield->sorted = TRUE;
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
error:
return FALSE;
}
OSyncPluginInfo *osync_plugin_info_new(OSyncError **error)
{
OSyncPluginInfo *info = osync_try_malloc0(sizeof(OSyncPluginInfo), error);
if (!info)
return NULL;
info->ref_count = 1;
return info;
}
static OSyncFormatConverterPathVertice *osync_format_converter_path_vertice_new(OSyncError **error)
{
OSyncFormatConverterPathVertice *v = osync_try_malloc0(sizeof(OSyncFormatConverterPathVertice), error);
if (!v)
return NULL;
v->ref_count = 1;
return v;
}
OSyncContext *osync_context_new(OSyncError **error)
{
OSyncContext *ctx = osync_try_malloc0(sizeof(OSyncContext), error);
if (!ctx)
return NULL;
ctx->ref_count = 1;
return ctx;
}
OSyncCapabilities *osync_capabilities_parse(const char *buffer, unsigned int size, OSyncError **error)
{
OSyncCapabilities *capabilities = NULL;
xmlNodePtr cur = NULL;
xmlChar *capsformat;
osync_trace(TRACE_ENTRY, "%s(%p, %u, %p)", __func__, buffer, size, error);
osync_assert(buffer);
capabilities = osync_try_malloc0(sizeof(OSyncCapabilities), error);
if(!capabilities) {
osync_trace(TRACE_EXIT_ERROR, "%s: %s" , __func__, osync_error_print(error));
return NULL;
}
capabilities->ref_count = 1;
capabilities->doc = xmlReadMemory(buffer, size, NULL, NULL, XML_PARSE_NOBLANKS);
if(capabilities->doc == NULL) {
osync_free(capabilities);
osync_error_set(error, OSYNC_ERROR_GENERIC, "Could not parse XML.");
goto error;
}
capabilities->doc->_private = capabilities;
/* Get CapsFormat Name */
capsformat = xmlGetProp(capabilities->doc->children, (const xmlChar*)"CapsFormat");
osync_capabilities_set_format(capabilities, (const char *) capsformat);
xmlFree(capsformat);
cur = xmlDocGetRootElement(capabilities->doc);
cur = cur->children;
for(; cur != NULL; cur = cur->next) {
if (cur->type != XML_ELEMENT_NODE)
continue;
OSyncCapabilitiesObjType *capabilitiesobjtype = osync_capabilities_objtype_parse_and_add(capabilities, cur, error);
if (!capabilitiesobjtype) {
osync_capabilities_unref(capabilities);
goto error;
}
else {
// we don't need our copy of the capabilitiesobjtype
osync_capabilities_objtype_unref(capabilitiesobjtype);
}
}
osync_trace(TRACE_EXIT, "%s: %p", __func__, capabilities);
return capabilities;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s" , __func__, osync_error_print(error));
return NULL;
}
static void create_file(char **buffer, unsigned int *size)
{
OSyncFileFormat *outfile = osync_try_malloc0(sizeof(OSyncFileFormat), NULL);
outfile->path = osync_rand_str(g_random_int_range(1, 100));
outfile->data = osync_rand_str(g_random_int_range(1, 100));
outfile->size = strlen(outfile->data);
*buffer = (char *)outfile;
*size = sizeof(OSyncFileFormat);
}
OSyncDB *osync_db_new(OSyncError **error)
{
OSyncDB *db = NULL;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
db = osync_try_malloc0(sizeof(OSyncDB), error);
if (!db) {
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
osync_trace(TRACE_EXIT, "%s: %p", __func__, db);
return db;
}
OSyncPluginEnv *osync_plugin_env_new(OSyncError **error)
{
OSyncPluginEnv *env = NULL;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
env = osync_try_malloc0(sizeof(OSyncPluginEnv), error);
if (!env) {
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
osync_trace(TRACE_EXIT, "%s: %p", __func__, env);
return env;
}
OSyncModule *osync_module_new(OSyncError **error)
{
OSyncModule *module = NULL;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
module = osync_try_malloc0(sizeof(OSyncModule), error);
if (!module) {
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
osync_trace(TRACE_EXIT, "%s: %p", __func__, module);
return module;
}
OSyncData *osync_data_new(char *buffer, unsigned int size, OSyncObjFormat *format, OSyncError **error)
{
OSyncData *data = osync_try_malloc0(sizeof(OSyncData), error);
if (!data)
return NULL;
if (buffer && size) {
data->data = buffer;
data->size = size;
}
data->ref_count = 1;
data->objformat = format;
osync_objformat_ref(format);
return data;
}
OSyncXMLField *osync_xmlfield_new_node(xmlNodePtr node, OSyncError **error)
{
OSyncXMLField *xmlfield = osync_try_malloc0(sizeof(OSyncXMLField), error);
if(!xmlfield) {
osync_trace(TRACE_ERROR, "%s: %s" , __func__, osync_error_print(error));
return NULL;
}
xmlfield->node = node;
node->_private = xmlfield;
// We don't know if the parsed xmlformat got sorted xmlfield -> unsorted
xmlfield->sorted = FALSE;
return xmlfield;
}
static osync_bool conv_mockformat1_to_mockformat2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
{
osync_trace(TRACE_INTERNAL, "Converting file to plain");
*free_input = TRUE;
OSyncFileFormat *file = (OSyncFileFormat *)input;
/* Add a \0 to make a usable plain (text) format. input gets freed by destroy_func() */
char *plaindata = osync_try_malloc0(file->size + 1, error);
memcpy(plaindata, file->data, file->size);
*output = plaindata;
*outpsize = file->size + 1;
return TRUE;
}
static osync_bool create_file(char **buffer, unsigned int *size, void *user_data, OSyncError **error)
{
OSyncFileFormat *outfile = osync_try_malloc0(sizeof(OSyncFileFormat), NULL);
outfile->path = osync_rand_str(g_random_int_range(1, 100), error);
osync_assert(*error == NULL);
outfile->data = osync_rand_str(g_random_int_range(1, 100), error);
osync_assert(*error == NULL);
outfile->size = strlen(outfile->data);
*buffer = (char *)outfile;
*size = sizeof(OSyncFileFormat);
return TRUE;
}
static osync_bool demarshal_file(OSyncMessage *message, char **output, unsigned int *outpsize, OSyncError **error)
{
osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p)", __func__, message, output, outpsize, error);
OSyncFileFormat *file = osync_try_malloc0(sizeof(OSyncFileFormat), error);
osync_assert(file);
osync_message_read_string(message, &(file->path));
osync_message_read_buffer(message, (void *)&(file->data), (int *)&(file->size));
*output = (char *)file;
*outpsize = sizeof(OSyncFileFormat);
osync_trace(TRACE_EXIT, "%s", __func__);
return TRUE;
}
static osync_bool conv_plain_to_file(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
{
osync_trace(TRACE_INTERNAL, "Converting plain to file");
*free_input = FALSE;
OSyncFileFormat *file = osync_try_malloc0(sizeof(OSyncFileFormat), error);
osync_assert(file);
file->path = osync_rand_str(g_random_int_range(1, 100));
file->data = input;
file->size = inpsize - 1;
*output = (char *)file;
*outpsize = sizeof(OSyncFileFormat);
return TRUE;
}
OSyncMapping *osync_mapping_new(OSyncError **error)
{
OSyncMapping *mapping = NULL;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
mapping = osync_try_malloc0(sizeof(OSyncMapping), error);
if (!mapping)
goto error;
mapping->ref_count = 1;
osync_trace(TRACE_EXIT, "%s: %p", __func__, mapping);
return mapping;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
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;
}
OSyncMappingEntry *osync_mapping_entry_new(OSyncError **error)
{
OSyncMappingEntry *entry = NULL;
osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
entry = osync_try_malloc0(sizeof(OSyncMappingEntry), error);
if (!entry)
goto error;
entry->ref_count = 1;
osync_trace(TRACE_EXIT, "%s: %p", __func__, entry);
return entry;
error:
osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
return NULL;
}
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;
}
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;
}
