nfsdrv.c

vxworks的完整的源代码

    char *	fullName,		/* full file or directory name */
    int		perm			/* 4:read 2:write 1:execute */
    )
    {
    diropres	dirResult;		/* directory info returned via nfs */
    nfs_fh	dirHandle;		/* file's directory file handle */
    int		retVal;			/* return from nfsLookUpByName */

    /* NFS permissions */
 
    int     nfsPerms;			/* permissions of the opened file */
    char    machineName [AUTH_UNIX_FIELD_LEN];
    int     uid;		        /* user ID */
    int     gid;		        /* group ID */
    int     nGids;		        /* number of groups */
    int     gids [MAX_GRPS];	        /* array of group IDs */
    BOOL    sameUid = FALSE;	        /* set to TRUE if users match */
    BOOL    sameGid = FALSE;	        /* set to TRUE if groups match */

    bzero ((char *) &dirResult, sizeof (dirResult));
    bzero ((char *) &dirHandle, sizeof (dirHandle));
    bzero ((char *) &gids, sizeof (int) * MAX_GRPS);


    if ((retVal = nfsLookUpByName (pNfsDev->host, fullName, 
				   &pNfsDev->fileHandle, 
				   &dirResult, &dirHandle)) != OK)
	return (retVal);	/* ERROR/FOLLOW_LINK. errno has S_nfsLib prefix */ 

    nfsPerms = dirResult.diropres_u.diropres.attributes.mode;
    nfsAuthUnixGet (machineName, &uid, &gid, &nGids, gids);
 
    sameUid = (uid == dirResult.diropres_u.diropres.attributes.uid
               ? TRUE : FALSE);
 
    if (gid == dirResult.diropres_u.diropres.attributes.gid)
	sameGid = TRUE;
    else while (nGids)
	if (gids [--nGids] == dirResult.diropres_u.diropres.attributes.gid)
            {
            sameGid = TRUE;
            break;
	    }

    /* Check "other" permissions */
    
    if (!sameGid && !sameUid &&	((nfsPerms & perm) == perm))
        goto permission_ok;

    /* check group permissions */
    
    else if (sameGid && ((nfsPerms & (perm << 3)) == (perm << 3)))
        goto permission_ok;

    /* check user permissions */
 
    else if (sameUid && ((nfsPerms & (perm << 6)) == (perm << 6)))
        goto permission_ok;

    else
	{
	errno = S_nfsDrv_PERMISSION_DENIED;
	return (ERROR);		/* caller should set EACCES to errno */
	}

permission_ok:
    return (OK);
    }
/*******************************************************************************
*
* nfsOpen - open an NFS file
*
* This routine opens the remote file.
* Called only by the I/O system.
*
* RETURNS: pointer to open network file descriptor || FOLLOW_LINK || ERROR
*/

LOCAL int nfsOpen
    (
    NFS_DEV * pNfsDev,		/* pointer to nfs device */
    char *    fileName,		/* remote file or directory name to open */
    int       flags,		/* O_RDONLY, O_WRONLY, or O_RDWR and O_CREAT */
    int       mode		/* UNIX chmod style */
    )
    {
    int status = OK;
    char *fullName;	                /* full file or directory name */
    FAST NFS_FD * nfsFd;
    diropres dirResult;			/* directory info returned via nfs */
    int	retVal;
    nfs_fh dirHandle;			/* file's directory file handle */
    int openMode = flags & FD_MODE;	/* mode to open file with */
    					/* (O_RDONLY, O_WRONLY, or O_RDWR */
    /* NFS permissions */
    int     filePermissions;	       	/* permissions of the opened file */
    int	    requestPerms = 0;		/* requested file permissions */
    char    machineName [AUTH_UNIX_FIELD_LEN];
    int     uid;		        /* user ID */
    int     gid;		        /* group ID */
    int     nGids;		        /* number of groups */
    int     gids [MAX_GRPS];	        /* array of group IDs */
    BOOL    correctPerms = FALSE;       /* set to TRUE if perms match */
    BOOL    sameUid = FALSE;	        /* set to TRUE if users match */
    BOOL    sameGid = FALSE;	        /* set to TRUE if groups match */
    
    if ((openMode != O_RDONLY) && (openMode != O_WRONLY) && 
        (openMode != O_RDWR))
	{
	errnoSet (S_nfsDrv_BAD_FLAG_MODE);
	return (ERROR);
	}

    if (strlen (fileName) >= nfsMaxPath)
	{
	errnoSet (S_nfsLib_NFSERR_NAMETOOLONG);
	return (ERROR);
	}

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

    if (fileName [0] == EOS)
	{
	if (flags & O_CREAT)
	    {
	    errnoSet (S_nfsDrv_CREATE_NO_FILE_NAME);
	    return (ERROR);
	    }
	(void) strcpy (fullName, ".");
	}
    else
	(void) strcpy (fullName, fileName);

    /* truncate file - check the file has write-permission */

    if (flags & O_TRUNC)
	{
	int err;
	
#define READ_PERMISSION 2

        if ((err = nfsChkFilePerms (pNfsDev, fullName,
				    READ_PERMISSION)) == FOLLOW_LINK)
	    return (FOLLOW_LINK);

	else if (err == ERROR && errno == S_nfsDrv_PERMISSION_DENIED)
	    return (ERROR);	/* i.e. don't return if NFSERR_NOENT */

        else if (err == OK)
            {

	    /* the file has write-permission, go for deletion */

	    retVal = nfsDelete (pNfsDev, fullName);
	    if ((retVal == ERROR) && !(flags & O_CREAT))
		return (ERROR);
	    else
		{
		if (retVal == FOLLOW_LINK)
		    {
		    (void) strcpy (fileName, fullName);
		    return (FOLLOW_LINK);
		    }
		}
	    }
	} /* O_TRUNC */


    if ((flags & O_CREAT) || (flags & O_TRUNC)) /* create file or directory */
        {
        retVal = nfsLookUpByName (pNfsDev->host, fullName, 
                                  &pNfsDev->fileHandle, 
                                  &dirResult, &dirHandle);
        if (retVal == FOLLOW_LINK)
            {
            (void) strcpy (fileName, fullName);
            return (FOLLOW_LINK);
            }

        status = nfsThingCreate (pNfsDev->host, fullName, &pNfsDev->fileHandle,
                                 &dirResult, &dirHandle, (u_int)mode);
        }
    else                        /* open existing file or directory */
        {
        status = nfsLookUpByName (pNfsDev->host, fullName, 
                                  &pNfsDev->fileHandle,
                                  &dirResult, &dirHandle);
        }
    if (status == ERROR)
	return (ERROR);

    /* Check file permissions */

    filePermissions = dirResult.diropres_u.diropres.attributes.mode;

    switch (openMode)
        {
	case O_RDONLY: requestPerms = 4; break;
	case O_WRONLY: requestPerms = 2; break;
	case O_RDWR:   requestPerms = 6; break;
	}

    /* Check if uid and gid match file uid and gid */
    
    nfsAuthUnixGet (machineName, &uid, &gid, &nGids, gids);

    sameUid = (uid == dirResult.diropres_u.diropres.attributes.uid
	       ? TRUE : FALSE);
    
    if (gid == dirResult.diropres_u.diropres.attributes.gid)
        sameGid = TRUE;
    else while (nGids)
        if (gids [--nGids] == dirResult.diropres_u.diropres.attributes.gid)
	    {
	    sameGid = TRUE;
	    break;
	    }

    /* Check "other" permissions */
    
    if (!sameGid && !sameUid &&
	((filePermissions & requestPerms) == requestPerms))
        correctPerms = TRUE;

    /* check group permissions */
    
    else if (sameGid &&
	     ((filePermissions & (requestPerms << 3)) == (requestPerms << 3)))
        correctPerms = TRUE;

    /* check user permissions */

    else if (sameUid &&
	     ((filePermissions & (requestPerms << 6)) == (requestPerms << 6)))
        correctPerms = TRUE;

    else
	{
	errno = S_nfsDrv_PERMISSION_DENIED;
	return (ERROR);
	}
    
    /*
     * If the name returned by nfsLookUpByName doesn't start with a
     * slash, then nfsLookUpByName has changed the name to the link, but the
     * name no longer includes the name of the correct device.  If you pass
     * this to iosDevFind, it returns a path on the default device, which is
     * wrong (unless, of course, you get lucky and you are in fact looking
     * for something on the default device).  So, need to prepend the name of
     * the NFS device if fullName doesn't include it already.
     */

    if (status == FOLLOW_LINK)
        {
	if (fullName [0] != '/')
	    {
	    pathCat (pNfsDev->devHdr.name, fullName, fileName);
	    }
	else
	    {
	    (void) strcpy (fileName, fullName);
	    }
	}

    if (status != OK)
	return (status);

    if ((nfsFd = (NFS_FD *) KHEAP_ALLOC(sizeof (NFS_FD) + nfsCacheSize)) == NULL)
	return (ERROR);

    /* fill in file descriptor with newly retrieved information */

    bcopy ((char *) &dirResult.diropres_u.diropres.file,
	   (char *) &nfsFd->fileHandle, sizeof (nfs_fh));
    bcopy ((char *) &dirHandle,
	   (char *) &nfsFd->dirHandle, sizeof (nfs_fh));
    bcopy ((char *) &dirResult.diropres_u.diropres.attributes,
	   (char *) &nfsFd->fileAttr, sizeof (fattr));

    nfsFd->fileCurByte	= 0;
    nfsFd->mode		= openMode;
    nfsFd->cacheValid	= FALSE;

    nfsFd->cacheBuf	= (char *) ((u_int) nfsFd + sizeof (NFS_FD));

    nfsFd->cacheCurByte = nfsFd->cacheBuf;
    nfsFd->cacheDirty	= FALSE;
    nfsFd->cacheBytesLeft = 0;

    nfsFd->nfsDev	= pNfsDev;

    nfsFd->nfsFdSem = semMCreate (mutexOptionsNfsDrv);
    if (nfsFd->nfsFdSem == NULL)
        {
        free ( (char *)nfsFd);
        return (ERROR);
        }

    return ((int) nfsFd);
    }
/*******************************************************************************
*
* nfsClose - close a remote file
*
* Called only by the I/O system.
*
* RETURNS: OK or ERROR if file failed to flush
*/

LOCAL STATUS nfsClose
    (
    FAST NFS_FD *nfsFd          /* nfs file descriptor */
    )
    {
    int status = OK;

    semTake (nfsFd->nfsFdSem, WAIT_FOREVER);

    if (nfsFd->cacheDirty)
	status = nfsCacheFlush (nfsFd);

    semDelete (nfsFd->nfsFdSem);	/* terminate nfs fd semaphore */
    KHEAP_FREE((char *) nfsFd);

    /* close client if "auto close" is selected */

    if (nfsAutoClose)
	nfsClientClose ();

    return (status == ERROR ? ERROR : OK);
    }
/*******************************************************************************
*
* nfsRead - read bytes from remote file
*
* nfsRead reads the specified number of bytes from the open NFS
* file and puts them into a buffer.  Bytes are read starting
* from the point marked by the file pointer.  The file pointer is then
* updated to point immediately after the last character that was read.
*
* A cache is used for keeping nfs network reads and writes down to a minimum.
*
* Called only by the I/O system.
*
* SIDE EFFECTS: moves file pointer
*
* RETURNS: number of bytes read or ERROR.
*/

LOCAL int nfsRead
    (
    FAST NFS_FD *nfsFd, /* pointer to open network file descriptor */
    char *buf,          /* pointer to buffer to receive bytes */
    FAST int maxBytes   /* max number of bytes to read into buffer */
    )
    {
    int nRead;			/* number of bytes read from cache or net */
    int nCacheRead;		/* number of bytes read into cache */
    int readCount;		/* cum. no. of bytes read into user's buf */
    STATUS status = OK;

    /* check for valid maxBytes */

    if (maxBytes < 0)
	{
	errnoSet (S_nfsDrv_INVALID_NUMBER_OF_BYTES);
	return (ERROR);
	}

    if (maxBytes == 0)
	return (0);

    /* if file opened for O_WRONLY, don't read */

    if (nfsFd->mode == O_WRONLY)
	{
	errnoSet (S_nfsDrv_WRITE_ONLY_CANNOT_READ);
	return (ERROR);
	}

    readCount = 0;

    semTake (nfsFd->nfsFdSem, WAIT_FOREVER);

    if (nfsCacheSize == 0)
	{
	/* no caching */

	readCount = nfsFileRead (nfsFd->nfsDev->host, &nfsFd->fileHandle,
			         nfsFd->fileCurByte, (unsigned) maxBytes, buf,
			         &nfsFd->fileAttr);

	if (readCount < 0)
	    {
	    semGive (nfsFd->nfsFdSem);
	    return (ERROR);
	    }

	status = nfsSeek (nfsFd, (int) nfsFd->fileCurByte + readCount);
	}
    else
	{
	/* read from cache */

	while ((readCount < maxBytes) && (status != ERROR))
	    {
	    /* keep reading until all bytes requested are read,
	     * or an error occurs,
	     * or the end of file is hit
	     */

	    if (!nfsFd->cacheValid)
		{
		/* if the cache isn't valid,
		 * freshen it by reading across the net.
		 */