#include <strings.h>
#endif
+#ifdef MAJOR_IN_MKDEV
+#include <sys/mkdev.h>
+#endif
+
+#ifdef MAJOR_IN_SYSMACROS
+#include <sys/sysmacros.h>
+#endif
+
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "libnfs-zdr.h"
+#include "slist.h"
#include "libnfs.h"
#include "libnfs-raw.h"
#include "libnfs-raw-mount.h"
#include "libnfs-raw-nfs.h"
+#include "libnfs-raw-portmap.h"
#include "libnfs-private.h"
+#define MAX_DIR_CACHE 128
+#define MAX_LINK_COUNT 40
+
struct nfsdir {
+ struct nfs_fh3 fh;
+ fattr3 attr;
+ struct nfsdir *next;
+
struct nfsdirent *entries;
struct nfsdirent *current;
};
+struct nfs_readahead {
+ uint64_t fh_offset;
+ uint64_t last_offset;
+ uint64_t buf_offset;
+ uint64_t buf_count;
+ time_t buf_ts;
+ void *buf;
+ uint32_t cur_ra;
+};
+
struct nfsfh {
struct nfs_fh3 fh;
int is_sync;
+ int is_append;
uint64_t offset;
+ struct nfs_readahead ra;
};
struct nfs_context {
struct nfs_fh3 rootfh;
uint64_t readmax;
uint64_t writemax;
+ char *cwd;
+ struct nfsdir *dircache;
};
void nfs_free_nfsdir(struct nfsdir *nfsdir)
free(nfsdir->entries);
nfsdir->entries = dirent;
}
+ free(nfsdir->fh.data.data_val);
free(nfsdir);
}
+static void nfs_dircache_add(struct nfs_context *nfs, struct nfsdir *nfsdir)
+{
+ int i;
+ LIBNFS_LIST_ADD(&nfs->dircache, nfsdir);
+
+ for (nfsdir = nfs->dircache, i = 0; nfsdir; nfsdir = nfsdir->next, i++) {
+ if (i > MAX_DIR_CACHE) {
+ LIBNFS_LIST_REMOVE(&nfs->dircache, nfsdir);
+ nfs_free_nfsdir(nfsdir);
+ break;
+ }
+ }
+}
+
+static struct nfsdir *nfs_dircache_find(struct nfs_context *nfs, struct nfs_fh3 *fh)
+{
+ struct nfsdir *nfsdir;
+
+ for (nfsdir = nfs->dircache; nfsdir; nfsdir = nfsdir->next) {
+ if (nfsdir->fh.data.data_len == fh->data.data_len &&
+ !memcmp(nfsdir->fh.data.data_val, fh->data.data_val, fh->data.data_len)) {
+ LIBNFS_LIST_REMOVE(&nfs->dircache, nfsdir);
+ return nfsdir;
+ }
+ }
+
+ return NULL;
+}
+
struct nfs_cb_data;
-typedef int (*continue_func)(struct nfs_context *nfs, struct nfs_cb_data *data);
+typedef int (*continue_func)(struct nfs_context *nfs, fattr3 *attr,
+ struct nfs_cb_data *data);
struct nfs_cb_data {
struct nfs_context *nfs;
struct nfsfh *nfsfh;
char *saved_path, *path;
+ int link_count, no_follow;
nfs_cb cb;
void *private_data;
/* for multi-read/write calls. */
int error;
int cancel;
+ int oom;
int num_calls;
- uint64_t start_offset, max_offset;
+ uint64_t offset, count, max_offset, org_offset, org_count;
char *buffer;
+ char *usrbuf;
};
struct nfs_mcb_data {
struct nfs_cb_data *data;
uint64_t offset;
uint64_t count;
+ int update_pos;
};
-static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb_data *data, struct nfs_fh3 *fh);
-
+static int nfs_lookup_path_async_internal(struct nfs_context *nfs, fattr3 *attr, struct nfs_cb_data *data, struct nfs_fh3 *fh);
+static int nfs_normalize_path(struct nfs_context *nfs, char *path);
void nfs_set_auth(struct nfs_context *nfs, struct AUTH *auth)
{
static int nfs_set_context_args(struct nfs_context *nfs, char *arg, char *val)
{
- if (!strncmp(arg, "tcp-syncnt", 10)) {
+ if (!strcmp(arg, "tcp-syncnt")) {
rpc_set_tcp_syncnt(nfs_get_rpc_context(nfs), atoi(val));
- } else if (!strncmp(arg, "uid", 3)) {
+ } else if (!strcmp(arg, "uid")) {
rpc_set_uid(nfs_get_rpc_context(nfs), atoi(val));
- } else if (!strncmp(arg, "gid", 3)) {
+ } else if (!strcmp(arg, "gid")) {
rpc_set_gid(nfs_get_rpc_context(nfs), atoi(val));
+ } else if (!strcmp(arg, "readahaed")) {
+ rpc_set_readahead(nfs_get_rpc_context(nfs), atoi(val));
}
return 0;
}
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;
}
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;
}
+ while (nfs->dircache) {
+ struct nfsdir *nfsdir = nfs->dircache;
+ LIBNFS_LIST_REMOVE(&nfs->dircache, nfsdir);
+ nfs_free_nfsdir(nfsdir);
+ }
+
free(nfs);
}
free(data);
}
+static void rpc_connect_program_5_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ struct rpc_cb_data *data = private_data;
+
+ assert(rpc->magic == RPC_CONTEXT_MAGIC);
+
+ /* Dont want any more callbacks even if the socket is closed */
+ rpc->connect_cb = NULL;
+
+ if (status == RPC_STATUS_ERROR) {
+ data->cb(rpc, status, command_data, data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+ if (status == RPC_STATUS_CANCEL) {
+ data->cb(rpc, status, "Command was cancelled", data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+
+ data->cb(rpc, status, NULL, data->private_data);
+ free_rpc_cb_data(data);
+}
+
static void rpc_connect_program_4_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
struct rpc_cb_data *data = private_data;
return;
}
+ switch (data->program) {
+ case MOUNT_PROGRAM:
+ if (rpc_mount3_null_async(rpc, rpc_connect_program_5_cb,
+ data) != 0) {
+ data->cb(rpc, status, command_data, data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+ return;
+ case NFS_PROGRAM:
+ if (rpc_nfs3_null_async(rpc, rpc_connect_program_5_cb,
+ data) != 0) {
+ data->cb(rpc, status, command_data, data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+ return;
+ }
+
data->cb(rpc, status, NULL, data->private_data);
free_rpc_cb_data(data);
}
static void rpc_connect_program_3_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
struct rpc_cb_data *data = private_data;
- uint32_t rpc_port;
+ struct pmap3_string_result *gar;
+ uint32_t rpc_port = 0;
+ unsigned char *ptr;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
- if (status == RPC_STATUS_ERROR) {
+ if (status == RPC_STATUS_ERROR) {
data->cb(rpc, status, command_data, data->private_data);
free_rpc_cb_data(data);
return;
return;
}
- rpc_port = *(uint32_t *)command_data;
+ switch (rpc->s.ss_family) {
+ case AF_INET:
+ rpc_port = *(uint32_t *)command_data;
+ break;
+ case AF_INET6:
+ /* ouch. portmapper and ipv6 are not great */
+ gar = command_data;
+ if (gar->addr == NULL) {
+ break;
+ }
+ ptr = strrchr(gar->addr, '.');
+ if (ptr == NULL) {
+ break;
+ }
+ rpc_port = atoi(ptr + 1);
+ *ptr = 0;
+ ptr = strrchr(gar->addr, '.');
+ if (ptr == NULL) {
+ break;
+ }
+ rpc_port += 256 * atoi(ptr + 1);
+ break;
+ }
if (rpc_port == 0) {
rpc_set_error(rpc, "RPC error. Program is not available on %s", data->server);
data->cb(rpc, RPC_STATUS_ERROR, rpc_get_error(rpc), data->private_data);
static void rpc_connect_program_2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
struct rpc_cb_data *data = private_data;
+ struct pmap3_mapping map;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
return;
}
- if (rpc_pmap_getport_async(rpc, data->program, data->version, IPPROTO_TCP, rpc_connect_program_3_cb, private_data) != 0) {
- data->cb(rpc, status, command_data, data->private_data);
- free_rpc_cb_data(data);
- return;
+ switch (rpc->s.ss_family) {
+ case AF_INET:
+ if (rpc_pmap2_getport_async(rpc, data->program, data->version, IPPROTO_TCP, rpc_connect_program_3_cb, private_data) != 0) {
+ data->cb(rpc, status, command_data, data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+ break;
+ case AF_INET6:
+ map.prog=data->program;
+ map.vers=data->version;
+ map.netid="";
+ map.addr="";
+ map.owner="";
+ if (rpc_pmap3_getaddr_async(rpc, &map, rpc_connect_program_3_cb, private_data) != 0) {
+ data->cb(rpc, status, command_data, data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+ break;
}
}
return;
}
- if (rpc_pmap_null_async(rpc, rpc_connect_program_2_cb, data) != 0) {
- data->cb(rpc, status, command_data, data->private_data);
- free_rpc_cb_data(data);
- return;
+ switch (rpc->s.ss_family) {
+ case AF_INET:
+ if (rpc_pmap2_null_async(rpc, rpc_connect_program_2_cb, data) != 0) {
+ data->cb(rpc, status, command_data, data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+ break;
+ case AF_INET6:
+ if (rpc_pmap3_null_async(rpc, rpc_connect_program_2_cb, data) != 0) {
+ data->cb(rpc, status, command_data, data->private_data);
+ free_rpc_cb_data(data);
+ return;
+ }
+ break;
}
}
-int rpc_connect_program_async(struct rpc_context *rpc, char *server, int program, int version, rpc_cb cb, void *private_data)
+int rpc_connect_program_async(struct rpc_context *rpc, const char *server, int program, int version, rpc_cb cb, void *private_data)
{
struct rpc_cb_data *data;
return 0;
}
-void free_nfs_cb_data(struct nfs_cb_data *data)
+static void free_nfs_cb_data(struct nfs_cb_data *data)
{
- if (data->saved_path != NULL) {
- free(data->saved_path);
- data->saved_path = NULL;
- }
-
if (data->continue_data != NULL) {
+ assert(data->free_continue_data);
data->free_continue_data(data->continue_data);
- data->continue_data = NULL;
- }
-
- if (data->fh.data.data_val != NULL) {
- free(data->fh.data.data_val);
- data->fh.data.data_val = NULL;
}
- if (data->buffer != NULL) {
- free(data->buffer);
- data->buffer = NULL;
- }
+ free(data->saved_path);
+ free(data->fh.data.data_val);
+ free(data->buffer);
free(data);
}
-
-
+static void free_nfsfh(struct nfsfh *nfsfh)
+{
+ if (nfsfh->fh.data.data_val != NULL) {
+ free(nfsfh->fh.data.data_val);
+ nfsfh->fh.data.data_val = NULL;
+ }
+ free(nfsfh->ra.buf);
+ free(nfsfh);
+}
static void nfs_mount_10_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
return;
}
+ /* NFS TCP connections we want to autoreconnect after sessions are torn down (due to inactivity or error) */
+ rpc_set_autoreconnect(rpc);
+
args.fsroot = nfs->rootfh;
if (rpc_nfs3_fsinfo_async(rpc, nfs_mount_9_cb, &args, data) != 0) {
data->cb(-ENOMEM, nfs, command_data, data->private_data);
}
}
-
-static void nfs_mount_7_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct nfs_cb_data *data = private_data;
- struct nfs_context *nfs = data->nfs;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- /* Dont want any more callbacks even if the socket is closed */
- rpc->connect_cb = NULL;
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(-EFAULT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- if (rpc_nfs3_null_async(rpc, nfs_mount_8_cb, data) != 0) {
- data->cb(-ENOMEM, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-}
-
-
static void nfs_mount_6_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
struct nfs_cb_data *data = private_data;
memcpy(nfs->rootfh.data.data_val, res->mountres3_u.mountinfo.fhandle.fhandle3_val, nfs->rootfh.data.data_len);
rpc_disconnect(rpc, "normal disconnect");
- if (rpc_connect_async(rpc, nfs->server, 2049, nfs_mount_7_cb, data) != 0) {
+
+ if (rpc_connect_program_async(nfs->rpc, nfs->server, NFS_PROGRAM, NFS_V3, nfs_mount_8_cb, data) != 0) {
data->cb(-ENOMEM, nfs, command_data, data->private_data);
free_nfs_cb_data(data);
return;
}
- /* NFS TCP connections we want to autoreconnect after sessions are torn down (due to inactivity or error) */
- rpc_set_autoreconnect(rpc);
}
}
}
-static void nfs_mount_4_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct nfs_cb_data *data = private_data;
- struct nfs_context *nfs = data->nfs;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- /* Dont want any more callbacks even if the socket is closed */
- rpc->connect_cb = NULL;
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(-EFAULT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- if (rpc_mount3_null_async(rpc, nfs_mount_5_cb, data) != 0) {
- data->cb(-ENOMEM, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-}
-
-static void nfs_mount_3_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct nfs_cb_data *data = private_data;
- struct nfs_context *nfs = data->nfs;
- uint32_t mount_port;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(-EFAULT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- mount_port = *(uint32_t *)command_data;
- if (mount_port == 0) {
- rpc_set_error(rpc, "RPC error. Mount program is not available on %s", nfs->server);
- data->cb(-ENOENT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- rpc_disconnect(rpc, "normal disconnect");
- if (rpc_connect_async(rpc, nfs->server, mount_port, nfs_mount_4_cb, data) != 0) {
- data->cb(-ENOMEM, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-}
-
-
-static void nfs_mount_2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct nfs_cb_data *data = private_data;
- struct nfs_context *nfs = data->nfs;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(-EFAULT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- if (rpc_pmap_getport_async(rpc, MOUNT_PROGRAM, MOUNT_V3, IPPROTO_TCP, nfs_mount_3_cb, private_data) != 0) {
- data->cb(-ENOMEM, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-}
-
-static void nfs_mount_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct nfs_cb_data *data = private_data;
- struct nfs_context *nfs = data->nfs;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- /* Dont want any more callbacks even if the socket is closed */
- rpc->connect_cb = NULL;
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(-EFAULT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- if (rpc_pmap_null_async(rpc, nfs_mount_2_cb, data) != 0) {
- data->cb(-ENOMEM, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-}
-
/*
* Async call for mounting an nfs share and geting the root filehandle
*/
data->cb = cb;
data->private_data = private_data;
- if (rpc_connect_async(nfs->rpc, server, 111, nfs_mount_1_cb, data) != 0) {
+ if (rpc_connect_program_async(nfs->rpc, server, MOUNT_PROGRAM, MOUNT_V3, nfs_mount_5_cb, data) != 0) {
rpc_set_error(nfs->rpc, "Failed to start connection");
free_nfs_cb_data(data);
return -1;
* Functions to first look up a path, component by component, and then finally call a specific function once
* the filehandle for the final component is found.
*/
-static void nfs_lookup_path_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+static void nfs_lookup_path_2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
- LOOKUP3res *res;
+ READLINK3res *res;
+ char *path, *newpath;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
res = command_data;
if (res->status != NFS3_OK) {
- rpc_set_error(nfs->rpc, "NFS: Lookup of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
+ rpc_set_error(nfs->rpc, "NFS: READLINK of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
free_nfs_cb_data(data);
return;
}
- if (nfs_lookup_path_async_internal(nfs, data, &res->LOOKUP3res_u.resok.object) != 0) {
- rpc_set_error(nfs->rpc, "Failed to create lookup pdu");
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-}
-
-static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb_data *data, struct nfs_fh3 *fh)
-{
- char *path, *str;
- LOOKUP3args args;
+ path = res->READLINK3res_u.resok.data;
- while (*data->path == '/') {
- data->path++;
- }
+ /* Handle absolute paths, ensuring that the path lies within the
+ * export. */
+ if (path[0] == '/') {
+ if (strstr(path, nfs->export) == path) {
+ char *ptr = path + strlen(nfs->export);
+ if (*ptr == '/') {
+ newpath = strdup(ptr);
+ } else if (*ptr == '\0') {
+ newpath = strdup("/");
+ } else {
+ data->cb(-ENOENT, nfs, "Symbolic link points outside export", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ } else {
+ data->cb(-ENOENT, nfs, "Symbolic link points outside export", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ if (!newpath)
+ goto nomem;
+ } else {
+ /* Handle relative paths, both the case where the current
+ * component is an intermediate component and when it is the
+ * final component. */
+ if (data->path[0]) {
+ /* Since path points to a component and saved_path
+ * always starts with '/', path[-1] is valid. */
+ data->path[-1] = '\0';
+ newpath = malloc(strlen(data->saved_path) + strlen(path) + strlen(data->path) + 6);
+ if (!newpath)
+ goto nomem;
+
+ sprintf(newpath, "%s/../%s/%s", data->saved_path, path, data->path);
+ } else {
+ newpath = malloc(strlen(data->saved_path) + strlen(path) + 5);
+ if (!newpath)
+ goto nomem;
+
+ sprintf(newpath, "%s/../%s", data->saved_path, path);
+ }
+ }
+ free(data->saved_path);
+ data->saved_path = newpath;
+
+ if (nfs_normalize_path(nfs, data->saved_path) != 0) {
+ data->cb(-ENOENT, nfs, "Symbolic link resolves to invalid path", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ data->path = data->saved_path;
+ nfs_lookup_path_async_internal(nfs, NULL, data, &nfs->rootfh);
+ return;
+
+nomem:
+ data->cb(-ENOMEM, nfs, "Failed to allocate memory for path", data->private_data);
+ free_nfs_cb_data(data);
+}
+
+static void nfs_lookup_path_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ struct nfs_cb_data *data = private_data;
+ struct nfs_context *nfs = data->nfs;
+ LOOKUP3res *res;
+ fattr3 *attr;
+
+ assert(rpc->magic == RPC_CONTEXT_MAGIC);
+
+ if (status == RPC_STATUS_ERROR) {
+ data->cb(-EFAULT, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ if (status == RPC_STATUS_CANCEL) {
+ data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ res = command_data;
+ if (res->status != NFS3_OK) {
+ rpc_set_error(nfs->rpc, "NFS: Lookup of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
+ data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ attr = res->LOOKUP3res_u.resok.obj_attributes.attributes_follow ?
+ &res->LOOKUP3res_u.resok.obj_attributes.post_op_attr_u.attributes :
+ NULL;
+
+ /* This function will always invoke the callback and cleanup
+ * for failures. So no need to check the return value.
+ */
+ nfs_lookup_path_async_internal(nfs, attr, data, &res->LOOKUP3res_u.resok.object);
+}
+
+static int nfs_lookup_path_async_internal(struct nfs_context *nfs, fattr3 *attr, struct nfs_cb_data *data, struct nfs_fh3 *fh)
+{
+ char *path, *slash;
+ LOOKUP3args args;
+
+ while (*data->path == '/') {
+ data->path++;
+ }
path = data->path;
- str = strchr(path, '/');
- if (str != NULL) {
- *str = 0;
- data->path = str+1;
+ slash = strchr(path, '/');
+
+ if (attr && attr->type == NF3LNK && (!data->no_follow || *path != '\0')) {
+ READLINK3args args;
+
+ if (data->link_count++ >= MAX_LINK_COUNT) {
+ data->cb(-ELOOP, nfs, "Too many levels of symbolic links", data->private_data);
+ free_nfs_cb_data(data);
+ return -1;
+ }
+
+ args.symlink = *fh;
+
+ if (rpc_nfs3_readlink_async(nfs->rpc, nfs_lookup_path_2_cb, &args, data) != 0) {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send READLINK call for %s", data->path);
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return -1;
+ }
+
+ if (slash != NULL) {
+ *slash = '/';
+ }
+ return 0;
+ }
+
+ 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++;
return -1;
}
memcpy(data->fh.data.data_val, fh->data.data_val, data->fh.data.data_len);
- data->continue_cb(nfs, data);
+ if (slash != NULL) {
+ *slash = '/';
+ }
+ data->continue_cb(nfs, attr, data);
return 0;
}
-
memset(&args, 0, sizeof(LOOKUP3args));
args.what.dir = *fh;
args.what.name = path;
free_nfs_cb_data(data);
return -1;
}
+ if (slash != NULL) {
+ *slash = '/';
+ }
return 0;
}
-static int nfs_lookuppath_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data, continue_func continue_cb, void *continue_data, void (*free_continue_data)(void *), int continue_int)
+static int nfs_normalize_path(struct nfs_context *nfs, char *path)
{
- struct nfs_cb_data *data;
+ char *str;
+ int len;
- if (path[0] != 0 && path[0] != '/') {
- rpc_set_error(nfs->rpc, "Pathname is not absolute %s", path);
+ /* // -> / */
+ 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;
+}
+
+static void nfs_lookup_path_getattr_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ struct nfs_cb_data *data = private_data;
+ struct nfs_context *nfs = data->nfs;
+ GETATTR3res *res;
+ fattr3 *attr;
+
+ assert(rpc->magic == RPC_CONTEXT_MAGIC);
+
+ if (status == RPC_STATUS_ERROR) {
+ data->cb(-EFAULT, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ if (status == RPC_STATUS_CANCEL) {
+ data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ res = command_data;
+ if (res->status != NFS3_OK) {
+ rpc_set_error(nfs->rpc, "NFS: GETATTR of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
+ data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ attr = &res->GETATTR3res_u.resok.obj_attributes;
+ /* This function will always invoke the callback and cleanup
+ * for failures. So no need to check the return value.
+ */
+ nfs_lookup_path_async_internal(nfs, attr, data, &nfs->rootfh);
+}
+
+static int nfs_lookuppath_async(struct nfs_context *nfs, const char *path, int no_follow, nfs_cb cb, void *private_data, continue_func continue_cb, void *continue_data, void (*free_continue_data)(void *), int continue_int)
+{
+ struct nfs_cb_data *data;
+ struct GETATTR3args args;
+
+ if (path[0] == '\0') {
+ path = ".";
+ }
+
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");
+ if (free_continue_data)
+ free_continue_data(continue_data);
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;
- data->saved_path = strdup(path);
+ data->no_follow = no_follow;
+ 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;
}
- data->path = data->saved_path;
+ if (nfs_normalize_path(nfs, data->saved_path) != 0) {
+ free_nfs_cb_data(data);
+ return -1;
+ }
- if (nfs_lookup_path_async_internal(nfs, data, &nfs->rootfh) != 0) {
- /* return 0 here since the callback will be invoked if there is a failure */
+ data->path = data->saved_path;
+ if (data->path[0]) {
+ /* This function will always invoke the callback and cleanup
+ * for failures. So no need to check the return value.
+ */
+ nfs_lookup_path_async_internal(nfs, NULL, data, &nfs->rootfh);
return 0;
}
+
+ /* We have a request for "", so just perform a GETATTR3 so we can
+ * return the attributes to the caller.
+ */
+ memset(&args, 0, sizeof(GETATTR3args));
+ args.object = nfs->rootfh;
+ if (rpc_nfs3_getattr_async(nfs->rpc, nfs_lookup_path_getattr_cb, &args, data) != 0) {
+ free_nfs_cb_data(data);
+ return -1;
+ }
return 0;
}
-
-
-
/*
* Async stat()
*/
+static dev_t specdata3_to_rdev(struct specdata3 *rdev)
+{
+#ifdef makedev
+ return makedev(rdev->specdata1, rdev->specdata2);
+#else
+ return 0;
+#endif
+}
+
static void nfs_stat_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
GETATTR3res *res;
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
+#ifdef WIN32
+ struct __stat64 st;
+#else
struct stat st;
+#endif
assert(rpc->magic == RPC_CONTEXT_MAGIC);
return;
}
- st.st_dev = -1;
+ st.st_dev = res->GETATTR3res_u.resok.obj_attributes.fsid;
st.st_ino = res->GETATTR3res_u.resok.obj_attributes.fileid;
st.st_mode = res->GETATTR3res_u.resok.obj_attributes.mode;
- if (res->GETATTR3res_u.resok.obj_attributes.type == NF3DIR) {
- st.st_mode |= S_IFDIR ;
- }
- if (res->GETATTR3res_u.resok.obj_attributes.type == NF3REG) {
- st.st_mode |= S_IFREG ;
+ switch (res->GETATTR3res_u.resok.obj_attributes.type) {
+ case NF3REG:
+ st.st_mode |= S_IFREG;
+ break;
+ case NF3DIR:
+ st.st_mode |= S_IFDIR;
+ break;
+ case NF3BLK:
+ st.st_mode |= S_IFBLK;
+ break;
+ case NF3CHR:
+ st.st_mode |= S_IFCHR;
+ break;
+ case NF3LNK:
+ st.st_mode |= S_IFLNK;
+ break;
+ case NF3SOCK:
+ st.st_mode |= S_IFSOCK;
+ break;
+ case NF3FIFO:
+ st.st_mode |= S_IFIFO;
+ break;
}
st.st_nlink = res->GETATTR3res_u.resok.obj_attributes.nlink;
st.st_uid = res->GETATTR3res_u.resok.obj_attributes.uid;
st.st_gid = res->GETATTR3res_u.resok.obj_attributes.gid;
- st.st_rdev = 0;
+ st.st_rdev = specdata3_to_rdev(&res->GETATTR3res_u.resok.obj_attributes.rdev);
st.st_size = res->GETATTR3res_u.resok.obj_attributes.size;
#ifndef WIN32
- st.st_blksize = 4096;
- st.st_blocks = res->GETATTR3res_u.resok.obj_attributes.size / 4096;
-#endif//WIN32
+ st.st_blksize = NFS_BLKSIZE;
+ st.st_blocks = (res->GETATTR3res_u.resok.obj_attributes.used + 512 - 1) / 512;
+#endif//WIN32
st.st_atime = res->GETATTR3res_u.resok.obj_attributes.atime.seconds;
st.st_mtime = res->GETATTR3res_u.resok.obj_attributes.mtime.seconds;
st.st_ctime = res->GETATTR3res_u.resok.obj_attributes.ctime.seconds;
+#ifdef HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
+ st.st_atim.tv_nsec = res->GETATTR3res_u.resok.obj_attributes.atime.nseconds;
+ st.st_mtim.tv_nsec = res->GETATTR3res_u.resok.obj_attributes.mtime.nseconds;
+ st.st_ctim.tv_nsec = res->GETATTR3res_u.resok.obj_attributes.ctime.nseconds;
+#endif
data->cb(0, nfs, &st, data->private_data);
free_nfs_cb_data(data);
}
-static int nfs_stat_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_stat_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
struct GETATTR3args args;
int nfs_stat_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
{
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_stat_continue_internal, NULL, NULL, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_stat_continue_internal, NULL, NULL, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
}
+/*
+ * Async nfs_stat64()
+ */
+static void nfs_stat64_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ GETATTR3res *res;
+ struct nfs_cb_data *data = private_data;
+ struct nfs_context *nfs = data->nfs;
+ struct nfs_stat_64 st;
+
+ assert(rpc->magic == RPC_CONTEXT_MAGIC);
+
+ if (status == RPC_STATUS_ERROR) {
+ data->cb(-EFAULT, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ if (status == RPC_STATUS_CANCEL) {
+ data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ res = command_data;
+ if (res->status != NFS3_OK) {
+ rpc_set_error(nfs->rpc, "NFS: GETATTR of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
+ data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ st.nfs_dev = res->GETATTR3res_u.resok.obj_attributes.fsid;
+ st.nfs_ino = res->GETATTR3res_u.resok.obj_attributes.fileid;
+ st.nfs_mode = res->GETATTR3res_u.resok.obj_attributes.mode;
+ switch (res->GETATTR3res_u.resok.obj_attributes.type) {
+ case NF3REG:
+ st.nfs_mode |= S_IFREG;
+ break;
+ case NF3DIR:
+ st.nfs_mode |= S_IFDIR;
+ break;
+ case NF3BLK:
+ st.nfs_mode |= S_IFBLK;
+ break;
+ case NF3CHR:
+ st.nfs_mode |= S_IFCHR;
+ break;
+ case NF3LNK:
+ st.nfs_mode |= S_IFLNK;
+ break;
+ case NF3SOCK:
+ st.nfs_mode |= S_IFSOCK;
+ break;
+ case NF3FIFO:
+ st.nfs_mode |= S_IFIFO;
+ break;
+ }
+ st.nfs_nlink = res->GETATTR3res_u.resok.obj_attributes.nlink;
+ st.nfs_uid = res->GETATTR3res_u.resok.obj_attributes.uid;
+ st.nfs_gid = res->GETATTR3res_u.resok.obj_attributes.gid;
+ st.nfs_rdev = specdata3_to_rdev(&res->GETATTR3res_u.resok.obj_attributes.rdev);
+ st.nfs_size = res->GETATTR3res_u.resok.obj_attributes.size;
+ st.nfs_blksize = NFS_BLKSIZE;
+ st.nfs_blocks = (res->GETATTR3res_u.resok.obj_attributes.used + 512 - 1) / 512;
+ st.nfs_atime = res->GETATTR3res_u.resok.obj_attributes.atime.seconds;
+ st.nfs_mtime = res->GETATTR3res_u.resok.obj_attributes.mtime.seconds;
+ st.nfs_ctime = res->GETATTR3res_u.resok.obj_attributes.ctime.seconds;
+ st.nfs_atime_nsec = res->GETATTR3res_u.resok.obj_attributes.atime.nseconds;
+ st.nfs_mtime_nsec = res->GETATTR3res_u.resok.obj_attributes.mtime.nseconds;
+ st.nfs_ctime_nsec = res->GETATTR3res_u.resok.obj_attributes.ctime.nseconds;
+ st.nfs_used = res->GETATTR3res_u.resok.obj_attributes.used;
+
+ data->cb(0, nfs, &st, data->private_data);
+ free_nfs_cb_data(data);
+}
+
+static int nfs_stat64_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
+{
+ struct GETATTR3args args;
+
+ memset(&args, 0, sizeof(GETATTR3args));
+ args.object = data->fh;
+
+ if (rpc_nfs3_getattr_async(nfs->rpc, nfs_stat64_1_cb, &args, data) != 0) {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send STAT GETATTR call for %s", data->path);
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ return 0;
+}
+
+int nfs_stat64_async_internal(struct nfs_context *nfs, const char *path, int no_follow, nfs_cb cb, void *private_data)
+{
+ if (nfs_lookuppath_async(nfs, path, no_follow, cb, private_data, nfs_stat64_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;
+}
+
+int nfs_stat64_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
+{
+ return nfs_stat64_async_internal(nfs, path, 0, cb, private_data);
+}
+
+int nfs_lstat64_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
+{
+ return nfs_stat64_async_internal(nfs, path, 1, cb, private_data);
+}
+
+/*
+ * Async open()
+ */
+static void nfs_open_trunc_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ struct nfs_cb_data *data = private_data;
+ struct nfs_context *nfs = data->nfs;
+ struct nfsfh *nfsfh;
+ SETATTR3res *res;
+
+ assert(rpc->magic == RPC_CONTEXT_MAGIC);
+
+ if (status == RPC_STATUS_ERROR) {
+ data->cb(-EFAULT, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ if (status == RPC_STATUS_CANCEL) {
+ data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ res = command_data;
+ if (res->status != NFS3_OK) {
+ rpc_set_error(nfs->rpc, "NFS: Setattr failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
+ data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ nfsfh = malloc(sizeof(struct nfsfh));
+ if (nfsfh == NULL) {
+ rpc_set_error(nfs->rpc, "NFS: Failed to allocate nfsfh structure");
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ memset(nfsfh, 0, sizeof(struct nfsfh));
+
+ if (data->continue_int & O_SYNC) {
+ nfsfh->is_sync = 1;
+ }
+ if (data->continue_int & O_APPEND) {
+ nfsfh->is_append = 1;
+ }
+ /* steal the filehandle */
+ nfsfh->fh = data->fh;
+ data->fh.data.data_val = NULL;
+ data->cb(0, nfs, nfsfh, data->private_data);
+ free_nfs_cb_data(data);
+}
-/*
- * Async open()
- */
static void nfs_open_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
ACCESS3res *res;
return;
}
+ /* Try to truncate it if we were requested to */
+ if ((data->continue_int & O_TRUNC) &&
+ (data->continue_int & (O_RDWR|O_WRONLY))) {
+ SETATTR3args args;
+
+ memset(&args, 0, sizeof(SETATTR3args));
+ args.object = data->fh;
+ args.new_attributes.size.set_it = 1;
+ args.new_attributes.size.set_size3_u.size = 0;
+
+ if (rpc_nfs3_setattr_async(nfs->rpc, nfs_open_trunc_cb, &args,
+ data) != 0) {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send "
+ "SETATTR call for %s", data->path);
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc),
+ data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ return;
+ }
+
nfsfh = malloc(sizeof(struct nfsfh));
if (nfsfh == NULL) {
rpc_set_error(nfs->rpc, "NFS: Failed to allocate nfsfh structure");
if (data->continue_int & O_SYNC) {
nfsfh->is_sync = 1;
}
+ if (data->continue_int & O_APPEND) {
+ nfsfh->is_append = 1;
+ }
/* steal the filehandle */
nfsfh->fh = data->fh;
free_nfs_cb_data(data);
}
-static int nfs_open_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_open_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
int nfsmode = 0;
ACCESS3args args;
args.access = nfsmode;
if (rpc_nfs3_access_async(nfs->rpc, nfs_open_cb, &args, data) != 0) {
- rpc_set_error(nfs->rpc, "RPC error: Failed to send OPEN ACCESS call for %s", data->path);
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send OPEN ACCESS "
+ "call for %s", data->path);
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc),
+ data->private_data);
free_nfs_cb_data(data);
return -1;
}
return 0;
}
-int nfs_open_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
+int nfs_open_async(struct nfs_context *nfs, const char *path, int flags, nfs_cb cb, void *private_data)
{
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_open_continue_internal, NULL, NULL, mode) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_open_continue_internal, NULL, NULL, flags) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
}
-
-
-
/*
- * Async pread()
+ * Async chdir()
*/
-static void nfs_pread_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+static int nfs_chdir_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
- struct nfs_cb_data *data = private_data;
- struct nfs_context *nfs = data->nfs;
- READ3res *res;
+ /* steal saved_path */
+ free(nfs->cwd);
+ nfs->cwd = data->saved_path;
+ data->saved_path = NULL;
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
+ data->cb(0, nfs, NULL, data->private_data);
+ free_nfs_cb_data(data);
- if (status == RPC_STATUS_ERROR) {
- data->cb(-EFAULT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
- free_nfs_cb_data(data);
- return;
- }
+ return 0;
+}
- res = command_data;
- if (res->status != NFS3_OK) {
- rpc_set_error(nfs->rpc, "NFS: Read failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
- data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
- free_nfs_cb_data(data);
- return;
+int nfs_chdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
+{
+ if (nfs_lookuppath_async(nfs, path, 0, 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;
}
- data->nfsfh->offset += res->READ3res_u.resok.count;
- data->cb(res->READ3res_u.resok.count, nfs, res->READ3res_u.resok.data.data_val, data->private_data);
- free_nfs_cb_data(data);
+ return 0;
+}
+
+
+/*
+ * Async pread()
+ */
+static void nfs_fill_READ3args(READ3args *args, struct nfsfh *fh, uint64_t offset, uint64_t count)
+{
+ memset(args, 0, sizeof(READ3args));
+ args->file = fh->fh;
+ args->offset = offset;
+ args->count = count;
}
static void nfs_pread_mcb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
data->cancel = 1;
}
- /* reassemble the data into the buffer */
if (status == RPC_STATUS_SUCCESS) {
res = command_data;
if (res->status != NFS3_OK) {
rpc_set_error(nfs->rpc, "NFS: Read failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
data->error = 1;
- } else {
- if (res->READ3res_u.resok.count > 0) {
- memcpy(&data->buffer[mdata->offset - data->start_offset], res->READ3res_u.resok.data.data_val, res->READ3res_u.resok.count);
- if ((unsigned)data->max_offset < mdata->offset + res->READ3res_u.resok.count) {
- data->max_offset = mdata->offset + res->READ3res_u.resok.count;
+ } else {
+ uint64_t count = res->READ3res_u.resok.count;
+
+ if (mdata->update_pos)
+ data->nfsfh->offset += count;
+
+ /* if we have more than one call or we have received a short read we need a reassembly buffer */
+ if (data->num_calls || (count < mdata->count && !res->READ3res_u.resok.eof)) {
+ if (data->buffer == NULL) {
+ data->buffer = malloc(data->count);
+ if (data->buffer == NULL) {
+ rpc_set_error(nfs->rpc, "Out-Of-Memory: Failed to allocate reassembly buffer for %d bytes", (int)data->count);
+ data->oom = 1;
+ }
+ }
+ }
+ if (count > 0) {
+ if (count <= mdata->count) {
+ /* copy data into reassembly buffer if we have one */
+ if (data->buffer != NULL) {
+ memcpy(&data->buffer[mdata->offset - data->offset], res->READ3res_u.resok.data.data_val, count);
+ }
+ if (data->max_offset < mdata->offset + count) {
+ data->max_offset = mdata->offset + count;
+ }
+ } else {
+ rpc_set_error(nfs->rpc, "NFS: Read overflow. Server has sent more data than requested!");
+ data->error = 1;
+ }
+ }
+ /* check if we have received a short read */
+ if (count < mdata->count && !res->READ3res_u.resok.eof) {
+ if (count == 0) {
+ rpc_set_error(nfs->rpc, "NFS: Read failed. No bytes read and not at EOF!");
+ data->error = 1;
+ } else {
+ /* reissue reminder of this read request */
+ READ3args args;
+ mdata->offset += count;
+ mdata->count -= count;
+ nfs_fill_READ3args(&args, data->nfsfh, mdata->offset, mdata->count);
+ if (rpc_nfs3_read_async(nfs->rpc, nfs_pread_mcb, &args, mdata) == 0) {
+ data->num_calls++;
+ return;
+ } else {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send READ call for %s", data->path);
+ data->oom = 1;
+ }
}
}
}
}
+ free(mdata);
+
if (data->num_calls > 0) {
/* still waiting for more replies */
- free(mdata);
return;
}
-
+ if (data->oom != 0) {
+ data->cb(-ENOMEM, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
if (data->error != 0) {
data->cb(-EFAULT, nfs, command_data, data->private_data);
free_nfs_cb_data(data);
- free(mdata);
return;
}
if (data->cancel != 0) {
data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
free_nfs_cb_data(data);
- free(mdata);
return;
}
- data->nfsfh->offset = data->max_offset;
- data->cb(data->max_offset - data->start_offset, nfs, data->buffer, data->private_data);
+ if (data->buffer) {
+ if (data->max_offset > data->org_offset + data->org_count) {
+ data->max_offset = data->org_offset + data->org_count;
+ }
+ data->cb(data->max_offset - data->org_offset, nfs, data->buffer + (data->org_offset - data->offset), data->private_data);
+ } else {
+ data->cb(res->READ3res_u.resok.count, nfs, res->READ3res_u.resok.data.data_val, data->private_data);
+ }
+ data->nfsfh->ra.fh_offset = data->max_offset;
+ if (data->nfsfh->ra.cur_ra) {
+ free(data->nfsfh->ra.buf);
+ data->nfsfh->ra.buf = data->buffer;
+ data->nfsfh->ra.buf_offset = data->offset;
+ data->nfsfh->ra.buf_count = data->count;
+ data->nfsfh->ra.buf_ts = time(NULL);
+ data->buffer = NULL;
+ }
free_nfs_cb_data(data);
- free(mdata);
}
-int nfs_pread_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, nfs_cb cb, void *private_data)
+static void nfs_ra_invalidate(struct nfsfh *nfsfh) {
+ free(nfsfh->ra.buf);
+ nfsfh->ra.buf = NULL;
+ nfsfh->ra.buf_offset = 0;
+ nfsfh->ra.buf_count = 0;
+ nfsfh->ra.buf_ts = time(NULL);
+ nfsfh->ra.cur_ra = NFS_BLKSIZE;
+}
+
+static int nfs_pread_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, nfs_cb cb, void *private_data, int update_pos)
{
struct nfs_cb_data *data;
data->cb = cb;
data->private_data = private_data;
data->nfsfh = nfsfh;
+ data->org_offset = offset;
+ data->org_count = count;
- nfsfh->offset = offset;
+ assert(data->num_calls == 0);
- if (count <= nfs_get_readmax(nfs)) {
- READ3args args;
+ if (nfs->rpc->readahead && time(NULL) - nfsfh->ra.buf_ts > NFS_RA_TIMEOUT) {
+ /* readahead cache timeout */
+ nfs_ra_invalidate(nfsfh);
+ }
+
+ if (nfs->rpc->readahead) {
+ if (offset >= nfsfh->ra.last_offset &&
+ offset - NFS_BLKSIZE <= nfsfh->ra.fh_offset + nfsfh->ra.cur_ra) {
+ if (nfs->rpc->readahead > nfsfh->ra.cur_ra) {
+ nfsfh->ra.cur_ra <<= 1;
+ }
+ } else {
+ nfsfh->ra.cur_ra = NFS_BLKSIZE;
+ }
- memset(&args, 0, sizeof(READ3args));
- args.file = nfsfh->fh;
- args.offset = offset;
- args.count = count;
+ nfsfh->ra.last_offset = offset;
- if (rpc_nfs3_read_async(nfs->rpc, nfs_pread_cb, &args, data) != 0) {
- rpc_set_error(nfs->rpc, "RPC error: Failed to send READ call for %s", data->path);
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ if (nfsfh->ra.buf_offset <= offset &&
+ nfsfh->ra.buf_offset + nfsfh->ra.buf_count >= offset + count) {
+ /* serve request completely from cache */
+ data->buffer = malloc(count);
+ if (data->buffer == NULL) {
+ free_nfs_cb_data(data);
+ return -ENOMEM;
+ }
+ memcpy(data->buffer, nfsfh->ra.buf + (offset - nfsfh->ra.buf_offset), count);
+ data->cb(count, nfs, data->buffer, data->private_data);
+ nfsfh->ra.fh_offset = offset + count;
free_nfs_cb_data(data);
- return -1;
+ return 0;
}
- return 0;
- }
- /* trying to read more than maximum server read size, we has to chop it up into smaller
- * reads and collect into a reassembly buffer.
- * we send all reads in parallel so that performance is still good.
- */
- data->max_offset = offset;
- data->start_offset = offset;
+ /* align start offset to blocksize */
+ count += offset & (NFS_BLKSIZE - 1);
+ offset &= ~(NFS_BLKSIZE - 1);
- data->buffer = malloc(count);
- if (data->buffer == NULL) {
- rpc_set_error(nfs->rpc, "Out-Of-Memory: Failed to allocate reassembly buffer for %d bytes", (int)count);
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
- free_nfs_cb_data(data);
- return -1;
+ /* align end offset to blocksize and add readahead */
+ count += nfsfh->ra.cur_ra - 1;
+ count &= ~(NFS_BLKSIZE - 1);
+
+ data->buffer = malloc(count);
+ if (data->buffer == NULL) {
+ free_nfs_cb_data(data);
+ return -ENOMEM;
+ }
+ data->offset = offset;
+ data->count = count;
+
+ if (nfsfh->ra.buf_count && nfsfh->ra.buf_offset <= offset &&
+ nfsfh->ra.buf_offset + nfsfh->ra.buf_count >= offset) {
+ /* serve request partially from cache */
+ size_t overlap = (nfsfh->ra.buf_offset + nfsfh->ra.buf_count) - offset;
+ if (overlap > count) count = overlap;
+ memcpy(data->buffer, nfsfh->ra.buf + (offset - nfsfh->ra.buf_offset), overlap);
+ offset += overlap;
+ count -= overlap;
+ }
+ } else {
+ data->offset = offset;
+ data->count = count;
}
- while (count > 0) {
+ data->max_offset = offset;
+
+ /* chop requests into chunks of at most READMAX bytes if necessary.
+ * we send all reads in parallel so that performance is still good.
+ */
+ do {
uint64_t readcount = count;
struct nfs_mcb_data *mdata;
READ3args args;
mdata = malloc(sizeof(struct nfs_mcb_data));
if (mdata == NULL) {
rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_mcb_data structure");
- return -1;
+ if (data->num_calls == 0) {
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ data->oom = 1;
+ break;
}
memset(mdata, 0, sizeof(struct nfs_mcb_data));
mdata->data = data;
mdata->offset = offset;
mdata->count = readcount;
+ mdata->update_pos = update_pos;
- memset(&args, 0, sizeof(READ3args));
- args.file = nfsfh->fh;
- args.offset = offset;
- args.count = readcount;
+ nfs_fill_READ3args(&args, nfsfh, offset, readcount);
if (rpc_nfs3_read_async(nfs->rpc, nfs_pread_mcb, &args, mdata) != 0) {
rpc_set_error(nfs->rpc, "RPC error: Failed to send READ call for %s", data->path);
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
free(mdata);
- return -1;
+ if (data->num_calls == 0) {
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ data->oom = 1;
+ break;
}
count -= readcount;
offset += readcount;
data->num_calls++;
- }
+ } while (count > 0);
return 0;
}
+int nfs_pread_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, nfs_cb cb, void *private_data)
+{
+ return nfs_pread_async_internal(nfs, nfsfh, offset, count, cb, private_data, 0);
+}
+
/*
* Async read()
*/
int nfs_read_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, nfs_cb cb, void *private_data)
{
- return nfs_pread_async(nfs, nfsfh, nfsfh->offset, count, cb, private_data);
+ return nfs_pread_async_internal(nfs, nfsfh, nfsfh->offset, count, cb, private_data, 1);
}
/*
* Async pwrite()
*/
-static void nfs_pwrite_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+static void nfs_fill_WRITE3args (WRITE3args *args, struct nfsfh *fh, uint64_t offset, uint64_t count,
+ void *buf)
{
- struct nfs_cb_data *data = private_data;
- struct nfs_context *nfs = data->nfs;
- WRITE3res *res;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(-EFAULT, nfs, command_data, data->private_data);
- free_nfs_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- res = command_data;
- if (res->status != NFS3_OK) {
- rpc_set_error(nfs->rpc, "NFS: Write failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
- data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
- free_nfs_cb_data(data);
- return;
- }
-
- data->nfsfh->offset += res->WRITE3res_u.resok.count;
- data->cb(res->WRITE3res_u.resok.count, nfs, NULL, data->private_data);
- free_nfs_cb_data(data);
+ memset(args, 0, sizeof(WRITE3args));
+ args->file = fh->fh;
+ args->offset = offset;
+ args->count = count;
+ args->stable = fh->is_sync ? FILE_SYNC : UNSTABLE;
+ args->data.data_len = count;
+ args->data.data_val = buf;
}
static void nfs_pwrite_mcb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
rpc_set_error(nfs->rpc, "NFS: Write failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
data->error = 1;
} else {
- if (res->WRITE3res_u.resok.count > 0) {
- if ((unsigned)data->max_offset < mdata->offset + res->WRITE3res_u.resok.count) {
- data->max_offset = mdata->offset + res->WRITE3res_u.resok.count;
+ uint64_t count = res->WRITE3res_u.resok.count;
+
+ if (mdata->update_pos)
+ data->nfsfh->offset += count;
+
+ if (count < mdata->count) {
+ if (count == 0) {
+ rpc_set_error(nfs->rpc, "NFS: Write failed. No bytes written!");
+ data->error = 1;
+ } else {
+ /* reissue reminder of this write request */
+ WRITE3args args;
+ mdata->offset += count;
+ mdata->count -= count;
+
+ nfs_fill_WRITE3args(&args, data->nfsfh, mdata->offset, mdata->count,
+ &data->usrbuf[mdata->offset - data->offset]);
+ if (rpc_nfs3_write_async(nfs->rpc, nfs_pwrite_mcb, &args, mdata) == 0) {
+ data->num_calls++;
+ return;
+ } else {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send WRITE call for %s", data->path);
+ data->oom = 1;
+ }
+ }
+ }
+ if (count > 0) {
+ if (data->max_offset < mdata->offset + count) {
+ data->max_offset = mdata->offset + count;
}
}
}
}
+ free(mdata);
+
if (data->num_calls > 0) {
/* still waiting for more replies */
- free(mdata);
return;
}
-
+ if (data->oom != 0) {
+ data->cb(-ENOMEM, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
if (data->error != 0) {
data->cb(-EFAULT, nfs, command_data, data->private_data);
free_nfs_cb_data(data);
- free(mdata);
return;
}
if (data->cancel != 0) {
data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
free_nfs_cb_data(data);
- free(mdata);
return;
}
- data->nfsfh->offset = data->max_offset;
- data->cb(data->max_offset - data->start_offset, nfs, NULL, data->private_data);
+ data->cb(data->max_offset - data->offset, nfs, NULL, data->private_data);
free_nfs_cb_data(data);
- free(mdata);
}
-int nfs_pwrite_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buf, nfs_cb cb, void *private_data)
+static int nfs_pwrite_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buf, nfs_cb cb, void *private_data, int update_pos)
{
struct nfs_cb_data *data;
data->cb = cb;
data->private_data = private_data;
data->nfsfh = nfsfh;
+ data->usrbuf = buf;
- nfsfh->offset = offset;
-
- if (count <= nfs_get_writemax(nfs)) {
- WRITE3args args;
-
- memset(&args, 0, sizeof(WRITE3args));
- args.file = nfsfh->fh;
- args.offset = offset;
- args.count = count;
- args.stable = nfsfh->is_sync?FILE_SYNC:UNSTABLE;
- args.data.data_len = count;
- args.data.data_val = buf;
+ /* hello, clang-analyzer */
+ assert(data->num_calls == 0);
- if (rpc_nfs3_write_async(nfs->rpc, nfs_pwrite_cb, &args, data) != 0) {
- rpc_set_error(nfs->rpc, "RPC error: Failed to send WRITE call for %s", data->path);
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
- free_nfs_cb_data(data);
- return -1;
- }
- return 0;
- }
-
- /* trying to write more than maximum server write size, we has to chop it up into smaller
- * chunks.
+ /* chop requests into chunks of at most WRITEMAX bytes if necessary.
* we send all writes in parallel so that performance is still good.
*/
data->max_offset = offset;
- data->start_offset = offset;
+ data->offset = offset;
- while (count > 0) {
+ do {
uint64_t writecount = count;
struct nfs_mcb_data *mdata;
WRITE3args args;
mdata = malloc(sizeof(struct nfs_mcb_data));
if (mdata == NULL) {
rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_mcb_data structure");
- return -1;
+ if (data->num_calls == 0) {
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ data->oom = 1;
+ break;
}
memset(mdata, 0, sizeof(struct nfs_mcb_data));
mdata->data = data;
mdata->offset = offset;
mdata->count = writecount;
+ mdata->update_pos = update_pos;
- memset(&args, 0, sizeof(WRITE3args));
- args.file = nfsfh->fh;
- args.offset = offset;
- args.count = writecount;
- args.stable = nfsfh->is_sync?FILE_SYNC:UNSTABLE;
- args.data.data_len = writecount;
- args.data.data_val = &buf[offset - data->start_offset];
+ nfs_fill_WRITE3args(&args, nfsfh, offset, writecount, &buf[offset - data->offset]);
if (rpc_nfs3_write_async(nfs->rpc, nfs_pwrite_mcb, &args, mdata) != 0) {
rpc_set_error(nfs->rpc, "RPC error: Failed to send WRITE call for %s", data->path);
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
free(mdata);
- return -1;
+ if (data->num_calls == 0) {
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ data->oom = 1;
+ break;
}
count -= writecount;
offset += writecount;
data->num_calls++;
- }
+ } while (count > 0);
return 0;
}
+int nfs_pwrite_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buf, nfs_cb cb, void *private_data)
+{
+ return nfs_pwrite_async_internal(nfs, nfsfh, offset, count, buf, cb, private_data, 0);
+}
+
/*
* Async write()
*/
+static void nfs_write_append_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ struct nfs_cb_data *data = private_data;
+ struct nfs_context *nfs = data->nfs;
+ GETATTR3res *res;
+
+ assert(rpc->magic == RPC_CONTEXT_MAGIC);
+
+ if (status == RPC_STATUS_ERROR) {
+ data->cb(-EFAULT, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ if (status == RPC_STATUS_CANCEL) {
+ data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ res = command_data;
+ if (res->status != NFS3_OK) {
+ rpc_set_error(nfs->rpc, "NFS: GETATTR failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
+ data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+
+ if (nfs_pwrite_async_internal(nfs, data->nfsfh, res->GETATTR3res_u.resok.obj_attributes.size, data->count, data->usrbuf, data->cb, data->private_data, 1) != 0) {
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return;
+ }
+ free_nfs_cb_data(data);
+}
+
int nfs_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, char *buf, nfs_cb cb, void *private_data)
{
- return nfs_pwrite_async(nfs, nfsfh, nfsfh->offset, count, buf, cb, private_data);
+ nfs_ra_invalidate(nfsfh);
+ if (nfsfh->is_append) {
+ struct GETATTR3args args;
+ struct nfs_cb_data *data;
+
+ 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");
+ return -1;
+ }
+ memset(data, 0, sizeof(struct nfs_cb_data));
+ data->nfs = nfs;
+ data->cb = cb;
+ data->private_data = private_data;
+ data->nfsfh = nfsfh;
+ data->usrbuf = buf;
+ data->count = count;
+
+ memset(&args, 0, sizeof(GETATTR3args));
+ args.object = nfsfh->fh;
+
+ if (rpc_nfs3_getattr_async(nfs->rpc, nfs_write_append_cb, &args, data) != 0) {
+ rpc_set_error(nfs->rpc, "out of memory: failed to send GETATTR");
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ return 0;
+ }
+ return nfs_pwrite_async_internal(nfs, nfsfh, nfsfh->offset, count, buf, cb, private_data, 1);
}
/*
* close
*/
-
+
int nfs_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, void *private_data)
{
- if (nfsfh->fh.data.data_val != NULL){
- free(nfsfh->fh.data.data_val);
- nfsfh->fh.data.data_val = NULL;
+ free_nfsfh(nfsfh);
+ cb(0, nfs, NULL, private_data);
+ return 0;
+};
+
+
+
+
+
+/*
+ * Async fstat()
+ */
+int nfs_fstat_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, void *private_data)
+{
+ struct nfs_cb_data *data;
+ struct GETATTR3args args;
+
+ 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");
+ return -1;
}
- free(nfsfh);
+ memset(data, 0, sizeof(struct nfs_cb_data));
+ data->nfs = nfs;
+ data->cb = cb;
+ data->private_data = private_data;
- cb(0, nfs, NULL, private_data);
+ memset(&args, 0, sizeof(GETATTR3args));
+ args.object = nfsfh->fh;
+
+ if (rpc_nfs3_getattr_async(nfs->rpc, nfs_stat_1_cb, &args, data) != 0) {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send STAT GETATTR call for %s", data->path);
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return -1;
+ }
return 0;
-};
-
-
-
-
+}
/*
- * Async fstat()
+ * Async fstat64()
*/
-int nfs_fstat_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, void *private_data)
+int nfs_fstat64_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, void *private_data)
{
struct nfs_cb_data *data;
struct GETATTR3args args;
memset(&args, 0, sizeof(GETATTR3args));
args.object = nfsfh->fh;
- if (rpc_nfs3_getattr_async(nfs->rpc, nfs_stat_1_cb, &args, data) != 0) {
+ if (rpc_nfs3_getattr_async(nfs->rpc, nfs_stat64_1_cb, &args, data) != 0) {
rpc_set_error(nfs->rpc, "RPC error: Failed to send STAT GETATTR call for %s", data->path);
data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
free_nfs_cb_data(data);
/*
* Async truncate()
*/
-static int nfs_truncate_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_truncate_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
uint64_t offset = data->continue_int;
struct nfsfh nfsfh;
offset = length;
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_truncate_continue_internal, NULL, NULL, offset) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_truncate_continue_internal, NULL, NULL, offset) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
char *str = data->continue_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
str = &str[strlen(str) + 1];
free_nfs_cb_data(data);
}
-static int nfs_mkdir_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_mkdir_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
char *str = data->continue_data;
MKDIR3args args;
ptr = strrchr(new_path, '/');
if (ptr == NULL) {
+ free(new_path);
rpc_set_error(nfs->rpc, "Invalid path %s", path);
return -1;
}
*ptr = 0;
/* new_path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
- if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_mkdir_continue_internal, new_path, free, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, new_path, 0, cb, private_data, nfs_mkdir_continue_internal, new_path, free, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path component");
return -1;
}
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
char *str = data->continue_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
str = &str[strlen(str) + 1];
free_nfs_cb_data(data);
}
-static int nfs_rmdir_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_rmdir_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
char *str = data->continue_data;
RMDIR3args args;
ptr = strrchr(new_path, '/');
if (ptr == NULL) {
+ free(new_path);
rpc_set_error(nfs->rpc, "Invalid path %s", path);
return -1;
}
*ptr = 0;
/* new_path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
- if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_rmdir_continue_internal, new_path, free, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, new_path, 0, cb, private_data, nfs_rmdir_continue_internal, new_path, free, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
/*
* Async creat()
*/
+struct create_cb_data {
+ char *path;
+ int flags;
+ int mode;
+};
+
+static void free_create_cb_data(void *ptr)
+{
+ struct create_cb_data *data = ptr;
+
+ free(data->path);
+ free(data);
+}
+
+static void nfs_create_trunc_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ struct nfs_cb_data *data = private_data;
+ struct nfs_context *nfs = data->nfs;
+ struct nfsfh *nfsfh;
+ SETATTR3res *res;
+
+ assert(rpc->magic == RPC_CONTEXT_MAGIC);
+
+ if (status == RPC_STATUS_ERROR) {
+ data->cb(-EFAULT, nfs, command_data, data->private_data);
+ free_nfs_cb_data(data);
+ free_nfsfh(nfsfh);
+ return;
+ }
+ if (status == RPC_STATUS_CANCEL) {
+ data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
+ free_nfs_cb_data(data);
+ free_nfsfh(nfsfh);
+ return;
+ }
+
+ res = command_data;
+ if (res->status != NFS3_OK) {
+ rpc_set_error(nfs->rpc, "NFS: Setattr failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
+ data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ free_nfsfh(nfsfh);
+ return;
+ }
+
+ data->cb(0, nfs, data->nfsfh, data->private_data);
+ free_nfs_cb_data(data);
+}
+
static void nfs_create_2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
LOOKUP3res *res;
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
struct nfsfh *nfsfh;
- char *str = data->continue_data;
+ struct create_cb_data *cb_data = data->continue_data;
+ char *str = cb_data->path;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
}
memset(nfsfh, 0, sizeof(struct nfsfh));
+ if (cb_data->flags & O_SYNC) {
+ nfsfh->is_sync = 1;
+ }
+ if (cb_data->flags & O_APPEND) {
+ nfsfh->is_append = 1;
+ }
+
/* copy the filehandle */
nfsfh->fh.data.data_len = res->LOOKUP3res_u.resok.object.data.data_len;
nfsfh->fh.data.data_val = malloc(nfsfh->fh.data.data_len);
+ if (nfsfh->fh.data.data_val == NULL) {
+ rpc_set_error(nfs->rpc, "Out of memory: Failed to allocate fh structure");
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ free(nfsfh);
+ return;
+ }
memcpy(nfsfh->fh.data.data_val, res->LOOKUP3res_u.resok.object.data.data_val, nfsfh->fh.data.data_len);
+ /* Try to truncate it if we were requested to */
+ if (cb_data->flags & O_TRUNC) {
+ SETATTR3args args;
+
+ data->nfsfh = nfsfh;
+
+ memset(&args, 0, sizeof(SETATTR3args));
+ args.object = nfsfh->fh;
+ args.new_attributes.size.set_it = 1;
+ args.new_attributes.size.set_size3_u.size = 0;
+
+ if (rpc_nfs3_setattr_async(nfs->rpc, nfs_create_trunc_cb,
+ &args, data) != 0) {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send "
+ "SETATTR call for %s", data->path);
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc),
+ data->private_data);
+ free_nfs_cb_data(data);
+ free_nfsfh(nfsfh);
+ return;
+ }
+ return;
+ }
+
data->cb(0, nfs, nfsfh, data->private_data);
free_nfs_cb_data(data);
}
-static void nfs_creat_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+static void nfs_create_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
CREATE3res *res;
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
- char *str = data->continue_data;
+ struct create_cb_data *cb_data = data->continue_data;
+ char *str = cb_data->path;
LOOKUP3args args;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
return;
}
-static int nfs_creat_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_create_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
- char *str = data->continue_data;
+ struct create_cb_data *cb_data = data->continue_data;
+ char *str = cb_data->path;
CREATE3args args;
str = &str[strlen(str) + 1];
memset(&args, 0, sizeof(CREATE3args));
args.where.dir = data->fh;
args.where.name = str;
- args.how.mode = UNCHECKED;
+ args.how.mode = (cb_data->flags & O_EXCL) ? GUARDED : UNCHECKED;
args.how.createhow3_u.obj_attributes.mode.set_it = 1;
- args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode = data->continue_int;
+ args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode = cb_data->mode;
- if (rpc_nfs3_create_async(nfs->rpc, nfs_creat_1_cb, &args, data) != 0) {
+ if (rpc_nfs3_create_async(nfs->rpc, nfs_create_1_cb, &args, data) != 0) {
rpc_set_error(nfs->rpc, "RPC error: Failed to send CREATE call for %s/%s", data->path, str);
data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
free_nfs_cb_data(data);
return 0;
}
-int nfs_creat_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
+int nfs_create_async(struct nfs_context *nfs, const char *path, int flags, int mode, nfs_cb cb, void *private_data)
{
- char *new_path;
+ struct create_cb_data *cb_data;
char *ptr;
- new_path = strdup(path);
- if (new_path == NULL) {
+ cb_data = malloc(sizeof(struct create_cb_data));
+ if (cb_data == NULL) {
+ rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for cb data");
+ return -1;
+ }
+
+ cb_data->path = strdup(path);
+ if (cb_data->path == NULL) {
rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for path");
+ free(cb_data);
return -1;
}
- ptr = strrchr(new_path, '/');
+ ptr = strrchr(cb_data->path, '/');
if (ptr == NULL) {
rpc_set_error(nfs->rpc, "Invalid path %s", path);
+ free_create_cb_data(cb_data);
return -1;
}
*ptr = 0;
+ cb_data->flags = flags;
+ cb_data->mode = mode;
+
/* new_path now points to the parent directory, and beyond the nul terminator is the new directory to create */
- if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_creat_continue_internal, new_path, free, mode) != 0) {
+ if (nfs_lookuppath_async(nfs, cb_data->path, 0, cb, private_data, nfs_create_continue_internal, cb_data, free_create_cb_data, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
return 0;
}
+int nfs_creat_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
+{
+ return nfs_create_async(nfs, path, 0, mode, cb, private_data);
+}
+
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
char *str = data->continue_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
str = &str[strlen(str) + 1];
free_nfs_cb_data(data);
}
-static int nfs_unlink_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_unlink_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
char *str = data->continue_data;
struct REMOVE3args args;
ptr = strrchr(new_path, '/');
if (ptr == NULL) {
+ free(new_path);
rpc_set_error(nfs->rpc, "Invalid path %s", path);
return -1;
}
*ptr = 0;
/* new_path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
- if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_unlink_continue_internal, new_path, free, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, new_path, 0, cb, private_data, nfs_unlink_continue_internal, new_path, free, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
char *str = data->continue_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
str = &str[strlen(str) + 1];
free_nfs_cb_data(data);
}
-static int nfs_mknod_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_mknod_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
struct mknod_cb_data *cb_data = data->continue_data;
char *str = cb_data->path;
MKNOD3args args;
-
+
str = &str[strlen(str) + 1];
args.where.dir = data->fh;
cb_data->path = strdup(path);
if (cb_data->path == NULL) {
rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for path");
- free(cb_data);
+ free(cb_data);
return -1;
}
ptr = strrchr(cb_data->path, '/');
if (ptr == NULL) {
rpc_set_error(nfs->rpc, "Invalid path %s", path);
+ free_mknod_cb_data(cb_data);
return -1;
}
*ptr = 0;
cb_data->minor = minor(dev);
/* data->path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
- if (nfs_lookuppath_async(nfs, cb_data->path, cb, private_data, nfs_mknod_continue_internal, cb_data, free_mknod_cb_data, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, cb_data->path, 0, cb, private_data, nfs_mknod_continue_internal, cb_data, free_mknod_cb_data, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
- free_mknod_cb_data(cb_data);
return -1;
}
rdpe_cb_data->getattrcount--;
if (status == RPC_STATUS_ERROR) {
+ rpc_set_error(nfs->rpc, "LOOKUP during READDIRPLUS emulation "
+ "failed with RPC_STATUS_ERROR");
rdpe_cb_data->status = RPC_STATUS_ERROR;
}
if (status == RPC_STATUS_CANCEL) {
+ rpc_set_error(nfs->rpc, "LOOKUP during READDIRPLUS emulation "
+ "failed with RPC_STATUS_CANCEL");
rdpe_cb_data->status = RPC_STATUS_CANCEL;
}
- if (status == RPC_STATUS_SUCCESS && res->status != NFS3_OK) {
- rdpe_cb_data->status = RPC_STATUS_ERROR;
- }
if (status == RPC_STATUS_SUCCESS && res->status == NFS3_OK) {
if (res->LOOKUP3res_u.resok.obj_attributes.attributes_follow) {
fattr3 *attributes = &res->LOOKUP3res_u.resok.obj_attributes.post_op_attr_u.attributes;
nfsdirent->atime.tv_sec = attributes->atime.seconds;
nfsdirent->atime.tv_usec = attributes->atime.nseconds/1000;
+ nfsdirent->atime_nsec = attributes->atime.nseconds;
nfsdirent->mtime.tv_sec = attributes->mtime.seconds;
nfsdirent->mtime.tv_usec = attributes->mtime.nseconds/1000;
+ nfsdirent->mtime_nsec = attributes->mtime.nseconds;
nfsdirent->ctime.tv_sec = attributes->ctime.seconds;
nfsdirent->ctime.tv_usec = attributes->ctime.nseconds/1000;
+ nfsdirent->ctime_nsec = attributes->ctime.nseconds;
+ nfsdirent->uid = attributes->uid;
+ nfsdirent->gid = attributes->gid;
+ nfsdirent->nlink = attributes->nlink;
+ nfsdirent->dev = attributes->fsid;
+ nfsdirent->rdev = specdata3_to_rdev(&attributes->rdev);
+ nfsdirent->blksize = NFS_BLKSIZE;
+ nfsdirent->blocks = (attributes->used + 512 - 1) / 512;
+ nfsdirent->used = attributes->used;
}
}
if (rdpe_cb_data->getattrcount == 0) {
if (rdpe_cb_data->status != RPC_STATUS_SUCCESS) {
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ rpc_set_error(nfs->rpc, "READDIRPLUS emulation "
+ "failed: %s", rpc_get_error(rpc));
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc),
+ data->private_data);
nfs_free_nfsdir(nfsdir);
} else {
data->cb(0, nfs, nfsdir, data->private_data);
struct nfsdir *nfsdir = data->continue_data;
struct nfsdirent *nfsdirent;
struct entry3 *entry;
- uint64_t cookie;
+ uint64_t cookie = 0;
struct rdpe_cb_data *rdpe_cb_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (status == RPC_STATUS_ERROR) {
nfsdirent->name = strdup(entry->name);
if (nfsdirent->name == NULL) {
data->cb(-ENOMEM, nfs, "Failed to allocate dirent->name", data->private_data);
+ free(nfsdirent);
nfs_free_nfsdir(nfsdir);
data->continue_data = NULL;
free_nfs_cb_data(data);
return;
}
+ if (res->READDIR3res_u.resok.dir_attributes.attributes_follow)
+ nfsdir->attr = res->READDIR3res_u.resok.dir_attributes.post_op_attr_u.attributes;
+
/* steal the dirhandle */
nfsdir->current = nfsdir->entries;
- rdpe_cb_data = malloc(sizeof(struct rdpe_cb_data));
- rdpe_cb_data->getattrcount = 0;
- rdpe_cb_data->status = RPC_STATUS_SUCCESS;
- rdpe_cb_data->data = data;
- for (nfsdirent = nfsdir->entries; nfsdirent; nfsdirent = nfsdirent->next) {
- struct rdpe_lookup_cb_data *rdpe_lookup_cb_data;
- LOOKUP3args args;
-
- rdpe_lookup_cb_data = malloc(sizeof(struct rdpe_lookup_cb_data));
- rdpe_lookup_cb_data->rdpe_cb_data = rdpe_cb_data;
- rdpe_lookup_cb_data->nfsdirent = nfsdirent;
-
- memset(&args, 0, sizeof(LOOKUP3args));
- args.what.dir = data->fh;
- args.what.name = nfsdirent->name;
-
- if (rpc_nfs3_lookup_async(nfs->rpc, nfs_opendir3_cb, &args, rdpe_lookup_cb_data) != 0) {
- rpc_set_error(nfs->rpc, "RPC error: Failed to send READDIR LOOKUP call");
-
- /* if we have already commands in flight, we cant just stop, we have to wait for the
- * commands in flight to complete
- */
- if (rdpe_cb_data->getattrcount > 0) {
- rdpe_cb_data->status = RPC_STATUS_ERROR;
+ if (nfsdir->entries) {
+ rdpe_cb_data = malloc(sizeof(struct rdpe_cb_data));
+ rdpe_cb_data->getattrcount = 0;
+ rdpe_cb_data->status = RPC_STATUS_SUCCESS;
+ rdpe_cb_data->data = data;
+ for (nfsdirent = nfsdir->entries; nfsdirent; nfsdirent = nfsdirent->next) {
+ struct rdpe_lookup_cb_data *rdpe_lookup_cb_data;
+ LOOKUP3args args;
+
+ rdpe_lookup_cb_data = malloc(sizeof(struct rdpe_lookup_cb_data));
+ rdpe_lookup_cb_data->rdpe_cb_data = rdpe_cb_data;
+ rdpe_lookup_cb_data->nfsdirent = nfsdirent;
+
+ memset(&args, 0, sizeof(LOOKUP3args));
+ args.what.dir = data->fh;
+ args.what.name = nfsdirent->name;
+
+ if (rpc_nfs3_lookup_async(nfs->rpc, nfs_opendir3_cb, &args, rdpe_lookup_cb_data) != 0) {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send READDIR LOOKUP call");
+
+ /* if we have already commands in flight, we cant just stop, we have to wait for the
+ * commands in flight to complete
+ */
+ if (rdpe_cb_data->getattrcount > 0) {
+ nfs_free_nfsdir(nfsdir);
+ data->continue_data = NULL;
+ free_nfs_cb_data(data);
+ rdpe_cb_data->status = RPC_STATUS_ERROR;
+ free(rdpe_lookup_cb_data);
+ return;
+ }
+
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ nfs_free_nfsdir(nfsdir);
+ data->continue_data = NULL;
+ free_nfs_cb_data(data);
free(rdpe_lookup_cb_data);
+ free(rdpe_cb_data);
return;
}
-
- data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
- nfs_free_nfsdir(nfsdir);
- data->continue_data = NULL;
- free_nfs_cb_data(data);
- free(rdpe_lookup_cb_data);
- free(rdpe_cb_data);
- return;
+ rdpe_cb_data->getattrcount++;
}
- rdpe_cb_data->getattrcount++;
}
}
-
static void nfs_opendir_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
{
READDIRPLUS3res *res = command_data;
struct nfs_context *nfs = data->nfs;
struct nfsdir *nfsdir = data->continue_data;
struct entryplus3 *entry;
- uint64_t cookie;
-
+ uint64_t cookie = 0;
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (status == RPC_STATUS_ERROR || (status == RPC_STATUS_SUCCESS && res->status == NFS3ERR_NOTSUPP) ){
nfsdirent->name = strdup(entry->name);
if (nfsdirent->name == NULL) {
data->cb(-ENOMEM, nfs, "Failed to allocate dirent->name", data->private_data);
+ free(nfsdirent);
nfs_free_nfsdir(nfsdir);
data->continue_data = NULL;
free_nfs_cb_data(data);
nfsdirent->atime.tv_sec = entry->name_attributes.post_op_attr_u.attributes.atime.seconds;
nfsdirent->atime.tv_usec = entry->name_attributes.post_op_attr_u.attributes.atime.nseconds/1000;
+ nfsdirent->atime_nsec = entry->name_attributes.post_op_attr_u.attributes.atime.nseconds;
nfsdirent->mtime.tv_sec = entry->name_attributes.post_op_attr_u.attributes.mtime.seconds;
nfsdirent->mtime.tv_usec = entry->name_attributes.post_op_attr_u.attributes.mtime.nseconds/1000;
+ nfsdirent->mtime_nsec = entry->name_attributes.post_op_attr_u.attributes.mtime.nseconds;
nfsdirent->ctime.tv_sec = entry->name_attributes.post_op_attr_u.attributes.ctime.seconds;
nfsdirent->ctime.tv_usec = entry->name_attributes.post_op_attr_u.attributes.ctime.nseconds/1000;
+ nfsdirent->ctime_nsec = entry->name_attributes.post_op_attr_u.attributes.ctime.nseconds;
+ nfsdirent->uid = entry->name_attributes.post_op_attr_u.attributes.uid;
+ nfsdirent->gid = entry->name_attributes.post_op_attr_u.attributes.gid;
+ nfsdirent->nlink = entry->name_attributes.post_op_attr_u.attributes.nlink;
+ nfsdirent->dev = entry->name_attributes.post_op_attr_u.attributes.fsid;
+ nfsdirent->rdev = specdata3_to_rdev(&entry->name_attributes.post_op_attr_u.attributes.rdev);
+ nfsdirent->blksize = NFS_BLKSIZE;
+ nfsdirent->blocks = (entry->name_attributes.post_op_attr_u.attributes.used + 512 - 1) / 512;
+ nfsdirent->used = entry->name_attributes.post_op_attr_u.attributes.used;
}
nfsdirent->next = nfsdir->entries;
return;
}
+ if (res->READDIRPLUS3res_u.resok.dir_attributes.attributes_follow)
+ nfsdir->attr = res->READDIRPLUS3res_u.resok.dir_attributes.post_op_attr_u.attributes;
+
/* steal the dirhandle */
data->continue_data = NULL;
nfsdir->current = nfsdir->entries;
free_nfs_cb_data(data);
}
-static int nfs_opendir_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_opendir_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
READDIRPLUS3args args;
+ struct nfsdir *nfsdir = data->continue_data;;
+ struct nfsdir *cached;
+
+ cached = nfs_dircache_find(nfs, &data->fh);
+ if (cached) {
+ if (attr && attr->mtime.seconds == cached->attr.mtime.seconds) {
+ cached->current = cached->entries;
+ data->cb(0, nfs, cached, data->private_data);
+ free_nfs_cb_data(data);
+ return 0;
+ } else {
+ /* cache must be stale */
+ nfs_free_nfsdir(cached);
+ }
+ }
+
+ nfsdir->fh.data.data_len = data->fh.data.data_len;
+ nfsdir->fh.data.data_val = malloc(nfsdir->fh.data.data_len);
+ if (nfsdir->fh.data.data_val == NULL) {
+ rpc_set_error(nfs->rpc, "OOM when allocating fh for nfsdir");
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ memcpy(nfsdir->fh.data.data_val, data->fh.data.data_val, data->fh.data.data_len);
args.dir = data->fh;
args.cookie = 0;
}
memset(nfsdir, 0, sizeof(struct nfsdir));
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_opendir_continue_internal, nfsdir, free, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_opendir_continue_internal, nfsdir, free, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
}
-void nfs_closedir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir)
+/*
+ * closedir()
+ */
+void nfs_closedir(struct nfs_context *nfs, struct nfsdir *nfsdir)
{
- nfs_free_nfsdir(nfsdir);
+ nfs_dircache_add(nfs, nfsdir);
}
-
-
-
+/*
+ * getcwd()
+ */
+void nfs_getcwd(struct nfs_context *nfs, const char **cwd)
+{
+ if (cwd) {
+ *cwd = nfs->cwd;
+ }
+}
/*
struct lseek_cb_data {
struct nfs_context *nfs;
struct nfsfh *nfsfh;
- uint64_t offset;
+ int64_t offset;
nfs_cb cb;
void *private_data;
};
GETATTR3res *res;
struct lseek_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
+ uint64_t size = 0;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
return;
}
- data->nfsfh->offset = data->offset + res->GETATTR3res_u.resok.obj_attributes.size;
- data->cb(0, nfs, &data->nfsfh->offset, data->private_data);
+ size = res->GETATTR3res_u.resok.obj_attributes.size;
+
+ if (data->offset < 0 &&
+ (uint64_t)(-data->offset) > size) {
+ data->cb(-EINVAL, nfs, &data->nfsfh->offset, data->private_data);
+ } else {
+ data->nfsfh->offset = data->offset + size;
+ data->cb(0, nfs, &data->nfsfh->offset, data->private_data);
+ }
+
free(data);
}
-int nfs_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, int whence, nfs_cb cb, void *private_data)
+int nfs_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int64_t offset, int whence, nfs_cb cb, void *private_data)
{
struct lseek_cb_data *data;
struct GETATTR3args args;
if (whence == SEEK_SET) {
- nfsfh->offset = offset;
- cb(0, nfs, &nfsfh->offset, private_data);
+ if (offset < 0) {
+ cb(-EINVAL, nfs, &nfsfh->offset, private_data);
+ } else {
+ nfsfh->offset = offset;
+ cb(0, nfs, &nfsfh->offset, private_data);
+ }
return 0;
}
if (whence == SEEK_CUR) {
- nfsfh->offset += offset;
- cb(0, nfs, &nfsfh->offset, private_data);
+ if (offset < 0 &&
+ nfsfh->offset < (uint64_t)(-offset)) {
+ cb(-EINVAL, nfs, &nfsfh->offset, private_data);
+ } else {
+ nfsfh->offset += offset;
+ cb(0, nfs, &nfsfh->offset, private_data);
+ }
return 0;
}
return;
}
- svfs.f_bsize = 4096;
- svfs.f_frsize = 4096;
- svfs.f_blocks = res->FSSTAT3res_u.resok.tbytes/4096;
- svfs.f_bfree = res->FSSTAT3res_u.resok.fbytes/4096;
- svfs.f_bavail = res->FSSTAT3res_u.resok.abytes/4096;
+ svfs.f_bsize = NFS_BLKSIZE;
+ svfs.f_frsize = NFS_BLKSIZE;
+ svfs.f_blocks = res->FSSTAT3res_u.resok.tbytes/NFS_BLKSIZE;
+ svfs.f_bfree = res->FSSTAT3res_u.resok.fbytes/NFS_BLKSIZE;
+ svfs.f_bavail = res->FSSTAT3res_u.resok.abytes/NFS_BLKSIZE;
svfs.f_files = res->FSSTAT3res_u.resok.tfiles;
svfs.f_ffree = res->FSSTAT3res_u.resok.ffiles;
#if !defined(ANDROID)
free_nfs_cb_data(data);
}
-static int nfs_statvfs_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_statvfs_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
FSSTAT3args args;
int nfs_statvfs_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
{
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_statvfs_continue_internal, NULL, NULL, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_statvfs_continue_internal, NULL, NULL, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
return;
}
-
+
data->cb(0, nfs, res->READLINK3res_u.resok.data, data->private_data);
free_nfs_cb_data(data);
}
-static int nfs_readlink_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_readlink_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
READLINK3args args;
int nfs_readlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
{
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_readlink_continue_internal, NULL, NULL, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 1, cb, private_data, nfs_readlink_continue_internal, NULL, NULL, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
free_nfs_cb_data(data);
}
-static int nfs_chmod_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_chmod_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
SETATTR3args args;
int nfs_chmod_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
{
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_chmod_continue_internal, NULL, NULL, mode) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_chmod_continue_internal, NULL, NULL, mode) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
}
memcpy(data->fh.data.data_val, nfsfh->fh.data.data_val, data->fh.data.data_len);
- if (nfs_chmod_continue_internal(nfs, data) != 0) {
- free_nfs_cb_data(data);
+ if (nfs_chmod_continue_internal(nfs, NULL, data) != 0) {
return -1;
}
gid_t gid;
};
-static int nfs_chown_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_chown_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
SETATTR3args args;
struct nfs_chown_data *chown_data = data->continue_data;
}
-int nfs_chown_async(struct nfs_context *nfs, const char *path, int uid, int gid, nfs_cb cb, void *private_data)
+int nfs_chown_async_internal(struct nfs_context *nfs, const char *path, int no_follow, int uid, int gid, nfs_cb cb, void *private_data)
{
struct nfs_chown_data *chown_data;
chown_data->uid = uid;
chown_data->gid = gid;
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_chown_continue_internal, chown_data, free, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, path, no_follow, cb, private_data, nfs_chown_continue_internal, chown_data, free, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
return 0;
}
+int nfs_chown_async(struct nfs_context *nfs, const char *path, int uid, int gid, nfs_cb cb, void *private_data)
+{
+ return nfs_chown_async_internal(nfs, path, 0, uid, gid, cb, private_data);
+}
+
+int nfs_lchown_async(struct nfs_context *nfs, const char *path, int uid, int gid, nfs_cb cb, void *private_data)
+{
+ return nfs_chown_async_internal(nfs, path, 1, uid, gid, cb, private_data);
+}
/*
* Async fchown()
chown_data->uid = uid;
chown_data->gid = gid;
-
data = malloc(sizeof(struct nfs_cb_data));
if (data == NULL) {
rpc_set_error(nfs->rpc, "out of memory. failed to allocate memory for fchown data");
+ free(chown_data);
return -1;
}
memset(data, 0, sizeof(struct nfs_cb_data));
data->cb = cb;
data->private_data = private_data;
data->continue_data = chown_data;
+ data->free_continue_data = free;
data->fh.data.data_len = nfsfh->fh.data.data_len;
data->fh.data.data_val = malloc(data->fh.data.data_len);
if (data->fh.data.data_val == NULL) {
}
memcpy(data->fh.data.data_val, nfsfh->fh.data.data_val, data->fh.data.data_len);
-
- if (nfs_chown_continue_internal(nfs, data) != 0) {
- free_nfs_cb_data(data);
+ if (nfs_chown_continue_internal(nfs, NULL, data) != 0) {
return -1;
}
free_nfs_cb_data(data);
}
-static int nfs_utimes_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_utimes_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
SETATTR3args args;
struct timeval *utimes_data = data->continue_data;
return 0;
}
-
-int nfs_utimes_async(struct nfs_context *nfs, const char *path, struct timeval *times, nfs_cb cb, void *private_data)
+int nfs_utimes_async_internal(struct nfs_context *nfs, const char *path, int no_follow, struct timeval *times, nfs_cb cb, void *private_data)
{
struct timeval *new_times = NULL;
memcpy(new_times, times, sizeof(struct timeval)*2);
}
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_utimes_continue_internal, new_times, free, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, path, no_follow, cb, private_data, nfs_utimes_continue_internal, new_times, free, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
return 0;
}
+int nfs_utimes_async(struct nfs_context *nfs, const char *path, struct timeval *times, nfs_cb cb, void *private_data)
+{
+ return nfs_utimes_async_internal(nfs, path, 0, times, cb, private_data);
+}
+
+int nfs_lutimes_async(struct nfs_context *nfs, const char *path, struct timeval *times, nfs_cb cb, void *private_data)
+{
+ return nfs_utimes_async_internal(nfs, path, 1, times, cb, private_data);
+}
+
/*
* Async utime()
*/
new_times[1].tv_usec = 0;
}
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_utimes_continue_internal, new_times, free, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_utimes_continue_internal, new_times, free, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
free_nfs_cb_data(data);
}
-static int nfs_access_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_access_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
int nfsmode = 0;
ACCESS3args args;
int nfs_access_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
{
- if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_access_continue_internal, NULL, NULL, mode) != 0) {
+ if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_access_continue_internal, NULL, NULL, mode) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
struct nfs_symlink_data *symlink_data = data->continue_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (status == RPC_STATUS_ERROR) {
free_nfs_cb_data(data);
}
-static int nfs_symlink_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_symlink_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
struct nfs_symlink_data *symlink_data = data->continue_data;
SYMLINK3args args;
return -1;
}
- if (nfs_lookuppath_async(nfs, symlink_data->newpathparent, cb, private_data, nfs_symlink_continue_internal, symlink_data, free_nfs_symlink_data, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, symlink_data->newpathparent, 0, cb, private_data, nfs_symlink_continue_internal, symlink_data, free_nfs_symlink_data, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
struct nfs_rename_data *rename_data = data->continue_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (status == RPC_STATUS_ERROR) {
free_nfs_cb_data(data);
}
-static int nfs_rename_continue_2_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_rename_continue_2_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
struct nfs_rename_data *rename_data = data->continue_data;
RENAME3args args;
}
-static int nfs_rename_continue_1_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_rename_continue_1_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
struct nfs_rename_data *rename_data = data->continue_data;
+ char* newpath = strdup(rename_data->newpath);
+ if (!newpath) {
+ rpc_set_error(nfs->rpc, "Out of memory. Could not allocate memory to store target path for rename");
+ data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
+ free_nfs_cb_data(data);
+ return -1;
+ }
/* steal the filehandle */
rename_data->olddir = data->fh;
data->fh.data.data_val = NULL;
- if (nfs_lookuppath_async(nfs, rename_data->newpath, data->cb, data->private_data, nfs_rename_continue_2_internal, rename_data, free_nfs_rename_data, 0) != 0) {
- rpc_set_error(nfs->rpc, "RPC error: Failed to send LOOKUP call for %s", rename_data->newpath);
+ if (nfs_lookuppath_async(nfs, rename_data->newpath, 0, data->cb, data->private_data, nfs_rename_continue_2_internal, rename_data, free_nfs_rename_data, 0) != 0) {
+ rpc_set_error(nfs->rpc, "RPC error: Failed to send LOOKUP call for %s", newpath);
data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
free_nfs_cb_data(data);
+ free(newpath);
return -1;
}
data->continue_data = NULL;
free_nfs_cb_data(data);
+ free(newpath);
return 0;
}
rename_data->newobject = ptr;
- if (nfs_lookuppath_async(nfs, rename_data->oldpath, cb, private_data, nfs_rename_continue_1_internal, rename_data, free_nfs_rename_data, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, rename_data->oldpath, 0, cb, private_data, nfs_rename_continue_1_internal, rename_data, free_nfs_rename_data, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
struct nfs_link_data *link_data = data->continue_data;
-
+
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (status == RPC_STATUS_ERROR) {
free_nfs_cb_data(data);
}
-static int nfs_link_continue_2_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_link_continue_2_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
struct nfs_link_data *link_data = data->continue_data;
LINK3args args;
}
-static int nfs_link_continue_1_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
+static int nfs_link_continue_1_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
{
struct nfs_link_data *link_data = data->continue_data;
link_data->oldfh = data->fh;
data->fh.data.data_val = NULL;
- if (nfs_lookuppath_async(nfs, link_data->newpath, data->cb, data->private_data, nfs_link_continue_2_internal, link_data, free_nfs_link_data, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, link_data->newpath, 0, data->cb, data->private_data, nfs_link_continue_2_internal, link_data, free_nfs_link_data, 0) != 0) {
rpc_set_error(nfs->rpc, "RPC error: Failed to send LOOKUP call for %s", link_data->newpath);
data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
free_nfs_cb_data(data);
link_data->newobject = ptr;
- if (nfs_lookuppath_async(nfs, link_data->oldpath, cb, private_data, nfs_link_continue_1_internal, link_data, free_nfs_link_data, 0) != 0) {
+ if (nfs_lookuppath_async(nfs, link_data->oldpath, 0, cb, private_data, nfs_link_continue_1_internal, link_data, free_nfs_link_data, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
return nfs->writemax;
}
+void nfs_set_tcp_syncnt(struct nfs_context *nfs, int v) {
+ rpc_set_tcp_syncnt(nfs->rpc, v);
+}
+
+void nfs_set_uid(struct nfs_context *nfs, int uid) {
+ rpc_set_uid(nfs->rpc, uid);
+}
+
+void nfs_set_gid(struct nfs_context *nfs, int gid) {
+ rpc_set_gid(nfs->rpc, gid);
+}
+
+void nfs_set_readahead(struct nfs_context *nfs, uint32_t v) {
+ rpc_set_readahead(nfs->rpc, v);
+}
+
void nfs_set_error(struct nfs_context *nfs, char *error_string, ...)
{
va_list ap;
free(nfs->rpc->error_string);
}
nfs->rpc->error_string = str;
- va_end(ap);
+ va_end(ap);
}
/* Dont want any more callbacks even if the socket is closed */
rpc->connect_cb = NULL;
- if (status == RPC_STATUS_ERROR) {
- data->cb(rpc, -EFAULT, command_data, data->private_data);
- free_mount_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
- free_mount_cb_data(data);
- return;
- }
-
- if (rpc_mount3_export_async(rpc, mount_export_5_cb, data) != 0) {
- data->cb(rpc, -ENOMEM, command_data, data->private_data);
- free_mount_cb_data(data);
- return;
- }
-}
-
-static void mount_export_3_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct mount_cb_data *data = private_data;
- uint32_t mount_port;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(rpc, -EFAULT, command_data, data->private_data);
- free_mount_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
- free_mount_cb_data(data);
- return;
- }
-
- mount_port = *(uint32_t *)command_data;
- if (mount_port == 0) {
- rpc_set_error(rpc, "RPC error. Mount program is not available");
- data->cb(rpc, -ENOENT, command_data, data->private_data);
- free_mount_cb_data(data);
- return;
- }
-
- rpc_disconnect(rpc, "normal disconnect");
- if (rpc_connect_async(rpc, data->server, mount_port, mount_export_4_cb, data) != 0) {
- data->cb(rpc, -ENOMEM, command_data, data->private_data);
- free_mount_cb_data(data);
- return;
- }
-}
-
-static void mount_export_2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct mount_cb_data *data = private_data;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- if (status == RPC_STATUS_ERROR) {
- data->cb(rpc, -EFAULT, command_data, data->private_data);
- free_mount_cb_data(data);
- return;
- }
- if (status == RPC_STATUS_CANCEL) {
- data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
- free_mount_cb_data(data);
- return;
- }
-
- if (rpc_pmap_getport_async(rpc, MOUNT_PROGRAM, MOUNT_V3, IPPROTO_TCP, mount_export_3_cb, private_data) != 0) {
- data->cb(rpc, -ENOMEM, command_data, data->private_data);
- free_mount_cb_data(data);
- return;
- }
-}
-
-static void mount_export_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
-{
- struct mount_cb_data *data = private_data;
-
- assert(rpc->magic == RPC_CONTEXT_MAGIC);
-
- /* Dont want any more callbacks even if the socket is closed */
- rpc->connect_cb = NULL;
-
if (status == RPC_STATUS_ERROR) {
data->cb(rpc, -EFAULT, command_data, data->private_data);
free_mount_cb_data(data);
return;
}
- if (rpc_pmap_null_async(rpc, mount_export_2_cb, data) != 0) {
+ if (rpc_mount3_export_async(rpc, mount_export_5_cb, data) != 0) {
data->cb(rpc, -ENOMEM, command_data, data->private_data);
free_mount_cb_data(data);
return;
if (data->server == NULL) {
free_mount_cb_data(data);
return -1;
- }
- if (rpc_connect_async(rpc, data->server, 111, mount_export_1_cb, data) != 0) {
+ }
+ if (rpc_connect_program_async(rpc, data->server, MOUNT_PROGRAM, MOUNT_V3, mount_export_4_cb, data) != 0) {
+ rpc_set_error(rpc, "Failed to start connection");
free_mount_cb_data(data);
return -1;
}
repositories / deb_libnfs.git / blobdiff