Net-LibNFS
view release on metacpan or search on metacpan
libnfs/lib/nfs_v4.c view on Meta::CPAN
cargs->objtype.createtype4_u.devdata.specdata2 = minor(dev);
break;
default:
;
}
return 1;
}
static int
nfs4_op_commit(struct nfs_context *nfs, nfs_argop4 *op)
{
COMMIT4args *coargs;
op[0].argop = OP_COMMIT;
coargs = &op[0].nfs_argop4_u.opcommit;
coargs->offset = 0;
coargs->count = 0;
return 1;
}
static int
nfs4_op_close(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh)
{
CLOSE4args *clargs;
int i = 0;
if (fh->is_dirty) {
i += nfs4_op_commit(nfs, &op[i]);
}
op[i].argop = OP_CLOSE;
clargs = &op[i++].nfs_argop4_u.opclose;
clargs->seqid = fh->open_seqid;
clargs->open_stateid.seqid = fh->stateid.seqid;
memcpy(clargs->open_stateid.other, fh->stateid.other, 12);
return i;
}
static int
nfs4_op_access(struct nfs_context *nfs, nfs_argop4 *op, uint32_t access_mask)
{
ACCESS4args *aargs;
op[0].argop = OP_ACCESS;
aargs = &op[0].nfs_argop4_u.opaccess;
memset(aargs, 0, sizeof(*aargs));
aargs->access = access_mask;
return 1;
}
static int
nfs4_op_setclientid(struct nfs_context *nfs, nfs_argop4 *op, verifier4 verifier,
const char *client_name)
{
SETCLIENTID4args *scidargs;
op[0].argop = OP_SETCLIENTID;
scidargs = &op[0].nfs_argop4_u.opsetclientid;
memcpy(scidargs->client.verifier, verifier, sizeof(verifier4));
scidargs->client.id.id_len = strlen(client_name);
scidargs->client.id.id_val = discard_const(client_name);
/* TODO: Decide what we should do here. As long as we only
* expose a single FD to the application we will not be able to
* do NFSv4 callbacks easily.
* Just give it garbage for now until we figure out how we should
* solve this. Until then we will just have to avoid doing things
* that require a callback.
* ( Clients (i.e. Linux) ignore this anyway and just call back to
* the originating address and program anyway. )
*/
scidargs->callback.cb_program = 0; /* NFS4_CALLBACK */
scidargs->callback.cb_location.r_netid = "tcp";
scidargs->callback.cb_location.r_addr = "0.0.0.0.0.0";
scidargs->callback_ident = 0x00000001;
return 1;
}
static int
nfs4_op_open_confirm(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh)
{
OPEN_CONFIRM4args *ocargs;
op[0].argop = OP_OPEN_CONFIRM;
ocargs = &op[0].nfs_argop4_u.opopen_confirm;
ocargs->open_stateid.seqid = fh->stateid.seqid;
memcpy(&ocargs->open_stateid.other, fh->stateid.other, 12);
ocargs->seqid = fh->open_seqid;
return 1;
}
static int
nfs4_op_truncate(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh,
void *sabuf)
{
SETATTR4args *saargs;
static uint32_t mask[2] = {1 << (FATTR4_SIZE),
1 << (FATTR4_TIME_MODIFY_SET - 32)};
op[0].argop = OP_SETATTR;
saargs = &op[0].nfs_argop4_u.opsetattr;
saargs->stateid.seqid = fh->stateid.seqid;
memcpy(saargs->stateid.other, fh->stateid.other, 12);
saargs->obj_attributes.attrmask.bitmap4_len = 2;
saargs->obj_attributes.attrmask.bitmap4_val = mask;
saargs->obj_attributes.attr_vals.attrlist4_len = 12;
saargs->obj_attributes.attr_vals.attrlist4_val = sabuf;
return 1;
}
static int
nfs4_op_chmod(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh,
void *sabuf)
{
SETATTR4args *saargs;
static uint32_t mask[2] = {0,
1 << (FATTR4_MODE - 32)};
op[0].argop = OP_SETATTR;
saargs = &op[0].nfs_argop4_u.opsetattr;
if (fh) {
saargs->stateid.seqid = fh->stateid.seqid;
memcpy(saargs->stateid.other, fh->stateid.other, 12);
}
saargs->obj_attributes.attrmask.bitmap4_len = 2;
saargs->obj_attributes.attrmask.bitmap4_val = mask;
saargs->obj_attributes.attr_vals.attrlist4_len = 4;
saargs->obj_attributes.attr_vals.attrlist4_val = sabuf;
return 1;
}
static int
nfs4_op_chown(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh,
void *sabuf, int len)
{
SETATTR4args *saargs;
static uint32_t mask[2] = {0,
1 << (FATTR4_OWNER - 32) |
1 << (FATTR4_OWNER_GROUP - 32)};
op[0].argop = OP_SETATTR;
saargs = &op[0].nfs_argop4_u.opsetattr;
if (fh) {
saargs->stateid.seqid = fh->stateid.seqid;
memcpy(saargs->stateid.other, fh->stateid.other, 12);
}
saargs->obj_attributes.attrmask.bitmap4_len = 2;
saargs->obj_attributes.attrmask.bitmap4_val = mask;
saargs->obj_attributes.attr_vals.attrlist4_len = len;
saargs->obj_attributes.attr_vals.attrlist4_val = sabuf;
return 1;
}
static int
nfs4_op_utimes(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh,
void *sabuf, int len)
{
SETATTR4args *saargs;
static uint32_t mask[2] = {0,
1 << (FATTR4_TIME_ACCESS_SET - 32) |
1 << (FATTR4_TIME_MODIFY_SET - 32)};
op[0].argop = OP_SETATTR;
saargs = &op[0].nfs_argop4_u.opsetattr;
if (fh) {
saargs->stateid.seqid = fh->stateid.seqid;
memcpy(saargs->stateid.other, fh->stateid.other, 12);
}
saargs->obj_attributes.attrmask.bitmap4_len = 2;
saargs->obj_attributes.attrmask.bitmap4_val = mask;
saargs->obj_attributes.attr_vals.attrlist4_len = len;
saargs->obj_attributes.attr_vals.attrlist4_val = sabuf;
return 1;
}
static int
nfs4_op_readdir(struct nfs_context *nfs, nfs_argop4 *op, uint64_t cookie)
{
READDIR4args *rdargs;
op[0].argop = OP_READDIR;
rdargs = &op[0].nfs_argop4_u.opreaddir;
memset(rdargs, 0, sizeof(*rdargs));
rdargs->cookie = cookie;
rdargs->dircount = nfs->nfsi->readdir_dircount;
rdargs->maxcount = nfs->nfsi->readdir_maxcount;
rdargs->attr_request.bitmap4_len = 2;
rdargs->attr_request.bitmap4_val = standard_attributes;
return 1;
}
static int
nfs4_op_rename(struct nfs_context *nfs, nfs_argop4 *op, const char *oldname,
const char *newname)
{
RENAME4args *rargs;
op[0].argop = OP_RENAME;
rargs = &op[0].nfs_argop4_u.oprename;
memset(rargs, 0, sizeof(*rargs));
rargs->oldname.utf8string_len = strlen(oldname);
rargs->oldname.utf8string_val = discard_const(oldname);
rargs->newname.utf8string_len = strlen(newname);
rargs->newname.utf8string_val = discard_const(newname);
return 1;
}
static int
nfs4_op_read(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh,
uint64_t offset, size_t count)
{
READ4args *rargs;
op[0].argop = OP_READ;
rargs = &op[0].nfs_argop4_u.opread;
rargs->stateid.seqid = fh->stateid.seqid;
memcpy(rargs->stateid.other, fh->stateid.other, 12);
rargs->offset = offset;
libnfs/lib/nfs_v4.c view on Meta::CPAN
static int
nfs4_op_locku(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh,
nfs_lock_type4 locktype, uint64_t offset, length4 length)
{
LOCKU4args *luargs;
op[0].argop = OP_LOCKU;
luargs = &op[0].nfs_argop4_u.oplocku;
luargs->locktype = locktype;
luargs->offset = offset;
luargs->length = length;
luargs->seqid = fh->lock_seqid;
luargs->lock_stateid.seqid = fh->lock_stateid.seqid;
memcpy(luargs->lock_stateid.other, fh->lock_stateid.other, 12);
fh->lock_seqid++;
return 1;
}
static int
nfs4_op_lockt(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh,
nfs_lock_type4 locktype, uint64_t offset, length4 length)
{
LOCKT4args *ltargs;
op[0].argop = OP_LOCKT;
ltargs = &op[0].nfs_argop4_u.oplockt;
ltargs->locktype = locktype;
ltargs->offset = offset;
ltargs->length = length;
ltargs->owner.clientid = nfs->nfsi->clientid;
ltargs->owner.owner.owner_len = strlen(nfs->nfsi->client_name);
ltargs->owner.owner.owner_val = nfs->nfsi->client_name;
return 1;
}
static int
nfs4_op_lookup(struct nfs_context *nfs, nfs_argop4 *op, const char *path)
{
LOOKUP4args *largs;
op[0].argop = OP_LOOKUP;
largs = &op[0].nfs_argop4_u.oplookup;
largs->objname.utf8string_len = strlen(path);
largs->objname.utf8string_val = discard_const(path);
return 1;
}
static int
nfs4_op_setclientid_confirm(struct nfs_context *nfs, struct nfs_argop4 *op,
uint64_t clientid, verifier4 verifier)
{
SETCLIENTID_CONFIRM4args *scidcargs;
op[0].argop = OP_SETCLIENTID_CONFIRM;
scidcargs = &op[0].nfs_argop4_u.opsetclientid_confirm;
scidcargs->clientid = clientid;
memcpy(scidcargs->setclientid_confirm, verifier, NFS4_VERIFIER_SIZE);
return 1;
}
static int
nfs4_op_putrootfh(struct nfs_context *nfs, nfs_argop4 *op)
{
op[0].argop = OP_PUTROOTFH;
return 1;
}
static int
nfs4_op_readlink(struct nfs_context *nfs, nfs_argop4 *op)
{
op[0].argop = OP_READLINK;
return 1;
}
static int
nfs4_op_remove(struct nfs_context *nfs, nfs_argop4 *op, const char *name)
{
REMOVE4args *rmargs;
op[0].argop = OP_REMOVE;
rmargs = &op[0].nfs_argop4_u.opremove;
memset(rmargs, 0, sizeof(*rmargs));
rmargs->target.utf8string_len = strlen(name);
rmargs->target.utf8string_val = discard_const(name);
return 1;
}
static int
nfs4_op_getattr(struct nfs_context *nfs, nfs_argop4 *op,
uint32_t *attributes, int count)
{
GETATTR4args *gaargs;
op[0].argop = OP_GETATTR;
gaargs = &op[0].nfs_argop4_u.opgetattr;
memset(gaargs, 0, sizeof(*gaargs));
gaargs->attr_request.bitmap4_val = attributes;
gaargs->attr_request.bitmap4_len = count;
return 1;
}
/*
* Allocate op and populate the path components.
* Will mutate path.
*
* Returns:
* -1 : On error.
* <idx> : On success. Idx represents the next free index in op.
* Caller must free op.
libnfs/lib/nfs_v4.c view on Meta::CPAN
gfhresok->object.nfs_fh4_val,
nfs->nfsi->rootfh.len);
data->cb(0, nfs, NULL, data->private_data);
free_nfs4_cb_data(data);
}
static void
nfs4_mount_3_cb(struct rpc_context *rpc, int status, void *command_data,
void *private_data)
{
struct nfs4_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
COMPOUND4res *res = command_data;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (check_nfs4_error(nfs, status, data, res, "SETCLIENTID_CONFIRM")) {
return;
}
data->filler.func = nfs4_populate_getfh;
data->filler.max_op = 1;
data->filler.data = malloc(2 * sizeof(uint32_t));
if (data->filler.data == NULL) {
nfs_set_error(nfs, "Out of memory. Failed to allocate "
"data structure.");
data->cb(-ENOMEM, nfs, res, data->private_data);
free_nfs4_cb_data(data);
return;
}
memset(data->filler.data, 0, 2 * sizeof(uint32_t));
if (nfs4_lookup_path_async(nfs, data, nfs4_mount_4_cb) < 0) {
data->cb(-ENOMEM, nfs, res, data->private_data);
free_nfs4_cb_data(data);
return;
}
}
static void
nfs4_mount_2_cb(struct rpc_context *rpc, int status, void *command_data,
void *private_data)
{
struct nfs4_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
COMPOUND4res *res = command_data;
COMPOUND4args args;
nfs_argop4 op[1];
SETCLIENTID4resok *scidresok;
int i;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (check_nfs4_error(nfs, status, data, res, "SETCLIENTID")) {
return;
}
scidresok = &res->resarray.resarray_val[0].nfs_resop4_u.opsetclientid.SETCLIENTID4res_u.resok4;
nfs->nfsi->clientid = scidresok->clientid;
memcpy(nfs->nfsi->setclientid_confirm,
scidresok->setclientid_confirm,
NFS4_VERIFIER_SIZE);
memset(op, 0, sizeof(op));
i = nfs4_op_setclientid_confirm(nfs, &op[0], nfs->nfsi->clientid,
nfs->nfsi->setclientid_confirm);
memset(&args, 0, sizeof(args));
args.argarray.argarray_len = i;
args.argarray.argarray_val = op;
if (rpc_nfs4_compound_async(rpc, nfs4_mount_3_cb, &args,
private_data) != 0) {
nfs_set_error(nfs, "Failed to queue SETCLIENTID_CONFIRM. %s",
nfs_get_error(nfs));
data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data);
free_nfs4_cb_data(data);
return;
}
}
static void
nfs4_mount_1_cb(struct rpc_context *rpc, int status, void *command_data,
void *private_data)
{
struct nfs4_cb_data *data = private_data;
struct nfs_context *nfs = data->nfs;
COMPOUND4args args;
nfs_argop4 op[1];
int i;
assert(rpc->magic == RPC_CONTEXT_MAGIC);
if (check_nfs4_error(nfs, status, data, NULL, "CONNECT")) {
return;
}
memset(op, 0, sizeof(op));
i = nfs4_op_setclientid(nfs, &op[0], nfs->nfsi->verifier, nfs->nfsi->client_name);
memset(&args, 0, sizeof(args));
args.argarray.argarray_len = i;
args.argarray.argarray_val = op;
if (rpc_nfs4_compound_async(rpc, nfs4_mount_2_cb, &args, data) != 0) {
nfs_set_error(nfs, "Failed to queue SETCLIENTID. %s",
nfs_get_error(nfs));
data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data);
free_nfs4_cb_data(data);
return;
}
}
int
nfs4_mount_async(struct nfs_context *nfs, const char *server,
const char *export, nfs_cb cb, void *private_data)
( run in 0.526 second using v1.01-cache-2.11-cpan-71847e10f99 )