diff --git a/src/csync_private.h b/src/csync_private.h
index 9f04293b40..2c7a65d0c8 100644
--- a/src/csync_private.h
+++ b/src/csync_private.h
@@ -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;
diff --git a/src/vio/csync_vio.c b/src/vio/csync_vio.c
index 62ebf74c55..6e86b2ee05 100644
--- a/src/vio/csync_vio.c
+++ b/src/vio/csync_vio.c
@@ -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;
+}
+
diff --git a/src/vio/csync_vio.h b/src/vio/csync_vio.h
index dcb0d64c04..4b34b5b94b 100644
--- a/src/vio/csync_vio.h
+++ b/src/vio/csync_vio.h
@@ -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);