/**
* FSAL_create:
* Create a regular file.
*
* \param parent_directory_handle (input):
* Handle of the parent directory where the file is to be created.
* \param p_filename (input):
* Pointer to the name of the file to be created.
* \param cred (input):
* Authentication context for the operation (user,...).
* \param accessmode (input):
* Mode for the file to be created.
* (the umask defined into the FSAL configuration file
* will be applied on it).
* \param object_handle (output):
* Pointer to the handle of the created file.
* \param object_attributes (optional input/output):
* The attributes of the created file.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* May be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occurred.
*/
fsal_status_t GPFSFSAL_create(fsal_handle_t * p_parent_directory_handle, /* IN */
fsal_name_t * p_filename, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_accessmode_t accessmode, /* IN */
fsal_handle_t * p_object_handle, /* OUT */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */
)
{
fsal_status_t status;
mode_t unix_mode;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t parent_dir_attrs;
/* sanity checks.
* note : object_attributes is optional.
*/
if(!p_parent_directory_handle || !p_context || !p_object_handle || !p_filename)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_create);
/* convert fsal mode to unix mode. */
unix_mode = fsal2unix_mode(accessmode);
/* Apply umask */
unix_mode = unix_mode & ~global_fs_info.umask;
LogFullDebug(COMPONENT_FSAL, "Creation mode: 0%o", accessmode);
/* retrieve directory metadata */
parent_dir_attrs.asked_attributes = GPFS_SUPPORTED_ATTRIBUTES;
status = GPFSFSAL_getattrs(p_parent_directory_handle, p_context, &parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_create);
/* Check the user can write in the directory */
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL, &parent_dir_attrs);
else
status = fsal_internal_access(p_context, p_parent_directory_handle, access_mask,
&parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_create);
/* call to filesystem */
fsal_set_credentials(p_context);
TakeTokenFSCall();
status = fsal_internal_create(p_context, p_parent_directory_handle,
p_filename, unix_mode | S_IFREG, 0,
p_object_handle, NULL);
ReleaseTokenFSCall();
fsal_restore_ganesha_credentials();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_create);
/* retrieve file attributes */
if(p_object_attributes)
{
status = GPFSFSAL_getattrs(p_object_handle, p_context, p_object_attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
// error injection to test DRC
//sleep(61);
/* OK */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_create);
}
/**
* FSAL_link:
* Create a hardlink.
*
* \param target_handle (input):
* Handle of the target object.
* \param dir_handle (input):
* Pointer to the directory handle where
* the hardlink is to be created.
* \param p_link_name (input):
* Pointer to the name of the hardlink to be created.
* \param cred (input):
* Authentication context for the operation (user,...).
* \param accessmode (input):
* Mode for the directory to be created.
* (the umask defined into the FSAL configuration file
* will be applied on it).
* \param attributes (optionnal input/output):
* The post_operation attributes of the linked object.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* May be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occured.
*/
fsal_status_t GPFSFSAL_link(fsal_handle_t * p_target_handle, /* IN */
fsal_handle_t * p_dir_handle, /* IN */
fsal_name_t * p_link_name, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_attrib_list_t * p_attributes /* [ IN/OUT ] */
)
{
fsal_status_t status;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t parent_dir_attrs;
/* sanity checks.
* note : attributes is optional.
*/
if(!p_target_handle || !p_dir_handle || !p_context || !p_context->export_context
|| !p_link_name || !p_link_name->name)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_link);
/* Tests if hardlinking is allowed by configuration. */
if(!global_fs_info.link_support)
Return(ERR_FSAL_NOTSUPP, 0, INDEX_FSAL_link);
/* retrieve target directory metadata */
parent_dir_attrs.asked_attributes = GPFS_SUPPORTED_ATTRIBUTES;
status = GPFSFSAL_getattrs(p_dir_handle, p_context, &parent_dir_attrs);
if(FSAL_IS_ERROR(status))
goto out_status_fsal_err;
/* check permission on target directory */
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL, &parent_dir_attrs);
else
status = fsal_internal_access(p_context, p_dir_handle, access_mask,
&parent_dir_attrs);
if(FSAL_IS_ERROR(status))
goto out_status_fsal_err;
/* Create the link on the filesystem */
TakeTokenFSCall();
status = fsal_internal_link_fh(p_context, p_target_handle, p_dir_handle,
p_link_name);
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(status))
goto out_status_fsal_err;
/* optionnaly get attributes */
if(p_attributes)
{
status = GPFSFSAL_getattrs(p_target_handle, p_context, p_attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_attributes->asked_attributes);
FSAL_SET_MASK(p_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* OK */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_link);
out_status_fsal_err:
ReturnStatus(status, INDEX_FSAL_link);
}
/**
* FSAL_mknode:
* Create a special object in the filesystem.
* Not supported upon HPSS.
*
* \return ERR_FSAL_NOTSUPP.
*/
fsal_status_t GPFSFSAL_mknode(fsal_handle_t * parentdir_handle, /* IN */
fsal_name_t * p_node_name, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_accessmode_t accessmode, /* IN */
fsal_nodetype_t nodetype, /* IN */
fsal_dev_t * dev, /* IN */
fsal_handle_t * p_object_handle, /* OUT (handle to the created node) */
fsal_attrib_list_t * node_attributes /* [ IN/OUT ] */
)
{
fsal_status_t status;
/* int flags=(O_RDONLY|O_NOFOLLOW); */
mode_t unix_mode = 0;
dev_t unix_dev = 0;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t parent_dir_attrs;
/* sanity checks.
* note : link_attributes is optional.
*/
if(!parentdir_handle || !p_context || !p_node_name)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_mknode);
unix_mode = fsal2unix_mode(accessmode);
/* Apply umask */
unix_mode = unix_mode & ~global_fs_info.umask;
switch (nodetype)
{
case FSAL_TYPE_BLK:
if(!dev)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_mknode);
unix_mode |= S_IFBLK;
unix_dev = (dev->major << 8) | (dev->minor & 0xFF);
break;
case FSAL_TYPE_CHR:
if(!dev)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_mknode);
unix_mode |= S_IFCHR;
unix_dev = (dev->major << 8) | (dev->minor & 0xFF);
break;
case FSAL_TYPE_SOCK:
unix_mode |= S_IFSOCK;
break;
case FSAL_TYPE_FIFO:
unix_mode |= S_IFIFO;
/* flags = (O_RDONLY | O_NOFOLLOW | O_NONBLOCK); */
break;
default:
LogMajor(COMPONENT_FSAL,
"Invalid node type in FSAL_mknode: %d", nodetype);
Return(ERR_FSAL_INVAL, 0, INDEX_FSAL_mknode);
}
/* retrieve directory attributes */
parent_dir_attrs.asked_attributes = GPFS_SUPPORTED_ATTRIBUTES;
status = GPFSFSAL_getattrs(parentdir_handle, p_context, &parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_mknode);
/* Check the user can write in the directory */
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL, &parent_dir_attrs);
else
status = fsal_internal_access(p_context, parentdir_handle, access_mask,
&parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_mknode);
fsal_set_credentials(p_context);
TakeTokenFSCall();
status = fsal_internal_create(p_context, parentdir_handle,
p_node_name, unix_mode, unix_dev,
p_object_handle, NULL);
ReleaseTokenFSCall();
fsal_restore_ganesha_credentials();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_mknode);
/* Fills the attributes if needed */
if(node_attributes)
{
status = GPFSFSAL_getattrs(p_object_handle, p_context, node_attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(node_attributes->asked_attributes);
FSAL_SET_MASK(node_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* Finished */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_mknode);
}
/**
* FSAL_lookup :
* Looks up for an object into a directory.
*
* Note : if parent handle and filename are NULL,
* this retrieves root's handle.
*
* \param parent_directory_handle (input)
* Handle of the parent directory to search the object in.
* \param filename (input)
* The name of the object to find.
* \param p_context (input)
* Authentication context for the operation (user,...).
* \param object_handle (output)
* The handle of the object corresponding to filename.
* \param object_attributes (optional input/output)
* Pointer to the attributes of the object we found.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* It can be NULL (increases performances).
*
* \return - ERR_FSAL_NO_ERROR, if no error.
* - Another error code else.
*
*/
fsal_status_t GPFSFSAL_lookup(fsal_handle_t * p_parent_directory_handle, /* IN */
fsal_name_t * p_filename, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_handle_t * object_handle, /* OUT */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */
)
{
fsal_status_t status;
int parentfd;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t parent_dir_attrs;
gpfsfsal_handle_t *p_object_handle = (gpfsfsal_handle_t *)object_handle;
/* sanity checks
* note : object_attributes is optional
* parent_directory_handle may be null for getting FS root.
*/
if(!p_object_handle || !p_context)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup);
/* filename AND parent handle are NULL => lookup "/" */
if((p_parent_directory_handle && !p_filename)
|| (!p_parent_directory_handle && p_filename))
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup);
/* get information about root */
if(!p_parent_directory_handle)
{
gpfsfsal_handle_t *root_handle = &((gpfsfsal_op_context_t *)p_context)->export_context->mount_root_handle;
/* get handle for the mount point */
memcpy(p_object_handle->data.handle.f_handle,
root_handle->data.handle.f_handle,
sizeof(root_handle->data.handle.handle_size));
p_object_handle->data.handle.handle_size = root_handle->data.handle.handle_size;
p_object_handle->data.handle.handle_key_size = root_handle->data.handle.handle_key_size;
/* get attributes, if asked */
if(p_object_attributes)
{
status = GPFSFSAL_getattrs(object_handle, p_context, p_object_attributes);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* Done */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup);
}
/* retrieve directory attributes */
TakeTokenFSCall();
status =
fsal_internal_handle2fd(p_context, p_parent_directory_handle, &parentfd, O_RDONLY);
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get directory metadata */
parent_dir_attrs.asked_attributes = GPFS_SUPPORTED_ATTRIBUTES;
status = GPFSFSAL_getattrs(p_parent_directory_handle, p_context, &parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* Be careful about junction crossing, symlinks, hardlinks,... */
switch (parent_dir_attrs.type)
{
case FSAL_TYPE_DIR:
// OK
break;
case FSAL_TYPE_JUNCTION:
// This is a junction
Return(ERR_FSAL_XDEV, 0, INDEX_FSAL_lookup);
case FSAL_TYPE_FILE:
case FSAL_TYPE_LNK:
case FSAL_TYPE_XATTR:
// not a directory
Return(ERR_FSAL_NOTDIR, 0, INDEX_FSAL_lookup);
default:
Return(ERR_FSAL_SERVERFAULT, 0, INDEX_FSAL_lookup);
}
// LogFullDebug(COMPONENT_FSAL,
// "lookup of %#llx:%#x:%#x/%s", p_parent_directory_handle->seq,
// p_parent_directory_handle->oid, p_parent_directory_handle->ver,
// p_filename->name);
/* check rights to enter into the directory */
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_R_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_LIST_DIR);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL, &parent_dir_attrs);
else
status = fsal_internal_access(p_context, p_parent_directory_handle, access_mask,
&parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get file handle, it it exists */
/* This might be a race, but it's the best we can currently do */
status = fsal_internal_get_handle_at(parentfd, p_filename, object_handle);
close(parentfd);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_lookup);
/* get object attributes */
if(p_object_attributes)
{
status = GPFSFSAL_getattrs(object_handle, p_context, p_object_attributes);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* lookup complete ! */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup);
}
/**
* FSAL_mkdir:
* Create a directory.
*
* \param parent_directory_handle (input):
* Handle of the parent directory where
* the subdirectory is to be created.
* \param p_dirname (input):
* Pointer to the name of the directory to be created.
* \param cred (input):
* Authentication context for the operation (user,...).
* \param accessmode (input):
* Mode for the directory to be created.
* (the umask defined into the FSAL configuration file
* will be applied on it).
* \param object_handle (output):
* Pointer to the handle of the created directory.
* \param object_attributes (optionnal input/output):
* The attributes of the created directory.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* May be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occured.
*/
fsal_status_t GPFSFSAL_mkdir(fsal_handle_t * p_parent_directory_handle, /* IN */
fsal_name_t * p_dirname, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_accessmode_t accessmode, /* IN */
fsal_handle_t * p_object_handle, /* OUT */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */
)
{
/* int setgid_bit = 0; */
mode_t unix_mode;
fsal_status_t status;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t parent_dir_attrs;
/* sanity checks.
* note : object_attributes is optional.
*/
if(!p_parent_directory_handle || !p_context || !p_object_handle || !p_dirname)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_mkdir);
/* convert FSAL mode to unix mode. */
unix_mode = fsal2unix_mode(accessmode);
/* Apply umask */
unix_mode = unix_mode & ~global_fs_info.umask;
/* get directory metadata */
parent_dir_attrs.asked_attributes = GPFS_SUPPORTED_ATTRIBUTES;
status = GPFSFSAL_getattrs(p_parent_directory_handle, p_context, &parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_mkdir);
/* Check the user can write in the directory, and check the setgid bit on the directory */
/* if(fsal2unix_mode(parent_dir_attrs.mode) & S_ISGID) */
/* setgid_bit = 1; */
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_SUBDIRECTORY);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL, &parent_dir_attrs);
else
status = fsal_internal_access(p_context, p_parent_directory_handle, access_mask,
&parent_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_mkdir);
/* build new entry path */
/* creates the directory and get its handle */
fsal_set_credentials(p_context);
TakeTokenFSCall();
status = fsal_internal_create(p_context, p_parent_directory_handle,
p_dirname, unix_mode | S_IFDIR, 0,
p_object_handle, NULL);
ReleaseTokenFSCall();
fsal_restore_ganesha_credentials();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_mkdir);
/* retrieve file attributes */
if(p_object_attributes)
{
status = GPFSFSAL_getattrs(p_object_handle, p_context, p_object_attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* OK */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_mkdir);
}
fsal_status_t GPFSFSAL_rename(fsal_handle_t * p_old_parentdir_handle, /* IN */
fsal_name_t * p_old_name, /* IN */
fsal_handle_t * p_new_parentdir_handle, /* IN */
fsal_name_t * p_new_name, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_attrib_list_t * p_src_dir_attributes, /* [ IN/OUT ] */
fsal_attrib_list_t * p_tgt_dir_attributes /* [ IN/OUT ] */
)
{
int rc, errsv;
fsal_status_t status;
struct stat buffstat;
int old_parent_fd, new_parent_fd;
int src_equal_tgt = FALSE;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t src_dir_attrs, tgt_dir_attrs;
/* sanity checks.
* note : src/tgt_dir_attributes are optional.
*/
if(!p_old_parentdir_handle || !p_new_parentdir_handle
|| !p_old_name || !p_new_name || !p_context)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_rename);
/* Get directory access path by fid */
TakeTokenFSCall();
status = fsal_internal_handle2fd(p_context, p_old_parentdir_handle,
&old_parent_fd,
O_RDONLY | O_DIRECTORY);
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_rename);
/* retrieve directory metadata for checking access rights */
src_dir_attrs.asked_attributes = GPFS_SUPPORTED_ATTRIBUTES;
status = GPFSFSAL_getattrs(p_old_parentdir_handle, p_context, &src_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_rename);
/* optimisation : don't do the job twice if source dir = dest dir */
if(!FSAL_handlecmp(p_old_parentdir_handle, p_new_parentdir_handle, &status))
{
new_parent_fd = old_parent_fd;
src_equal_tgt = TRUE;
tgt_dir_attrs = src_dir_attrs;
}
else
{
TakeTokenFSCall();
status = fsal_internal_handle2fd(p_context, p_new_parentdir_handle,
&new_parent_fd,
O_RDONLY | O_DIRECTORY);
ReleaseTokenFSCall();
if(FSAL_IS_ERROR(status))
{
close(old_parent_fd);
ReturnStatus(status, INDEX_FSAL_rename);
}
/* retrieve destination attrs */
tgt_dir_attrs.asked_attributes = GPFS_SUPPORTED_ATTRIBUTES;
status = GPFSFSAL_getattrs(p_new_parentdir_handle, p_context, &tgt_dir_attrs);
if(FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_rename);
}
/* check access rights */
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_DELETE_CHILD);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL, &src_dir_attrs);
else
status = fsal_internal_access(p_context, p_old_parentdir_handle, access_mask,
&src_dir_attrs);
if(FSAL_IS_ERROR(status)) {
close(old_parent_fd);
if (!src_equal_tgt)
close(new_parent_fd);
ReturnStatus(status, INDEX_FSAL_rename);
}
if(!src_equal_tgt)
{
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE |
FSAL_ACE_PERM_ADD_SUBDIRECTORY);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL, &tgt_dir_attrs);
else
status = fsal_internal_access(p_context, p_new_parentdir_handle, access_mask,
&tgt_dir_attrs);
if(FSAL_IS_ERROR(status)) {
close(old_parent_fd);
close(new_parent_fd);
ReturnStatus(status, INDEX_FSAL_rename);
}
}
/* build file paths */
TakeTokenFSCall();
rc = fstatat(old_parent_fd, p_old_name->name, &buffstat, AT_SYMLINK_NOFOLLOW);
errsv = errno;
ReleaseTokenFSCall();
if(rc) {
close(old_parent_fd);
if (!src_equal_tgt)
close(new_parent_fd);
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_rename);
}
/* Check sticky bits */
/* Sticky bit on the source directory => the user who wants to delete the file must own it or its parent dir */
if((fsal2unix_mode(src_dir_attrs.mode) & S_ISVTX) &&
src_dir_attrs.owner != p_context->credential.user &&
buffstat.st_uid != p_context->credential.user && p_context->credential.user != 0) {
close(old_parent_fd);
if (!src_equal_tgt)
close(new_parent_fd);
Return(ERR_FSAL_ACCESS, 0, INDEX_FSAL_rename);
}
/* Sticky bit on the target directory => the user who wants to create the file must own it or its parent dir */
if(fsal2unix_mode(tgt_dir_attrs.mode) & S_ISVTX)
{
TakeTokenFSCall();
rc = fstatat(new_parent_fd, p_new_name->name, &buffstat, AT_SYMLINK_NOFOLLOW);
errsv = errno;
ReleaseTokenFSCall();
if(rc < 0)
{
if(errsv != ENOENT)
{
close(old_parent_fd);
if (!src_equal_tgt)
close(new_parent_fd);
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_rename);
}
}
else
{
if(tgt_dir_attrs.owner != p_context->credential.user
&& buffstat.st_uid != p_context->credential.user
&& p_context->credential.user != 0)
{
close(old_parent_fd);
if (!src_equal_tgt)
close(new_parent_fd);
Return(ERR_FSAL_ACCESS, 0, INDEX_FSAL_rename);
}
}
}
/*************************************
* Rename the file on the filesystem *
*************************************/
TakeTokenFSCall();
rc = renameat(old_parent_fd, p_old_name->name, new_parent_fd, p_new_name->name);
errsv = errno;
ReleaseTokenFSCall();
close(old_parent_fd);
if (!src_equal_tgt)
close(new_parent_fd);
if(rc)
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_rename);
/***********************
* Fill the attributes *
***********************/
if(p_src_dir_attributes)
{
status = GPFSFSAL_getattrs(p_old_parentdir_handle, p_context, p_src_dir_attributes);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_src_dir_attributes->asked_attributes);
FSAL_SET_MASK(p_src_dir_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
if(p_tgt_dir_attributes)
{
status = GPFSFSAL_getattrs(p_new_parentdir_handle, p_context, p_tgt_dir_attributes);
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(p_tgt_dir_attributes->asked_attributes);
FSAL_SET_MASK(p_tgt_dir_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* OK */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_rename);
}
/**
* FSAL_create:
* Create a regular file.
*
* \param parent_directory_handle (input):
* Handle of the parent directory where the file is to be created.
* \param p_filename (input):
* Pointer to the name of the file to be created.
* \param cred (input):
* Authentication context for the operation (user,...).
* \param accessmode (input):
* Mode for the file to be created.
* (the umask defined into the FSAL configuration file
* will be applied on it).
* \param object_handle (output):
* Pointer to the handle of the created file.
* \param object_attributes (optional input/output):
* The attributes of the created file.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* May be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occurred.
*/
fsal_status_t
PTFSAL_create(fsal_handle_t * p_parent_directory_handle, /* IN */
fsal_name_t * p_filename, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_accessmode_t accessmode, /* IN */
fsal_handle_t * p_object_handle, /* OUT */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */)
{
int errsv;
int setgid_bit = 0;
fsal_status_t status;
mode_t unix_mode;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t parent_dir_attrs;
int open_rc;
ptfsal_handle_t * p_fsi_handle = (ptfsal_handle_t *)p_object_handle;
FSI_TRACE(FSI_DEBUG, "Begin to create file************************\n");
/* sanity checks.
* note : object_attributes is optional.
*/
if(!p_parent_directory_handle || !p_context || !p_object_handle ||
!p_filename) {
FSI_TRACE(FSI_DEBUG, "BAD Happen!");
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_create);
}
/* convert fsal mode to unix mode. */
unix_mode = fsal2unix_mode(accessmode);
/* Apply umask */
unix_mode = unix_mode & ~global_fs_info.umask;
LogFullDebug(COMPONENT_FSAL, "Creation mode: 0%o", accessmode);
/* retrieve directory metadata */
parent_dir_attrs.asked_attributes = PTFS_SUPPORTED_ATTRIBUTES;
status = PTFSAL_getattrs(p_parent_directory_handle, p_context,
&parent_dir_attrs);
if(FSAL_IS_ERROR(status)) {
ReturnStatus(status, INDEX_FSAL_create);
}
/* Check the user can write in the directory, and check the setgid bit
* on the directory
*/
if(fsal2unix_mode(parent_dir_attrs.mode) & S_ISGID) {
setgid_bit = 1;
}
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support) {
status = fsal_internal_testAccess(p_context, access_mask, NULL,
&parent_dir_attrs);
} else {
status = fsal_internal_access(p_context,
p_parent_directory_handle,
access_mask,
&parent_dir_attrs);
}
if(FSAL_IS_ERROR(status)) {
ReturnStatus(status, INDEX_FSAL_create);
}
// Create the file, return handle
open_rc = ptfsal_open(p_parent_directory_handle,
p_filename, p_context, unix_mode, p_object_handle);
if (open_rc < 0) {
errsv = errno;
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_create);
}
FSI_TRACE(FSI_DEBUG, "New Handle = %s",
(char *)p_fsi_handle->data.handle.f_handle);
/* retrieve file attributes */
if(p_object_attributes) {
status = PTFSAL_getattrs(p_object_handle,
p_context,
p_object_attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(status)) {
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
}
FSI_TRACE(FSI_DEBUG, "End to create file************************\n");
/* OK */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_create);
}
/**
* FSAL_mkdir:
* Create a directory.
*
* \param parent_directory_handle (input):
* Handle of the parent directory where
* the subdirectory is to be created.
* \param p_dirname (input):
* Pointer to the name of the directory to be created.
* \param cred (input):
* Authentication context for the operation (user,...).
* \param accessmode (input):
* Mode for the directory to be created.
* (the umask defined into the FSAL configuration file
* will be applied on it).
* \param object_handle (output):
* Pointer to the handle of the created directory.
* \param object_attributes (optionnal input/output):
* The attributes of the created directory.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* May be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occured.
*/
fsal_status_t
PTFSAL_mkdir(fsal_handle_t * p_parent_directory_handle, /* IN */
fsal_name_t * p_dirname, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_accessmode_t accessmode, /* IN */
fsal_handle_t * p_object_handle, /* OUT */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */)
{
int rc, errsv;
int setgid_bit = 0;
mode_t unix_mode;
fsal_status_t status;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t parent_dir_attrs;
char newPath[PATH_MAX];
FSI_TRACE(FSI_INFO,"MKDIR BEGIN-------------------------\n");
/* sanity checks.
* note : object_attributes is optional.
*/
if(!p_parent_directory_handle || !p_context || !p_object_handle ||
!p_dirname) {
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_mkdir);
}
/* convert FSAL mode to unix mode. */
unix_mode = fsal2unix_mode(accessmode);
/* Apply umask */
unix_mode = unix_mode & ~global_fs_info.umask;
/* get directory metadata */
parent_dir_attrs.asked_attributes = PTFS_SUPPORTED_ATTRIBUTES;
status = PTFSAL_getattrs(p_parent_directory_handle, p_context,
&parent_dir_attrs);
if(FSAL_IS_ERROR(status)) {
ReturnStatus(status, INDEX_FSAL_create);
}
/* Check the user can write in the directory, and check the
* setgid bit on the directory
*/
if(fsal2unix_mode(parent_dir_attrs.mode) & S_ISGID) {
setgid_bit = 1;
}
/* Set both mode and ace4 mask */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK | FSAL_X_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_SUBDIRECTORY);
if(!p_context->export_context->fe_static_fs_info->accesscheck_support) {
status = fsal_internal_testAccess(p_context, access_mask, NULL,
&parent_dir_attrs);
} else {
status = fsal_internal_access(p_context, p_parent_directory_handle,
access_mask,
&parent_dir_attrs);
}
if(FSAL_IS_ERROR(status)) {
ReturnStatus(status, INDEX_FSAL_mkdir);
}
rc = ptfsal_mkdir(p_parent_directory_handle, p_dirname,
p_context, unix_mode, p_object_handle);
errsv = errno;
if(rc) {
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_mkdir);
}
if(FSAL_IS_ERROR(status)) {
ReturnStatus(status, INDEX_FSAL_mkdir);
}
/* the directory has been created */
/* chown the dir to the current user/group */
if(p_context->credential.user != geteuid()) {
FSI_TRACE(FSI_DEBUG, "MKDIR %d",__LINE__);
/* if the setgid_bit was set on the parent directory, do not change
* the group of the created file, because it's already the parentdir's
* group
*/
if(fsi_get_name_from_handle(
p_context,
(char *)p_object_handle->data.handle.f_handle,
(char *)newPath, NULL) < 0) {
FSI_TRACE(FSI_DEBUG, "Failed to get name from handle %s",
(char *)p_object_handle->data.handle.f_handle);
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_mkdir);
}
rc = ptfsal_chown(p_context, newPath,
p_context->credential.user,
setgid_bit ? -1 : (int)p_context->credential.group);
errsv = errno;
if(rc) {
Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_mkdir);
}
}
/* retrieve file attributes */
if(p_object_attributes) {
FSI_TRACE(FSI_DEBUG, "MKDIR %d",__LINE__);
status = PTFSAL_getattrs(p_object_handle, p_context,
p_object_attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(status)) {
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
}
FSI_TRACE(FSI_INFO,"MKDIR END ------------------\n");
FSI_TRACE(FSI_DEBUG, "MKDIR %d",__LINE__);
/* OK */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_mkdir);
}
/**
* PTFSAL_getattrs:
* Get attributes for the object specified by its filehandle.
*
* \param filehandle (input):
* The handle of the object to get parameters.
* \param cred (input):
* Authentication context for the operation (user,...).
* \param object_attributes (mandatory input/output):
* The retrieved attributes for the object.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occured.
*/
fsal_status_t
PTFSAL_getattrs(fsal_handle_t * p_filehandle, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_attrib_list_t * p_object_attributes /* IN/OUT */)
{
fsal_status_t st;
int stat_rc;
fsi_stat_struct buffstat;
ptfsal_op_context_t * fsi_op_context = (ptfsal_op_context_t *)p_context;
ptfsal_export_context_t * fsi_export_context =
fsi_op_context->export_context;
#ifdef _USE_NFS4_ACL
fsal_accessflags_t access_mask = 0;
#endif
FSI_TRACE(FSI_DEBUG, "Begin-------------------\n");
/* sanity checks.
* note : object_attributes is mandatory in PTFSAL_getattrs.
*/
if (!p_filehandle || !p_context || !p_object_attributes) {
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_getattrs);
}
stat_rc = ptfsal_stat_by_handle(p_filehandle, p_context, &buffstat);
if (stat_rc) {
Return(ERR_FSAL_INVAL, errno, INDEX_FSAL_getattrs);
}
/* convert attributes */
st = posix2fsal_attributes(&buffstat, p_object_attributes);
FSI_TRACE(FSI_DEBUG, "Handle type=%d st_mode=%o (octal)",
p_object_attributes->type, buffstat.st_mode);
p_object_attributes->mounted_on_fileid =
fsi_export_context->ganesha_export_id;
if (FSAL_IS_ERROR(st)) {
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes,
FSAL_ATTR_RDATTR_ERR);
ReturnStatus(st, INDEX_FSAL_getattrs);
}
#ifdef _USE_NFS4_ACL
/* Check permission to get attributes and ACL. */
access_mask = FSAL_MODE_MASK_SET(0) | /* Dummy */
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_READ_ATTR |
FSAL_ACE_PERM_READ_ACL);
if (!p_context->export_context->fe_static_fs_info->accesscheck_support) {
st = fsal_internal_testAccess(p_context, access_mask, NULL,
p_object_attributes);
} else {
st = fsal_internal_access(p_context, p_filehandle, access_mask,
p_object_attributes);
}
if (FSAL_IS_ERROR(st)) {
ReturnStatus(st, INDEX_FSAL_getattrs);
}
#endif
FSI_TRACE(FSI_DEBUG, "End-----------------------------\n");
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_getattrs);
}
/**
* PTFSAL_setattrs:
* Set attributes for the object specified by its filehandle.
*
* \param filehandle (input):
* The handle of the object to get parameters.
* \param cred (input):
* Authentication context for the operation (user,...).
* \param attrib_set (mandatory input):
* The attributes to be set for the object.
* It defines the attributes that the caller
* wants to set and their values.
* \param object_attributes (optionnal input/output):
* The post operation attributes for the object.
* As input, it defines the attributes that the caller
* wants to retrieve (by positioning flags into this structure)
* and the output is built considering this input
* (it fills the structure according to the flags it contains).
* May be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - Another error code if an error occured.
*/
fsal_status_t
PTFSAL_setattrs(fsal_handle_t * p_filehandle, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_attrib_list_t * p_attrib_set, /* IN */
fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */)
{
unsigned int i;
fsal_status_t status;
ptfsal_xstat_t buffxstat;
fsal_accessflags_t access_mask = 0;
fsal_attrib_list_t wanted_attrs, current_attrs;
mode_t st_mode_in_cache = 0;
char fsi_name[PATH_MAX];
int rc;
int fd;
FSI_TRACE(FSI_DEBUG, "Begin-----------------------------------------\n");
/* sanity checks.
* note : object_attributes is optional.
*/
if (!p_filehandle || !p_context || !p_attrib_set) {
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_setattrs);
}
/* local copy of attributes */
wanted_attrs = *p_attrib_set;
/* First, check that FSAL attributes changes are allowed. */
if (!global_fs_info.cansettime) {
if (wanted_attrs.asked_attributes
& (FSAL_ATTR_ATIME | FSAL_ATTR_CREATION | FSAL_ATTR_CTIME
| FSAL_ATTR_MTIME)) {
/* handled as an unsettable attribute. */
Return(ERR_FSAL_INVAL, 0, INDEX_FSAL_setattrs);
}
}
/* apply umask, if mode attribute is to be changed */
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_MODE)) {
wanted_attrs.mode &= (~global_fs_info.umask);
}
/* get current attributes */
current_attrs.asked_attributes = PTFS_SUPPORTED_ATTRIBUTES;
status = PTFSAL_getattrs(p_filehandle, p_context, ¤t_attrs);
if (FSAL_IS_ERROR(status)) {
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes,
FSAL_ATTR_RDATTR_ERR);
ReturnStatus(status, INDEX_FSAL_setattrs);
}
/**************
* TRUNCATE *
**************/
if(FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_SIZE)) {
status = fsal_internal_handle2fd(p_context, p_filehandle, &fd, O_RDONLY);
if (FSAL_IS_ERROR(status)) {
ReturnStatus(status, INDEX_FSAL_setattrs);
}
status = PTFSAL_truncate( p_filehandle,
p_context,
wanted_attrs.filesize,
&fd,
p_object_attributes);
if (FSAL_IS_ERROR(status)) {
ReturnStatus(status, INDEX_FSAL_setattrs);
}
}
/***********
* CHMOD *
***********/
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_MODE)) {
FSI_TRACE(FSI_DEBUG, "Begin chmod------------------\n");
/* The POSIX chmod call don't affect the symlink object, but
* the entry it points to. So we must ignore it.
*/
if (current_attrs.type != FSAL_TYPE_LNK) {
/* For modifying mode, user must be root or the owner */
if ((p_context->credential.user != 0)
&& (p_context->credential.user != current_attrs.owner)) {
FSI_TRACE(FSI_DEBUG,
"Permission denied for CHMOD opeartion: "
"current owner=%d, credential=%d",
current_attrs.owner,
p_context->credential.user);
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_setattrs);
}
#ifdef _USE_NFS4_ACL
/* Check permission using ACL. */
access_mask = FSAL_MODE_MASK_SET(0) | /* Dummy. */
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_WRITE_ATTR);
if (!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL,
¤t_attrs);
else
status = fsal_internal_access(p_context, p_filehandle, access_mask,
¤t_attrs);
if (FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_setattrs);
#endif
/* Fill wanted mode. */
buffxstat.buffstat.st_mode = fsal2unix_mode(wanted_attrs.mode);
FSI_TRACE(FSI_DEBUG,
"current mode = %o, new mode = %o",
fsal2unix_mode(current_attrs.mode),
buffxstat.buffstat.st_mode);
rc = fsi_get_name_from_handle(p_context,
p_filehandle->data.handle.f_handle,
fsi_name,
NULL);
if (rc < 0) {
FSI_TRACE(FSI_ERR,
"Failed to convert file handle back to filename" );
FSI_TRACE(FSI_DEBUG, "Handle to name failed for hanlde %s",
p_filehandle->data.handle.f_handle);
Return (ERR_FSAL_BADHANDLE, 0, INDEX_FSAL_setattrs);
}
FSI_TRACE(FSI_DEBUG, "Handle to name: %s for handle %s",
fsi_name, p_filehandle->data.handle.f_handle);
rc = ptfsal_chmod(p_context, fsi_name,
buffxstat.buffstat.st_mode);
if (rc == -1) {
FSI_TRACE(FSI_ERR, "chmod FAILED");
Return (ERR_FSAL_PERM, 0, INDEX_FSAL_setattrs);
} else {
st_mode_in_cache = (buffxstat.buffstat.st_mode
| fsal_type2unix(current_attrs.type));
fsi_update_cache_stat(fsi_name,
st_mode_in_cache,
p_context->export_context->pt_export_id);
FSI_TRACE(FSI_INFO,
"Chmod SUCCEED with st_mode in cache being %o",
st_mode_in_cache);
}
}
FSI_TRACE(FSI_DEBUG, "End chmod-------------------\n");
}
/***********
* CHOWN *
***********/
FSI_TRACE(FSI_DEBUG, "Begin chown------------------------------\n");
/* Only root can change uid and A normal user must be in the group
* he wants to set
*/
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_OWNER)) {
/* For modifying owner, user must be root or current
* owner==wanted==client
*/
if ((p_context->credential.user != 0) &&
((p_context->credential.user != current_attrs.owner) ||
(p_context->credential.user != wanted_attrs.owner))) {
FSI_TRACE(FSI_DEBUG,
"Permission denied for CHOWN opeartion: "
"current owner=%d, credential=%d, new owner=%d",
current_attrs.owner, p_context->credential.user,
wanted_attrs.owner);
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_setattrs);
}
#ifdef _USE_NFS4_ACL
/* Check permission using ACL. */
access_mask = FSAL_MODE_MASK_SET(0) | /* Dummy. */
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_WRITE_OWNER);
if (!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL,
¤t_attrs);
else
status = fsal_internal_access(p_context, p_filehandle, access_mask,
¤t_attrs);
if (FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_setattrs);
#endif
}
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_GROUP)) {
/* For modifying group, user must be root or current owner */
if ((p_context->credential.user != 0)
&& (p_context->credential.user != current_attrs.owner)) {
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_setattrs);
}
int in_grp = 0;
/* set in_grp */
if (p_context->credential.group == wanted_attrs.group) {
in_grp = 1;
} else {
for(i = 0; i < p_context->credential.nbgroups; i++) {
if ((in_grp = (wanted_attrs.group ==
p_context->credential.alt_groups[i])))
break;
}
}
/* it must also be in target group */
if (p_context->credential.user != 0 && !in_grp) {
FSI_TRACE(FSI_DEBUG,
"Permission denied for CHOWN operation: "
"current group=%d, credential=%d, new group=%d",
current_attrs.group, p_context->credential.group,
wanted_attrs.group);
Return(ERR_FSAL_PERM, 0, INDEX_FSAL_setattrs);
}
#ifdef _USE_NFS4_ACL
/* Check permission using ACL. */
access_mask = FSAL_MODE_MASK_SET(0) | /* Dummy. */
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_WRITE_OWNER);
if (!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL,
¤t_attrs);
else
status = fsal_internal_access(p_context, p_filehandle, access_mask,
¤t_attrs);
if (FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_setattrs);
#endif
}
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_OWNER |
FSAL_ATTR_GROUP)) {
/* Fill wanted owner. */
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_OWNER)) {
buffxstat.buffstat.st_uid = (int)wanted_attrs.owner;
} else {
buffxstat.buffstat.st_uid = (int)current_attrs.owner;
}
FSI_TRACE(FSI_DEBUG,
"current uid = %d, new uid = %d",
current_attrs.owner, buffxstat.buffstat.st_uid);
/* Fill wanted group. */
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_GROUP)) {
buffxstat.buffstat.st_gid = (int)wanted_attrs.group;
} else {
buffxstat.buffstat.st_gid = (int)current_attrs.group;
}
FSI_TRACE(FSI_DEBUG,
"current gid = %d, new gid = %d",
current_attrs.group, buffxstat.buffstat.st_gid);
rc = fsi_get_name_from_handle(p_context,
p_filehandle->data.handle.f_handle,
fsi_name,
NULL);
if (rc < 0) {
FSI_TRACE(FSI_ERR, "Failed to convert file handle back to filename" );
FSI_TRACE(FSI_DEBUG, "Handle to name failed for hanlde %s",
p_filehandle->data.handle.f_handle);
Return (ERR_FSAL_BADHANDLE, 0, INDEX_FSAL_setattrs);
}
FSI_TRACE(FSI_DEBUG, "handle to name: %s for handle %s",
fsi_name, p_filehandle->data.handle.f_handle);
rc = ptfsal_chown(p_context, fsi_name, buffxstat.buffstat.st_uid,
buffxstat.buffstat.st_gid);
if (rc == -1) {
FSI_TRACE(FSI_ERR, "chown FAILED");
Return (ERR_FSAL_PERM, 1, INDEX_FSAL_setattrs);
} else {
FSI_TRACE(FSI_INFO, "Chown SUCCEED");
}
}
FSI_TRACE(FSI_DEBUG, "End chown-----------------------------------\n");
/***********
* UTIME *
***********/
FSI_TRACE(FSI_DEBUG, "Begin UTIME-----------------------------------\n");
/* user must be the owner or have read access to modify 'atime' */
access_mask = FSAL_MODE_MASK_SET(FSAL_R_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_WRITE_ATTR);
if (!p_context->export_context->fe_static_fs_info->accesscheck_support) {
status = fsal_internal_testAccess(p_context, access_mask, NULL,
¤t_attrs);
} else {
status = fsal_internal_access(p_context, p_filehandle, access_mask,
¤t_attrs);
}
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_ATIME)
&& (p_context->credential.user != 0)
&& (p_context->credential.user != current_attrs.owner)
&& (status.major
!= ERR_FSAL_NO_ERROR)) {
ReturnStatus(status, INDEX_FSAL_setattrs);
}
/* user must be the owner or have write access to modify 'mtime' */
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_WRITE_ATTR);
if (!p_context->export_context->fe_static_fs_info->accesscheck_support) {
status = fsal_internal_testAccess(p_context, access_mask, NULL,
¤t_attrs);
} else {
status = fsal_internal_access(p_context, p_filehandle, access_mask,
¤t_attrs);
}
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_MTIME)
&& (p_context->credential.user != 0)
&& (p_context->credential.user != current_attrs.owner)
&& (status.major
!= ERR_FSAL_NO_ERROR)) {
ReturnStatus(status, INDEX_FSAL_setattrs);
}
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_ATIME |
FSAL_ATTR_MTIME)) {
/* Fill wanted atime. */
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_ATIME)) {
buffxstat.buffstat.st_atime = (time_t) wanted_attrs.atime.seconds;
FSI_TRACE(FSI_DEBUG,
"current atime = %lu, new atime = %lu",
(unsigned long)current_attrs.atime.seconds,
(unsigned long)buffxstat.buffstat.st_atime);
} else {
buffxstat.buffstat.st_atime = (time_t) current_attrs.atime.seconds;
}
FSI_TRACE(FSI_DEBUG,
"current atime = %lu, new atime = %lu",
(unsigned long)current_attrs.atime.seconds,
(unsigned long)buffxstat.buffstat.st_atime);
/* Fill wanted mtime. */
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_MTIME)) {
buffxstat.buffstat.st_mtime = (time_t) wanted_attrs.mtime.seconds;
} else {
buffxstat.buffstat.st_mtime = (time_t) current_attrs.mtime.seconds;
}
FSI_TRACE(FSI_DEBUG,
"current mtime = %lu, new mtime = %lu",
(unsigned long)current_attrs.mtime.seconds,
(unsigned long)buffxstat.buffstat.st_mtime);
rc = fsi_get_name_from_handle(p_context,
p_filehandle->data.handle.f_handle,
fsi_name,
NULL);
if (rc < 0) {
FSI_TRACE(FSI_ERR,
"Failed to convert file handle back to filename "
"from cache" );
FSI_TRACE(FSI_DEBUG, "Handle to name failed for hanlde %s",
p_filehandle->data.handle.f_handle);
Return (ERR_FSAL_BADHANDLE, 0, INDEX_FSAL_setattrs);
}
FSI_TRACE(FSI_DEBUG, "Handle to name: %s for handle %s",
fsi_name, p_filehandle->data.handle.f_handle);
rc = ptfsal_ntimes(p_context, fsi_name, buffxstat.buffstat.st_atime,
buffxstat.buffstat.st_mtime);
if (rc == -1) {
FSI_TRACE(FSI_ERR, "ntime FAILED");
Return (ERR_FSAL_PERM, 2, INDEX_FSAL_setattrs);
} else {
FSI_TRACE(FSI_INFO, "ntime SUCCEED");
}
}
FSI_TRACE(FSI_DEBUG, "End UTIME------------------------------\n");
#ifdef _USE_NFS4_ACL
/***********
* ACL *
***********/
if (FSAL_TEST_MASK(wanted_attrs.asked_attributes, FSAL_ATTR_ACL)) {
/* Check permission to set ACL. */
access_mask = FSAL_MODE_MASK_SET(0) | /* Dummy */
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_WRITE_ACL);
if (!p_context->export_context->fe_static_fs_info->accesscheck_support)
status = fsal_internal_testAccess(p_context, access_mask, NULL,
¤t_attrs);
else
status = fsal_internal_access(p_context, p_filehandle, access_mask,
¤t_attrs);
if (FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_setattrs);
if (wanted_attrs.acl) {
LogDebug(COMPONENT_FSAL, "setattr acl = %p", wanted_attrs.acl);
/* Convert FSAL ACL to PTFS NFS4 ACL and fill the buffer. */
status = fsal_acl_2_ptfs_acl(wanted_attrs.acl, &buffxstat);
if (FSAL_IS_ERROR(status))
ReturnStatus(status, INDEX_FSAL_setattrs);
} else {
LogCrit(COMPONENT_FSAL, "setattr acl is NULL");
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_setattrs);
}
}
#endif /* _USE_NFS4_ACL */
/* Optionaly fills output attributes. */
if (p_object_attributes) {
status = PTFSAL_getattrs(p_filehandle, p_context, p_object_attributes);
/* on error, we set a special bit in the mask. */
if (FSAL_IS_ERROR(status)) {
FSAL_CLEAR_MASK(p_object_attributes->asked_attributes);
FSAL_SET_MASK(p_object_attributes->asked_attributes,
FSAL_ATTR_RDATTR_ERR);
}
}
FSI_TRACE(FSI_DEBUG, "End--------------------------------------------\n");
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_setattrs);
}
