* NOMANUAL*/void * nfsproc_writecache_2    (    void    )    {    /* Increment statistics */    nfsdServerStatus.writecacheCalls++;    return ((void *) KHEAP_ALLOC(0));    }/******************************************************************************** nfsproc_write_2 -* * Writes "data" beginning "offset" bytes from the beginning of "file".* The first byte of the file is at offset zero.  If the reply "status"* is NFS_OK, then the reply "attributes" contains the attributes of the* file after the write has completed.  The write operation is atomic.* Data from this "WRITE" will not be mixed with data from another* client's "WRITE".* * Notes:  The arguments "beginoffset" and "totalcount" are ignored and* are removed in the next protocol revision.** NOMANUAL*/attrstat * nfsproc_write_2    (    writeargs * wrArgs		/* File, write data, and offset information */    )    {    char *      fileName;       /* Name of the file to write */    attrstat *  retVal;		/* Return value */    int         fd;		/* File descriptor for file to write */    int		nBytes;		/* Number of bytes actually written */    int         writeCount;     /* Number of bytes to write */    BOOL        writeError = FALSE;        if ((retVal = KHEAP_ALLOC(sizeof (*retVal))) == NULL)	return (NULL);        if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)	return (NULL);    /* Increment statistics */    nfsdServerStatus.writeCalls++;    nfsdFhNtoh ((NFS_FILE_HANDLE *) &wrArgs->file);        /* Make sure the file system is writeable */    if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &wrArgs->file))	{	retVal->status = NFSERR_ACCES;	return (retVal);	}    if (nfsdFhToName ((NFS_FILE_HANDLE *) &wrArgs->file, fileName) == ERROR)	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    if ((fd = open (fileName, O_WRONLY, 0)) == ERROR)	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}        if (lseek (fd, wrArgs->offset, SEEK_SET) != wrArgs->offset)    	{	retVal->status = nfsdErrToNfs (errno);	close (fd);	return (retVal);	}    errno = OK;    writeCount = wrArgs->data.data_len;    if ((nBytes = write (fd, wrArgs->data.data_val, writeCount)) != writeCount)	{	if (errno == OK)	    {	    /* Try this twice to get around a dosFs bug */	    writeCount -= nBytes;	    if (write (fd, wrArgs->data.data_val, writeCount) != writeCount)		writeError = TRUE;	    }	else	    writeError = TRUE;		if (writeError)	    {	    retVal->status = nfsdErrToNfs (errno);	    close (fd);	    return (retVal);	    }	}        if (close (fd) == ERROR)    	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    if (nfsdFattrGet ((NFS_FILE_HANDLE *) &wrArgs->file,			 &retVal->attrstat_u.attributes) == ERROR)	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    retVal->status = NFS_OK;    return (retVal);    }/******************************************************************************** nfsproc_create_2 - create a file* * The file "name" is created in the directory given by "dir".  The* initial attributes of the new file are given by "attributes".  A* reply "status" of NFS_OK indicates that the file was created, and* reply "file" and reply "attributes" are its file handle and* attributes.  Any other reply "status" means that the operation failed* and no file was created.* * Notes:  This routine should pass an exclusive create flag, meaning* "create the file only if it is not already there".* * NOMANUAL*/diropres * nfsproc_create_2    (    createargs * newFile  /* File to create */    )    {    diropres *   retVal = KHEAP_ALLOC(sizeof (diropres)); /* Return value */    char *       newName;       /* Name of file to create */    int          fd;		/* File descriptor for file to create */    if (retVal == NULL)        return (NULL);        if ((newName = (char *) alloca (nfsMaxPath)) == NULL)	return (NULL);    /* Increment statistics */    nfsdServerStatus.createCalls++;    /* Create the name for the new file by getting the name of the directory,     * followed by "/" and the name of the new file     */        nfsdFhNtoh ((NFS_FILE_HANDLE *) &newFile->where.dir);        /* Make sure the file system is writeable */    if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &newFile->where.dir))	{	retVal->status = NFSERR_ACCES;	return (retVal);	}    if (nfsdFhToName ((NFS_FILE_HANDLE *) &newFile->where.dir, newName)	== ERROR)	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    strcat (newName, "/");    strcat (newName, newFile->where.name);    /* Check if the file has been created already */    if ((fd = open (newName, O_RDWR, 0)) != ERROR)	{	retVal->status = NFSERR_EXIST;	close(fd);	return (retVal);	}    /* Create the file */        if ((fd = open (newName, O_RDWR | O_CREAT, 0)) == ERROR)    	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}        if (close (fd) == ERROR)	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    /* Create its file handle */    if (nfsdFhCreate ((NFS_FILE_HANDLE *) &newFile->where.dir,			 newFile->where.name,			 (NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file)	== ERROR)    	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    /* Get its attributes */    if (nfsdFattrGet ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file,		     &retVal->diropres_u.diropres.attributes) == ERROR)    	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    retVal->status = NFS_OK;    nfsdFhHton ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file);        return (retVal);    }/******************************************************************************** nfsproc_remove_2 - remove a file* * The file "name" is removed from the directory given by "dir".  A* reply of NFS_OK means the directory entry was removed.* * Notes:  possibly non-idempotent operation.* * NOMANUAL*/nfsstat * nfsproc_remove_2    (    diropargs * removeFile	/* File to be removed */    )    {    nfsstat * retVal = KHEAP_ALLOC(sizeof (nfsstat)); /* Return value */    char *    newName;          /* Name of the file to be removed */    if (retVal == NULL)        return NULL;    if ((newName = (char *) alloca (nfsMaxPath)) == NULL)	return (NULL);    /* Increment statistics */    nfsdServerStatus.removeCalls++;    /* Create the name for removed file by getting the name of the directory,     * followed by "/" and the name of the new file     */    nfsdFhNtoh ((NFS_FILE_HANDLE *) &removeFile->dir);        /* Make sure the file system is writeable */    if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &removeFile->dir))	{	*retVal = NFSERR_ACCES;	return (retVal);	}    if (nfsdFhToName ((NFS_FILE_HANDLE *) &removeFile->dir, newName)	== ERROR)	{	*retVal = nfsdErrToNfs (errno);	return (retVal);	}    strcat (newName, "/");    strcat (newName, removeFile->name);    /* Do the removal */    if (unlink (newName) == ERROR)	*retVal = nfsdErrToNfs (errno);    else	*retVal = NFS_OK;    return (retVal);    }/******************************************************************************** nfsproc_rename_2 - rename a file* * The existing file "from.name" in the directory given by "from.dir" is* renamed to "to.name" in the directory given by "to.dir".  If the* reply is NFS_OK, the file was renamed.  The RENAME operation is* atomic on the server; it cannot be interrupted in the middle.* * Notes:  possibly non-idempotent operation.* * NOMANUAL*/nfsstat * nfsproc_rename_2    (    renameargs * names		/* New and old file names */    )    {    nfsstat * retVal = KHEAP_ALLOC(sizeof (nfsstat)); /* Return value */    char *    oldName;                                /* Old file name */    char *    newName;                                /* New file name */    /* Increment statistics */    nfsdServerStatus.renameCalls++;    if (retVal == NULL)        return (NULL);        if ((oldName = (char *) alloca (nfsMaxPath)) == NULL)	return (NULL);    if ((newName = (char *) alloca (nfsMaxPath)) == NULL)	return (NULL);    /* Create strings for the old and new file names */        nfsdFhNtoh ((NFS_FILE_HANDLE *)  &names->from.dir);    nfsdFhNtoh ((NFS_FILE_HANDLE *)  &names->to.dir);        /* Make sure the file system is writeable */    if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &names->from.dir))	{	*retVal = NFSERR_ACCES;	return (retVal);	}    if (nfsdFhToName ((NFS_FILE_HANDLE *) &names->from.dir, oldName)	== ERROR)	{	*retVal = nfsdErrToNfs (errno);	return (retVal);	}    strcat (oldName, "/");    strcat (oldName, names->from.name);    if (nfsdFhToName ((NFS_FILE_HANDLE *) &names->to.dir, newName)	== ERROR)	{	*retVal = nfsdErrToNfs (errno);	return (retVal);	}    strcat (newName, "/");    strcat (newName, names->to.name);    /* Do the rename() */    if (rename (oldName, newName) == ERROR)	{	*retVal = nfsdErrToNfs (errno);	return (retVal);	}    else        *retVal = NFS_OK;        return (retVal);    }/******************************************************************************** nfsproc_link_2 - create a link - not supported by VxWorks** NOMANUAL*/nfsstat * nfsproc_link_2    (    void    )    {    nfsstat * notSupported = KHEAP_ALLOC(sizeof (nfsstat));    *notSupported = EOPNOTSUPP;    return ((nfsstat *) notSupported);    }/******************************************************************************** nfsproc_symlink_2 - create a symbolic link - not supported by VxWorks** NOMANUAL*/nfsstat * nfsproc_symlink_2    (    void    )    {    nfsstat * notSupported = KHEAP_ALLOC(sizeof (nfsstat));    /* Increment statistics */    nfsdServerStatus.symlinkCalls++;    *notSupported = EOPNOTSUPP;    return ((nfsstat *) notSupported);    }/******************************************************************************** nfsproc_mkdir_2 - create a directory* * The new directory "where.name" is created in the directory given by* "where.dir".  The initial attributes of the new directory are given* by "attributes".  A reply "status" of NFS_OK indicates that the new* directory was created, and reply "file" and reply "attributes" are* its file handle and attributes.  Any other reply "status" means that* the operation failed and no directory was created.* * Notes:  possibly non-idempotent operation.** NOMANUAL*/diropres * nfsproc_mkdir_2    (    createargs * crArgs    )    {    diropres *      retVal = KHEAP_ALLOC(sizeof (diropres));    char *          newName;    if (retVal == NULL)        return (NULL);        if ((newName = (char *) alloca (nfsMaxPath)) == NULL)	return (NULL);    /* Increment statistics */    nfsdServerStatus.mkdirCalls++;    retVal->status = NFS_OK;    /* Create the string for the name of the directory to make */        nfsdFhNtoh ((NFS_FILE_HANDLE *) &crArgs->where.dir);        /* Make sure the file system is writeable */    if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &crArgs->where.dir))	{	retVal->status = NFSERR_ACCES;	return (retVal);	}    if (nfsdFhToName ((NFS_FILE_HANDLE *) &crArgs->where.dir, newName)	== ERROR)	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    strcat (newName, "/");    strcat (newName, crArgs->where.name);    /* make the directory */    if (mkdir (newName) == ERROR)    	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    /* Create a file handle for the new directory */    if (nfsdFhCreate ((NFS_FILE_HANDLE *) &crArgs->where.dir,			 crArgs->where.name,			 (NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file)	== ERROR)    	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    /* Get the file attributes for the new directory */    if (nfsdFattrGet ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file,		     &retVal->diropres_u.diropres.attributes) == ERROR)    	{	retVal->status = nfsdErrToNfs (errno);	return (retVal);	}    nfsdFhHton ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file);    return (retVal);    }/******************************************************************************** nfsproc_rmdir_2 - remove a directory* * The existing empty directory "name" in the directory given by "dir"* is removed.  If the reply is NFS_OK, the directory was removed.* * Notes:  possibly non-idempotent operation.** NOMANUAL*/nfsstat * nfsproc_rmdir_2    (    diropargs * removeDir	/* Directory to remove */    )    {    nfsstat * retVal = KHEAP_ALLOC(sizeof (nfsstat)); /* Return value */    char *    newName;          /* Path name of directory to remove */    if (retVal == NULL)        return NULL;    if ((newName = (char *) alloca (nfsMaxPath)) == NULL)	return (NULL);    /* Increment statistics */    nfsdServerStatus.rmdirCalls++;    nfsdFhNtoh ((NFS_FILE_HANDLE *) &removeDir->dir);        /* Make sure the file system is writeable */    if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &removeDir->dir))	{	*retVal = NFSERR_ACCES;	return (retVal);	}    /* Create the name of the doomed directory */    if (nfsdFhToName ((NFS_FILE_HANDLE *) &removeDir->dir, newName) == ERROR)	{	*retVal = nfsdErrToNfs (errno);	return (retVal);	}    strcat (newName, "/");    strcat (newName, removeDir->name);    /* Remove it */    if (rmdir (newName) == ERROR)	*retVal = nfsdErrToNfs (errno);    else	*retVal = NFS_OK;    return (retVal);    }/******************************************************************************** nfsproc_readdir_2 - read from a directory* * Returns a variable number of directory entries, with a total size of* up to "count" bytes, from the directory given by "dir".  If the* returned value of "status" is NFS_OK, then it is followed by a* variable number of "entry"s.  Each "entry" contains a "fileid" which* consists of a unique number to identify the file within a filesystem,* the "name" of the file, and a "cookie" which is an opaque pointer to* the next entry in the directory.  The cookie is used in the next* READDIR call to get more entries starting at a given point in the* directory.  The special cookie zero (all bits zero) can be used to* get the entries starting at the beginning of the directory.  The* "fileid" field should be the same number as the "fileid" in the the* attributes of the file.  (See section "2.3.5. fattr" under "Basic* Data Types".)  The "eof" flag has a value of TRUE if there are no* more entries in the directory.* * NOMANUAL*/