/**
* FSAL_access :
* Tests whether the user or entity identified by the p_context structure
* can access the object identified by object_handle,
* as indicated by the access_type parameter.
*
* \param object_handle (input):
* The handle of the object to test permissions on.
* \param p_context (input):
* Authentication context for the operation (export entry, user,...).
* \param access_type (input):
* Indicates the permissions to be tested.
* This is an inclusive OR of the permissions
* to be checked for the user specified by p_context.
* Permissions constants are :
* - FSAL_R_OK : test for read permission
* - FSAL_W_OK : test for write permission
* - FSAL_X_OK : test for exec permission
* - FSAL_F_OK : test for file existence
* \param object_attributes (optional 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).
* Can be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error, asked permission is granted)
* - ERR_FSAL_ACCESS (object permissions doesn't fit asked access type)
* - ERR_FSAL_STALE (object_handle does not address an existing object)
* - ERR_FSAL_FAULT (a NULL pointer was passed as mandatory argument)
* - Other error codes when something anormal occurs.
*/
fsal_status_t SNMPFSAL_access(fsal_handle_t * object_handle, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_accessflags_t access_type, /* IN */
fsal_attrib_list_t * object_attributes /* [ IN/OUT ] */
)
{
fsal_attrib_list_t attrs;
fsal_status_t st;
/* sanity checks.
* note : object_attributes is optional in FSAL_access.
*/
if(!object_handle || !p_context)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_access);
FSAL_CLEAR_MASK(attrs.asked_attributes);
FSAL_SET_MASK(attrs.asked_attributes, global_fs_info.supported_attrs);
st = SNMPFSAL_getattrs(object_handle, p_context, &attrs);
if(FSAL_IS_ERROR(st))
Return(st.major, st.minor, INDEX_FSAL_access);
/* set attributes if needed, then call test_access.
*/
if(object_attributes)
{
*object_attributes = attrs;
}
st = SNMPFSAL_test_access(p_context, access_type, &attrs);
Return(st.major, st.minor, INDEX_FSAL_access);
}
fsal_status_t SNMPFSAL_readlink(snmpfsal_handle_t * linkhandle, /* IN */
snmpfsal_op_context_t * p_context, /* IN */
fsal_path_t * p_link_content, /* OUT */
fsal_attrib_list_t * link_attributes /* [ IN/OUT ] */
)
{
int rc;
fsal_status_t st;
char link_content_out[FSAL_MAX_PATH_LEN];
/* sanity checks.
* note : link_attributes is optional.
*/
if(!linkhandle || !p_context || !p_link_content)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_readlink);
TakeTokenFSCall();
/* >> call your filesystem readlink function << */
ReleaseTokenFSCall();
/* >> convert error code and return on error << */
/* >> convert fs output to fsal_path_t
* for example, if this is a char * (link_content_out) :
*/
st = FSAL_str2path(link_content_out, FSAL_MAX_PATH_LEN, p_link_content);
if(FSAL_IS_ERROR(st))
Return(st.major, st.minor, INDEX_FSAL_readlink);
/* retrieves object attributes, if asked */
if(link_attributes)
{
fsal_status_t status;
status = SNMPFSAL_getattrs(linkhandle, p_context, link_attributes);
/* On error, we set a flag in the returned attributes */
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(link_attributes->asked_attributes);
FSAL_SET_MASK(link_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_readlink);
}
fsal_status_t SNMPFSAL_setattrs(fsal_handle_t * filehandle, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_attrib_list_t * attrib_set, /* IN */
fsal_attrib_list_t * object_attributes /* [ IN/OUT ] */
)
{
int rc;
fsal_status_t status;
fsal_attrib_list_t attrs;
/* sanity checks.
* note : object_attributes is optional.
*/
if(!filehandle || !p_context || !attrib_set)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_setattrs);
/* no attributes can be set in SNMP */
if(attrs.asked_attributes != 0)
{
Return(ERR_FSAL_INVAL, 0, INDEX_FSAL_setattrs);
}
if(object_attributes)
{
status = SNMPFSAL_getattrs(filehandle, p_context, object_attributes);
/* on error, we set a special bit in the mask. */
if(FSAL_IS_ERROR(status))
{
FSAL_CLEAR_MASK(object_attributes->asked_attributes);
FSAL_SET_MASK(object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_setattrs);
}
/**
* FSAL_opendir :
* Opens a directory for reading its content.
*
* \param dir_handle (input)
* the handle of the directory to be opened.
* \param p_context (input)
* Permission context for the operation (user, export context...).
* \param dir_descriptor (output)
* pointer to an allocated structure that will receive
* directory stream informations, on successfull completion.
* \param dir_attributes (optional output)
* On successfull completion,the structure pointed
* by dir_attributes receives the new directory attributes.
* Can be NULL.
*
* \return Major error codes :
* - ERR_FSAL_NO_ERROR (no error)
* - ERR_FSAL_ACCESS (user does not have read permission on directory)
* - ERR_FSAL_STALE (dir_handle does not address an existing object)
* - ERR_FSAL_FAULT (a NULL pointer was passed as mandatory argument)
* - Other error codes can be returned :
* ERR_FSAL_IO, ...
*/
fsal_status_t SNMPFSAL_opendir(fsal_handle_t * dir_handle, /* IN */
fsal_op_context_t * p_context, /* IN */
fsal_dir_t * dir_descriptor, /* OUT */
fsal_attrib_list_t * dir_attributes /* [ IN/OUT ] */
)
{
fsal_status_t st;
/* sanity checks
* note : dir_attributes is optionnal.
*/
if(!dir_handle || !p_context || !dir_descriptor)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_opendir);
/* check it is a node... */
if(((snmpfsal_handle_t *)dir_handle)->data.object_type_reminder == FSAL_NODETYPE_LEAF)
Return(ERR_FSAL_NOTDIR, 0, INDEX_FSAL_opendir);
/* save request info to the dir_dircriptor */
memcpy(&((snmpfsal_dir_t *)dir_descriptor)->node_handle,
(snmpfsal_handle_t *)dir_handle, sizeof(snmpfsal_handle_t));
((snmpfsal_dir_t *)dir_descriptor)->p_context = (snmpfsal_op_context_t *)p_context;
if(dir_attributes && dir_attributes->asked_attributes)
{
st = SNMPFSAL_getattrs(dir_handle, p_context, dir_attributes);
if(FSAL_IS_ERROR(st))
{
FSAL_CLEAR_MASK(dir_attributes->asked_attributes);
FSAL_SET_MASK(dir_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_opendir);
}
fsal_status_t SNMPFSAL_rename(snmpfsal_handle_t * old_parentdir_handle, /* IN */
fsal_name_t * p_old_name, /* IN */
snmpfsal_handle_t * new_parentdir_handle, /* IN */
fsal_name_t * p_new_name, /* IN */
snmpfsal_op_context_t * p_context, /* IN */
fsal_attrib_list_t * src_dir_attributes, /* [ IN/OUT ] */
fsal_attrib_list_t * tgt_dir_attributes /* [ IN/OUT ] */
)
{
int rc;
/* sanity checks.
* note : src/tgt_dir_attributes are optional.
*/
if(!old_parentdir_handle ||
!new_parentdir_handle || !p_old_name || !p_new_name || !p_context)
Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_rename);
TakeTokenFSCall();
/* >> call your filesystem rename function << */
ReleaseTokenFSCall();
/* >> interpret the returned error << */
/* >> get last parent post op attributes if asked
* For example : << */
if(src_dir_attributes)
{
fsal_status_t st;
st = SNMPFSAL_getattrs(old_parentdir_handle, p_context, src_dir_attributes);
if(FSAL_IS_ERROR(st))
{
FSAL_CLEAR_MASK(src_dir_attributes->asked_attributes);
FSAL_SET_MASK(src_dir_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
/* >> get new parent post op attributes if asked
* For example : << */
if(tgt_dir_attributes)
{
fsal_status_t st;
/* optimization when src=tgt : */
if(!SNMPFSAL_handlecmp(old_parentdir_handle, new_parentdir_handle, &st)
&& src_dir_attributes)
{
/* If source dir = target dir, we just copy the attributes.
* to avoid doing another getattr.
*/
(*tgt_dir_attributes) = (*src_dir_attributes);
}
else
{
/* get attributes */
st = SNMPFSAL_getattrs(new_parentdir_handle, p_context, tgt_dir_attributes);
if(FSAL_IS_ERROR(st))
{
FSAL_CLEAR_MASK(tgt_dir_attributes->asked_attributes);
FSAL_SET_MASK(tgt_dir_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR);
}
}
}
/* OK */
Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_rename);
}