mirrors/nextcloud-desktop
3
0
Fork 0
mirror of https://github.com/nextcloud/desktop.git synced 2025-10-26 11:17:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add missing vio functions.

Browse Source 
This is the last step to get the vio framework working.
This commit is contained in:
Andreas Schneider 2008-04-22 12:12:23 +02:00
parent 8b31bb70b7
commit 9a97f52e4f
3 changed files with 315 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/csync_private.h
View File

@ -70,6 +70,7 @@ struct csync_s {
c_rbtree_t *remote;
c_strlist_t *excludes;
sqlite3 *journal;
enum csync_replica_e replica;
struct {
void *handle;

322
src/vio/csync_vio.c
View File

@ -30,6 +30,7 @@
#include "csync_private.h"
#include "vio/csync_vio.h"
#include "vio/csync_vio_handle_private.h"
#include "vio/csync_vio_local.h"
#define CSYNC_LOG_CATEGORY_NAME "csync.vio.main"
#include "csync_log.h"
@ -37,7 +38,7 @@
int csync_vio_init(CSYNC *ctx, const char *module, const char *args) {
char *path = NULL;
char *err = NULL;
csync_vio_method_t *m;
csync_vio_method_t *m = NULL;
csync_vio_method_init_fn init_fn;
#if DEVELOPER
@ -52,6 +53,8 @@ int csync_vio_init(CSYNC *ctx, const char *module, const char *args) {
if ((err = dlerror()) != NULL) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "loading %s plugin failed - %s",
module, err);
SAFE_FREE(path);
return -1;
}
SAFE_FREE(path);
@ -71,7 +74,7 @@ int csync_vio_init(CSYNC *ctx, const char *module, const char *args) {
/* get the method struct */
m = (*init_fn)(module, args);
if (m == NULL) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "module %s return a NULL method", module);
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "module %s returned a NULL method", module);
return -1;
}
@ -86,6 +89,11 @@ int csync_vio_init(CSYNC *ctx, const char *module, const char *args) {
return -1;
}
if (! VIO_METHOD_HAS_FUNC(m, opendir)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "module %s has no opendir fn", module);
return -1;
}
if (! VIO_METHOD_HAS_FUNC(m, open)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "module %s has no stat fn", module);
return -1;
@ -106,21 +114,317 @@ void csync_vio_shutdown(CSYNC *ctx) {
}
}
csync_vio_handle_t *csync_vio_open(CSYNC *ctx, const char *uri, int flags, mode_t mode) {
csync_vio_handle_t *h = NULL;
csync_vio_method_handle_t *mh = NULL;
switch(ctx->replica) {
case REMOTE_REPLCIA:
mh = ctx->module.method->open(uri, flags, mode);
break;
case LOCAL_REPLICA:
mh = csync_vio_local_open(uri, flags, mode);
break;
default:
break;
}
h = csync_vio_handle_new(uri, mh);
if (h == NULL) {
return NULL;
}
return h;
}
csync_vio_handle_t *csync_vio_creat(CSYNC *ctx, const char *uri, mode_t mode) {
csync_vio_handle_t *h = NULL;
csync_vio_method_handle_t *mh = NULL;
switch(ctx->replica) {
case REMOTE_REPLCIA:
mh = ctx->module.method->creat(uri, mode);
break;
case LOCAL_REPLICA:
mh = csync_vio_local_creat(uri, mode);
break;
default:
break;
}
h = csync_vio_handle_new(uri, mh);
if (h == NULL) {
return NULL;
}
return h;
}
int csync_vio_close(CSYNC *ctx, csync_vio_handle_t *handle) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->close(handle->method_handle);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_close(handle->method_handle);
break;
default:
break;
}
/* handle->method_handle is free'd by the above close */
SAFE_FREE(handle->uri);
SAFE_FREE(handle);
return rc;
}
ssize_t csync_vio_read(CSYNC *ctx, csync_vio_handle_t *fhandle, void *buf, size_t count) {
ssize_t rs = 0;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rs = ctx->module.method->read(fhandle->method_handle, buf, count);
break;
case LOCAL_REPLICA:
rs = csync_vio_local_read(fhandle->method_handle, buf, count);
break;
default:
break;
}
return rs;
}
ssize_t csync_vio_write(CSYNC *ctx, csync_vio_handle_t *fhandle, const void *buf, size_t count) {
ssize_t rs = 0;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rs = ctx->module.method->write(fhandle->method_handle, buf, count);
break;
case LOCAL_REPLICA:
rs = csync_vio_local_write(fhandle->method_handle, buf, count);
break;
default:
break;
}
return rs;
}
off_t csync_vio_lseek(CSYNC *ctx, csync_vio_handle_t *fhandle, off_t offset, int whence) {
off_t ro = 0;
switch(ctx->replica) {
case REMOTE_REPLCIA:
ro = ctx->module.method->lseek(fhandle->method_handle, offset, whence);
break;
case LOCAL_REPLICA:
ro = csync_vio_local_lseek(fhandle->method_handle, offset, whence);
break;
default:
break;
}
return ro;
}
csync_vio_handle_t *csync_vio_opendir(CSYNC *ctx, const char *name) {
csync_vio_handle_t *h = NULL;
csync_vio_method_handle_t *mh = NULL;
switch(ctx->replica) {
case REMOTE_REPLCIA:
mh = ctx->module.method->opendir(name);
break;
case LOCAL_REPLICA:
mh = csync_vio_local_opendir(name);
break;
default:
break;
}
h = csync_vio_handle_new(name, mh);
if (h == NULL) {
return NULL;
}
if (ctx) {
mh = ctx->module.method->opendir(name);
} else {
/* TODO opendir */
}
h = csync_vio_handle_new(name, mh);
return h;
}
int csync_vio_closedir(CSYNC *ctx, csync_vio_handle_t *dhandle) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->closedir(dhandle->method_handle);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_closedir(dhandle->method_handle);
break;
default:
break;
}
SAFE_FREE(dhandle->uri);
SAFE_FREE(dhandle);
return rc;
}
csync_vio_file_stat_t *csync_vio_readdir(CSYNC *ctx, csync_vio_handle_t *dhandle) {
csync_vio_file_stat_t *fs = NULL;
switch(ctx->replica) {
case REMOTE_REPLCIA:
fs = ctx->module.method->readdir(dhandle->method_handle);
break;
case LOCAL_REPLICA:
fs = csync_vio_local_readdir(dhandle->method_handle);
break;
default:
break;
}
return fs;
}
int csync_vio_mkdir(CSYNC *ctx, const char *uri, mode_t mode) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->mkdir(uri, mode);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_mkdir(uri, mode);
break;
default:
break;
}
return rc;
}
int csync_vio_rmdir(CSYNC *ctx, const char *uri) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->rmdir(uri);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_rmdir(uri);
break;
default:
break;
}
return rc;
}
int csync_vio_stat(CSYNC *ctx, const char *uri, csync_vio_file_stat_t *buf) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->stat(uri, buf);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_stat(uri, buf);
break;
default:
break;
}
return rc;
}
int csync_vio_rename(CSYNC *ctx, const char *olduri, const char *newuri) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->rename(olduri, newuri);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_rename(olduri, newuri);
break;
default:
break;
}
return rc;
}
int csync_vio_unlink(CSYNC *ctx, const char *uri) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->unlink(uri);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_unlink(uri);
break;
default:
break;
}
return rc;
}
int csync_vio_chmod(CSYNC *ctx, const char *uri, mode_t mode) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->chmod(uri, mode);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_chmod(uri, mode);
break;
default:
break;
}
return rc;
}
int csync_vio_chown(CSYNC *ctx, const char *uri, uid_t owner, gid_t group) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->chown(uri, owner, group);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_chown(uri, owner, group);
break;
default:
break;
}
return rc;
}
int csync_vio_utimes(CSYNC *ctx, const char *uri, const struct timeval times[2]) {
int rc = -1;
switch(ctx->replica) {
case REMOTE_REPLCIA:
rc = ctx->module.method->utimes(uri, times);
break;
case LOCAL_REPLICA:
rc = csync_vio_local_utimes(uri, times);
break;
default:
break;
}
return rc;
}

2
src/vio/csync_vio.h
View File

@ -34,7 +34,7 @@ csync_vio_handle_t *csync_vio_creat(CSYNC *ctx, const char *uri, mode_t mode);
int csync_vio_close(CSYNC *ctx, csync_vio_handle_t *handle);
ssize_t csync_vio_read(CSYNC *ctx, csync_vio_handle_t *fhandle, void *buf, size_t count);
ssize_t csync_vio_write(CSYNC *ctx, csync_vio_handle_t *fhandle, const void *buf, size_t count);
off_t csync_vio_seek(CSYNC *ctx, csync_vio_handle_t *fhandle, off_t offset, int whence);
off_t csync_vio_lseek(CSYNC *ctx, csync_vio_handle_t *fhandle, off_t offset, int whence);
csync_vio_handle_t *csync_vio_opendir(CSYNC *ctx, const char *name);
int csync_vio_closedir(CSYNC *ctx, csync_vio_handle_t *dhandle);