nfs_filehandle_mgmt.c

Go to the documentation of this file.

/*
 *
 * Copyright CEA/DAM/DIF  (2008)
 * contributeur : Philippe DENIEL   philippe.deniel@cea.fr
 *                Thomas LEIBOVICI  thomas.leibovici@cea.fr
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * ---------------------------------------
 */

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

#ifdef _SOLARIS
#include "solaris_port.h"
#endif

#include <stdio.h>
#include <sys/types.h>
#include <ctype.h>              /* for having isalnum */
#include <stdlib.h>             /* for having atoi */
#include <dirent.h>             /* for having MAXNAMLEN */
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/file.h>           /* for having FNDELAY */
#include <pwd.h>
#include <grp.h>
#include "log.h"
#include "ganesha_rpc.h"
#include "nfs_core.h"
#include "nfs23.h"
#include "nfs4.h"
#include "fsal.h"
#include "nfs_tools.h"
#include "nfs_exports.h"
#include "nfs_file_handle.h"

int nfs4_FhandleToFSAL(nfs_fh4 *pfh4,
                       struct fsal_handle_desc *fh_desc,
                       fsal_op_context_t *pcontext)
{
  fsal_status_t fsal_status;
  file_handle_v4_t *pfile_handle;

  BUILD_BUG_ON(sizeof(struct alloc_file_handle_v4) != NFS4_FHSIZE);
  print_fhandle4(COMPONENT_FILEHANDLE, pfh4);

  /* Cast the fh as a non opaque structure */
  pfile_handle = (file_handle_v4_t *) (pfh4->nfs_fh4_val);

  /* validate the filehandle  */
  if(pfh4->nfs_fh4_len != nfs4_sizeof_handle(pfile_handle) ||
     pfile_handle->fhversion != GANESHA_FH_VERSION ||
     pfile_handle->pseudofs_id != 0 ||
     pfile_handle->pseudofs_flag != FALSE)
    return 0;                   /* Bad FH */

  /* Fill in the fs opaque part */
  fh_desc->start = (caddr_t)&pfile_handle->fsopaque;
  fh_desc->len = pfile_handle->fs_len;
  fsal_status = FSAL_ExpandHandle(FSAL_GET_EXP_CTX(pcontext),
                                  FSAL_DIGEST_NFSV4,
                                  fh_desc);
  if(FSAL_IS_ERROR(fsal_status))
    return 0;                   /* Corrupted (or stale) FH */
  return 1;
}                               /* nfs4_FhandleToFSAL */

int nfs3_FhandleToFSAL(nfs_fh3 * pfh3,
                       struct fsal_handle_desc *fh_desc,
                       fsal_op_context_t * pcontext)
{
  fsal_status_t fsal_status;
  file_handle_v3_t *pfile_handle;

  BUILD_BUG_ON(sizeof(struct alloc_file_handle_v3) != NFS3_FHSIZE);
  print_fhandle3(COMPONENT_FILEHANDLE, pfh3);

  /* Cast the fh as a non opaque structure */
  pfile_handle = (file_handle_v3_t *) (pfh3->data.data_val);

  /* validate the filehandle  */
  if(nfs3_Is_Fh_Invalid(pfh3) != NFS3_OK)
    return 0;                   /* Bad FH */

  /* Fill in the fs opaque part */
  fh_desc->start = (caddr_t) &pfile_handle->fsopaque;
  fh_desc->len = pfile_handle->fs_len;
  fsal_status = FSAL_ExpandHandle(FSAL_GET_EXP_CTX(pcontext),
                                  FSAL_DIGEST_NFSV3,
                                  fh_desc);
  if(FSAL_IS_ERROR(fsal_status))
    return 0;                   /* Corrupted FH */

  return 1;
}                               /* nfs3_FhandleToFSAL */

int nfs2_FhandleToFSAL(fhandle2 * pfh2,
                       struct fsal_handle_desc *fh_desc,
                       fsal_op_context_t * pcontext)
{
  fsal_status_t fsal_status;
  file_handle_v2_t *pfile_handle;

  BUILD_BUG_ON(sizeof(struct alloc_file_handle_v2) != NFS2_FHSIZE);
  /* Cast the fh as a non opaque structure */
  pfile_handle = (file_handle_v2_t *) pfh2;
  print_fhandle2(COMPONENT_FILEHANDLE, pfh2);

  /* validate the filehandle  */
  if(pfile_handle->fhversion != GANESHA_FH_VERSION)
    return 0;                   /* Bad FH */

  /* Fill in the fs opaque part */
  fh_desc->start = (caddr_t) & (pfile_handle->fsopaque);
  fh_desc->len = sizeof(pfile_handle->fsopaque);
  fsal_status = FSAL_ExpandHandle(FSAL_GET_EXP_CTX(pcontext),
                                  FSAL_DIGEST_NFSV2,
                                  fh_desc);
  if(FSAL_IS_ERROR(fsal_status))
    return 0;                   /* Corrupted FH */

  print_buff(COMPONENT_FILEHANDLE, (char *)fh_desc->start, fh_desc->len);

  return 1;
}                               /* nfs2_FhandleToFSAL */

int nfs4_FSALToFhandle(nfs_fh4 *pfh4,
                       fsal_handle_t *pfsalhandle,
                       compound_data_t *data)
{
  fsal_status_t fsal_status;
  file_handle_v4_t *file_handle;
  struct fsal_handle_desc fh_desc;

  /* reset the buffer to be used as handle */
  pfh4->nfs_fh4_len = sizeof(struct alloc_file_handle_v4);
  memset(pfh4->nfs_fh4_val, 0, pfh4->nfs_fh4_len);
  file_handle = (file_handle_v4_t *)pfh4->nfs_fh4_val;

  /* Fill in the fs opaque part */
  fh_desc.start = (caddr_t) &file_handle->fsopaque;
  fh_desc.len = pfh4->nfs_fh4_len - offsetof(file_handle_v4_t, fsopaque);
  fsal_status =
      FSAL_DigestHandle(&data->pexport->FS_export_context,
                        FSAL_DIGEST_NFSV4,
                        pfsalhandle,
                        &fh_desc);
  if(FSAL_IS_ERROR(fsal_status))
    return 0;

  file_handle->fhversion = GANESHA_FH_VERSION;
  file_handle->fs_len = fh_desc.len;   /* set the actual size */
  /* keep track of the export id */
  file_handle->exportid = data->pexport->id;

  /* if FH expires, set it there */
  if(nfs_param.nfsv4_param.fh_expire == TRUE)
    {
      LogFullDebug(COMPONENT_NFS_V4, "An expireable file handle was created.");
      file_handle->srvboot_time = ServerBootTime;
    }

  /* Set the len */
  pfh4->nfs_fh4_len = nfs4_sizeof_handle(file_handle); /* re-adjust to as built */

  return 1;
}                               /* nfs4_FSALToFhandle */

int nfs3_FSALToFhandle(nfs_fh3 *pfh3,
                       fsal_handle_t *pfsalhandle,
                       exportlist_t *pexport)
{
  fsal_status_t fsal_status;
  file_handle_v3_t *file_handle;
  struct fsal_handle_desc fh_desc;

  print_buff(COMPONENT_FILEHANDLE, (char *)pfsalhandle, sizeof(fsal_handle_t));

  /* reset the buffer to be used as handle */
  pfh3->data.data_len = sizeof(struct alloc_file_handle_v3);
  memset(pfh3->data.data_val, 0, pfh3->data.data_len);
  file_handle = (file_handle_v3_t *)pfh3->data.data_val;

  /* Fill in the fs opaque part */
  fh_desc.start = (caddr_t) &file_handle->fsopaque;
  fh_desc.len = pfh3->data.data_len - offsetof(file_handle_v3_t, fsopaque);
  fsal_status =
      FSAL_DigestHandle(&pexport->FS_export_context, FSAL_DIGEST_NFSV3, pfsalhandle,
                        &fh_desc);
  if(FSAL_IS_ERROR(fsal_status))
    return 0;

  file_handle->fhversion = GANESHA_FH_VERSION;
  file_handle->fs_len = fh_desc.len;   /* set the actual size */
  /* keep track of the export id */
  file_handle->exportid = pexport->id;

  /* Set the len */
  pfh3->data.data_len = nfs3_sizeof_handle(file_handle); /* re-adjust to as built */

  print_fhandle3(COMPONENT_FILEHANDLE, pfh3);

  return 1;
}                               /* nfs3_FSALToFhandle */

int nfs2_FSALToFhandle(fhandle2 * pfh2, fsal_handle_t * pfsalhandle,
                       exportlist_t * pexport)
{
  fsal_status_t fsal_status;
  file_handle_v2_t *file_handle;
  struct fsal_handle_desc fh_desc;

  print_buff(COMPONENT_FILEHANDLE, (char *)pfsalhandle, sizeof(fsal_handle_t));

  /* zero-ification of the buffer to be used as handle */
  memset(pfh2, 0, sizeof(struct alloc_file_handle_v2));
  file_handle = (file_handle_v2_t *)pfh2;

  /* Fill in the fs opaque part */
  fh_desc.start = (caddr_t) &file_handle->fsopaque;
  fh_desc.len = sizeof(file_handle->fsopaque);
  fsal_status =
      FSAL_DigestHandle(&pexport->FS_export_context, FSAL_DIGEST_NFSV2, pfsalhandle,
                        &fh_desc);
  if(FSAL_IS_ERROR(fsal_status))
   {
     if( fsal_status.major == ERR_FSAL_TOOSMALL )
      LogCrit( COMPONENT_FILEHANDLE, "NFSv2 file handle is too small to manage this fsal" ) ;
     else
      LogCrit( COMPONENT_FILEHANDLE, "FSAL_DigestHandle return (%u,%u) when called from %s", 
               fsal_status.major, fsal_status.minor, __func__ ) ;
    return 0;
   }

  file_handle->fhversion = GANESHA_FH_VERSION;
  /* keep track of the export id */
  file_handle->exportid = pexport->id;

  /* Set the last byte */
  file_handle->xattr_pos = 0;

/*   /\* Set the data *\/ */
/*   memcpy((caddr_t) pfh2, &file_handle, sizeof(file_handle_v2_t)); */

  print_fhandle2(COMPONENT_FILEHANDLE, pfh2);

  return 1;
}                               /* nfs2_FSALToFhandle */

short nfs4_FhandleToExportId(nfs_fh4 * pfh4)
{
  file_handle_v4_t *pfile_handle = NULL;

  pfile_handle = (file_handle_v4_t *) (pfh4->nfs_fh4_val);

  if(pfile_handle == NULL)
    return -1;                  /* Badly formed arguments */

  return pfile_handle->exportid;
}                               /* nfs4_FhandleToExportId */

short nfs3_FhandleToExportId(nfs_fh3 * pfh3)
{
  file_handle_v3_t *pfile_handle;

  pfile_handle = (file_handle_v3_t *) (pfh3->data.data_val);

  if(pfile_handle == NULL)
    return -1;                  /* Badly formed argument */

  print_buff(COMPONENT_FILEHANDLE, (char *)pfh3->data.data_val, pfh3->data.data_len);

  return pfile_handle->exportid;
}                               /* nfs3_FhandleToExportId */

#ifdef _USE_NLM
short nlm4_FhandleToExportId(netobj * pfh3)
{
  file_handle_v3_t *pfile_handle;

  if(pfh3->n_bytes == NULL || pfh3->n_len < sizeof(file_handle_v3_t))
    return -1;                  /* Badly formed argument */

  pfile_handle = (file_handle_v3_t *) (pfh3->n_bytes);

  print_buff(COMPONENT_FILEHANDLE, pfh3->n_bytes, pfh3->n_len);

  return pfile_handle->exportid;
}
#endif

short nfs2_FhandleToExportId(fhandle2 * pfh2)
{
  file_handle_v2_t *pfile_handle;

  pfile_handle = (file_handle_v2_t *) (*pfh2);

  if(pfile_handle == NULL)
    return -1;                  /* Badly formed argument */

  return pfile_handle->exportid;
}                               /* nfs2_FhandleToExportId */

int nfs3_Is_Fh_Xattr(nfs_fh3 * pfh)
{
  file_handle_v3_t *pfhandle3;

  if(pfh == NULL)
    return 0;

  pfhandle3 = (file_handle_v3_t *) (pfh->data.data_val);

  return (pfhandle3->xattr_pos != 0) ? 1 : 0;
}                               /* nfs4_Is_Fh_Xattr */

int nfs4_Is_Fh_Empty(nfs_fh4 * pfh)
{
  if(pfh == NULL)
    return NFS4ERR_NOFILEHANDLE;

  if(pfh->nfs_fh4_len == 0)
    return NFS4ERR_NOFILEHANDLE;

  return 0;
}                               /* nfs4_Is_Fh_Empty */

int nfs4_Is_Fh_Xattr(nfs_fh4 * pfh)
{
  file_handle_v4_t *pfhandle4;

  if(pfh == NULL)
    return 0;

  pfhandle4 = (file_handle_v4_t *) (pfh->nfs_fh4_val);

  return (pfhandle4->xattr_pos != 0) ? 1 : 0;
}                               /* nfs4_Is_Fh_Xattr */

int nfs4_Is_Fh_Pseudo(nfs_fh4 * pfh)
{
  file_handle_v4_t *pfhandle4;

  if(pfh == NULL)
    return 0;

  pfhandle4 = (file_handle_v4_t *) (pfh->nfs_fh4_val);

  return pfhandle4->pseudofs_flag;
}                               /* nfs4_Is_Fh_Pseudo */

int nfs4_Is_Fh_DSHandle(nfs_fh4 * pfh)
{
  file_handle_v4_t *pfhandle4;

  if(pfh == NULL)
    return 0;

  pfhandle4 = (file_handle_v4_t *) (pfh->nfs_fh4_val);

  return pfhandle4->ds_flag;
}                               /* nfs4_Is_Fh_DSHandle */

int nfs4_Is_Fh_Expired(nfs_fh4 * pfh)
{
  file_handle_v4_t *pfilehandle4;

  if(pfh == NULL)
    return NFS4ERR_BADHANDLE;

  pfilehandle4 = (file_handle_v4_t *) pfh;

  if((nfs_param.nfsv4_param.fh_expire == TRUE)
     && (pfilehandle4->srvboot_time != (unsigned int)ServerBootTime))
    {
      if(nfs_param.nfsv4_param.returns_err_fh_expired == TRUE)
        return NFS4ERR_FHEXPIRED;
    }

  return NFS4_OK;
}                               /* nfs4_Is_Fh_Expired */

int nfs4_Is_Fh_Invalid(nfs_fh4 * pfh)
{
  file_handle_v4_t *pfilehandle4;

  if(pfh == NULL || pfh->nfs_fh4_val == NULL)
  {
    LogMajor(COMPONENT_FILEHANDLE,
             "Invalid (NULL) File handle: pfh=0x%p",
             pfh);
    return NFS4ERR_BADHANDLE;
  }

  pfilehandle4 = (file_handle_v4_t *) pfh->nfs_fh4_val;
  if(pfh->nfs_fh4_len > sizeof(struct alloc_file_handle_v4) ||
     pfh->nfs_fh4_len < nfs4_sizeof_handle(pfilehandle4) ||
     pfilehandle4->fhversion != GANESHA_FH_VERSION)
  {
    LogMajor(COMPONENT_FILEHANDLE,
             "Invalid File handle: len=%d, version=%x",
             pfh->nfs_fh4_len,
             pfilehandle4->fhversion);
    return NFS4ERR_BADHANDLE;
  }

  return NFS4_OK;
}                               /* nfs4_Is_Fh_Invalid */

int nfs3_Is_Fh_Invalid(nfs_fh3 *pfh3)
{
  file_handle_v3_t *pfilehandle3;

  if(pfh3 == NULL || pfh3->data.data_val == NULL)
  {
    LogMajor(COMPONENT_FILEHANDLE,
             "Invalid (NULL) File handle: pfh3=0x%p",
             pfh3);
    return NFS3ERR_BADHANDLE;
  }

  pfilehandle3 = (file_handle_v3_t *) pfh3->data.data_val;
  if(pfh3->data.data_len > sizeof(struct alloc_file_handle_v3) ||
     pfh3->data.data_len < nfs3_sizeof_handle(pfilehandle3) ||
     pfilehandle3->fhversion != GANESHA_FH_VERSION)
  {
    LogMajor(COMPONENT_FILEHANDLE,
             "Invalid File handle: len=%d, version=%x",
             pfh3->data.data_len,
             pfilehandle3->fhversion);
    return NFS3ERR_BADHANDLE;
  }

  return NFS3_OK;
}                               /* nfs4_Is_Fh_Invalid */

int nfs4_Is_Fh_Referral(nfs_fh4 * pfh)
{
  file_handle_v4_t *pfhandle4;

  if(pfh == NULL)
    return 0;

  pfhandle4 = (file_handle_v4_t *) (pfh->nfs_fh4_val);

  /* Referrals are fh whose pseudofs_id is set without pseudofs_flag set */
  if(pfhandle4->refid > 0)
    {
      return TRUE;
    }

  return FALSE;
}                               /* nfs4_Is_Fh_Referral */

void print_fhandle2(log_components_t component, fhandle2 *fh)
{
  if(isFullDebug(component))
    {
      char str[LEN_FH_STR];

      sprint_fhandle2(str, fh);
      LogFullDebug(component, "%s", str);
    }
}                               /* print_fhandle2 */

void sprint_fhandle2(char *str, fhandle2 *fh)
{
  char *tmp = str +  sprintf(str, "File Handle V2: ");

  sprint_mem(tmp, (char *) fh, 32);
}                               /* sprint_fhandle2 */

void print_fhandle3(log_components_t component, nfs_fh3 *fh)
{
  if(isFullDebug(component))
    {
      char str[LEN_FH_STR];

      sprint_fhandle3(str, fh);
      LogFullDebug(component, "%s", str);
    }
}                               /* print_fhandle3 */

void sprint_fhandle3(char *str, nfs_fh3 *fh)
{
  char *tmp = str + sprintf(str, "File Handle V3: Len=%u ", fh->data.data_len);

  sprint_mem(tmp, fh->data.data_val, fh->data.data_len);
}                               /* sprint_fhandle3 */

void print_fhandle4(log_components_t component, nfs_fh4 *fh)
{
  if(isFullDebug(component))
    {
      char str[LEN_FH_STR];

      sprint_fhandle4(str, fh);
      LogFullDebug(component, "%s", str);
    }
}                               /* print_fhandle4 */

void sprint_fhandle4(char *str, nfs_fh4 *fh)
{
  char *tmp = str + sprintf(str, "File Handle V4: Len=%u ", fh->nfs_fh4_len);

  sprint_mem(tmp, fh->nfs_fh4_val, fh->nfs_fh4_len);
}                               /* sprint_fhandle4 */

void print_fhandle_nlm(log_components_t component, netobj *fh)
{
  if(isFullDebug(component))
    {
      char str[LEN_FH_STR];

      sprint_fhandle_nlm(str, fh);
      LogFullDebug(component, "%s", str);
    }
}                               /* print_fhandle_nlm */

void sprint_fhandle_nlm(char *str, netobj *fh)
{
  char *tmp = str + sprintf(str, "File Handle V3: Len=%u ", fh->n_len);

  sprint_mem(tmp, fh->n_bytes, fh->n_len);
}                               /* sprint_fhandle_nlm */

void print_buff(log_components_t component, char *buff, int len)
{
  if(isFullDebug(component))
    {
      char str[1024];

      sprint_buff(str, buff, len);
      LogFullDebug(component, "%s", str);
    }
}                               /* print_buff */

void sprint_buff(char *str, char *buff, int len)
{
  char *tmp = str + sprintf(str, "  Len=%u Buff=%p Val: ", len, buff);

  sprint_mem(tmp, buff, len);
}                               /* sprint_buff */

void sprint_mem(char *str, char *buff, int len)
{
  int i;

  if(buff == NULL)
    sprintf(str, "<null>");
  else for(i = 0; i < len; i++)
    sprintf(str + i * 2, "%02x", (unsigned char)buff[i]);
}

void LogCompoundFH(compound_data_t * data)
{
  if(isFullDebug(COMPONENT_FILEHANDLE))
    {
      char str[LEN_FH_STR];
      
      sprint_fhandle4(str, &data->currentFH);
      LogFullDebug(COMPONENT_FILEHANDLE, "Current FH  %s", str);
      
      sprint_fhandle4(str, &data->savedFH);
      LogFullDebug(COMPONENT_FILEHANDLE, "Saved FH    %s", str);
      
      sprint_fhandle4(str, &data->publicFH);
      LogFullDebug(COMPONENT_FILEHANDLE, "Public FH   %s", str);
      
      sprint_fhandle4(str, &data->rootFH);
      LogFullDebug(COMPONENT_FILEHANDLE, "Root FH     %s", str);
    }
}                               /* print_compoud_fh */

void nfs4_sprint_fhandle(nfs_fh4 * fh4p, char *outstr)
{
  char *tmp = outstr + sprintf(outstr, "File Handle V4: Len=%u ", fh4p->nfs_fh4_len);

  sprint_mem(tmp, (char *)fh4p->nfs_fh4_val, fh4p->nfs_fh4_len);
}                               /* nfs4_sprint_fhandle */