nfsdlib.c

This is a source code of VxWorks

readdirres * nfsproc_readdir_2
    (
    readdirargs * readDir	/* Directory to read */
    )
    {
    struct entry *  dirEntries;
    filename *      fileNames;
    int             fileNameSize;
    int             entrySpace;
    char *          currentName;
    char *          dirName;
    DIR	*	    theDir = NULL;
    struct dirent * localEntry;
    readdirres *    retVal;
    int		    dirCount = 0;
    char *          newFile;
    int             numEntries;
    int             entryCurrent;

    if ((dirName = (char *) alloca (nfsMaxPath)) == NULL)
	return (NULL);

    if ((newFile = (char *) alloca (nfsMaxPath)) == NULL)
	return (NULL);

    /* Increment statistics */
    nfsdServerStatus.readdirCalls++;

    /* Compute the amount of space needed for each directory entry */

    fileNameSize = MEM_ROUND_UP (NAME_LEN + 1);
    entrySpace = MEM_ROUND_UP (sizeof (readdirres)) +
	         MEM_ROUND_UP (sizeof (entry)) +
	         fileNameSize;
    
    /* Compute the number of possible entries to return */
    
    numEntries = readDir->count / entrySpace;

    /* Allocate space for the entries */
    
    if ((retVal = KHEAP_ALLOC(numEntries * entrySpace)) == NULL)
	{
        return (NULL);
	}
    else
	{
	bzero ((char *) retVal, numEntries * entrySpace);
	dirEntries = ((struct entry *) retVal) + 1;
	fileNames = (filename *) (dirEntries + numEntries);
	}

    nfsdFhNtoh ((NFS_FILE_HANDLE *) &readDir->dir);
    
    /* Create the directory name */
    if (nfsdFhToName ((NFS_FILE_HANDLE *) &readDir->dir, dirName) == ERROR)
    	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    /* Open the directory and set the cookie field to what was
     * passed in readDir
     */
    if ((theDir = opendir (dirName)) == NULL)
    	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}
    else
        theDir->dd_cookie = *((int *) &readDir->cookie);

    retVal->readdirres_u.reply.eof = FALSE;
    
    /* Read through all the files in the directory */
    for (entryCurrent = 0; entryCurrent < numEntries; entryCurrent++)
	{
	errno = OK;
	localEntry = readdir (theDir);
	if (localEntry == NULL)
	    {
	    if (errno != OK)
		{
		retVal->status = nfsdErrToNfs (errno);
		closedir (theDir);
		return (retVal);
		}
	    else
		{
		retVal->readdirres_u.reply.eof = TRUE;
		if (entryCurrent != 0)
		    dirEntries[entryCurrent - 1].nextentry = NULL;
		else
		    retVal->readdirres_u.reply.entries = NULL;
	        break;
		}
	    }

	strcpy (newFile, dirName);
	strcat (newFile, "/");
	strcat (newFile, localEntry->d_name);
	dirEntries[entryCurrent].fileid = 
	   nameToInode (((NFS_FILE_HANDLE *) &readDir->dir)->volumeId, newFile);
	if (dirEntries[entryCurrent].fileid == ERROR)
	    {
	    retVal->status = nfsdErrToNfs (errno);
	    closedir (theDir);
	    return (retVal);
	    }
	currentName = ((char *) fileNames) + entryCurrent * fileNameSize;
	strcpy(currentName, localEntry->d_name);
	dirEntries[entryCurrent].name = currentName;
	*((int *) dirEntries[entryCurrent].cookie) = theDir->dd_cookie;

	if (entryCurrent == numEntries - 1)
	    dirEntries[entryCurrent].nextentry = NULL;
	else
	    dirEntries[entryCurrent].nextentry = &dirEntries[entryCurrent + 1];
	    
	dirCount++;
	}

    retVal->status = NFS_OK;

    if (dirCount != 0)
	retVal->readdirres_u.reply.entries = dirEntries;
    else
	retVal->readdirres_u.reply.entries = NULL;

    closedir (theDir);

    return (retVal);
    }

/******************************************************************************
*
* nfsproc_statfs_2 - Get filesystem attributes
* 
* Return information about the filesystem.  The NFS equivalent of statfs().
*
* NOMANUAL
*/

statfsres * nfsproc_statfs_2
    (
    nfs_fh * fh
    )
    {
    char *        fileName;
    struct statfs statInfo;
    statfsres *   retVal = KHEAP_ALLOC(sizeof (statfsres));

    if (retVal == NULL)
        return (NULL);

    if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)
	return (NULL);

    /* Increment statistics */
    nfsdServerStatus.statfsCalls++;

    nfsdFhNtoh ((NFS_FILE_HANDLE *) fh);

    if (nfsdFhToName ((NFS_FILE_HANDLE *) fh, fileName) == ERROR)
    	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    if (statfs (fileName, &statInfo) == ERROR)
    	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    retVal->status = NFS_OK;
    retVal->statfsres_u.reply.tsize  = 8 * 1024;
    retVal->statfsres_u.reply.bsize  = statInfo.f_bsize;
    retVal->statfsres_u.reply.blocks = statInfo.f_blocks;
    retVal->statfsres_u.reply.bfree  = statInfo.f_bfree;
    retVal->statfsres_u.reply.bavail = statInfo.f_bavail;
    return (retVal);
    }

/******************************************************************************
*
* nfsdStatusGet - get the status of the NFS server
* 
* This routine gets status information about the NFS server.
* 
* RETURNS: OK, or ERROR if the information cannot be obtained.
*/

STATUS nfsdStatusGet
    (
    NFS_SERVER_STATUS * serverStats /* pointer to status structure */
    )
    {
    memcpy (serverStats, &nfsdServerStatus, sizeof (nfsdServerStatus));
    return (OK);
    }

/******************************************************************************
*
* nfsdStatusShow - show the status of the NFS server
* 
* This routine shows status information about the NFS server.
* 
* RETURNS: OK, or ERROR if the information cannot be obtained.
*/

STATUS nfsdStatusShow
    (
    int options			/* unused */
    )
    {
    NFS_SERVER_STATUS serverStat;
    char*             outputFormat = "%15s	%8d\n";

    if (nfsdStatusGet (&serverStat) == ERROR)
        return (ERROR);

    printf ("%15s    %8s\n", "Service", "Number of Calls");
    printf ("%15s    %8s\n", "-------", "---------------");
    printf (outputFormat, "null", serverStat.nullCalls);
    printf (outputFormat, "getattr", serverStat.getattrCalls);
    printf (outputFormat, "setattr", serverStat.setattrCalls);
    printf (outputFormat, "root", serverStat.rootCalls);
    printf (outputFormat, "lookup", serverStat.lookupCalls);
    printf (outputFormat, "readlink", serverStat.readlinkCalls);
    printf (outputFormat, "read", serverStat.readCalls);
    printf (outputFormat, "writecache", serverStat.writecacheCalls);
    printf (outputFormat, "write", serverStat.writeCalls);
    printf (outputFormat, "create", serverStat.createCalls);
    printf (outputFormat, "remove", serverStat.removeCalls);
    printf (outputFormat, "rename", serverStat.renameCalls);
    printf (outputFormat, "link", serverStat.linkCalls);
    printf (outputFormat, "symlink", serverStat.symlinkCalls);
    printf (outputFormat, "mkdir", serverStat.mkdirCalls);
    printf (outputFormat, "rmdir", serverStat.rmdirCalls);
    printf (outputFormat, "readdir", serverStat.readdirCalls);
    printf (outputFormat, "statfs", serverStat.statfsCalls);

    return (OK);
    }


/******************************************************************************
*
* nfsdFhCreate - Create an NFS file handle
*
* Given a handle to the parent directory, and the name of a file inside that
* directory, create a new file handle that specifies the file.
* 
* RETURNS:  OK, or ERROR if a file handle for the specified file could not be
* created.
*
* NOMANUAL
*/

STATUS nfsdFhCreate
    (
    NFS_FILE_HANDLE * parentDir,
    char *            fileName,
    NFS_FILE_HANDLE * fh
    )
    {
    struct stat       str;
    char *            fullName;
    char              *p;       /* to remove slash from end of fileName */

    if ((fullName = (char *) alloca (nfsMaxPath)) == NULL)
	return (ERROR);

    memset (fh, 0, NFS_FHSIZE);
    
    if (nfsdFhToName (parentDir, fullName) == ERROR)
        return (ERROR);
    
    /* build fullname, but remove slash from the end of fileName */
    /* in order to lkup correspond name from nfsHash             */
 
    strcat (fullName, "/");
    strcat (fullName, fileName);
    pathCondense (fullName);
    for (p = strchr (fullName, EOS); p != fullName && *--p == '/'; )
         *p = EOS;
    if (stat (fullName, &str) == ERROR)
        return (ERROR);
    fh->volumeId = parentDir->volumeId;
    fh->fsId     = parentDir->fsId;
    fh->inode    = nfsNmLkupIns (parentDir->volumeId, fullName);
    if (fh->inode == ERROR)
	return (ERROR);
    return (OK);
    }

/******************************************************************************
*
* nfsdFhToName - Convert a file handle to a complete file name
* 
* Given a file handle, fill in the variable fileName with a string specifying
* that file.
* 
* RETURNS:  OK, or ERROR if the file name could not be created.
*
* NOMANUAL
*/

STATUS nfsdFhToName
    (
    NFS_FILE_HANDLE * fh,
    char *            fileName
    )
    {
    NFS_EXPORT_ENTRY *  fileSys;

    if ((fileSys = nfsExportFindById (fh->volumeId)) == NULL)
        return (ERROR);

    if (nfsFhLkup (fh, fileName) == ERROR)
        {
	errno = NFSERR_STALE;
        return (ERROR);
	}
    return (OK);
    }

/******************************************************************************
*
* nfsdFattrGet - Get the file attributes for a file specified by a file handle
* 
* Given a file handle, fill in the file attribute structure pointed to by
* fileAttributes.
* 
* RETURNS:  OK, or ERROR if the file attributes could not be obtained.
*
* NOMANUAL
*/

STATUS nfsdFattrGet
    (
    NFS_FILE_HANDLE * fh,
    struct fattr *    fileAttributes
    )
    {
    char *         fileName;
    struct stat    str;
    
    if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)
	return (ERROR);

    if (nfsdFhToName (fh, fileName) == ERROR)
        return (ERROR);
    
    if (stat (fileName, &str) == ERROR)
        return (ERROR);

    /* set the type */

    switch (str.st_mode & S_IFMT)
	{
	case S_IFIFO:
	    fileAttributes->type = NFFIFO;
	    break;
	case S_IFCHR:
	    fileAttributes->type = NFCHR;
	    break;
	case S_IFDIR:
	    fileAttributes->type = NFDIR;
	    break;
	case S_IFBLK:
	    fileAttributes->type = NFBLK;
	    break;
	case S_IFREG:
	    fileAttributes->type = NFREG;
	    break;
	case S_IFLNK:
	    fileAttributes->type = NFLNK;
	    break;
	case S_IFSOCK:
	    fileAttributes->type = NFSOCK;
	    break;
	}

    fileAttributes->mode      = str.st_mode;
    fileAttributes->nlink     = str.st_nlink;
    fileAttributes->uid       = str.st_uid;
    fileAttributes->gid       = str.st_gid;
    fileAttributes->size      = str.st_size;
    fileAttributes->blocksize = str.st_blksize;
    fileAttributes->rdev      = str.st_rdev;
    fileAttributes->blocks    = str.st_blocks + 1;
    fileAttributes->fileid    = fh->inode;
    fileAttributes->fsid      = str.st_dev;
    fileAttributes->rdev      = str.st_rdev;

    fileAttributes->atime.seconds = str.st_atime;
    fileAttributes->mtime.seconds = str.st_mtime;
    fileAttributes->ctime.seconds = str.st_ctime;

    fileAttributes->atime.useconds = 0;
    fileAttributes->mtime.useconds = 0;
    fileAttributes->ctime.useconds = 0;

    return (OK);
    }

/******************************************************************************
*
* nfsdErrToNfs - Convert a VxWorks error number to an NFS error number
* 
* Given a VxWorks error number, find the equivalent NFS error number.
* If an exact match is not found, return NFSERR_IO.
* 
* RETURNS:  The NFS error number.
*
* NOMANUAL
*/

nfsstat nfsdErrToNfs
    (
    int theErr			/* The error number to convert  */
    )
    {
    switch (theErr)
	{
	case EPERM:
	case S_dosFsLib_READ_ONLY:
	case S_dosFsLib_WRITE_ONLY:
	    return (NFSERR_PERM);
	    break;
	    
	case ENOENT:
	case S_dosFsLib_FILE_NOT_FOUND:
	    return (NFSERR_NOENT);
	    break;

	case EIO:
	    return (NFSERR_IO);
	    break;
	    
	case ENXIO:
	case S_dosFsLib_VOLUME_NOT_AVAILABLE:
	    return (NFSERR_NXIO);
	    break;
	    
	case EACCES:
	    return (NFSERR_ACCES);
	    break;
	    
	case EEXIST:
	case S_dosFsLib_FILE_EXISTS:
	    return (NFSERR_EXIST);
	    break;

	case ENODEV:
	    return (NFSERR_NODEV);
	    break;
	    
	case ENOTDIR:
	case S_dosFsLib_NOT_DIRECTORY:
	    return (NFSERR_NOTDIR);
	    break;
	    
	case EISDIR:
	    return (NFSERR_ISDIR);
	    break;
	    
	case EFBIG:
	    return (NFSERR_FBIG);
	    break;
	    
	case ENOSPC:
	case S_dosFsLib_DISK_FULL:
	    return (NFSERR_NOSPC);
	    break;
	    
	case EROFS:
	    return (NFSERR_ROFS);
	    break;
	    
	case ENAMETOOLONG:
	case S_dosFsLib_ILLEGAL_NAME:
	    return (NFSERR_NAMETOOLONG);
	    break;
	    
	case S_dosFsLib_DIR_NOT_EMPTY:
	case ENOTEMPTY:
	    return (NFSERR_NOTEMPTY);
	    break;
	    
        default:
	    /* If the error number is less than 100, just return it.
	     * NFS client implementations should understand anything
	     * that looks like a UNIX error number.  If it's greater than
	     * 100, return NFSERR_IO.
	     */
	
	    if (theErr < 100)
		return theErr;
	    else
		return (NFSERR_IO);

	    break;
	}
    }


/******************************************************************************
*
* nfsdFhHton - convert a file handle from host to network byte order
*
* NOMANUAL
*/

void nfsdFhHton
    (
    NFS_FILE_HANDLE * fh
    )
    {
    fh->volumeId = htonl (fh->volumeId);
    fh->fsId = htonl (fh->fsId);
    fh->inode = htonl (fh->inode);
    }

/******************************************************************************
*
* nfsdFhNtoh - convert a file handle from host to network byte order
*
* NOMANUAL
*/

void nfsdFhNtoh
    (
    NFS_FILE_HANDLE * fh
    )
    {
    fh->volumeId = ntohl (fh->volumeId);
    fh->fsId = ntohl (fh->fsId);
    fh->inode = ntohl (fh->inode);
    }

/******************************************************************************
*
* nfsdFsReadOnly - get the mode of the NFS file system
* 
* This routine returns TRUE if the filesystem that contains the file
* pointed to by <fh> is exported read-only.
* 
* RETURNS: TRUE, or FALSE if the filesystem is exported read-write.
* 
* NOMANUAL
*/

LOCAL BOOL nfsdFsReadOnly
    (
    NFS_FILE_HANDLE * fh
    )
    {
    NFS_EXPORT_ENTRY *  fileSys;

    if ((fileSys = nfsExportFindById (fh->volumeId)) == NULL)
        return (ERROR);
    else
	return (fileSys->readOnly);
    }