nfsdlib.c

VxWorks源码

    nfsstat       authorized;	/* request is authorized if == NFS_OK*/
    
    /* Initialize task for VxWorks RPC work */
    
    rpcTaskInit ();

    transp = svcudp_create(-1);

    /* Work loop is repeated until catastrophic error encountered */
    
    FOREVER
	{
	/* Get the next message */
	
	if (msgQReceive (nfsRequestQ, (char *) &request, sizeof(request),
			 WAIT_FOREVER) == ERROR)
	    {
	    perror ("NFS server aborted abnormally");
	    return;
	    }

	/* Break down the incoming message */
	
	local        = request.routine;
	argument     = request.argument;
	xdr_argument = request.xdrArg;  
	xdr_result   = request.xdrResult;
	addr         = &request.sockAddr;
	xid          = request.xid;
	sock         = request.socket;

	/* Create a new RPC transport to reply.  Need to do this as
	 * next incoming client request will alter xid field of old
	 * transport, and replies won't match the correct request.
	 */

	transp->xp_sock = sock;
	((struct svcudp_data *) transp->xp_p2)->su_xid = xid;
	transp->xp_raddr = *addr;
	memset (&transp->xp_verf, 0, sizeof(transp->xp_verf));
	transp->xp_addrlen = sizeof (transp->xp_raddr);

	/* Authenticate the request, then call the correct NFS routine */

	if (nfsdAuthHook)
	    {
	    authorized = (*nfsdAuthHook) (NFS_PROGRAM, NFS_VERSION,
					  request.procNum, request.sockAddr,
					  argument);
	    }
	else
	    authorized = NFS_OK;

	if (authorized  != NFS_OK)
	    {
	    result = KHEAP_ALLOC(sizeof (nfsstat));

	    if (NULL != result)
		{
		bzero ((char *)result, sizeof (nfsstat));
		}

	    *((nfsstat *) result) = authorized;
	    }
	else
	    result = (char *) (*local)(argument);

	/* Send the result */
	
	if (result != NULL && !svc_sendreply(transp, xdr_result, result))
	    {
	    svcerr_systemerr(transp);
	    }

	/* Free any space used by RPC/XDR */
	
	if (!svc_freeargs(transp, xdr_argument, argument))
	    {
	    perror ("unable to free arguments for NFS server");
	    return;
	    }

	/* Free space allocated when request was queued up */
	
	KHEAP_FREE((char *)result);
	KHEAP_FREE((char *)argument);

	/* Unfortunately, there's no way to tell svc_destroy() to not close
	 * the socket.  So, set the socket to -1. svc_destroy() doesn't
	 * check the value of the close() anyway.  If errno is set to
	 * S_iosLib_INVALID_FILE_DESCRIPTOR due to the close (-1), reset it
	 * to OK.  (svc_destroy() returns NULL, so there's no way to check
	 * its return value.)
	 */
	
	}
    transp->xp_sock = -1;
    svc_destroy (transp);
    if (errno == S_iosLib_INVALID_FILE_DESCRIPTOR)
        errno = OK;
    }

/******************************************************************************
*
* nfsd - NFS daemon process
*
* Used as the entrypoint to a task spawned from nfsdInit().  This task
* sets up the NFS RPC service, and calls svc_run(), which should never return.
* nfsdRequestEnqueue() is called from the svc_run() call.
*
* This routine is not declared LOCAL only because the symbol for its entry
* point should be displayed by i().
* 
* NOTE:  Some of this routine was generated by rpcgen.
* 
* RETURNS:  Never returns unless an error is encountered.
* 
* SEE ALSO: nfsdRequestEnqueue().
* 
* NOMANUAL
*/

void nfsd
    (
    void
    )
    {
    register SVCXPRT * transp;	/* RPC transport */
    int                sock;	/* NFS socket */
    struct sockaddr_in addr;	/* Address of NFS (port 2049 */
    int                optVal = NFS_MAXDATA * 2 + sizeof (struct rpc_msg) * 2;
                                /* XXX - too much space is wasted here */
    
    /* Initialize the task to use VxWorks RPC code */
    
    rpcTaskInit();

    /* Create NFS socket and bind it to correct address */
    
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    /* Set up the socket address */
    
    addr.sin_family             = AF_INET;
    addr.sin_addr.s_addr        = INADDR_ANY;
    addr.sin_port               = htons (NFS_PORT);

    bzero (addr.sin_zero, sizeof (addr.sin_zero));
    if (bind (sock, (struct sockaddr *) &addr, sizeof (addr)) == ERROR)
	{
	perror ("Could not bind to NFS port address");
	return;
	}

    /* Unset any previous NFS services */
    pmap_unset(NFS_PROGRAM, NFS_VERSION);

    /* Set socket buffer large enough to accommodate max NFS message */
    if ((setsockopt (sock, SOL_SOCKET, SO_SNDBUF, (char *)&optVal,
		     sizeof (optVal)) == ERROR)
	|| (setsockopt (sock, SOL_SOCKET, SO_RCVBUF, (char *)&optVal,
			sizeof (optVal)) == ERROR))
        return;

    /* Create RPC transport */
    transp = svcudp_create(sock);
    if (transp == NULL)
	{
	fprintf(stderr, "cannot create udp service.");
	exit(1);
	}

    /* Register NFS */
    if (!svc_register(transp, NFS_PROGRAM, NFS_VERSION, nfsdRequestEnqueue,
		      IPPROTO_UDP))
	{
	perror ("unable to register (NFS_PROGRAM, NFS_VERSION, udp).\n");
	return;
	}

    /* Start the RPC service, and never come back */
    svc_run();

    /* Should never get to this point */
    
    perror ("NFS svc_run returned");
    }

/******************************************************************************
*
* nfsproc_null_2 - do nothing
*
* RETURNS: A pointer to malloced spaced that contains no information.
*
* NOMANUAL
*/

void * nfsproc_null_2
    (
    void
    )
    {
    nfsdServerStatus.nullCalls++;
    
    return ((void *) KHEAP_ALLOC(0));
    }

/******************************************************************************
*
* nfsproc_getattr_2 - get file attributes
*
* If the reply status is NFS_OK, then the reply attributes contains the
* attributes for the file given by the input fhandle.
* 
* RETURNS: A pointer to an attrstat struct.
*
* NOMANUAL
*/

attrstat * nfsproc_getattr_2
    (
    nfs_fh *   fh /* File handle to get attributes of */
    )
    {
    attrstat * retVal = KHEAP_ALLOC(sizeof (attrstat)); /* Struct to fill in */

    nfsdServerStatus.getattrCalls++;

    nfsdFhNtoh ((NFS_FILE_HANDLE *) fh);
    
    if (retVal == NULL)
        return (NULL);

    /* Get the attributes for the file */
    
    if (nfsdFattrGet ((NFS_FILE_HANDLE *) fh,
			 &retVal->attrstat_u.attributes) == ERROR)
	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}
    else
        retVal->status = NFS_OK;
    
    return (retVal);
    }

/******************************************************************************
*
* nfsproc_setattr_2 - set the attributes for a file
* 
* The "attr" argument contains fields which are either -1 or are
* the new value for the attributes of "file".  If the reply status is
* NFS_OK, then the reply attributes have the attributes of the file
* after the "SETATTR" operation has completed.
* 
* Notes:  The use of -1 to indicate an unused field in "attributes" is
* changed in the next version of the protocol.
*
* NOMANUAL
*/

attrstat * nfsproc_setattr_2
    (
    sattrargs *    attr		/* Attributes to change */
    )
    {
    attrstat *     retVal = KHEAP_ALLOC(sizeof (attrstat));/* Return info */
    char *         fileName;    /* Name of the file being changed */
    int 	   fd;		/* File descriptor for file being changed */
    struct utimbuf timeBuf;	/* New time settings for file */

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

    nfsdServerStatus.setattrCalls++;

    nfsdFhNtoh ((NFS_FILE_HANDLE *) &attr->file);

    /* Make sure the file system is writeable */

    if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &attr->file))
	{
	retVal->status = NFSERR_ACCES;
	return (retVal);
	}

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

    if (attr->attributes.mode != -1)
        /* Currently don't have any way to set the mode */
        ;
        
    if (attr->attributes.uid != -1)
        /* Currently don't have any way to set the uid */
        ;
        
    if (attr->attributes.gid != -1)
        /* Currently don't have any way to set the gid */
        ;
        
    if (attr->attributes.size != -1)
	{
	/* Set the size of the file using FIOTRUNC ioctl, as VxWorks
	 * doesn't have ftruncate() */
	
        fd = open (fileName, O_RDWR, 0666);
	if (fd != ERROR)
	    {
	    if (ioctl (fd, FIOTRUNC, attr->attributes.size) == ERROR)
		{
		retVal->status = nfsdErrToNfs (errno);
		close (fd);
		return (retVal);
		}
	    else
	        close (fd);
	    }
	else
	    {
	    retVal->status = nfsdErrToNfs (errno);
	    close (fd);
	    return (retVal);
	    }
	}

    /* Set file time.
     *
     * As there's no way to set only one of these fields, if only one
     * is set, set the other one to the same value.
     */
    
    if (attr->attributes.atime.seconds != -1)
	timeBuf.modtime = timeBuf.actime = attr->attributes.atime.seconds;
    
    if (attr->attributes.mtime.seconds != -1)
	{
	timeBuf.modtime = attr->attributes.mtime.seconds;
	if (attr->attributes.atime.seconds == -1)
	    timeBuf.actime = timeBuf.modtime;
	}

    if ((attr->attributes.atime.seconds != -1) ||
	(attr->attributes.mtime.seconds != -1))
        if (utime (fileName, &timeBuf) == ERROR)
	    {
	    retVal->status = nfsdErrToNfs (errno);
	    return (retVal);
	    }
    
    /* Get the status information for the file to return */
    
    if (nfsdFattrGet ((NFS_FILE_HANDLE *) &attr->file,
			 &retVal->attrstat_u.attributes) != OK)
	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    retVal->status = NFS_OK;

    return (retVal);
    }

/******************************************************************************
*
* nfsproc_root_2 - obsolete
* 
* Obsolete.  This procedure is no longer used because finding the root
* file handle of a filesystem requires moving pathnames between client
* and server.  To do this right, we would have to define a network
* standard representation of pathnames.  Instead, the function of
* looking up the root file handle is done by the MNTPROC_MNT procedure.
* 
* RETURNS:  A pointer to no information.
*
* NOMANUAL
*/

void * nfsproc_root_2
    (
    void
    )
    {
    nfsdServerStatus.setattrCalls++;
    return ((void *) KHEAP_ALLOC(0));
    }

/******************************************************************************
*
* nfsproc_lookup_2 -
* 
* If the reply "status" is NFS_OK, then the reply "file" and reply
* "attributes" are the file handle and attributes for the file "name"
* in the directory given by "dir" in the argument.
* 
* RETURNS:  A pointer to a diropres struct, or NULL.
*
* NOMANUAL
*/

diropres * nfsproc_lookup_2
    (
    diropargs * dir		/* The direcory and file to look up */
    )
    {
    diropres *  retVal = KHEAP_ALLOC(sizeof (diropres)); /* return status */

    if (retVal == NULL)
        return (NULL);
    
    nfsdServerStatus.lookupCalls++;

    nfsdFhNtoh ((NFS_FILE_HANDLE *) &dir->dir);
    
    /* Build file handle for new file */

    if (nfsdFhCreate ((NFS_FILE_HANDLE *) &dir->dir, dir->name,
			 (NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file)
	== ERROR)
	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    /* Get the attributes for the newly created file handle */
    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_readlink_2 - read from a symbolic link
* 
* VxWorks does not support symbolic links.
* 
* RETURNS:  A pointer to an EOPNOTSUPP error.
*
* NOMANUAL
*/

readlinkres * nfsproc_readlink_2
    (
    nfs_fh * fh			/* File handle to read */
    )
    {
    readlinkres * retVal = KHEAP_ALLOC(sizeof (retVal->status));

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

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

    /* symbolic links not supported */
    retVal->status = EOPNOTSUPP;
    return (retVal);
    }

/******************************************************************************
*
* nfsproc_read_2 - read data from a file
* 
* Returns up to "count" bytes of "data" from the file given by "file",
* starting at "offset" bytes from the beginning of the file.  The first
* byte of the file is at offset zero.  The file attributes after the
* read takes place are returned in "attributes".
* 
* Notes:  The argument "totalcount" is unused, and is removed in the
* next protocol revision.
*
* NOMANUAL
*/

readres * nfsproc_read_2
    (
    readargs * readFile		/* File, offset, and count information */
    )
    {
    char *     fileName;        /* Name of the file being read */
    readres *  retVal = KHEAP_ALLOC(sizeof (readres) + readFile->count);
				/* Return information, including read data */
    char *     readData;	/* Address of read data in retVal */
    int        fd;		/* File descriptor for file being read */
    int	       nBytes;		/* Number of bytes actually read */

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

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

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

    /* set readData to point to the correct position in the return value */
    readData = (char *) retVal + sizeof (readres);
    
    nfsdFhNtoh ((NFS_FILE_HANDLE *) &readFile->file);
    
    if (nfsdFhToName ((NFS_FILE_HANDLE *) &readFile->file, fileName)
	== ERROR)
	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    if ((fd = open (fileName, O_RDONLY, 0)) == ERROR)
	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    if (lseek (fd, readFile->offset, SEEK_SET) == ERROR)
	{
	retVal->status = nfsdErrToNfs (errno);
	close (fd);
	return (retVal);
	}

    if ((nBytes = read (fd, readData, readFile->count)) == ERROR)
    	{
	retVal->status = nfsdErrToNfs (errno);
	close (fd);
	return (retVal);
	}
    else
	{
        retVal->readres_u.reply.data.data_val = readData;
	retVal->readres_u.reply.data.data_len = nBytes;
	}

    if (close (fd) == ERROR)
	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    if (nfsdFattrGet ((NFS_FILE_HANDLE *) &readFile->file,
			 &retVal->readres_u.reply.attributes) == ERROR)
    	{
	retVal->status = nfsdErrToNfs (errno);
	return (retVal);
	}

    retVal->status = NFS_OK;

    return (retVal);
    }

/******************************************************************************
*
* nfsproc_writecache_2 - unused
*