usrfslib.c

VXWORKS源代码

* brevity and backward compatibility. It produces a list of files
* and directories, without details such as file size and date,
* and without recursion into subdirectories.
*
* <dirName> is a name of a directory or file, and may contain wildcards.
* <doLong> is provided for backward compatibility.
*
* .iP NOTE
* This is a target resident function, which manipulates the target I/O
* system. It must be preceded with the
* '@' letter if executed from the Tornado Shell (windsh), which has a
* built-in command of the same name that operates on the Host's I/O
* system.
*
* RETURNS: OK or ERROR.
*
* SEE ALSO: dirList()
*/

STATUS ls
    (
    char	*dirName,	/* name of dir to list */
    BOOL	doLong		/* switch on details */
    )
    {
    return (dirList (STD_OUT, dirName, doLong, FALSE));
    }

/******************************************************************************
*
* ll - generate a long listing of directory contents
*
* This command causes a long listing of a directory's contents to be
* displayed.  It is equivalent to:
* .CS
*     -> dirList 1, dirName, TRUE, FALSE
* .CE
*
* <dirName> is a name of a directory or file, and may contain wildcards.
*
* .iP "NOTE 1:"
* This is a target resident function, which manipulates the target I/O
* system. It must be preceded with the
* '@' letter if executed from the Tornado Shell (windsh), which has a
* built-in command of the same name that operates on the Host's I/O
* system.
*
* .iP "NOTE 2:"
* When used with netDrv devices (FTP or RSH), ll() does not give
* directory information.  It is equivalent to an ls() call with no
* long-listing option.
*
* RETURNS: OK or ERROR.
*
* SEE ALSO: dirList()
*/
STATUS ll
    (   
    char *dirName               /* name of directory to list */
    )
    {
    return (dirList (STD_OUT, dirName, TRUE, FALSE));
    }

/*******************************************************************************
*
* lsr - list the contents of a directory and any of its subdirectories
*
* This function is simply a front-end for dirList(), intended for
* brevity and backward compatibility. It produces a list of files
* and directories, without details such as file size and date,
* with recursion into subdirectories.
*
* <dirName> is a name of a directory or file, and may contain wildcards.
*
* RETURNS: OK or ERROR.
*
* SEE ALSO: dirList()
*/

STATUS lsr
    (
    char	*dirName	/* name of dir to list */
    )
    {
    return (dirList( STD_OUT, dirName, FALSE, TRUE));
    }

/******************************************************************************
*
* llr - do a long listing of directory and all its subdirectories contents
*
* This command causes a long listing of a directory's contents to be
* displayed.  It is equivalent to:
* .CS
*     -> dirList 1, dirName, TRUE, TRUE
* .CE
 *
* <dirName> is a name of a directory or file, and may contain wildcards.
*
* NOTE: When used with netDrv devices (FTP or RSH), ll() does not give
* directory information.  It is equivalent to an ls() call with no
* long-listing option.
*
* RETURNS: OK or ERROR.
*
* SEE ALSO: dirList()
*/
STATUS llr
    (   
    char *dirName               /* name of directory to list */
    )
    {
    return (dirList (STD_OUT, dirName, TRUE, TRUE));
    }

/********************************************************************************
* cp - copy file into other file/directory.
*
* This command copies from the input file to the output file.
* If destination name is directory, a source file is copied into
* this directory, using the last element of the source file name
* to be the name of the destination file.
*
* This function is very similar to copy(), except it is somewhat
* more similar to the UNIX "cp" program in its handling of the
* destination.
*
* <src> may contain a wildcard pattern, in which case all files
* matching the pattern will be copied to the directory specified in
* <dest>.
* This function does not copy directories, and is not recursive.
* To copy entire subdirectories recursively, use xcopy().
*
* EXAMPLES
* .CS
* -> cp( "/sd0/FILE1.DAT","/sd0/dir2/f001.dat")
* -> cp( "/sd0/dir1/file88","/sd0/dir2")
* -> cp( "/sd0/@.tmp","/sd0/junkdir")
* .CE
*
* RETURNS: OK or ERROR if destination is not a directory while <src> is
* a wildcard pattern, or if any of the files could not be copied.
*
* SEE ALSO; xcopy()
*
*/
STATUS cp
    (
    const char *src,   /* source file or wildcard pattern */
    const char *dest   /* destination file name or directory */
    )
    {
    FAST DIR *pDir;		/* ptr to directory descriptor */
    FAST struct dirent	*pDirEnt;	/* ptr to dirent */
    STATUS status = OK ;
    char * pattern = NULL ;
    char * dirName = NULL ;
    char  dir[MAX_FILENAME_LENGTH] ;
    char  fileName[MAX_FILENAME_LENGTH] ;
    char  destName[MAX_FILENAME_LENGTH] ;

    if (src == NULL)
    	{
	errno = EINVAL ;
        return ERROR;
    	}

    if (dest == NULL)
	dest = "." ;

    /* dest does not exist or regular file */
    if (!nameIsDir (dest))
	{
	if (dirNameWildcard (src))
	    {
	    printErr("mv: destination \"%s\" not a directory\n", dest );
	    errno = ENOTDIR ;
	    return ERROR;
	    }
	printf("copying file %s -> %s\n", src, dest );
        return copy( src, dest );
	}

    strncpy( dir, src, MAX_FILENAME_LENGTH-1 );

    pattern = rindex(dir, '/');
    if ( pattern != NULL && pattern != dir && dirNameWildcard(pattern))
	{
	/* dir and pattern e.g. dir1/a*.c */
	*pattern++ = EOS ;
	dirName = dir ;
	}
    else if (dirNameWildcard (dir))
	{
	/* just pattern e.g. *.c or abc.? */
	pattern = dir;
	dirName = "." ;
	}
    else
	{
	pattern = NULL ;
	dirName = dir ;
	}

    if (pattern == NULL)
	{
	printf("copying file %s -> %s\n", src, dest );
	return copy(src, dest ) ;
	}

    pDir = opendir (dirName) ;

    if (pDir == NULL)
	{
	perror(dirName);
	return ERROR;
	}

    errno = OK;

    do
	{
    	pDirEnt = readdir (pDir);
	if (pDirEnt != NULL)
	    {
	    if (pattern != NULL &&
		dirListPattern( pattern, pDirEnt->d_name) == FALSE)
		continue ;

	    if (strcmp(pDirEnt->d_name,"." )  == 0 &&
		strcmp(pDirEnt->d_name,".." ) == 0)
		continue ;

	    /* Construct path/filename for stat */
	    usrPathCat( dirName, pDirEnt->d_name, fileName );
	    usrPathCat( dest, pDirEnt->d_name, destName );

	    if (nameIsDir( fileName ))
		{
		printf("skipping directory %s\n", fileName );
		continue;
		}

	    printf("copying file %s -> %s\n", fileName, destName );
	    status |= copy( fileName, destName );
	    }
	} while (pDirEnt != NULL);		/* until end of dir */

    status |= closedir (pDir);
    return status ;
    }/* cp() */

/********************************************************************************
* mv - mv file into other directory.
*
* This function is similar to rename() but behaves somewhat more
* like the UNIX program "mv", it will overwrite files.
*
* This command moves the <src> file or directory into
* a file which name is passed in the <dest> argument, if <dest> is
* a regular file or does not exist.
* If <dest> name is a directory, the source object is moved into
* this directory as with the same name,
* if <dest> is NULL, the current directory is assumed as the destination
* directory.
* <src> may be a single file name or a path containing a wildcard
* pattern, in which case all files or directories matching the pattern
* will be moved to <dest> which must be a directory in this case.
*
* EXAMPLES
* .CS
* -> mv( "/sd0/dir1","/sd0/dir2")
* -> mv( "/sd0/@.tmp","/sd0/junkdir")
* -> mv( "/sd0/FILE1.DAT","/sd0/dir2/f001.dat")
* .CE
*
* RETURNS: OK or error if any of the files or directories could not be
* moved, or if <src> is a pattern but the destination is not a
* directory.
*/
STATUS mv
    (   
    const char *src,   /* source file name or wildcard */
    const char *dest   /* destination name or directory */
    )
    {
    FAST DIR *pDir;		/* ptr to directory descriptor */
    FAST struct dirent	*pDirEnt;	/* ptr to dirent */
    STATUS status = OK ;
    char * pattern = NULL ;
    char * dirName = NULL ;
    char  dir[MAX_FILENAME_LENGTH] ;
    char  fileName[MAX_FILENAME_LENGTH] ;
    char  destName[MAX_FILENAME_LENGTH] ;

    if (src == NULL)
    	{
	errno = EINVAL ;
        return ERROR;
    	}

    if (dest == NULL)
	dest = "." ;

    /* dest does not exist or regular file */

    if (nameIsDir( dest ) == nameIsDir( src ))
	{
	if (dirNameWildcard( src))
	    {
	    printErr("mv: destination \"%s\" not a directory\n", dest );
	    errno = ENOTDIR ;
	    return ERROR;
	    }

	printf("moving file %s -> %s\n", src, dest );

        return mvFile ( src, dest );
	}

    strncpy( dir, src, MAX_FILENAME_LENGTH-1 );

    pattern = rindex(dir, '/');

    if ( pattern != NULL && pattern != dir && dirNameWildcard(pattern))
	{
	/* dir and pattern e.g. dir1/a*.c */
	*pattern++ = EOS ;
	dirName = dir ;
	}
    else if (dirNameWildcard( dir))
	{
	/* just pattern e.g. *.c or abc.? */
	pattern = dir;
	dirName = "." ;
	}
    else
	{
	pattern = NULL ;
	dirName = dir ;
	}

    if (pattern == NULL)
	{
	printf("moving file %s -> %s\n", src, dest );
	return (mvFile (src, dest ));
	}

    pDir = opendir (dirName) ;

    if (pDir == NULL)
	{
	perror(dirName);
	return ERROR;
	}

    errno = OK;

    do
	{
    	pDirEnt = readdir (pDir);
	if (pDirEnt != NULL)
	    {
	    if (pattern != NULL &&
		dirListPattern( pattern, pDirEnt->d_name) == FALSE)
		continue ;

	    if (strcmp(pDirEnt->d_name,"." )  == 0 &&
		strcmp(pDirEnt->d_name,".." ) == 0)
		continue ;

	    /* Construct path/filename for stat */
	    usrPathCat( dirName, pDirEnt->d_name, fileName );
	    usrPathCat( dest, pDirEnt->d_name, destName );

	    printf("moving file %s -> %s\n", fileName, destName );
	    status |= mvFile( fileName, destName );
	    }
	} while (pDirEnt != NULL);		/* until end of dir */

    status |= closedir (pDir);
    return status ;
    }  /* mv() */


/*******************************************************************************
*
* mvFile - move a file from one place to another.  
*
* This routine does some of the work of the mv() function.
*
* RETURNS: OK, or ERROR if the file could not be opened or moved.
*/

LOCAL int mvFile
    (
    const char *oldname,        /* name of file to move */
    const char *newname         /* name with which to move file */
    )
    {
    int fd;
    int status;

    if ((oldname == NULL) || (newname == NULL) || (newname[0] == EOS))
        {
        errnoSet (ENOENT);
        return (ERROR);
        }

    /* try to open file */

    if (ERROR == (fd = open ((char *) oldname, O_RDONLY, 0)))
        return (ERROR);

    /* move it */

    status = ioctl (fd, FIOMOVE, (int) newname);

    close (fd);
    return (status);
    }

/******************************************************************************
*
* xcopy - copy a hierarchy of files with wildcards
*
* <source> is a string containing a name of a directory, or a wildcard
* or both which will cause this function to make a recursive copy of all
* files residing in that directory and matching the wildcard pattern into
* the <dest> directory, preserving the file names and subdirectories.
*
* CAVEAT
* This function may call itself in accordance with the depth of the
* source directory, and occupies approximately 800 bytes per stack
* frame, meaning that to accommodate the maximum depth of subdirectories
* which is 20, at least 16 Kbytes of stack space should be available to
* avoid stack overflow.
*
* RETURNS: OK or ERROR if any operation has failed.
*
* SEE ALSO: tarLib, checkStack(), cp()
*/
STATUS xcopy
    (
    const char *source,	/* source directory or wildcard name */
    const char *dest		/* destination directory */
    )
    {
    FAST DIR *pDir;		/* ptr to directory descriptor */
    FAST struct dirent	*pDirEnt;	/* ptr to dirent */
    STATUS status = OK ;
    char * pattern = NULL ;
    char * dirName = NULL ;
    char  dir[MAX_FILENAME_LENGTH] ;
    char  fileName[MAX_FILENAME_LENGTH] ;
    char  destName[MAX_FILENAME_LENGTH] ;

    if (!nameIsDir( dest ))
	{
	printErr("xcopy: error: destination \"%s\" is not a directory\n",
		dest );
	errno = ENOTDIR ;
	return ERROR ;
	}

    strncpy( dir, source, MAX_FILENAME_LENGTH-1 );

    pattern = rindex(dir, '/');
    if ( pattern != NULL && pattern != dir && dirNameWildcard(pattern))
	{
	/* dir and pattern e.g. dir1/a*.c */
	*pattern++ = EOS ;
	dirName = dir ;
	}
    else if (dirNameWildcard( dir))
	{
	/* just pattern e.g. *.c or abc.? */
	pattern = dir;
	dirName = "." ;
	}
    else
	{
	pattern = NULL ;
	dirName = dir ;
	}

    if (!nameIsDir (dirName))
	{
	printf("copying file %s -> %s\n", source, dest );
	return copy(source, dest ) ;
	}

    pDir = opendir (dirName) ;

    if (pDir == NULL)
	{
	perror(dirName);
	return ERROR;
	}

    errno = OK;

    do
	{
    	pDirEnt = readdir (pDir);
	if (pDirEnt != NULL)
	    {
	    if (pattern != NULL &&
		dirListPattern( pattern, pDirEnt->d_name) == FALSE)
		continue ;

	    /* Construct path/filename for stat */
	    usrPathCat( dirName, pDirEnt->d_name, fileName );
	    usrPathCat( dest, pDirEnt->d_name, destName );


	    if (!nameIsDir( fileName ))
		{
		printf("copying file %s -> %s\n", fileName, destName );