mountlib.c

VXWORKS源代码

    if(mountPoints == NULL || lstCount(mountPoints) == 0) 
      {
      if(exportList != NULL) 
        {
	KHEAP_FREE((char *)exportList);
	exportList = NULL;
        }
      return (&exportList);
    }

    if (exportList == NULL)
	{
	exportList = KHEAP_ALLOC((mountdNExports * 
			(sizeof (exportnode) + nfsMaxPath)));
	if (exportList == NULL)
	    {
	    return (&exportList);
	    }
	else
	    {
	    bzero ((char *)exportList,(mountdNExports *
                        (sizeof (exportnode) + nfsMaxPath)));
	    }
	}

    strTbl = (char *) &exportList[mountdNExports];
    
    /* Bogus group information */
    aGroup.gr_name = NULL;
    aGroup.gr_next = NULL;

    semTake (mountSem, WAIT_FOREVER);
    for (exportEntry =  (NFS_EXPORT_ENTRY *) lstFirst (mountPoints);
	 exportEntry != NULL;
	 exportEntry = (NFS_EXPORT_ENTRY *) lstNext ((NODE *) exportEntry))
	{
	nextEntry = (NFS_EXPORT_ENTRY *) lstNext ((NODE *) exportEntry);
	exportList [lstPos].ex_dir = strTbl;
	strncpy (strTbl, exportEntry->dirName, nfsMaxPath - 1);
	strTbl += strlen (strTbl);
	*strTbl++ = EOS;
	exportList [lstPos].ex_groups = NULL;
	if (nextEntry != NULL)
	    exportList [lstPos].ex_next = &exportList [lstPos + 1];
	else
	    exportList [lstPos].ex_next = NULL;
	lstPos++;
	}
    
    semGive (mountSem);
    return ((exports *) &exportList);
    }

/******************************************************************************
*
* nfsExport - specify a file system to be NFS exported
*
* This routine makes a file system available for mounting by a client.
* The client should be in the local host table (see hostAdd()),
* although this is not required.
* 
* The <id> parameter can either be set to a specific value, or to 0.
* If it is set to 0, an ID number is assigned sequentially.
* Every time a file system is exported, it must have the same ID
* number, or clients currently mounting the file system will not be
* able to access files.
*
* To display a list of exported file systems, use:
* .CS
*     -> nfsExportShow "localhost"
* .CE
* 
* RETURNS: OK, or ERROR if the file system could not be exported.
*
* SEE ALSO: nfsLib, nfsExportShow(), nfsUnexport()
*/

STATUS nfsExport
    (
    char * directory,	 /* Directory to export - FS must support NFS */
    int    id,   	 /* ID number for file system */
    BOOL   readOnly,     /* TRUE if file system is exported read-only */
    int    options	 /* Reserved for future use - set to 0 */
    )
    {
    NFS_EXPORT_ENTRY * exportFs; /* The file system to be exported */
    int		       exportDirFd; /* File descriptor for the exported dir */
    struct stat statInfo;	/* information from fstat() call */

    if (strlen (directory) >= nfsMaxPath)
	return (ERROR);

    /* Create the export point */
    
    if ((exportFs = KHEAP_ALLOC (sizeof (*exportFs) + nfsMaxPath)) == NULL)
        return (ERROR);

    if ((exportDirFd = open (directory, O_RDONLY, 0666)) == ERROR)
        {
	KHEAP_FREE ((char *)exportFs);
        return (ERROR);
	}

    /* Set up the NFS_EXPORT_ENTRY structure */
    
    strncpy (exportFs->dirName, directory, nfsMaxPath - 1);
    exportFs->dirFd = exportDirFd;

    /* Set the ID number for the exported system */
    
    if (id == 0)
        exportFs->volumeId = fsIdNumber++;
    else
        exportFs->volumeId = id;

    exportFs->readOnly = readOnly;

    /* Add it to the list */
    semTake (mountSem, WAIT_FOREVER);
    lstAdd (mountPoints, (NODE *)exportFs);
    semGive (mountSem);

    if (fstat (exportDirFd, &statInfo) != OK)
	{
	semTake (mountSem, WAIT_FOREVER);
	lstDelete (mountPoints, (NODE *)exportFs);
	semGive (mountSem);

        KHEAP_FREE ((char *) exportFs);
	close (exportDirFd);
        return (ERROR);
	}
    else
	{
        nfsHashTblSet (exportFs->dirName, exportFs->volumeId, statInfo.st_dev);
	}

    if ((exportFs->fsId = nameToInode (exportFs->volumeId, directory)) == ERROR)
	{
	semTake (mountSem, WAIT_FOREVER);
	lstDelete (mountPoints, (NODE *) exportFs);
	semGive (mountSem);

        nfsHashTblUnset (exportFs->dirName, exportFs->volumeId);  
	KHEAP_FREE ((char *)exportFs);
	close (exportDirFd);
        return (ERROR);
	}
    return (OK);
    }

/******************************************************************************
*
* nfsUnexport - remove a file system from the list of exported file systems
*
* This routine removes a file system from the list of file systems
* exported from the target.  Any client attempting to mount a file
* system that is not exported will receive an error (NFSERR_ACCESS).
* 
* RETURNS: OK, or ERROR if the file system could not be removed from
* the exports list.
* 
* ERRNO: ENOENT
*
* SEE ALSO: nfsLib, nfsExportShow(), nfsExport()
*/

STATUS nfsUnexport
    (
    char * dirName		/* Name of the directory to unexport */
    )
    {
    NFS_EXPORT_ENTRY * mntPoint; /* Mount point from mountPoints list */

    /* Make sure the directory name is mentioned */

    if ((dirName == NULL) || (strlen (dirName) >= nfsMaxPath))
	return(ERROR);
    
    /* Make sure there's a list of file systems */
    if (mountPoints == NULL)
        return (ERROR);

    /* Find it and take it off the list */
    if ((mntPoint = nfsExportFindByName (dirName)) != NULL)
        {
	semTake (mountSem, WAIT_FOREVER);
	lstDelete (mountPoints, (NODE *) mntPoint);
        nfsHashTblUnset (mntPoint->dirName, mntPoint->volumeId);
	semGive (mountSem);
	close(mntPoint->dirFd);
        KHEAP_FREE ((char *)mntPoint);
	return (OK);
	}
    else
	{
	/* Didn't find it, set errno and return ERROR */
	semGive (mountSem);
	errno = ENOENT;
	return (ERROR);
	}
    }

/******************************************************************************
*
* nfsExportFindByName - find a pointer to an exported file system
*
* Given a directory name, return a pointer to the corresponding
* NFS_EXPORT_ENTRY structure.
* 
* RETURNS:  OK, or NULL if the file system could not be found.
* 
* NOMANUAL 
*/

NFS_EXPORT_ENTRY * nfsExportFindByName
    (
    char * dirName		/* name of file system to find */
    )
    {
    NFS_EXPORT_ENTRY * mntPoint = NULL;	/* mount point from mountPoints list */
    char *             matchName;       /* fs name to find */

    /* Make sure the list exists */
    if (mountPoints == NULL)
        return (NULL);
    
    if ((matchName = (char *) alloca (nfsMaxPath)) == NULL)
	return (NULL);

    /* Make sure matchName doesn't have ending slash */
    strcpy (matchName, dirName);
    if (matchName[strlen (matchName) - 1] == '/')
        matchName[strlen (matchName) - 1] = EOS;
    
    /* Search through the list */
    semTake (mountSem, WAIT_FOREVER);
    for (mntPoint = (NFS_EXPORT_ENTRY *) lstFirst (mountPoints);
	 mntPoint != NULL;
	 mntPoint = (NFS_EXPORT_ENTRY *) lstNext ((NODE *) mntPoint))
	{
	if (strcmp(mntPoint->dirName, matchName) == 0)
	    {
	    /* Found it, give the semaphore and return */
	    semGive (mountSem);
	    return (mntPoint);
	    }
	}

    /* Didn't find a match, return NULL */
    semGive (mountSem);
    return (NULL);
    }

/******************************************************************************
*
* nfsExportFindById - find a pointer to an exported file system
* 
* Given a directory ID number, return a pointer to the corresponding
* NFS_EXPORT_ENTRY structure.
* 
* RETURNS:  OK, or NULL if the file system could not be found.
* 
* NOMANUAL
*/

NFS_EXPORT_ENTRY * nfsExportFindById
    (
    int volumeId		/* volume ID number */
    )
    {
    NFS_EXPORT_ENTRY * mntPoint; /* mount point from mountPoints list */

    /* Make sure the list exists */
    if (mountPoints == NULL)
        return (NULL);
    
    /* Search through the list */
    semTake (mountSem, WAIT_FOREVER);
    for (mntPoint = (NFS_EXPORT_ENTRY *) lstFirst (mountPoints);
	 mntPoint != NULL;
	 mntPoint = (NFS_EXPORT_ENTRY *) lstNext ((NODE *) mntPoint))
	{
	if (volumeId == mntPoint->volumeId)
	    {
	    /* Found it, give the semaphore and return */
	    semGive (mountSem);
	    return (mntPoint);
	    }
	}

    /* Didn't find a match, return NULL */
    semGive (mountSem);
    return (NULL);
    }

/******************************************************************************
*
* nameToInode - file name to inode number
* 
* Given a file name, return the inode number associated with it.
* 
* RETURNS: the inode number for the file descriptor, or ERROR.
*
* NOMANUAL
*/

int nameToInode
    (
    int    mntId,               /* mount id */
    char * fileName		/* name of the file */
    )
    {
    int    fd;			/* File descriptor */
    int    inode;		/* inode of file */

    
    if ((fd = open (fileName, O_RDONLY, 0)) == ERROR)
        return (ERROR);
    else
	{
	inode = nfsNmLkupIns (mntId, fileName);
	}

    close (fd);
    return (inode);
    }

/******************************************************************************
*
* svc_reqToHostName - convert svc_req struct to host name
* 
* Given a pointer to a svc_req structure, fill in a string with the
* host name of the client associated with that svc_req structure.
* The calling routine is responsible for allocating space for the
* name string, which should be NAME_MAX characters long.
*
* RETURNS:  A pointer to the name of the client.
* 
* NOMANUAL
*/

LOCAL char * svc_reqToHostName
    (
    struct svc_req * rqstp,	/* Client information */
    char *           hostName	/* String to fill in with client name */
    )
    {
    /* Convert the callers address to a host name.  If hostGetByAddr()
     * returns ERROR, convert the address to a numeric string
     */
    if (hostGetByAddr (rqstp->rq_xprt->xp_raddr.sin_addr.s_addr, hostName)!= OK)
        inet_ntoa_b (rqstp->rq_xprt->xp_raddr.sin_addr, hostName);
    return (hostName);
    }

/******************************************************************************
*
* mountListFind - find an entry in the NFS mount list
*
* Given a pointer to a svc_req structure and a path name, search
* the client mount list to see if the client already has this
* particular path mounted.
*
* RETURNS:  A pointer to the mount list entry which we found,
*           or NULL if there was no match.
* 
* NOMANUAL
*/

LOCAL MOUNT_CLIENT * mountListFind
    (
    struct svc_req * rqstp,	/* Client information */
    dirpath *        path	/* path to search for */
    )
    {
    MOUNT_CLIENT *   clientEntry;
    char             clientName [MAXHOSTNAMELEN + 1];

    semTake (clientsSem, WAIT_FOREVER);
    for (clientEntry = (MOUNT_CLIENT *) lstFirst (nfsClients);
         clientEntry != NULL;
         clientEntry = (MOUNT_CLIENT *) lstNext ((NODE *) clientEntry))
        {
        svc_reqToHostName (rqstp, clientName);
        if ((strncmp(clientName, clientEntry->clientName, MAXHOSTNAMELEN) == 0)
            && strncmp (*path, clientEntry->directory, PATH_MAX) == 0)
            {
            semGive (clientsSem);
            return (clientEntry);
            }
        }
    semGive (clientsSem);
    return(NULL);
    }