int nfs4_op_link(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_link";
cache_entry_t * dir_pentry = NULL;
cache_entry_t * file_pentry = NULL;
cache_inode_status_t cache_status;
fsal_attrib_list_t attr;
fsal_name_t newname;
resp->resop = NFS4_OP_LINK;
res_LINK4.status = NFS4_OK;
/* Do basic checks on a filehandle */
res_LINK4.status = nfs4_sanity_check_FH(data, 0LL);
if(res_LINK4.status != NFS4_OK)
return res_LINK4.status;
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->savedFH)))
{
res_LINK4.status = NFS4ERR_NOFILEHANDLE;
return res_LINK4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->savedFH)))
{
res_LINK4.status = NFS4ERR_BADHANDLE;
return res_LINK4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->savedFH)))
{
res_LINK4.status = NFS4ERR_FHEXPIRED;
return res_LINK4.status;
}
/* Pseudo Fs is explictely a Read-Only File system */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
{
res_LINK4.status = NFS4ERR_ROFS;
return res_LINK4.status;
}
/* If data->exportp is null, a junction from pseudo fs was traversed, credp and exportp have to be updated */
if(data->pexport == NULL)
{
res_LINK4.status = nfs4_SetCompoundExport(data);
if(res_LINK4.status != NFS4_OK)
return res_LINK4.status;
}
/*
* This operation creates a hard link, for the file represented by the saved FH, in directory represented by currentFH under the
* name arg_LINK4.target
*/
/* Crossing device is not allowed */
if(((file_handle_v4_t *) (data->currentFH.nfs_fh4_val))->exportid !=
((file_handle_v4_t *) (data->savedFH.nfs_fh4_val))->exportid)
{
res_LINK4.status = NFS4ERR_XDEV;
return res_LINK4.status;
}
/* If name is empty, return EINVAL */
if(arg_LINK4.newname.utf8string_len == 0)
{
res_LINK4.status = NFS4ERR_INVAL;
return res_LINK4.status;
}
/* Check for name to long */
if(arg_LINK4.newname.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_LINK4.status = NFS4ERR_NAMETOOLONG;
return res_LINK4.status;
}
/* Convert the UFT8 objname to a regular string */
if((cache_status =
cache_inode_error_convert(FSAL_buffdesc2name
((fsal_buffdesc_t *) & arg_LINK4.newname,
&newname))) != CACHE_INODE_SUCCESS)
{
res_LINK4.status = nfs4_Errno(cache_status);
return res_LINK4.status;
}
/* Sanity check: never create a link named '.' or '..' */
if(!FSAL_namecmp(&newname, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&newname, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_LINK4.status = NFS4ERR_BADNAME;
return res_LINK4.status;
}
/* get info from compound data */
dir_pentry = data->current_entry;
/* Destination FH (the currentFH) must be a directory */
if(data->current_filetype != DIRECTORY)
{
res_LINK4.status = NFS4ERR_NOTDIR;
return res_LINK4.status;
}
/* Target object (the savedFH) must not be a directory */
if(data->saved_filetype == DIRECTORY)
{
res_LINK4.status = NFS4ERR_ISDIR;
return res_LINK4.status;
}
/* We have to keep track of the 'change' file attribute for reply structure */
if((cache_status = cache_inode_getattr(dir_pentry,
&attr,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_LINK4.status = nfs4_Errno(cache_status);
return res_LINK4.status;
}
res_LINK4.LINK4res_u.resok4.cinfo.before
= cache_inode_get_changeid4(dir_pentry);
/* Convert savedFH into a vnode */
file_pentry = data->saved_entry;
/* make the link */
if(cache_inode_link(file_pentry,
dir_pentry,
&newname,
&attr,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_LINK4.status = nfs4_Errno(cache_status);
return res_LINK4.status;
}
res_LINK4.LINK4res_u.resok4.cinfo.after
= cache_inode_get_changeid4(dir_pentry);
res_LINK4.LINK4res_u.resok4.cinfo.atomic = FALSE;
res_LINK4.status = NFS4_OK;
return NFS4_OK;
} /* nfs4_op_link */
int nfs4_op_link(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
LINK4args * const arg_LINK4 = &op->nfs_argop4_u.oplink;
LINK4res * const res_LINK4 = &resp->nfs_resop4_u.oplink;
cache_entry_t *dir_entry = NULL;
cache_entry_t *file_entry = NULL;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
char *newname = NULL;
resp->resop = NFS4_OP_LINK;
res_LINK4->status = NFS4_OK;
/* Do basic checks on a filehandle */
res_LINK4->status = nfs4_sanity_check_FH(data, DIRECTORY, false);
if (res_LINK4->status != NFS4_OK)
goto out;
res_LINK4->status = nfs4_sanity_check_saved_FH(data, -DIRECTORY, false);
if (res_LINK4->status != NFS4_OK)
goto out;
/*
* This operation creates a hard link, for the file
* represented by the saved FH, in directory represented by
* currentFH under the name arg_LINK4.target
*/
/* Validate and convert the UFT8 objname to a regular string */
res_LINK4->status = nfs4_utf8string2dynamic(&arg_LINK4->newname,
UTF8_SCAN_ALL,
&newname);
if (res_LINK4->status != NFS4_OK)
goto out;
/* get info from compound data */
dir_entry = data->current_entry;
res_LINK4->LINK4res_u.resok4.cinfo.before =
cache_inode_get_changeid4(dir_entry);
file_entry = data->saved_entry;
/* make the link */
cache_status =
cache_inode_link(file_entry, dir_entry, newname);
if (cache_status != CACHE_INODE_SUCCESS) {
res_LINK4->status = nfs4_Errno(cache_status);
goto out;
}
res_LINK4->LINK4res_u.resok4.cinfo.after =
cache_inode_get_changeid4(dir_entry);
res_LINK4->LINK4res_u.resok4.cinfo.atomic = FALSE;
res_LINK4->status = NFS4_OK;
out:
if (newname)
gsh_free(newname);
return res_LINK4->status;
} /* nfs4_op_link */
int nfs4_op_remove(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_remove";
cache_entry_t * parent_entry = NULL;
fsal_attrib_list_t attr_parent;
fsal_name_t name;
cache_inode_status_t cache_status;
resp->resop = NFS4_OP_REMOVE;
res_REMOVE4.status = NFS4_OK;
/*
* Do basic checks on a filehandle
* Delete arg_REMOVE4.target in directory pointed by currentFH
* Make sure the currentFH is pointed a directory
*/
res_REMOVE4.status = nfs4_sanity_check_FH(data, DIRECTORY);
if(res_REMOVE4.status != NFS4_OK)
return res_REMOVE4.status;
/* Pseudo Fs is explictely a Read-Only File system */
if(nfs4_Is_Fh_Pseudo(&(data->currentFH)))
{
res_REMOVE4.status = NFS4ERR_ROFS;
return res_REMOVE4.status;
}
if (nfs_in_grace())
{
res_REMOVE4.status = NFS4ERR_GRACE;
return res_REMOVE4.status;
}
/* If Filehandle points to a xattr object, manage it via the xattrs specific functions */
if(nfs4_Is_Fh_Xattr(&(data->currentFH)))
return nfs4_op_remove_xattr(op, data, resp);
/* Get the parent entry (aka the current one in the compound data) */
parent_entry = data->current_entry;
/* We have to keep track of the 'change' file attribute for reply structure */
memset(&(res_REMOVE4.REMOVE4res_u.resok4.cinfo.before), 0, sizeof(changeid4));
res_REMOVE4.REMOVE4res_u.resok4.cinfo.before =
cache_inode_get_changeid4(parent_entry);
/* Check for name length */
if(arg_REMOVE4.target.utf8string_len > FSAL_MAX_NAME_LEN)
{
res_REMOVE4.status = NFS4ERR_NAMETOOLONG;
return res_REMOVE4.status;
}
/* get the filename from the argument, it should not be empty */
if(arg_REMOVE4.target.utf8string_len == 0)
{
res_REMOVE4.status = NFS4ERR_INVAL;
return res_REMOVE4.status;
}
/* NFS4_OP_REMOVE can delete files as well as directory, it replaces NFS3_RMDIR and NFS3_REMOVE
* because of this, we have to know if object is a directory or not */
if((cache_status =
cache_inode_error_convert(FSAL_buffdesc2name
((fsal_buffdesc_t *) & arg_REMOVE4.target,
&name))) != CACHE_INODE_SUCCESS)
{
res_REMOVE4.status = nfs4_Errno(cache_status);
return res_REMOVE4.status;
}
/* Test RM7: remiving '.' should return NFS4ERR_BADNAME */
if(!FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&name, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_REMOVE4.status = NFS4ERR_BADNAME;
return res_REMOVE4.status;
}
if((cache_status = cache_inode_remove(parent_entry,
&name,
&attr_parent,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_REMOVE4.status = nfs4_Errno(cache_status);
return res_REMOVE4.status;
}
res_REMOVE4.REMOVE4res_u.resok4.cinfo.after
= cache_inode_get_changeid4(parent_entry);
/* Operation was not atomic .... */
res_REMOVE4.REMOVE4res_u.resok4.cinfo.atomic = FALSE;
/* If you reach this point, everything was ok */
res_REMOVE4.status = NFS4_OK;
return NFS4_OK;
} /* nfs4_op_remove */
int nfs4_op_rename(struct nfs_argop4 *op, compound_data_t * data, struct nfs_resop4 *resp)
{
char __attribute__ ((__unused__)) funcname[] = "nfs4_op_rename";
cache_entry_t * dst_entry = NULL;
cache_entry_t * src_entry = NULL;
cache_entry_t * tst_entry_dst = NULL;
cache_entry_t * tst_entry_src = NULL;
fsal_attrib_list_t attr_dst;
fsal_attrib_list_t attr_src;
fsal_attrib_list_t attr_tst_dst;
fsal_attrib_list_t attr_tst_src;
cache_inode_status_t cache_status;
fsal_status_t fsal_status;
fsal_handle_t * handlenew = NULL;
fsal_handle_t * handleold = NULL;
fsal_name_t oldname;
fsal_name_t newname;
resp->resop = NFS4_OP_RENAME;
res_RENAME4.status = NFS4_OK;
/* Do basic checks on a filehandle */
res_RENAME4.status = nfs4_sanity_check_FH(data, 0LL);
if(res_RENAME4.status != NFS4_OK)
return res_RENAME4.status;
/* Do basic checks on saved filehandle */
/* If there is no FH */
if(nfs4_Is_Fh_Empty(&(data->savedFH)))
{
res_RENAME4.status = NFS4ERR_NOFILEHANDLE;
return res_RENAME4.status;
}
/* If the filehandle is invalid */
if(nfs4_Is_Fh_Invalid(&(data->savedFH)))
{
res_RENAME4.status = NFS4ERR_BADHANDLE;
return res_RENAME4.status;
}
/* Tests if the Filehandle is expired (for volatile filehandle) */
if(nfs4_Is_Fh_Expired(&(data->savedFH)))
{
res_RENAME4.status = NFS4ERR_FHEXPIRED;
return res_RENAME4.status;
}
/* Pseudo Fs is explictely a Read-Only File system */
if(nfs4_Is_Fh_Pseudo(&(data->savedFH)))
{
res_RENAME4.status = NFS4ERR_ROFS;
return res_RENAME4.status;
}
if (nfs_in_grace())
{
res_RENAME4.status = NFS4ERR_GRACE;
return res_RENAME4.status;
}
/* get the names from the RPC input */
cache_status = utf8_to_name(&arg_RENAME4.oldname, &oldname);
if(cache_status != CACHE_INODE_SUCCESS)
{
res_RENAME4.status = nfs4_Errno(cache_status);
return res_RENAME4.status;
}
cache_status = utf8_to_name(&arg_RENAME4.newname, &newname);
if(cache_status != CACHE_INODE_SUCCESS)
{
res_RENAME4.status = nfs4_Errno(cache_status);
return res_RENAME4.status;
}
/* Sanuty check: never rename to '.' or '..' */
if(!FSAL_namecmp(&newname, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&newname, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_RENAME4.status = NFS4ERR_BADNAME;
return res_RENAME4.status;
}
/* Sanuty check: never rename to '.' or '..' */
if(!FSAL_namecmp(&oldname, (fsal_name_t *) & FSAL_DOT)
|| !FSAL_namecmp(&oldname, (fsal_name_t *) & FSAL_DOT_DOT))
{
res_RENAME4.status = NFS4ERR_BADNAME;
return res_RENAME4.status;
}
/*
* This operation renames
* - the object in directory pointed by savedFH, named arg_RENAME4.oldname
* into
* - an object in directory pointed by currentFH, named arg_RENAME4.newname
*
* Because of this, we will use 2 entry and we have verified both currentFH and savedFH */
/* No Cross Device */
if(((file_handle_v4_t *) (data->currentFH.nfs_fh4_val))->exportid !=
((file_handle_v4_t *) (data->savedFH.nfs_fh4_val))->exportid)
{
res_RENAME4.status = NFS4ERR_XDEV;
return res_RENAME4.status;
}
/* destination must be a directory */
dst_entry = data->current_entry;
if(data->current_filetype != DIRECTORY)
{
res_RENAME4.status = NFS4ERR_NOTDIR;
return res_RENAME4.status;
}
/* Convert saved FH into a vnode */
src_entry = data->saved_entry;
/* Source must be a directory */
if(data->saved_filetype != DIRECTORY)
{
res_RENAME4.status = NFS4ERR_NOTDIR;
return res_RENAME4.status;
}
/* Renaming a file to himself is allowed, returns NFS4_OK */
if(src_entry == dst_entry)
{
if(!FSAL_namecmp(&oldname, &newname))
{
res_RENAME4.status = NFS4_OK;
return res_RENAME4.status;
}
}
/* For the change_info4, get the 'change' attributes for both directories */
if((cache_status = cache_inode_getattr(src_entry,
&attr_src,
data->pcontext,
&cache_status)) != CACHE_INODE_SUCCESS)
{
res_RENAME4.status = nfs4_Errno(cache_status);
return res_RENAME4.status;
}
#ifdef BUGAZOMEU
/* Ne devrait pas se produire dans le cas de exportid differents */
/* Both object must resides on the same filesystem, return NFS4ERR_XDEV if not */
if(attr_src.va_rdev != attr_dst.va_rdev)
{
res_RENAME4.status = NFS4ERR_XDEV;
return res_RENAME4.status;
}
#endif
/* Lookup oldfile to see if it exists (refcount +1) */
if((tst_entry_src = cache_inode_lookup(src_entry,
&oldname,
&attr_tst_src,
data->pcontext,
&cache_status)) == NULL)
{
res_RENAME4.status = nfs4_Errno(cache_status);
goto release;
}
/* Lookup file with new name to see if it already exists (refcount +1),
* I expect to get NO_ERROR or ENOENT, anything else means an error */
tst_entry_dst = cache_inode_lookup(dst_entry,
&newname,
&attr_tst_dst,
data->pcontext,
&cache_status);
if((cache_status != CACHE_INODE_SUCCESS) &&
(cache_status != CACHE_INODE_NOT_FOUND))
{
/* Unexpected status at this step, exit with an error */
res_RENAME4.status = nfs4_Errno(cache_status);
goto release;
}
if(cache_status == CACHE_INODE_NOT_FOUND)
tst_entry_dst = NULL; /* Just to make sure */
/* Renaming a file to one of its own hardlink is allowed, return NFS4_OK */
if(tst_entry_src == tst_entry_dst) {
res_RENAME4.status = NFS4_OK;
goto release;
}
/* Renaming dir into existing file should return NFS4ERR_EXIST */
if ((tst_entry_src->type == DIRECTORY) &&
((tst_entry_dst != NULL) &&
(tst_entry_dst->type == REGULAR_FILE)))
{
res_RENAME4.status = NFS4ERR_EXIST;
goto release;
}
/* Renaming file into existing dir should return NFS4ERR_EXIST */
if(tst_entry_src->type == REGULAR_FILE)
{
if(tst_entry_dst != NULL)
{
if(tst_entry_dst->type == DIRECTORY)
{
res_RENAME4.status = NFS4ERR_EXIST;
goto release;
}
}
}
/* Renaming dir1 into existing, nonempty dir2 should return NFS4ERR_EXIST
* Renaming file into existing, nonempty dir should return NFS4ERR_EXIST */
if(tst_entry_dst != NULL)
{
if((tst_entry_dst->type == DIRECTORY)
&& ((tst_entry_src->type == DIRECTORY)
|| (tst_entry_src->type == REGULAR_FILE)))
{
if(cache_inode_is_dir_empty_WithLock(tst_entry_dst) ==
CACHE_INODE_DIR_NOT_EMPTY)
{
res_RENAME4.status = NFS4ERR_EXIST;
goto release;
}
}
}
res_RENAME4.RENAME4res_u.resok4.source_cinfo.before
= cache_inode_get_changeid4(src_entry);
res_RENAME4.RENAME4res_u.resok4.target_cinfo.before
= cache_inode_get_changeid4(dst_entry);
if(cache_status == CACHE_INODE_SUCCESS)
{
/* New entry already exists, its attributes are in attr_tst_*,
check for old entry to see if types are compatible */
handlenew = &tst_entry_dst->handle;
handleold = &tst_entry_src->handle;
if(!FSAL_handlecmp(handlenew, handleold, &fsal_status))
{
/* For the change_info4, get the 'change' attributes for both directories */
res_RENAME4.RENAME4res_u.resok4.source_cinfo.before
= cache_inode_get_changeid4(src_entry);
res_RENAME4.RENAME4res_u.resok4.target_cinfo.before
= cache_inode_get_changeid4(dst_entry);
res_RENAME4.RENAME4res_u.resok4.target_cinfo.atomic = FALSE;
res_RENAME4.RENAME4res_u.resok4.source_cinfo.atomic = FALSE;
res_RENAME4.status = NFS4_OK;
goto release;
}
else
{
/* Destination exists and is something different from source */
if(( tst_entry_src->type == REGULAR_FILE &&
tst_entry_dst->type == REGULAR_FILE ) ||
( tst_entry_src->type == DIRECTORY &&
tst_entry_dst->type == DIRECTORY ))
{
if(cache_inode_rename(src_entry,
&oldname,
dst_entry,
&newname,
&attr_src,
&attr_dst,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_RENAME4.status = nfs4_Errno(cache_status);
goto release;
}
}
else
{
res_RENAME4.status = NFS4ERR_EXIST;
goto release;
}
}
}
else
{
/* New entry does not already exist, call cache_entry_rename */
if(cache_inode_rename(src_entry,
&oldname,
dst_entry,
&newname,
&attr_src,
&attr_dst,
data->pcontext, &cache_status) != CACHE_INODE_SUCCESS)
{
res_RENAME4.status = nfs4_Errno(cache_status);
goto release;
}
}
/* If you reach this point, then everything was alright */
/* For the change_info4, get the 'change' attributes for both directories */
res_RENAME4.RENAME4res_u.resok4.source_cinfo.after =
cache_inode_get_changeid4(src_entry);
res_RENAME4.RENAME4res_u.resok4.target_cinfo.after =
cache_inode_get_changeid4(dst_entry);
res_RENAME4.RENAME4res_u.resok4.target_cinfo.atomic = FALSE;
res_RENAME4.RENAME4res_u.resok4.source_cinfo.atomic = FALSE;
res_RENAME4.status = nfs4_Errno(cache_status);
release:
if (tst_entry_src)
(void) cache_inode_put(tst_entry_src);
if (tst_entry_dst)
(void) cache_inode_put(tst_entry_dst);
return (res_RENAME4.status);
} /* nfs4_op_rename */
int nfs4_op_remove(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
REMOVE4args * const arg_REMOVE4 = &op->nfs_argop4_u.opremove;
REMOVE4res * const res_REMOVE4 = &resp->nfs_resop4_u.opremove;
cache_entry_t *parent_entry = NULL;
char *name = NULL;
cache_inode_status_t cache_status = CACHE_INODE_SUCCESS;
resp->resop = NFS4_OP_REMOVE;
res_REMOVE4->status = NFS4_OK;
/* Do basic checks on a filehandle
* Delete arg_REMOVE4.target in directory pointed by currentFH
* Make sure the currentFH is pointed a directory
*/
res_REMOVE4->status = nfs4_sanity_check_FH(data, DIRECTORY, false);
if (res_REMOVE4->status != NFS4_OK)
goto out;
/* Validate and convert the UFT8 target to a regular string */
res_REMOVE4->status =
nfs4_utf8string2dynamic(&arg_REMOVE4->target, UTF8_SCAN_ALL, &name);
if (res_REMOVE4->status != NFS4_OK)
goto out;
if (nfs_in_grace()) {
res_REMOVE4->status = NFS4ERR_GRACE;
goto out;
}
/* Get the parent entry (aka the current one in the compound data) */
parent_entry = data->current_entry;
/* We have to keep track of the 'change' file attribute
* for reply structure
*/
memset(&res_REMOVE4->REMOVE4res_u.resok4.cinfo.before,
0,
sizeof(changeid4));
res_REMOVE4->REMOVE4res_u.resok4.cinfo.before =
cache_inode_get_changeid4(parent_entry, data->req_ctx);
cache_status = cache_inode_remove(parent_entry, name, data->req_ctx);
if (cache_status != CACHE_INODE_SUCCESS) {
res_REMOVE4->status = nfs4_Errno(cache_status);
goto out;
}
res_REMOVE4->REMOVE4res_u.resok4.cinfo.after =
cache_inode_get_changeid4(parent_entry, data->req_ctx);
/* Operation was not atomic .... */
res_REMOVE4->REMOVE4res_u.resok4.cinfo.atomic = FALSE;
/* If you reach this point, everything was ok */
res_REMOVE4->status = NFS4_OK;
out:
if (name)
gsh_free(name);
return res_REMOVE4->status;
} /* nfs4_op_remove */
