#include <string.h>
#include <assert.h>
#include <errno.h>
+#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
struct nfs_cb_data *data = mdata->data;
struct nfs_context *nfs = data->nfs;
READ3res *res;
+ int cb_err;
+ void *cb_data;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
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);
+ cb_err = data->max_offset - data->org_offset;
+ cb_data = data->buffer + (data->org_offset - data->offset);
} else {
- data->cb(res->READ3res_u.resok.count, nfs, res->READ3res_u.resok.data.data_val, data->private_data);
+ cb_err = res->READ3res_u.resok.count;
+ cb_data = res->READ3res_u.resok.data.data_val;
}
data->nfsfh->ra.fh_offset = data->max_offset;
data->nfsfh->ra.buf_ts = time(NULL);
data->buffer = NULL;
}
+
+ data->cb(cb_err, nfs, cb_data, data->private_data);
free_nfs_cb_data(data);
}
{
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
- struct nfsfh *nfsfh;
+ struct nfsfh *nfsfh = data->nfsfh;
SETATTR3res *res;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
return;
}
- data->cb(0, nfs, data->nfsfh, data->private_data);
+ data->cb(0, nfs, nfsfh, data->private_data);
free_nfs_cb_data(data);
}
}
-int nfs_chmod_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
+int nfs_chmod_async_internal(struct nfs_context *nfs, const char *path, int no_follow, int mode, nfs_cb cb, void *private_data)
{
- if (nfs_lookuppath_async(nfs, path, 0, cb, private_data, nfs_chmod_continue_internal, NULL, NULL, mode) != 0) {
+ if (nfs_lookuppath_async(nfs, path, no_follow, 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;
}
return 0;
}
+int nfs_chmod_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
+{
+ return nfs_chmod_async_internal(nfs, path, 0, mode, cb, private_data);
+}
+
+int nfs_lchmod_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
+{
+ return nfs_chmod_async_internal(nfs, path, 1, mode, cb, private_data);
+}
+
/*
* Async fchmod()
*/
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, 0, 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()
*/
ACCESS3res *res;
struct nfs_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
- unsigned int nfsmode = 0;
+ unsigned int mode = 0;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
return;
}
- if (data->continue_int & R_OK) {
- nfsmode |= ACCESS3_READ;
+ if ((data->continue_int & R_OK) && (res->ACCESS3res_u.resok.access & ACCESS3_READ)) {
+ mode |= R_OK;
}
- if (data->continue_int & W_OK) {
- nfsmode |= ACCESS3_MODIFY;
+ if ((data->continue_int & W_OK) && (res->ACCESS3res_u.resok.access & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE))) {
+ mode |= W_OK;
}
- if (data->continue_int & X_OK) {
- nfsmode |= ACCESS3_EXECUTE;
+ if ((data->continue_int & X_OK) && (res->ACCESS3res_u.resok.access & (ACCESS3_LOOKUP | ACCESS3_EXECUTE))) {
+ mode |= X_OK;
}
- if (res->ACCESS3res_u.resok.access != nfsmode) {
+ if (data->continue_int != mode) {
rpc_set_error(nfs->rpc, "NFS: ACCESS denied. Required access %c%c%c. Allowed access %c%c%c",
- nfsmode&ACCESS3_READ?'r':'-',
- nfsmode&ACCESS3_MODIFY?'w':'-',
- nfsmode&ACCESS3_EXECUTE?'x':'-',
- res->ACCESS3res_u.resok.access&ACCESS3_READ?'r':'-',
- res->ACCESS3res_u.resok.access&ACCESS3_MODIFY?'w':'-',
- res->ACCESS3res_u.resok.access&ACCESS3_EXECUTE?'x':'-');
+ data->continue_int&R_OK?'r':'-',
+ data->continue_int&W_OK?'w':'-',
+ data->continue_int&X_OK?'x':'-',
+ mode&R_OK?'r':'-',
+ mode&W_OK?'w':'-',
+ mode&X_OK?'x':'-');
data->cb(-EACCES, nfs, rpc_get_error(nfs->rpc), data->private_data);
free_nfs_cb_data(data);
return;
nfsmode |= ACCESS3_READ;
}
if (data->continue_int & W_OK) {
- nfsmode |= ACCESS3_MODIFY;
+ nfsmode |= ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE;
}
if (data->continue_int & X_OK) {
- nfsmode |= ACCESS3_EXECUTE;
+ nfsmode |= ACCESS3_LOOKUP | ACCESS3_EXECUTE;
}
memset(&args, 0, sizeof(ACCESS3args));
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, 0, 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 & (R_OK | W_OK | X_OK)) != 0) {
+ rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+
+/*
+ * Async access2()
+ */
+static void nfs_access2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
+{
+ ACCESS3res *res;
+ struct nfs_cb_data *data = private_data;
+ struct nfs_context *nfs = data->nfs;
+ unsigned int result = 0;
+
+ 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: ACCESS 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 (res->ACCESS3res_u.resok.access & ACCESS3_READ) {
+ result |= R_OK;
+ }
+ if (res->ACCESS3res_u.resok.access & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE)) {
+ result |= W_OK;
+ }
+ if (res->ACCESS3res_u.resok.access & (ACCESS3_LOOKUP | ACCESS3_EXECUTE)) {
+ result |= X_OK;
+ }
+
+ data->cb(result, nfs, NULL, data->private_data);
+ free_nfs_cb_data(data);
+}
+
+static int nfs_access2_continue_internal(struct nfs_context *nfs, fattr3 *attr _U_, struct nfs_cb_data *data)
+{
+ ACCESS3args args;
+
+ memset(&args, 0, sizeof(ACCESS3args));
+ args.object = data->fh;
+ args.access = ACCESS3_READ | ACCESS3_LOOKUP | ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE | ACCESS3_EXECUTE;
+
+ if (rpc_nfs3_access_async(nfs->rpc, nfs_access2_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);
+ free_nfs_cb_data(data);
+ return -1;
+ }
+ return 0;
+}
+
+int nfs_access2_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_access2_continue_internal, NULL, NULL, 0) != 0) {
rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
return -1;
}
repositories / deb_libnfs.git / blobdiff