nfs_remote_functions.c

Go to the documentation of this file.

/*
 * vim:expandtab:shiftwidth=8:tabstop=8:
 *
 *
 * 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
 * 
 * ---------------------------------------
 *
 * nfs_remote_functions.c : Functions for NFS protocol through RPCs. 
 *
 *
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

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

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/file.h>           /* for having FNDELAY */
#include "log.h"
#include "ganesha_rpc.h"
#include "nfs23.h"
#include "nfs4.h"
#include "nfs_core.h"
#include "nfs_tools.h"
#include "mount.h"

#include "nfs_remote_functions.h"

static struct timeval TIMEOUT = { 25, 0 };

int mnt1_remote_Null(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, MOUNTPROC2_NULL,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int mnt1_remote_Mnt(CLIENT * clnt /* IN  */ ,
                    nfs_arg_t * parg /* IN  */ ,
                    nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt1_remote_Mnt\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(fhstatus2));
  return clnt_call(clnt, MOUNTPROC2_MNT,
                   (xdrproc_t) xdr_dirpath, (caddr_t) parg,
                   (xdrproc_t) xdr_fhstatus2, (caddr_t) pres, TIMEOUT);
}

int mnt1_remote_Dump(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt1_remote_Dump\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(mountlist));
  return clnt_call(clnt, MOUNTPROC2_DUMP,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_mountlist, (caddr_t) pres, TIMEOUT);
}

int mnt1_remote_Umnt(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt1_remote_Umnt\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, MOUNTPROC2_UMNT,
                   (xdrproc_t) xdr_dirpath, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int mnt1_remote_UmntAll(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt1_remote_UmntAll\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, MOUNTPROC2_UMNTALL,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int mnt1_remote_Export(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt1_remote_Export\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(exports));
  return clnt_call(clnt, MOUNTPROC2_EXPORT,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_exports, (caddr_t) pres, TIMEOUT);
}

int mnt3_remote_Null(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt3_remote_Null\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, MOUNTPROC3_NULL,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int mnt3_remote_Mnt(CLIENT * clnt /* IN  */ ,
                    nfs_arg_t * parg /* IN  */ ,
                    nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt3_remote_Mnt\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(mountres3));
  return clnt_call(clnt, MOUNTPROC3_MNT,
                   (xdrproc_t) xdr_dirpath, (caddr_t) parg,
                   (xdrproc_t) xdr_mountres3, (caddr_t) pres, TIMEOUT);
}

int mnt3_remote_Dump(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt3_remote_Dump\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(mountlist));
  return clnt_call(clnt, MOUNTPROC3_DUMP,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_mountlist, (caddr_t) pres, TIMEOUT);
}

int mnt3_remote_Umnt(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt3_remote_Umnt\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, MOUNTPROC3_UMNT,
                   (xdrproc_t) xdr_dirpath, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int mnt3_remote_UmntAll(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt3_remote_UmntAll\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, MOUNTPROC3_UMNTALL,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int mnt3_remote_Export(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling mnt3_remote_Export\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(exports));
  return clnt_call(clnt, MOUNTPROC3_EXPORT,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_exports, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Null(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Null\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, NFSPROC_NULL,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Getattr(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Getattr\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(ATTR2res));
  return clnt_call(clnt, NFSPROC_GETATTR,
                   (xdrproc_t) xdr_fhandle2, (caddr_t) parg,
                   (xdrproc_t) xdr_ATTR2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Setattr(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Setattr\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(ATTR2res));
  return clnt_call(clnt, NFSPROC_SETATTR,
                   (xdrproc_t) xdr_SETATTR2args, (caddr_t) parg,
                   (xdrproc_t) xdr_ATTR2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Root(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Root\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, NFSPROC_ROOT,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Lookup(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Lookup\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(DIROP2res));
  return clnt_call(clnt, NFSPROC_LOOKUP,
                   (xdrproc_t) xdr_diropargs2, (caddr_t) parg,
                   (xdrproc_t) xdr_DIROP2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Readlink(CLIENT * clnt /* IN  */ ,
                         nfs_arg_t * parg /* IN  */ ,
                         nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Readlink\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(READLINK2res));
  return clnt_call(clnt, NFSPROC_READLINK,
                   (xdrproc_t) xdr_fhandle2, (caddr_t) parg,
                   (xdrproc_t) xdr_READLINK2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Read(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Read\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(READ2res));
  return clnt_call(clnt, NFSPROC_READ,
                   (xdrproc_t) xdr_READ2args, (caddr_t) parg,
                   (xdrproc_t) xdr_READ2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Writecache(CLIENT * clnt /* IN  */ ,
                           nfs_arg_t * parg /* IN  */ ,
                           nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Writecache\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, NFSPROC_WRITECACHE,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Write(CLIENT * clnt /* IN  */ ,
                      nfs_arg_t * parg /* IN  */ ,
                      nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Write\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(ATTR2res));
  return clnt_call(clnt, NFSPROC_WRITE,
                   (xdrproc_t) xdr_WRITE2args, (caddr_t) parg,
                   (xdrproc_t) xdr_ATTR2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Create(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Create\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(DIROP2res));
  return clnt_call(clnt, NFSPROC_CREATE,
                   (xdrproc_t) xdr_CREATE2args, (caddr_t) parg,
                   (xdrproc_t) xdr_DIROP2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Remove(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Remove\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(nfsstat2));
  return clnt_call(clnt, NFSPROC_REMOVE,
                   (xdrproc_t) xdr_diropargs2, (caddr_t) parg,
                   (xdrproc_t) xdr_nfsstat2, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Rename(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Rename\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(nfsstat2));
  return clnt_call(clnt, NFSPROC_RENAME,
                   (xdrproc_t) xdr_RENAME2args, (caddr_t) parg,
                   (xdrproc_t) xdr_nfsstat2, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Link(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Link\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(nfsstat2));
  return clnt_call(clnt, NFSPROC_LINK,
                   (xdrproc_t) xdr_LINK2args, (caddr_t) parg,
                   (xdrproc_t) xdr_nfsstat2, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Symlink(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Symlink\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(nfsstat2));
  return clnt_call(clnt, NFSPROC_SYMLINK,
                   (xdrproc_t) xdr_SYMLINK2args, (caddr_t) parg,
                   (xdrproc_t) xdr_nfsstat2, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Mkdir(CLIENT * clnt /* IN  */ ,
                      nfs_arg_t * parg /* IN  */ ,
                      nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Mkdir\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(DIROP2res));
  return clnt_call(clnt, NFSPROC_MKDIR,
                   (xdrproc_t) xdr_CREATE2args, (caddr_t) parg,
                   (xdrproc_t) xdr_DIROP2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Rmdir(CLIENT * clnt /* IN  */ ,
                      nfs_arg_t * parg /* IN  */ ,
                      nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Rmdir\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(nfsstat2));
  return clnt_call(clnt, NFSPROC_RMDIR,
                   (xdrproc_t) xdr_diropargs2, (caddr_t) parg,
                   (xdrproc_t) xdr_nfsstat2, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Readdir(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Readdir\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(READDIR2res));
  return clnt_call(clnt, NFSPROC_READDIR,
                   (xdrproc_t) xdr_READDIR2args, (caddr_t) parg,
                   (xdrproc_t) xdr_READDIR2res, (caddr_t) pres, TIMEOUT);
}

int nfs2_remote_Fsstat(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs2_remote_Fsstat\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(STATFS2res));
  return clnt_call(clnt, NFSPROC_STATFS,
                   (xdrproc_t) xdr_fhandle2, (caddr_t) parg,
                   (xdrproc_t) xdr_STATFS2res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Null(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Null\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, NFSPROC3_NULL,
                   (xdrproc_t) xdr_void, (caddr_t) parg,
                   (xdrproc_t) xdr_void, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Getattr(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Getattr\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(GETATTR3res));
  return clnt_call(clnt, NFSPROC3_GETATTR,
                   (xdrproc_t) xdr_GETATTR3args, (caddr_t) parg,
                   (xdrproc_t) xdr_GETATTR3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Setattr(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Setattr\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(SETATTR3res));
  return clnt_call(clnt, NFSPROC3_SETATTR,
                   (xdrproc_t) xdr_SETATTR3args, (caddr_t) parg,
                   (xdrproc_t) xdr_SETATTR3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Lookup(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Lookup\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(LOOKUP3res));
  return clnt_call(clnt, NFSPROC3_LOOKUP,
                   (xdrproc_t) xdr_LOOKUP3args, (caddr_t) parg,
                   (xdrproc_t) xdr_LOOKUP3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Readlink(CLIENT * clnt /* IN  */ ,
                         nfs_arg_t * parg /* IN  */ ,
                         nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Readlink\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(READLINK3res));
  return clnt_call(clnt, NFSPROC3_READLINK,
                   (xdrproc_t) xdr_READLINK3args, (caddr_t) parg,
                   (xdrproc_t) xdr_READLINK3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Read(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Read\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(READ3res));
  return clnt_call(clnt, NFSPROC3_READ,
                   (xdrproc_t) xdr_READ3args, (caddr_t) parg,
                   (xdrproc_t) xdr_READ3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Write(CLIENT * clnt /* IN  */ ,
                      nfs_arg_t * parg /* IN  */ ,
                      nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Write\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(WRITE3res));
  return clnt_call(clnt, NFSPROC3_WRITE,
                   (xdrproc_t) xdr_WRITE3args, (caddr_t) parg,
                   (xdrproc_t) xdr_WRITE3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Create(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Create\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(CREATE3res));
  return clnt_call(clnt, NFSPROC3_CREATE,
                   (xdrproc_t) xdr_CREATE3args, (caddr_t) parg,
                   (xdrproc_t) xdr_CREATE3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Remove(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Remove\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(REMOVE3res));
  return clnt_call(clnt, NFSPROC3_REMOVE,
                   (xdrproc_t) xdr_REMOVE3args, (caddr_t) parg,
                   (xdrproc_t) xdr_REMOVE3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Rename(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Rename\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(RENAME3res));
  return clnt_call(clnt, NFSPROC3_RENAME,
                   (xdrproc_t) xdr_RENAME3args, (caddr_t) parg,
                   (xdrproc_t) xdr_RENAME3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Link(CLIENT * clnt /* IN  */ ,
                     nfs_arg_t * parg /* IN  */ ,
                     nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Link\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(LINK3res));
  return clnt_call(clnt, NFSPROC3_LINK,
                   (xdrproc_t) xdr_LINK3args, (caddr_t) parg,
                   (xdrproc_t) xdr_LINK3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Symlink(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Symlink\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(SYMLINK3res));
  return clnt_call(clnt, NFSPROC3_SYMLINK,
                   (xdrproc_t) xdr_SYMLINK3args, (caddr_t) parg,
                   (xdrproc_t) xdr_SYMLINK3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Mkdir(CLIENT * clnt /* IN  */ ,
                      nfs_arg_t * parg /* IN  */ ,
                      nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Mkdir\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(MKDIR3res));
  return clnt_call(clnt, NFSPROC3_MKDIR,
                   (xdrproc_t) xdr_MKDIR3args, (caddr_t) parg,
                   (xdrproc_t) xdr_MKDIR3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Rmdir(CLIENT * clnt /* IN  */ ,
                      nfs_arg_t * parg /* IN  */ ,
                      nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Rmdir\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(RMDIR3res));
  return clnt_call(clnt, NFSPROC3_RMDIR,
                   (xdrproc_t) xdr_RMDIR3args, (caddr_t) parg,
                   (xdrproc_t) xdr_RMDIR3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Readdir(CLIENT * clnt /* IN  */ ,
                        nfs_arg_t * parg /* IN  */ ,
                        nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Readdir\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(READDIR3res));
  return clnt_call(clnt, NFSPROC3_READDIR,
                   (xdrproc_t) xdr_READDIR3args, (caddr_t) parg,
                   (xdrproc_t) xdr_READDIR3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Fsstat(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Fsstat\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(FSSTAT3res));
  return clnt_call(clnt, NFSPROC3_FSSTAT,
                   (xdrproc_t) xdr_FSSTAT3args, (caddr_t) parg,
                   (xdrproc_t) xdr_FSSTAT3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Access(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Access\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(ACCESS3res));
  return clnt_call(clnt, NFSPROC3_ACCESS,
                   (xdrproc_t) xdr_ACCESS3args, (caddr_t) parg,
                   (xdrproc_t) xdr_ACCESS3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Readdirplus(CLIENT * clnt /* IN  */ ,
                            nfs_arg_t * parg /* IN  */ ,
                            nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Readdirplus\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(READDIRPLUS3res));
  return clnt_call(clnt, NFSPROC3_READDIRPLUS,
                   (xdrproc_t) xdr_READDIRPLUS3args, (caddr_t) parg,
                   (xdrproc_t) xdr_READDIRPLUS3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Fsinfo(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Fsinfo\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(FSINFO3res));
  return clnt_call(clnt, NFSPROC3_FSINFO,
                   (xdrproc_t) xdr_FSINFO3args, (caddr_t) parg,
                   (xdrproc_t) xdr_FSINFO3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Pathconf(CLIENT * clnt /* IN  */ ,
                         nfs_arg_t * parg /* IN  */ ,
                         nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Pathconf\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(PATHCONF3res));
  return clnt_call(clnt, NFSPROC3_PATHCONF,
                   (xdrproc_t) xdr_PATHCONF3args, (caddr_t) parg,
                   (xdrproc_t) xdr_PATHCONF3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Commit(CLIENT * clnt /* IN  */ ,
                       nfs_arg_t * parg /* IN  */ ,
                       nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Commit\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(COMMIT3res));
  return clnt_call(clnt, NFSPROC3_COMMIT,
                   (xdrproc_t) xdr_COMMIT3args, (caddr_t) parg,
                   (xdrproc_t) xdr_COMMIT3res, (caddr_t) pres, TIMEOUT);
}

int nfs3_remote_Mknod(CLIENT * clnt /* IN  */ ,
                      nfs_arg_t * parg /* IN  */ ,
                      nfs_res_t * pres /* OUT */ )
{
  //printf("REQUEST PROCESSING: Calling nfs3_remote_Mknod\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(MKNOD3res));
  return clnt_call(clnt, NFSPROC3_MKNOD,
                   (xdrproc_t) xdr_MKNOD3args, (caddr_t) parg,
                   (xdrproc_t) xdr_MKNOD3res, (caddr_t) pres, TIMEOUT);
}

int nfs4_remote_Null(CLIENT * clnt /* IN  */ )
{
  COMPOUND4args parg;
  COMPOUND4res pres;
//      printf("REQUEST PROCESSING: Calling nfs4_remote_Null\n");
  if(clnt == NULL)
    {
      return -1;
    }

  return clnt_call(clnt, NFSPROC4_NULL,
                   (xdrproc_t) xdr_void, (caddr_t) & parg,
                   (xdrproc_t) xdr_void, (caddr_t) & pres, TIMEOUT);
}

int nfs4_remote_COMPOUND(CLIENT * clnt /* IN  */ ,
                         COMPOUND4args * parg /* IN  */ ,
                         COMPOUND4res * pres /* OUT */ )
{
//      printf("REQUEST PROCESSING: Calling nfs4_remote_COMPOUND\n");
  if(clnt == NULL)
    {
      return -1;
    }

  memset((char *)pres, 0, sizeof(COMPOUND4res) * parg->argarray.argarray_len);
  return clnt_call(clnt, NFSPROC4_COMPOUND,
                   (xdrproc_t) xdr_COMPOUND4args, (caddr_t) parg,
                   (xdrproc_t) xdr_COMPOUND4res, (caddr_t) pres, TIMEOUT);
}

/* Free functions */

void mnt1_remote_Null_Free(nfs_res_t * pres)
{
  return;
}

void mnt1_remote_Mnt_Free(nfs_res_t * pres)
{
  return;
}

void mnt1_remote_Dump_Free(nfs_res_t * pres)
{
  return;
}

void mnt1_remote_Export_Free(nfs_res_t * pres)
{
  return;
}

void mnt1_remote_Umnt_Free(nfs_res_t * pres)
{
  return;
}

void mnt1_remote_UmntAll_Free(nfs_res_t * pres)
{
  return;
}

void mnt3_remote_Null_Free(nfs_res_t * pres)
{
  return;
}

void mnt3_remote_Mnt_Free(nfs_res_t * pres)
{
  return;
}

void mnt3_remote_Dump_Free(nfs_res_t * pres)
{
  return;
}

void mnt3_remote_Export_Free(nfs_res_t * pres)
{
  return;
}

void mnt3_remote_Umnt_Free(nfs_res_t * pres)
{
  return;
}

void mnt3_remote_UmntAll_Free(nfs_res_t * pres)
{
  return;
}

void nfs2_remote_Null_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Getattr_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Setattr_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Lookup_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Read_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Write_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Create_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Mkdir_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Symlink_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Remove_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Rmdir_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Rename_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Link_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Fsstat_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Root_Free(nfs_res_t * pres)
{
  return;
}

void nfs2_remote_Writecache_Free(nfs_res_t * pres)
{
  return;
}

void nfs2_remote_Readdir_Free(nfs_res_t * resp)
{
  return;
}

void nfs2_remote_Readlink_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Null_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Getattr_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Setattr_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Lookup_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Access_Free(nfs_res_t * pres)
{
  return;
}

void nfs3_remote_Readlink_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Write_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Create_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Mkdir_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Symlink_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Mknod_Free(nfs_res_t * pres)
{
  return;
}

void nfs3_remote_Remove_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Rmdir_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Rename_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Link_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Readdir_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Readdirplus_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Fsstat_Free(nfs_res_t * resp)
{
  return;
}

void nfs3_remote_Fsinfo_Free(nfs_res_t * pres)
{
  return;
}

void nfs3_remote_Pathconf_Free(nfs_res_t * pres)
{
  return;
}

void nfs3_remote_Commit_Free(nfs_res_t * pres)
{
  return;
}

void nfs3_remote_Read_Free(nfs_res_t * resp)
{
  return;
}