Add support for chdir and getcwd

[deb_libnfs.git] / lib / libnfs.c

diff --git a/lib/libnfs.c b/lib/libnfs.c
index b19a373bc2ba05d557342ecbf3887a974a7156c7..d4ad029574a497b9dcc04fe80247ca01bce4b6cb 100644 (file)
--- a/lib/libnfs.c
+++ b/lib/libnfs.c
@@ -93,6 +93,7 @@ struct nfs_context {
        struct nfs_fh3 rootfh;
        uint64_t readmax;
        uint64_t writemax;
+       char *cwd;
 };
 
 void nfs_free_nfsdir(struct nfsdir *nfsdir)
@@ -334,17 +335,15 @@ struct nfs_context *nfs_init_context(void)
        if (nfs == NULL) {
                return NULL;
        }
+       memset(nfs, 0, sizeof(struct nfs_context));
+
        nfs->rpc = rpc_init_context();
        if (nfs->rpc == NULL) {
                free(nfs);
                return NULL;
        }
 
-       nfs->server = NULL;
-       nfs->export = NULL;
-
-       nfs->rootfh.data.data_len = 0;
-       nfs->rootfh.data.data_val = NULL;
+       nfs->cwd = strdup("/");
 
        return nfs;
 }
@@ -364,6 +363,11 @@ void nfs_destroy_context(struct nfs_context *nfs)
                nfs->export = NULL;
        }
 
+       if (nfs->cwd) {
+               free(nfs->cwd);
+               nfs->cwd = NULL;
+       }
+
        if (nfs->rootfh.data.data_val != NULL) {
                free(nfs->rootfh.data.data_val);
                nfs->rootfh.data.data_val = NULL;
@@ -932,7 +936,7 @@ static void nfs_lookup_path_1_cb(struct rpc_context *rpc, int status, void *comm
 
 static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb_data *data, struct nfs_fh3 *fh)
 {
-       char *path, *str;
+       char *path, *slash;
        LOOKUP3args args;
 
        while (*data->path == '/') {
@@ -940,10 +944,16 @@ static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb
        }
 
        path = data->path;
-       str = strchr(path, '/');
-       if (str != NULL) {
-               *str = 0;
-               data->path = str+1;
+       slash = strchr(path, '/');
+       if (slash != NULL) {
+               /* Clear slash so that path is a zero terminated string for
+                * the current path component. Set it back to '/' again later
+                * when we are finished referencing this component so that
+                * data->saved_path will still point to the full
+                * normalized path.
+                */
+               *slash = 0;
+               data->path = slash+1;
        } else {
                while (*data->path != 0) {
                      data->path++;
@@ -960,6 +970,9 @@ static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb
                        return -1;
                }
                memcpy(data->fh.data.data_val, fh->data.data_val, data->fh.data.data_len);
+               if (slash != NULL) {
+                       *slash = '/';
+               }
                data->continue_cb(nfs, data);
                return 0;
        }
@@ -975,6 +988,109 @@ static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb
                free_nfs_cb_data(data);
                return -1;
        }
+       if (slash != NULL) {
+               *slash = '/';
+       }
+       return 0;
+}
+
+static int nfs_normalize_path(struct nfs_context *nfs, char *path)
+{
+       char *str;
+       int len;
+
+       /* // -> / */
+       while (str = strstr(path, "//")) {
+               while(*str) {
+                       *str = *(str + 1);
+                       str++;
+               }
+       }
+
+       /* /./ -> / */
+       while (str = strstr(path, "/./")) {
+               while(*(str + 1)) {
+                       *str = *(str + 2);
+                       str++;
+               }
+       }
+
+       /* ^/../ -> error */
+       if (!strncmp(path, "/../", 4)) {
+               rpc_set_error(nfs->rpc,
+                       "Absolute path starts with '/../' "
+                       "during normalization");
+               return -1;
+       }
+
+       /* ^[^/] -> error */
+       if (path[0] != '/') {
+               rpc_set_error(nfs->rpc,
+                       "Absolute path does not start with '/'");
+               return -1;
+       }
+
+       /* /string/../ -> / */
+       while (str = strstr(path, "/../")) {
+               char *tmp;
+
+               if (!strncmp(path, "/../", 4)) {
+                       rpc_set_error(nfs->rpc,
+                               "Absolute path starts with '/../' "
+                               "during normalization");
+                       return -1;
+               }
+
+               tmp = str - 1;
+               while (*tmp != '/') {
+                       tmp--;
+               }
+               str += 3;
+               while((*(tmp++) = *(str++)) != '\0')
+                       ;
+       }
+
+       /* /$ -> \0 */
+       len = strlen(path);
+       if (len >= 1) {
+               if (path[len - 1] == '/') {
+                       path[len - 1] = '\0';
+                       len--;
+               }
+       }
+       if (path[0] == '\0') {
+               rpc_set_error(nfs->rpc,
+                       "Absolute path became '' "
+                       "during normalization");
+               return -1;
+       }
+
+       /* /.$ -> \0 */
+       if (len >= 2) {
+               if (!strcmp(&path[len - 2], "/.")) {
+                       path[len - 2] = '\0';
+                       len -= 2;
+               }
+       }
+
+       /* ^/..$ -> error */
+       if (!strcmp(path, "/..")) {
+               rpc_set_error(nfs->rpc,
+                       "Absolute path is '/..' "
+                       "during normalization");
+               return -1;
+       }
+
+       /* /string/..$ -> / */
+       if (len >= 3) {
+               if (!strcmp(&path[len - 3], "/..")) {
+                       char *tmp = &path[len - 3];
+                       while (*--tmp != '/')
+                               ;
+                       *tmp = '\0'; 
+               }
+       }
+
        return 0;
 }
 
@@ -982,14 +1098,15 @@ static int nfs_lookuppath_async(struct nfs_context *nfs, const char *path, nfs_c
 {
        struct nfs_cb_data *data;
 
-       if (path[0] != 0 && path[0] != '/') {
-               rpc_set_error(nfs->rpc, "Pathname is not absolute %s", path);
+       if (path[0] == '\0') {
+               rpc_set_error(nfs->rpc, "Path is empty");
                return -1;
        }
 
        data = malloc(sizeof(struct nfs_cb_data));
        if (data == NULL) {
-               rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_cb_data structure");
+               rpc_set_error(nfs->rpc, "out of memory: failed to allocate "
+                       "nfs_cb_data structure");
                return -1;
        }
        memset(data, 0, sizeof(struct nfs_cb_data));
@@ -1000,12 +1117,29 @@ static int nfs_lookuppath_async(struct nfs_context *nfs, const char *path, nfs_c
        data->free_continue_data = free_continue_data;
        data->continue_int       = continue_int;
        data->private_data       = private_data;
-       data->saved_path         = strdup(path);
+       if (path[0] == '/') {
+               data->saved_path = strdup(path);
+       } else {
+               data->saved_path = malloc(strlen(path) + strlen(nfs->cwd) + 2);
+               if (data->saved_path == NULL) {
+                       rpc_set_error(nfs->rpc, "out of memory: failed to "
+                               "malloc path string");
+                       free_nfs_cb_data(data);
+                       return -1;
+               }
+               sprintf(data->saved_path, "%s/%s", nfs->cwd, path);
+       }
+
        if (data->saved_path == NULL) {
                rpc_set_error(nfs->rpc, "out of memory: failed to copy path string");
                free_nfs_cb_data(data);
                return -1;
        }
+       if (nfs_normalize_path(nfs, data->saved_path) != 0) {
+               free_nfs_cb_data(data);
+               return -1;
+       }
+
        data->path = data->saved_path;
 
        if (nfs_lookup_path_async_internal(nfs, data, &nfs->rootfh) != 0) {
@@ -1108,8 +1242,6 @@ int nfs_stat_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *p
 
 
 
-
-
 /*
  * Async open()
  */
@@ -1226,7 +1358,31 @@ int nfs_open_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb c
 }
 
 
+/*
+ * Async chdir()
+ */
+static int nfs_chdir_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+{
+       /* steal saved_path */
+       free(nfs->cwd);
+       nfs->cwd = data->saved_path;
+       data->saved_path = NULL;
 
+       data->cb(0, nfs, NULL, data->private_data);
+       free_nfs_cb_data(data);
+
+       return 0;
+}
+
+int nfs_chdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
+{
+       if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_chdir_continue_internal, NULL, NULL, 0) != 0) {
+               rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
+               return -1;
+       }
+
+       return 0;
+}
 
 
 /*
@@ -2754,15 +2910,24 @@ struct nfsdirent *nfs_readdir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir
 }
 
 
+/*
+ * closedir()
+ */
 void nfs_closedir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir)
 {
        nfs_free_nfsdir(nfsdir);
 }
 
 
-
-
-
+/*
+ * getcwd()
+ */
+void nfs_getcwd(struct nfs_context *nfs, const char **cwd)
+{
+       if (cwd) {
+               *cwd = nfs->cwd;
+       }
+}
 
 
 /*
@@ -3928,7 +4093,7 @@ void nfs_set_error(struct nfs_context *nfs, char *error_string, ...)
                free(nfs->rpc->error_string);
        }
        nfs->rpc->error_string = str;
-    va_end(ap);
+       va_end(ap);
 }