dav: comparison dav/sync.c

-:3cfe65695a8c
+:36a7f2ea7d12
 fprintf(synclog, "%s", str.ptr);
 }
 free(str.ptr);
 va_end(ap);
+}
+void log_resource_error(DavSession *sn, const char *path) {
+print_resource_error(sn, path);
+if(synclog) {
+print_resource_error_to_file(synclog, sn, path);
+}
 }
 int logfile_open(SyncDirectory *dir) {
 int ret = 0;
 DavBool locked = FALSE;
 DavResource *root = dav_resource_new(sn, "/");
 root->iscollection = TRUE;
 if((dir->lockpush || cmd_getoption(a, "lock")) && !cmd_getoption(a, "nolock")) {
 if(dav_lock_t(root, dir->lock_timeout)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 dav_session_destroy(sn);
-fprintf(stderr, "Abort\n");
+log_error("Abort\n");
 return -1;
 }
 DavLock *lock = dav_get_lock(sn, "/");
 if(lock) {
 log_printf("Lock-Token: %s\n", lock->token);
 }
 int ret = 0;
 DavResource *ls = dav_query(sn, "select D:getetag,idav:split,idav:status,`idav:content-hash`,idavprops:tags,idavprops:finfo,idavprops:xattributes,idavprops:link from / with depth = infinity");
 if(!ls) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 if(locked) {
 if(dav_unlock(root)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 } else {
 locked = FALSE;
 }
 }
-fprintf(stderr, "Abort\n");
+log_error("Abort\n");
 dav_session_destroy(sn);
 // TODO: free
 return -1;
 }
 if(!ls->iscollection) {
 fprintf(stderr, "%s is not a collection.\nAbort.\n", ls->path);
 if(locked) {
 if(dav_unlock(root)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 } else {
 locked = FALSE;
 }
 }
 // TODO: free
 }
 // unlock repository
 if(locked) {
 if(dav_unlock(root)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 ret = -1;
 } else {
 locked = FALSE;
 }
 }
 DavBool restore = restore_removed || restore_modified;
 int depth = restore ? -1 : 0;
 DavResource *root = dav_query(sn, "select D:getetag,idav:status from / with depth = %d", depth);
 if(!root) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 dav_session_destroy(sn);
-fprintf(stderr, "Abort\n");
+log_error("Abort\n");
 return -1;
 }
 CxMap *svrres = NULL;
 if(restore) {
 // lock repository
 DavBool locked = FALSE;
 char *locktokenfile = NULL;
 if((dir->lockpush || cmd_getoption(a, "lock")) && !cmd_getoption(a, "nolock") && !outgoing) {
 if(dav_lock_t(root, dir->lock_timeout)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 dav_session_destroy(sn);
-fprintf(stderr, "Abort\n");
+log_error("Abort\n");
 return -1;
 }
 DavLock *lock = dav_get_lock(sn, "/");
 if(lock) {
 log_printf("Lock-Token: %s\n", lock->token);
 cxListAdd(ls_update, local_res);
 }
 if(local_res->isnew) {
 if(local_resource_load_metadata(dir, local_res)) {
-fprintf(
+log_error(
-stderr,
 "Failed to load metadata: %s\n",
 local_resource_path(local_res));
 }
 }
 }
 break;
 }
 DavResource *res = dav_resource_new(sn, local_res->path);
 if(!res) {
-print_resource_error(sn, local_res->path);
+log_resource_error(sn, local_res->path);
 ret = -1;
 sync_error++;
 }
 int abort = 0;
 if(sn->error == DAV_NOT_FOUND) {
 // create collection
 // TODO: show 405
 log_printf("mkcol: %s\n", local_res->path);
 if(sync_mkdir(dir, res, local_res) && sn->error != DAV_METHOD_NOT_ALLOWED) {
-print_resource_error(sn, res->path);
+log_resource_error(sn, res->path);
 ret = -1;
 sync_error++;
 error = 1;
 abort = 1;
 }
 } else if(sn->error != DAV_OK) {
 // dav_exists() failed
-print_resource_error(sn, local_res->path);
+log_resource_error(sn, local_res->path);
 ret = -1;
 sync_error++;
 error = 1;
 abort = 1;
 }
 }
 }
 if(err) {
 sync_error++;
-print_resource_error(sn, res->path);
+log_resource_error(sn, res->path);
 ret = -1;
 error = 1;
 } else {
 LocalResource *dbres = cxMapGet(db->resources, cx_hash_key_str(local->path));
 cxMapPut(db->resources, cx_hash_key_str(local->path), local);
 int err = 0;
 DavResource *res = dav_resource_new(sn, local_res->path);
 if(!res) {
-print_resource_error(sn, local_res->path);
+log_resource_error(sn, local_res->path);
 ret = -1;
 sync_error++;
 } else {
 DavBool equal = FALSE;
 DavBool res_conflict = FALSE;
 } else {
 log_printf("put: %s\n", local_res->path);
 }
 if(sync_put_resource(dir, res, local_res, &sync_success)) {
 sync_error++;
-print_resource_error(sn, res->path);
+log_resource_error(sn, res->path);
 ret = -1;
 error = 1;
 err = 1;
 }
 if(local->keep) {
 continue;
 }
 if(sync_delete_remote_resource(dir, sn, local, &sync_delete, col_list)) {
 if(sn->error != DAV_NOT_FOUND) {
-print_resource_error(sn, local->path);
+log_resource_error(sn, local->path);
 sync_error++;
 break;
 }
 } else {
 LocalResource *dbres = cxMapRemoveAndGet(db->resources, cx_hash_key_str(local->path));
 cxListDestroy(cols_del);
 // unlock repository
 if(locked) {
 if(dav_unlock(root)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 ret = -1;
 } else {
 locked = FALSE;
 }
 }
 // store db
 if(store_db(db, dir->database, dir->db_settings)) {
-fprintf(stderr, "Cannot store sync db\n");
+log_error("Cannot store sync db\n");
 ret = -2;
 }
 // cleanup
 if(!locked && locktokenfile) {
 restore_removed = 1;
 }
 SyncDatabase *db = load_db(dir->database);
 if(!db) {
-fprintf(stderr, "Cannot load database file: %s\n", dir->database);
+log_error("Cannot load database file: %s\n", dir->database);
 return -1;
 }
 remove_deleted_conflicts(dir, db);
 CxList *modified = cxLinkedListCreate(cxDefaultAllocator, (cx_compare_func)localres_cmp_path, CX_STORE_POINTERS);
 if(errno == ENOENT) {
 if(restore_removed) {
 cxListAdd(deleted, resource);
 }
 } else {
-fprintf(stderr, "Cannot stat file: %s\n", file_path);
+log_error("Cannot stat file: %s\n", file_path);
-perror("");
+log_error("%s\n", strerror(errno));
 }
 } else {
 if(files) {
 cxListAdd(modified, resource);
 } else if(!resource->isdirectory && !S_ISDIR(s.st_mode)) {
 int ret = 0;
 // create DavSession
 Repository *repo = get_repository(cx_str(dir->repository));
 if(!repo) {
-fprintf(stderr, "Unkown repository %s\n", dir->name);
+log_error("Unkown repository %s\n", dir->name);
 return -1;
 }
 DavSession *sn = create_session(a, ctx, repo, dir->collection);
 cxMempoolRegister(sn->mp, db, (cx_destructor_func)destroy_db);
 if (cmd_getoption(a, "verbose")) {
 DavBool locked = FALSE;
 DavResource *root = dav_resource_new(sn, "/");
 root->iscollection = TRUE;
 if((dir->lockpush || cmd_getoption(a, "lock")) && !cmd_getoption(a, "nolock")) {
 if(dav_lock_t(root, dir->lock_timeout)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 dav_session_destroy(sn);
-fprintf(stderr, "Abort\n");
+log_error("Abort\n");
 return -1;
 }
 DavLock *lock = dav_get_lock(sn, "/");
 if(lock) {
 log_printf("Lock-Token: %s\n", lock->token);
 log_printf("skip: %s\n", resource->path);
 continue;
 }
 char *status = dav_get_string_property(res, "idav:status");
 if(status && !strcmp(status, "broken")) {
-fprintf(stderr, "Resource %s broken\n", res->path);
+log_error("Resource %s broken\n", res->path);
 continue;
 }
 DavResource *vres = NULL;
 DavBool update_local_entry = TRUE;
 vres = versioning_simple_find(res, version);
 } else if(dir->versioning->type == VERSIONING_DELTAV) {
 vres = versioning_deltav_find(res, version);
 }
 if(!vres) {
-fprintf(stderr, "Cannot find  specified version for resource %s\n", res->path);
+log_error("Cannot find specified version for resource %s\n", res->path);
 ret = 1;
 break;
 }
 // By restoring an old version of a file, the local dir is not
 // download the resource
 if(!sync_shutdown) {
 if(resource->isdirectory) {
 char *local_path = create_local_path(dir, res->path);
 if(sys_mkdir(local_path) && errno != EEXIST) {
-fprintf(stderr,
+log_error(
 "Cannot create directory %s: %s",
 local_path, strerror(errno));
 }
 free(local_path);
 } else {
 if(sync_get_resource(a, dir, res->path, vres, db, update_local_entry, &sync_success)) {
-fprintf(stderr, "sync_get_resource failed for resource: %s\n", res->path);
+log_error("sync_get_resource failed for resource: %s\n", res->path);
 sync_error++;
 } else if(!update_local_entry) {
 LocalResource *lr = cxMapGet(db->resources, cx_hash_key_str(res->path));
 if(lr) {
 lr->last_modified = 0;
 }
 // unlock repository
 if(locked) {
 if(dav_unlock(root)) {
-print_resource_error(sn, "/");
+log_resource_error(sn, "/");
 ret = -1;
 } else {
 locked = FALSE;
 }
 }
 // store db
 if(store_db(db, dir->database, dir->db_settings)) {
-fprintf(stderr, "Cannot store sync db\n");
+log_error("Cannot store sync db\n");
 ret = -2;
 }
 // cleanup
 dav_session_destroy(sn);
 }
 log_printf("%s\n", "File                                                Last Modified    Size");
 log_printf("%s\n", "==============================================================================");
-if(ls_mkcol) {
+if(ls_mkcol->size > 0) {
 log_printf("Directories:\n");
 CxIterator i = cxListIterator(ls_mkcol);
 cx_foreach(LocalResource *, res, i) {
 log_printf(" %-49s\n", res->path+1);
 total_size += res->size;
 }
 }
-if(ls_new) {
+if(ls_new->size > 0) {
 log_printf("New:\n");
 CxIterator i = cxListIterator(ls_new);
 cx_foreach(LocalResource *, res, i) {
 print_outgoging_file(res);
 total_size += res->size;
 }
 }
-if(ls_modified) {
+if(ls_modified->size > 0) {
 log_printf("Modified:\n");
 CxIterator i = cxListIterator(ls_modified);
 cx_foreach(LocalResource *, res, i) {
 print_outgoging_file(res);
 total_size += res->size;
 }
 }
-if(ls_update) {
+if(ls_update->size > 0) {
 log_printf("Update:\n");
 CxIterator i = cxListIterator(ls_update);
 cx_foreach(LocalResource *, res, i) {
 char *lastmodified = util_date_str(res->last_modified);
 log_printf(" %-49s  %12s\n", res->path+1, lastmodified);
 free(lastmodified);
 }
 }
-if(ls_delete) {
+if(ls_delete->size > 0) {
 log_printf("Delete:\n");
 CxIterator i = cxListIterator(ls_delete);
 cx_foreach(LocalResource *, res, i) {
 log_printf(" %s\n", res->path+1);
 }
 }
-if(ls_copy) {
+if(ls_copy->size > 0) {
 log_printf("Copy:\n");
 CxIterator i = cxListIterator(ls_copy);
 cx_foreach(LocalResource *, res, i) {
 log_printf("%s -> %s\n", res->origin->path+1, res->path);
 }
 }
-if(ls_move) {
+if(ls_move->size > 0) {
 log_printf("Move:\n");
 CxIterator i = cxListIterator(ls_move);
 cx_foreach(LocalResource *, res, i) {
 log_printf("%s -> %s\n", res->origin->path+1, res->path);
 }
 }
-if(ls_conflict) {
+if(ls_conflict->size > 0) {
 log_printf("Conflict\n");
 CxIterator i = cxListIterator(ls_conflict);
 cx_foreach(LocalResource *, res, i) {
 log_printf(" %s\n", res->path+1);
 }
 cxListRemove(stack, 0);
 char *local_path = create_local_path(dir, p);
 SYS_DIR local_dir = sys_opendir(local_path);
 if(!local_dir) {
-fprintf(stderr, "Cannot open directory %s\n", local_path);
+log_error("Cannot open directory %s: %s\n", local_path, strerror(errno));
 } else {
 SysDirEnt *ent;
 while((ent = sys_readdir(local_dir)) != NULL) {
 if(!strcmp(ent->name, ".") || !strcmp(ent->name, "..")) {
 continue;
 LocalResource* local_resource_new(SyncDirectory *dir, SyncDatabase *db, char *path) {
 char *file_path = create_local_path(dir, path);
 SYS_STAT s;
 if(sys_lstat(file_path, &s)) {
-fprintf(stderr, "Cannot stat file %s\n", file_path);
+log_error("Cannot stat file %s: %s\n", file_path, strerror(errno));
 free(file_path);
 return NULL;
 }
 LocalResource *res = calloc(1, sizeof(LocalResource));
 return NULL;
 }
 if(dav_load_prop(vcol, defprops, numdefprops)) {
-print_resource_error(res->session, vcol->path);
+log_resource_error(res->session, vcol->path);
 dav_resource_free(vcol);
 return NULL;
 }
 DavResource *ret = NULL;
 // set mtime
 struct utimbuf t;
 t.actime = f.last_modified;
 t.modtime = f.last_modified;
 if(utime(path, &t)) {
-fprintf(stderr, "utime failed for file: %s : %s\n", path, strerror(errno));
+log_error("utime failed for file: %s : %s\n", path, strerror(errno));
 ret = 1;
 } else {
 local->last_modified = f.last_modified;
 }
 }
 if((dir->metadata & FINFO_MODE) == FINFO_MODE && f.mode_set) {
 // set mode
 if(chmod(path, f.mode)) {
-fprintf(stderr, "chmod failed for file: %s : %s\n", path, strerror(errno));
+log_error("chmod failed for file: %s : %s\n", path, strerror(errno));
 ret = 1;
 } else {
 local->mode = f.mode;
 }
 }
 // store extended attributes
 size_t nattr = xattr ? xattr->nattr : 0;
 for(int i=0;i<nattr;i++) {
 cxmutstr value = xattr->values[i];
 if(xattr_set(path, xattr->names[i], value.ptr, value.length)) {
-fprintf(stderr,
+log_error(
 "Cannot store xattr '%s' for file: %s\n",
 xattr->names[i],
 path);
 }
 // Make sure the resource is a collection. If it was a normal
 // resource until now, delete it and recreate it as collection
 if(res->exists) {
 if(!res->iscollection) {
 if(dav_delete(res)) {
-print_resource_error(res->session, res->path);
+log_resource_error(res->session, res->path);
 *err = 1;
 return NULL;
 }
 res->exists = 0;
 return upload_parts(local, res, in, filesize, blocksize, blockcount, err);
 }
 } else {
 res->iscollection = 1;
 if(dav_create(res)) {
-print_resource_error(res->session, res->path);
+log_resource_error(res->session, res->path);
 *err = 1;
 return NULL;
 }
 }
 res->exists = 1;
 if(!res->href) {
 // this should never happen, but just make sure it doesn't crash
-fprintf(stderr, "href is NULL\n");
+log_error("href is NULL\n");
 *err = 1;
 return NULL;
 }
 char *buffer = malloc(blocksize);
 // calculate the maximal length of resource names
 // names should have all the same length and contain the block number
 int nblocks = filesize / blocksize;
 int digits = LOG10((double)nblocks) + 1;
 if(digits > 127) {
-fprintf(stderr, "Too many parts\n");
+log_error("Too many parts\n");
 *err = 1;
 	free(buffer);
 return NULL;
 }
 // upload part
 dav_set_content_data(part, buffer, r);
 if(dav_store(part)) {
 *err = 1;
-print_resource_error(res->session, part->path);
+log_resource_error(res->session, part->path);
 } else {
 // successfully uploaded part
 // store the FilePart in a map
 // later we do a propfind and add the etag
 // get etags from uploaded resources
 // also delete everything, that is not part of the file
 CxList *updated_parts = cxLinkedListCreateSimple(CX_STORE_POINTERS);
 DavResource *parts = dav_query(res->session, "select D:getetag from %s order by name", res->path);
 if(!parts) {
-print_resource_error(res->session, parts->path);
+log_resource_error(res->session, parts->path);
 *err = 1;
 cxMapDestroy(updated_parts_map);
 return NULL;
 }
 DavResource *part = parts->children;
 }
 }
 if(delete_part) {
 if(dav_delete(part)) {
-print_resource_error(part->session, part->path);
+log_resource_error(part->session, part->path);
 }
 }
 }
 part = part->next;
 }
 {
 char *local_path = create_local_path(dir, local_resource_path(local));
 SYS_STAT s;
 if(sys_stat(local_path, &s)) {
-fprintf(stderr, "Cannot stat file: %s\n", local_path);
+log_error("Cannot stat file: %s: %s\n", local_path, strerror(errno));
-perror("");
 free(local_path);
 return -1;
 }
 DavBool islink = local->link_target ? 1 : 0;
 size_t split_blocksize = resource_get_blocksize(dir, local, res, s.st_size);
 FILE *in = sys_fopen(local_path, "rb");
 if(!in) {
-fprintf(stderr, "Cannot open file %s\n", local_path);
+log_error("Cannot open file %s: %s\n", local_path, strerror(errno));
 free(local_path);
 return -1;
 }
 DavBool issplit = split_blocksize == 0 ? FALSE : TRUE;
 if(dir->versioning && dir->versioning->always && !issplit) {
 // in case the file exists, we need to put the file under
 // versioncontrol (DeltaV only, does nothing with simple versioning)
 if(exists && versioning_init(dir, local, res)) {
 // init failed
-fprintf(stderr, "Cannot activate versioncontrol for resource: %s\n", res->href);
+log_error("Cannot activate versioncontrol for resource: %s\n", res->href);
 free(local_path);
 return -1;
 } else {
 int err = versioning_begin(dir, res, &exists, &vend_required);
 if(err) {
-fprintf(stderr, "Cannot store version for resource: %s\n", res->href);
+log_error("Cannot store version for resource: %s\n", res->href);
 free(local_path);
 return -1;
 }
 }
 }
 break;
 }
 if(vend_required) {
 if(versioning_end(dir, res)) {
-fprintf(stderr, "Cannot checkin resource\n");
+log_error("Cannot checkin resource\n");
 ret = 1;
 }
 }
 if(ret == 0) {
 DavResource *up_res = dav_get(res->session, res->path, "D:getetag,idav:status");
 if(up_res) {
 // the new content length must be equal or greater than the file size
 if(up_res->contentlength < s.st_size && !issplit && !islink) {
-fprintf(stderr, "Incomplete Upload: %s\n", local_path);
+log_error("Incomplete Upload: %s\n", local_path);
 ret = -1;
 // try to set the resource status to 'broken'
 sync_set_status(res, "broken");
 } else {
 // everything seems fine, we can update the local resource
 {
 char *local_path = create_local_path(dir, local->path);
 SYS_STAT s;
 if(sys_stat(local_path, &s)) {
-fprintf(stderr, "Cannot stat file: %s\n", local_path);
+log_error("Cannot stat file: %s: %s\n", local_path, strerror(errno));
-perror("");
 free(local_path);
 return -1;
 }
 free(local_path);
 sync_set_metadata_from_stat(local, &s);
 MetadataHashes hashes;
 hashes = sync_set_metadata_properties(dir, up_res->session, up_res, local, TRUE);
 if(dav_store(up_res)) {
-fprintf(stderr, "Error: cannot store resource metadata\n");
+log_error("Error: cannot store resource metadata\n");
 }
 // get new etag
 DavPropName p;
 p.ns = "DAV:";
 cxListAdd(cols, local_res);
 } else if(split || !res->children) {
 log_printf("delete: %s\n", res->path);
 if(dav_delete(res)) {
 ret = 1;
-fprintf(stderr, "Cannot delete collection %s\n", res->path);
+log_error("Cannot delete collection %s\n", res->path);
 } else {
 (*counter)++;
 }
 }
 } else {
 log_printf("delete: %s\n", res->path);
 int exists = 1;
 int vend_required = 0;
 if(dir->versioning && dir->versioning->always) {
 if(versioning_delete_begin(dir, res, &exists, &vend_required)) {
-fprintf(
+log_error("Cannot save resource version before deletion\n");
-stderr,
-"Cannot save resource version before deletion\n");
 ret = 1;
 }
 }
 if(!ret && dav_delete(res) && exists) {
 if(sn->error != DAV_NOT_FOUND) {
-fprintf(stderr, "Cannot delete resource %s\n", res->path);
+log_error("Cannot delete resource %s\n", res->path);
 ret = 1;
 }
 } else {
 (*counter)++;
 }
 // get remote tags
 DavPropName p;
 p.ns = DAV_PROPS_NS;
 p.name = "tags";
 if(dav_load_prop(res, &p, 1) && sn->error != DAV_NOT_FOUND) {
-print_resource_error(sn, res->path);
+log_resource_error(sn, res->path);
 }
 CxList *remote_tags = NULL;
 DavXmlNode *tagsprop = dav_get_property_ns(res, DAV_PROPS_NS, "tags");
 if(tagsprop) {
 remote_tags = parse_dav_xml_taglist(tagsprop);
 {
 MetadataHashes hashes = sync_set_metadata_properties(dir, sn, res, local, FALSE);
 int err = 0;
 if(dav_store(res)) {
-print_resource_error(sn, local->path);
+log_resource_error(sn, local->path);
 err = 1;
 } else {
 update_metadata_hashes(local, hashes);
 local->tags_updated = 0;
 }
 if(sys_stat(path, &s)) {
 if(errno == ENOENT) {
 dc[numdc] = res->path;
 numdc++;
 } else {
-fprintf(stderr, "Cannot stat file: %s\n", path);
+log_error("Cannot stat file: %s: %s\n", path, strerror(errno));
-perror("");
 }
 }
 free(path);
 }
 CxIterator i = cxMapIteratorValues(db->resources);
 int skipped = 0;
 cx_foreach(LocalResource *, res, i) {
 if(res->skipped) {
 skipped++;
-fprintf(stderr, "skipped from push: %s\n", res->path);
+log_error("skipped from push: %s\n", res->path);
 }
 }
 if(skipped > 0) {
-fprintf(stderr,
+log_error(
 "  To resolve conflict resources skipped by push run dav-sync pull first\n"
 "  before resolve-conflicts or delete-conflicts.\n\n");
 }
 }
 int cmd_resolve_conflicts(CmdArgs *a) {
 if(a->argc != 1) {
-fprintf(stderr, "Too %s arguments\n", a->argc < 1 ? "few" : "many");
+log_error("Too %s arguments\n", a->argc < 1 ? "few" : "many");
 return -1;
 }
 SyncDirectory *dir = scfg_get_dir(a->argv[0]);
 if(!dir) {
-fprintf(stderr, "Unknown sync dir: %s\n", a->argv[0]);
+log_error("Unknown sync dir: %s\n", a->argv[0]);
 return -1;
 }
 if(scfg_check_dir(dir)) {
 return -1;
 }
 return -1;
 }
 SyncDatabase *db = load_db(dir->database);
 if(!db) {
-fprintf(stderr, "Cannot load database file: %s\n", dir->database);
+log_error("Cannot load database file: %s\n", dir->database);
 return -1;
 }
 resolve_skipped(db);
 //ucx_map_free_content(db->conflict, (ucx_destructor)local_resource_free);
 cxMapClear(db->conflict);
 // store db
 if(store_db(db, dir->database, dir->db_settings)) {
-fprintf(stderr, "Cannot store sync db\n");
+log_error("Cannot store sync db\n");
-fprintf(stderr, "Abort\n");
+log_error("Abort\n");
 ret = -2;
 }
 // cleanup
 destroy_db(db);
 return -1;
 }
 SyncDatabase *db = load_db(dir->database);
 if(!db) {
-fprintf(stderr, "Cannot load database file: %s\n", dir->database);
+log_error("Cannot load database file: %s\n", dir->database);
 return -1;
 }
 resolve_skipped(db);
 cx_foreach(LocalResource*, res, i) {
 log_printf("delete: %s\n", res->path);
 char *path = create_local_path(dir, res->path);
 if(sys_unlink(path)) {
 if(errno != ENOENT) {
-perror("unlink");
+log_error("unlink: %s", strerror(errno));
 num_err++;
 }
 } else {
 num_del++;
 }
 //ucx_map_free_content(db->conflict, (ucx_destructor)local_resource_free);
 cxMapClear(db->conflict);
 // store db
 if(store_db(db, dir->database, dir->db_settings)) {
-fprintf(stderr, "Cannot store sync db\n");
+log_error("Cannot store sync db\n");
-fprintf(stderr, "Abort\n");
+log_error("Abort\n");
 ret = -1;
 }
 // cleanup
 destroy_db(db);
 if(logfile_open(syncdir)) {
 return -1;
 }
 if(!syncdir->trash) {
-fprintf(stderr, "trash not configured for %s\n", syncdir->name);
+log_error("trash not configured for %s\n", syncdir->name);
 return -1;
 }
 SYS_DIR dir = sys_opendir(syncdir->trash);
 if(!dir) {
-fprintf(stderr, "cannot open trash directory: %s\n", syncdir->trash);
+log_error("cannot open trash directory: %s\n", syncdir->trash);
-perror("opendir");
+log_error("opendir: %s\n", strerror(errno));
 return -1;
 }
 SysDirEnt *ent;
 while((ent = sys_readdir(dir)) != NULL) {
 char *path = util_concat_path(syncdir->trash, ent->name);
 log_printf("delete: %s\n", path);
 SYS_STAT s;
 if(sys_stat(path, &s)) {
-perror("stat");
+log_error("stat: %s\n", strerror(errno));
 free(path);
 continue;
 }
 if(S_ISDIR(s.st_mode)) {
 if(rmdir(path)) {
-perror("rmdir");
+log_error("rmdir: %s\n", strerror(errno));
 }
 } else {
 if(sys_unlink(path)) {
-perror("unlink");
+log_error("unlink: %s\n", strerror(errno));
 }
 }
 free(path);
 }
 return 0;
 }
 void sync_print_get_file_err(const char *path, int err) {
 switch(err) {
-case 1: fprintf(stderr, "File %s: not found\n", path); break;
+case 1: log_error("File %s: not found\n", path); break;
-case 2: fprintf(stderr, "File %s: permission denied\n", path); break;
+case 2: log_error("File %s: permission denied\n", path); break;
-case 3: fprintf(stderr, "File %s: stat failed: %s\n", path, strerror(errno)); break;
+case 3: log_error("File %s: stat failed: %s\n", path, strerror(errno)); break;
-case 4: fprintf(stderr, "File %s is not in any syncdir\n", path); break;
+case 4: log_error("File %s is not in any syncdir\n", path); break;
-case 5: fprintf(stderr, "File %s is in multiple syncdirs\n", path); break;
+case 5: log_error("File %s is in multiple syncdirs\n", path); break;
-case 6: fprintf(stderr, "Syncdir not found\n"); break;
+case 6: log_error("Syncdir not found\n"); break;
 }
 }
 int cmd_add_directory(CmdArgs *args) {
 char *path = config_file_path(fname.ptr);
 free(fname.ptr);
 FILE *file = sys_fopen(path, "w");
 if(file) {
-fprintf(file, "%s\n", locktoken);
+log_error("%s\n", locktoken);
 fclose(file);
 return path;
 } else {
-perror("Cannot create locktoken file");
+log_error("Cannot create locktoken file: %s", strerror(errno));
 free(path);
 return NULL;
 }
 }

Mercurial > hg > dav / file comparison

comparison: dav/sync.c

dav/sync.c