From: Ronnie Sahlberg Date: Fri, 31 Jan 2014 02:26:39 +0000 (-0800) Subject: Revert "Add support for chdir and getcwd" X-Git-Tag: upstream/1.9.6^2~125 X-Git-Url: https://git.piment-noir.org/?p=deb_libnfs.git;a=commitdiff_plain;h=0df47959c44f959665683e84ed0db3fe98bcd0eb Revert "Add support for chdir and getcwd" This reverts commit fb6f315257a8752c3a8b96a71261a5613a6f2069. --- diff --git a/README b/README index f717c07..6d3eb73 100644 --- a/README +++ b/README @@ -1,15 +1,15 @@ LIBNFS is a client library for accessing NFS shares over a network. LIBNFS offers three different APIs, for different use : -1, RAW : A fully async low level RPC library for NFS protocols +1, RAW : A fully async low level rpc library for nfs protocols This API is described in include/libnfs-raw.h it offers a fully async interface to raw XDR encoded blobs. -This API provides very flexible and precise control of the RPC issued. +This api provides very flexible and precice control of the RPC issued. examples/nfsclient-raw.c provides examples on how to use the raw API 2, NFS ASYNC : A fully asynchronous library for high level vfs functions -This API is described by the *_async() functions in include/libnfs.h. +This API is described by the *_async() fucntions in include/libnfs.h. This API provides a fully async access to posix vfs like functions such as stat(), read(), ... @@ -17,7 +17,7 @@ examples/nfsclient-async.c provides examples on how to use this API 3, NFS SYNC : A synchronous library for high level vfs functions -This API is described by the *_sync() functions in include/libnfs.h. +This API is described by the *_sync() fucntions in include/libnfs.h. This API provides access to posix vfs like functions such as stat(), read(), ... @@ -31,8 +31,8 @@ The basic syntax of these URLs is : nfs:///path[?arg=val[&arg=val]*] Arguments supported by libnfs are : - tcp-syncnt= : Number of SYNs to send during the session establish - before failing setting up the tcp connection to the + tcp-syncnt= : Number of SYNs to send during the seccion establish + before failing settin up the tcp connection to the server. uid= : UID value to use when talking to the server. default it 65534 on Windows and getuid() on unixen. @@ -43,7 +43,7 @@ Arguments supported by libnfs are : ROOT vs NON-ROOT ================ When running as root, libnfs tries to allocate a system port for its connection -to the NFS server. When running as non-root it will use a normal +to the nfs server. When running as non-root it will use a normal ephemeral port. Many NFS servers default to a mode where they do not allow non-system ports from connecting. @@ -75,7 +75,7 @@ PLATFORM support ================= This is a truly multiplatform library. -Linux: - tested with Ubuntu 10.04 - should work with others as well +Linux: - tested with Ubuntu 10.04 - should work with others aswell Cygwin: - tested under 64bit win2k8. MacOSX: - tested with SDK 10.4 (under Snow Leopard) - should also work with later SDKs and 64Bit iOS: - tested with iOS SDK 4.2 - running on iOS 4.3.x @@ -92,8 +92,8 @@ Release tarballs are available at https://sites.google.com/site/libnfstarballs/l -MAILING LIST -============ -A libnfs mailing list is available at http://groups.google.com/group/libnfs +MAILINGLIST +=========== +A libnfs mailinglist is available at http://groups.google.com/group/libnfs Announcements of new versions of libnfs will be posted to this list. diff --git a/include/nfsc/libnfs.h b/include/nfsc/libnfs.h index e075064..7a9accd 100644 --- a/include/nfsc/libnfs.h +++ b/include/nfsc/libnfs.h @@ -281,7 +281,7 @@ EXTERN int nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, struct stat * */ EXTERN int nfs_open_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data); /* - * Sync open() + * Sync stat() * Function returns * 0 : The operation was successfull. *nfsfh is filled in. * -errno : The command failed. @@ -723,7 +723,7 @@ EXTERN struct nfsdirent *nfs_readdir(struct nfs_context *nfs, struct nfsdir *nfs /* - * CLOSEDIR() + * READDIR() */ /* * nfs_closedir() never blocks, so no special sync/async versions are available @@ -731,49 +731,6 @@ EXTERN struct nfsdirent *nfs_readdir(struct nfs_context *nfs, struct nfsdir *nfs EXTERN void nfs_closedir(struct nfs_context *nfs, struct nfsdir *nfsdir); -/* - * CHDIR() - */ -/* - * Async chdir() - * - * Function returns - * 0 : The operation was initiated. Once the operation finishes, the callback will be invoked. - * <0 : An error occured when trying to set up the operation. The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL; - * -errno : An error occured. - * data is the error string. - */ -EXTERN int nfs_chdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data); -/* - * Sync chdir() - * Function returns - * 0 : The operation was successfull. - * -errno : The command failed. - */ -EXTERN int nfs_chdir(struct nfs_context *nfs, const char *path); - -/* - * GETCWD() - */ -/* - * nfs_getcwd() never blocks, so no special sync/async versions are available - */ -/* - * Sync getcwd() - * This function returns a pointer to the current working directory. - * This pointer is only stable until the next [f]chdir or when the - * context is destroyed. - * - * Function returns - * 0 : The operation was successfull and *cwd is filled in. - * -errno : The command failed. - */ -EXTERN void nfs_getcwd(struct nfs_context *nfs, const char **cwd); - /* * STATVFS() diff --git a/lib/libnfs-sync.c b/lib/libnfs-sync.c index 8ab05d7..baadefa 100644 --- a/lib/libnfs-sync.c +++ b/lib/libnfs-sync.c @@ -237,6 +237,8 @@ int nfs_stat(struct nfs_context *nfs, const char *path, struct stat *st) } + + /* * open() */ @@ -275,38 +277,6 @@ int nfs_open(struct nfs_context *nfs, const char *path, int mode, struct nfsfh * return cb_data.status; } -/* - * chdir() - */ -static void chdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "chdir call failed with \"%s\"", (char *)data); - return; - } -} - -int nfs_chdir(struct nfs_context *nfs, const char *path) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_chdir_async(nfs, path, chdir_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_chdir_async failed with %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} diff --git a/lib/libnfs-win32.def b/lib/libnfs-win32.def index b1018ec..eb5f55a 100644 --- a/lib/libnfs-win32.def +++ b/lib/libnfs-win32.def @@ -7,7 +7,6 @@ nfs_find_local_servers free_nfs_srvr_list nfs_access nfs_access_async -nfs_chdir nfs_chmod nfs_chmod_async nfs_chown @@ -32,7 +31,6 @@ nfs_get_error nfs_get_fd nfs_get_readmax nfs_get_writemax -nfs_getcwd nfs_init_context nfs_link nfs_link_async diff --git a/lib/libnfs.c b/lib/libnfs.c index d4ad029..b19a373 100644 --- a/lib/libnfs.c +++ b/lib/libnfs.c @@ -93,7 +93,6 @@ struct nfs_context { struct nfs_fh3 rootfh; uint64_t readmax; uint64_t writemax; - char *cwd; }; void nfs_free_nfsdir(struct nfsdir *nfsdir) @@ -335,15 +334,17 @@ 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->cwd = strdup("/"); + nfs->server = NULL; + nfs->export = NULL; + + nfs->rootfh.data.data_len = 0; + nfs->rootfh.data.data_val = NULL; return nfs; } @@ -363,11 +364,6 @@ 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; @@ -936,7 +932,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, *slash; + char *path, *str; LOOKUP3args args; while (*data->path == '/') { @@ -944,16 +940,10 @@ static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb } path = data->path; - 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; + str = strchr(path, '/'); + if (str != NULL) { + *str = 0; + data->path = str+1; } else { while (*data->path != 0) { data->path++; @@ -970,9 +960,6 @@ 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; } @@ -988,109 +975,6 @@ 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; } @@ -1098,15 +982,14 @@ static int nfs_lookuppath_async(struct nfs_context *nfs, const char *path, nfs_c { struct nfs_cb_data *data; - if (path[0] == '\0') { - rpc_set_error(nfs->rpc, "Path is empty"); + if (path[0] != 0 && path[0] != '/') { + rpc_set_error(nfs->rpc, "Pathname is not absolute %s", path); 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)); @@ -1117,29 +1000,12 @@ 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; - 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); - } - + data->saved_path = strdup(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) { @@ -1242,6 +1108,8 @@ int nfs_stat_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *p + + /* * Async open() */ @@ -1358,31 +1226,7 @@ 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; -} /* @@ -2910,24 +2754,15 @@ 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; - } -} + + + /* @@ -4093,7 +3928,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); }