int csync_init(CSYNC *ctx) {
int rc;
char *config = NULL;
if (ctx == NULL) {
errno = EBADF;
return -1;
}
ctx->status_code = CSYNC_STATUS_OK;
/* Do not initialize twice */
if (ctx->status & CSYNC_STATUS_INIT) {
return 1;
}
/* check for uri */
if (csync_fnmatch("owncloud://*", ctx->remote.uri, 0) == 0 && csync_fnmatch("ownclouds://*", ctx->remote.uri, 0) == 0) {
ctx->status_code = CSYNC_STATUS_NO_MODULE;
rc = -1;
goto out;
}
ctx->local.type = LOCAL_REPLICA;
if ( !ctx->options.local_only_mode) {
owncloud_init(csync_get_auth_callback(ctx), csync_get_userdata(ctx));
ctx->remote.type = REMOTE_REPLICA;
} else {
ctx->remote.type = LOCAL_REPLICA;
}
if (ctx->options.timeout)
csync_vio_set_property(ctx, "timeout", &ctx->options.timeout);
if (c_rbtree_create(&ctx->local.tree, _key_cmp, _data_cmp) < 0) {
ctx->status_code = CSYNC_STATUS_TREE_ERROR;
rc = -1;
goto out;
}
if (c_rbtree_create(&ctx->remote.tree, _key_cmp, _data_cmp) < 0) {
ctx->status_code = CSYNC_STATUS_TREE_ERROR;
rc = -1;
goto out;
}
ctx->status = CSYNC_STATUS_INIT;
csync_set_module_property(ctx, "csync_context", ctx);
/* initialize random generator */
srand(time(NULL));
rc = 0;
out:
SAFE_FREE(config);
return rc;
}
int csync_set_module_property(CSYNC* ctx, const char* key, void* value)
{
return csync_vio_set_property(ctx, key, value);
}
int csync_init(CSYNC *ctx) {
int rc;
time_t timediff = -1;
char *exclude = NULL;
char *lock = NULL;
char *config = NULL;
char errbuf[256] = {0};
if (ctx == NULL) {
errno = EBADF;
return -1;
}
ctx->status_code = CSYNC_STATUS_OK;
/* Do not initialize twice */
if (ctx->status & CSYNC_STATUS_INIT) {
return 1;
}
/* create dir if it doesn't exist */
if (! c_isdir(ctx->options.config_dir)) {
c_mkdirs(ctx->options.config_dir, 0700);
}
/* create lock file */
if (asprintf(&lock, "%s/%s", ctx->options.config_dir, CSYNC_LOCK_FILE) < 0) {
rc = -1;
ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
goto out;
}
#ifndef _WIN32
if (csync_lock(lock) < 0) {
rc = -1;
ctx->status_code = CSYNC_STATUS_NO_LOCK;
goto out;
}
#endif
/* load config file */
if (asprintf(&config, "%s/%s", ctx->options.config_dir, CSYNC_CONF_FILE) < 0) {
ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
rc = -1;
goto out;
}
rc = csync_config_parse_file(ctx, config);
if (rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN, "Could not load config file %s, using defaults.", config);
}
#ifndef _WIN32
/* load global exclude list */
if (asprintf(&exclude, "%s/csync/%s", SYSCONFDIR, CSYNC_EXCLUDE_FILE) < 0) {
rc = -1;
ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
goto out;
}
if (csync_exclude_load(ctx, exclude) < 0) {
strerror_r(errno, errbuf, sizeof(errbuf));
CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN, "Could not load %s - %s", exclude,
errbuf);
}
SAFE_FREE(exclude);
#endif
/* load exclude list */
if (asprintf(&exclude, "%s/%s", ctx->options.config_dir,
CSYNC_EXCLUDE_FILE) < 0) {
ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
rc = -1;
goto out;
}
if (csync_exclude_load(ctx, exclude) < 0) {
strerror_r(errno, errbuf, sizeof(errbuf));
CSYNC_LOG(CSYNC_LOG_PRIORITY_INFO, "Could not load %s - %s", exclude,
errbuf);
}
/* create/load statedb */
if (! csync_is_statedb_disabled(ctx)) {
rc = asprintf(&ctx->statedb.file, "%s/.csync_journal.db",
ctx->local.uri);
if (rc < 0) {
ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
goto out;
}
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Journal: %s", ctx->statedb.file);
rc = csync_statedb_load(ctx, ctx->statedb.file, &ctx->statedb.db);
if (rc < 0) {
ctx->status_code = CSYNC_STATUS_STATEDB_LOAD_ERROR;
goto out;
}
}
ctx->local.type = LOCAL_REPLICA;
/* check for uri */
if ( !ctx->options.local_only_mode && csync_fnmatch("*://*", ctx->remote.uri, 0) == 0) {
size_t len;
len = strstr(ctx->remote.uri, "://") - ctx->remote.uri;
/* get protocol */
if (len > 0) {
char *module = NULL;
/* module name */
module = c_strndup(ctx->remote.uri, len);
if (module == NULL) {
rc = -1;
ctx->status_code = CSYNC_STATUS_MEMORY_ERROR;
goto out;
}
/* load module */
retry_vio_init:
rc = csync_vio_init(ctx, module, NULL);
if (rc < 0) {
len = strlen(module);
if (module[len-1] == 's') {
module[len-1] = '\0';
goto retry_vio_init;
}
SAFE_FREE(module);
ctx->status_code = CSYNC_STATUS_NO_MODULE;
goto out;
}
SAFE_FREE(module);
ctx->remote.type = REMOTE_REPLICA;
}
} else {
ctx->remote.type = LOCAL_REPLICA;
}
if( !ctx->options.local_only_mode ) {
timediff = csync_timediff(ctx);
if (timediff > ctx->options.max_time_difference) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_FATAL,
"Clock skew detected. The time difference is greater than %d seconds!",
ctx->options.max_time_difference);
ctx->status_code = CSYNC_STATUS_TIMESKEW;
rc = -1;
goto out;
} else if (timediff < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_FATAL, "Synchronisation is not possible!");
ctx->status_code = CSYNC_STATUS_TIMESKEW;
rc = -1;
goto out;
}
if (csync_unix_extensions(ctx) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_FATAL, "Could not detect filesystem type.");
ctx->status_code = CSYNC_STATUS_FILESYSTEM_UNKNOWN;
rc = -1;
goto out;
}
}
/* Install progress callbacks in the module. */
if (ctx->callbacks.file_progress_cb != NULL) {
int prc;
prc = csync_vio_set_property(ctx, "file_progress_callback", &ctx->callbacks.file_progress_cb);
if (prc == -1) {
/* The module does not support the callbacks */
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Could not install file progress callback!");
ctx->callbacks.file_progress_cb = NULL;
}
}
if (ctx->callbacks.overall_progress_cb != NULL) {
int prc;
prc = csync_vio_set_property(ctx, "overall_progress_callback", &ctx->callbacks.overall_progress_cb);
if (prc == -1) {
/* The module does not support the callbacks */
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Could not install overall progress callback!");
ctx->callbacks.overall_progress_cb = NULL;
}
}
if (c_rbtree_create(&ctx->local.tree, _key_cmp, _data_cmp) < 0) {
ctx->status_code = CSYNC_STATUS_TREE_ERROR;
rc = -1;
goto out;
}
if (c_rbtree_create(&ctx->remote.tree, _key_cmp, _data_cmp) < 0) {
ctx->status_code = CSYNC_STATUS_TREE_ERROR;
rc = -1;
goto out;
}
ctx->status = CSYNC_STATUS_INIT;
/* initialize random generator */
srand(time(NULL));
rc = 0;
out:
SAFE_FREE(lock);
SAFE_FREE(exclude);
SAFE_FREE(config);
return rc;
}
