fsal_access.c

Go to the documentation of this file.

/*
 * vim:expandtab:shiftwidth=8:tabstop=8:
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "fsal.h"
#include "fsal_internal.h"
#include "fsal_convert.h"
#include "namespace.h"

fsal_status_t FUSEFSAL_access(fsal_handle_t * obj_handle,        /* IN */
                              fsal_op_context_t * p_context,        /* IN */
                              fsal_accessflags_t access_type,   /* IN */
                              fsal_attrib_list_t * object_attributes    /* [ IN/OUT ] */
    )
{

  int mask, rc;
  char object_path[FSAL_MAX_PATH_LEN];
  fsal_attrib_list_t tmp_attrs;
  fusefsal_handle_t * object_handle = (fusefsal_handle_t *)obj_handle;

  /* sanity checks.
   * note : object_attributes is optional in FSAL_access.
   */
  if(!object_handle || !p_context)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_access);

  /* convert fsal access mask to FUSE access mask */
  mask = fsal2posix_testperm(access_type);

  /* get the full path for the object */
  rc = NamespacePath(object_handle->data.inode, object_handle->data.device,
                     object_handle->data.validator, object_path);

  if(rc)
    Return(ERR_FSAL_STALE, rc, INDEX_FSAL_access);

  /* set context for the next operation, so it can be retrieved by FS thread */
  fsal_set_thread_context(p_context);

  if(p_fs_ops->access)
    {

      TakeTokenFSCall();

      rc = p_fs_ops->access(object_path, mask);

      ReleaseTokenFSCall();

      /* TODO : remove entry from namespace if entry is stale */
      if(rc)
        Return(fuse2fsal_error(rc, TRUE), rc, INDEX_FSAL_access);
    }
  else if(p_fs_ops->getattr)
    {
      /* we emulate 'access' call using getattr + fsal_test_access
       * from attributes value (mode, owner, group, ...)
       */
      fsal_status_t status;

      FSAL_CLEAR_MASK(tmp_attrs.asked_attributes);
      FSAL_SET_MASK(tmp_attrs.asked_attributes, FSAL_ATTR_TYPE);
      FSAL_SET_MASK(tmp_attrs.asked_attributes, FSAL_ATTR_MODE);
      FSAL_SET_MASK(tmp_attrs.asked_attributes, FSAL_ATTR_OWNER);
      FSAL_SET_MASK(tmp_attrs.asked_attributes, FSAL_ATTR_GROUP);

      status = FUSEFSAL_getattrs(obj_handle, p_context, &tmp_attrs);

      if(FSAL_IS_ERROR(status))
        Return(status.major, status.minor, INDEX_FSAL_access);

      status = FUSEFSAL_test_access(p_context, access_type, &tmp_attrs);

      if(FSAL_IS_ERROR(status))
        Return(status.major, status.minor, INDEX_FSAL_access);

    }
  /* else : always grant access */

  /* get attributes if object_attributes is not null.
   * If an error occures during getattr operation,
   * an error bit is set in the output structure.
   */
  if(object_attributes)
    {
      fsal_status_t status;

      status = FUSEFSAL_getattrs(obj_handle, 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_access);

}

fsal_status_t FUSEFSAL_test_access(fsal_op_context_t * p_context,   /* IN */
                                   fsal_accessflags_t access_type,      /* IN */
                                   fsal_attrib_list_t * object_attributes       /* IN */
    )
{
  fsal_accessflags_t missing_access;
  int is_grp;

  /* sanity checks. */

  if(!object_attributes || !p_context)
    Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_test_access);

  /* If the FSAL_F_OK flag is set, returns ERR INVAL */

  if(access_type & FSAL_F_OK)
    Return(ERR_FSAL_INVAL, 0, INDEX_FSAL_test_access);

  LogFullDebug(COMPONENT_FSAL, "test_access: mode=%#o, user=%d, owner=%u",
               object_attributes->mode, p_context->credential.user,
               object_attributes->owner);

  /* test root access */

  if(p_context->credential.user == 0)
    Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_test_access);

  /* unsatisfied permissions */

  missing_access = FSAL_MODE_MASK(access_type); /* only modes, no ACLs here */

  /* Test if file belongs to user. */

  if(p_context->credential.user == object_attributes->owner)
    {

      if(object_attributes->mode & FSAL_MODE_RUSR)
        missing_access &= ~FSAL_R_OK;

      if(object_attributes->mode & FSAL_MODE_WUSR)
        missing_access &= ~FSAL_W_OK;

      if(object_attributes->mode & FSAL_MODE_XUSR)
        missing_access &= ~FSAL_X_OK;

      if(missing_access == 0)
        Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_test_access);
      else
        Return(ERR_FSAL_ACCESS, 0, INDEX_FSAL_test_access);

    }

  /* Test if the file belongs to user's group. */

  is_grp = (p_context->credential.group == object_attributes->group);

  /* XXX Test here if file belongs to user's alt groups */

  /* finally apply group rights */

  if(is_grp)
    {
      if(object_attributes->mode & FSAL_MODE_RGRP)
        missing_access &= ~FSAL_R_OK;

      if(object_attributes->mode & FSAL_MODE_WGRP)
        missing_access &= ~FSAL_W_OK;

      if(object_attributes->mode & FSAL_MODE_XGRP)
        missing_access &= ~FSAL_X_OK;

      if(missing_access == 0)
        Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_test_access);
      else
        Return(ERR_FSAL_ACCESS, 0, INDEX_FSAL_test_access);

    }

  /* test other perms */

  if(object_attributes->mode & FSAL_MODE_ROTH)
    missing_access &= ~FSAL_R_OK;

  if(object_attributes->mode & FSAL_MODE_WOTH)
    missing_access &= ~FSAL_W_OK;

  if(object_attributes->mode & FSAL_MODE_XOTH)
    missing_access &= ~FSAL_X_OK;

  if(missing_access == 0)
    Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_test_access);
  else
    Return(ERR_FSAL_ACCESS, 0, INDEX_FSAL_test_access);

}