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(), ...
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(), ...
nfs://<server|ipv4>/path[?arg=val[&arg=val]*]
Arguments supported by libnfs are :
- tcp-syncnt=<int> : Number of SYNs to send during the session establish
- before failing setting up the tcp connection to the
+ tcp-syncnt=<int> : Number of SYNs to send during the seccion establish
+ before failing settin up the tcp connection to the
server.
uid=<int> : UID value to use when talking to the server.
default it 65534 on Windows and getuid() on unixen.
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.
=================
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
-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.
*/
EXTERN int nfs_open_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data);
/*
- * Sync open(<filename>)
+ * Sync stat(<filename>)
* Function returns
* 0 : The operation was successfull. *nfsfh is filled in.
* -errno : The command failed.
/*
- * CLOSEDIR()
+ * READDIR()
*/
/*
* nfs_closedir() never blocks, so no special sync/async versions are available
EXTERN void nfs_closedir(struct nfs_context *nfs, struct nfsdir *nfsdir);
-/*
- * CHDIR()
- */
-/*
- * Async chdir(<path>)
- *
- * 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(<path>)
- * 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()
struct nfs_fh3 rootfh;
uint64_t readmax;
uint64_t writemax;
- char *cwd;
};
void nfs_free_nfsdir(struct nfsdir *nfsdir)
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;
}
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;
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 == '/') {
}
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++;
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;
}
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;
}
{
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));
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) {
+
+
/*
* Async open()
*/
}
-/*
- * 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;
-}
/*
}
-/*
- * 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;
- }
-}
+
+
+
/*
free(nfs->rpc->error_string);
}
nfs->rpc->error_string = str;
- va_end(ap);
+ va_end(ap);
}
repositories / deb_libnfs.git / commitdiff
