/** * 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); }