tarlib.c

VXWORKS源代码

	    cnt = pCtrl->bFactor - pCtrl->bValid ;
	    cnt = min( (ULONG)cnt, nBlocks );

	    bcopy( pBuf, (char *) (pCtrl->pBuf + pCtrl->bValid), cnt*TBLOCK );
	    pBuf += cnt*TBLOCK;
	    nBlocks -= cnt ;
	    pCtrl->bValid += cnt ;
	    }

	if( pCtrl->bValid == pCtrl->bFactor  )
	    {
	    /* one full blocked buffer, write to tape */
	    rc = write( pCtrl->fd, (char *) pCtrl->pBuf,
			pCtrl->bFactor*TBLOCK ) ;

	    if ( rc == ERROR )
		return ERROR ;

	    /* adjust count and pointer */
	    pCtrl->bValid = 0 ;
	    }

	} /* while */

    return OK;
    }

/*******************************************************************************
*
* tarCreateHdr - build a tar header block 
*
* NOTE:
* SunOS tar(5) man page is not accurate, this function
* was built using empiric methods with that tar(1) command.
* RETURNS: file size in bytes
*/

LOCAL int tarCreateHdr
    (
    MT_TAR_SOFT *pCtrl,		/* control structure */
    const char  *name,		/* file/dir name */
    struct stat *pStat,		/* file stats */
    MT_HBLOCK *	pBlk		/* block buffer for header */
    )
    {
    int	chksum;

    strncpy( pBlk->dbuf.name, name, NAMSIZ );

    if( S_ISDIR(pStat->st_mode) )
	{
	pStat->st_mode |= 0200 ;
	pStat->st_size = 0 ;
	}

    sprintf( pBlk->dbuf.mode, "%6o ", pStat->st_mode );
    sprintf( pBlk->dbuf.uid, "%6o ", pStat->st_uid );
    sprintf( pBlk->dbuf.gid, "%6o ", pStat->st_gid );
    sprintf( pBlk->dbuf.size, "%11lo ", pStat->st_size );
    sprintf( pBlk->dbuf.mtime, "%11lo ", pStat->st_mtime );
    pBlk->dbuf.linkflag = '0';
    bfill( pBlk->dbuf.chksum, 8, ' ');		/* fill blanks */

    chksum = mtChecksum( pBlk->dummy, TBLOCK ) ;

    sprintf( pBlk->dbuf.chksum, "%6o", chksum);

    return( pStat->st_size );
    }

/*******************************************************************************
*
* tarArchDo - archive a file/dir onto tape (recursive)
*
* Handle one file or one directory, in case of directory,
* write the dir entry and recurse.
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS tarArchDo
    (
    MT_TAR_SOFT *pCtrl,		/* control structure */
    BOOL	verbose,	/* verbosity flag */
    char *	name		/* file/dir name */
    )
    {
    MT_HBLOCK	hblock;		/* header block */
    struct stat	st;		/* file/dir stat */
    register int rc;

    bzero ( (char *) &hblock, sizeof( MT_HBLOCK ) );
    if( strlen( name ) >= (NAMSIZ-1))
	{
	printErr("tar: name too long %s, skip.\n", name );
	return ERROR;
	}

    rc = stat( name, &st );

    if ( rc == ERROR)
	{
	perror("tar: stat error ");
	return ERROR ;
	}

    if ( pCtrl->recurseCnt++ > MAXLEVEL )
	{
	printErr("tar: nesting too deep, skipping %s\n", name);
	goto abort ;
	}

    if( S_ISDIR(st.st_mode) )
	{
	char	fn [ NAMSIZ ];	/* subdir name */
	register DIR *	pDir;
	struct dirent *	pDirEnt ;

	/* handle directory */
	strncpy( fn, name, NAMSIZ-2 );
	strcat( fn, "/" );
	/* write directory header block to tape */
	tarCreateHdr( pCtrl, fn, &st, &hblock ) ;

	if( verbose )
	    printErr("tar: writing directory %s\n", name );

	if (tarWrtBlks( pCtrl, (char *) &hblock, 1 ) == ERROR )
	    {
	    perror("tar: error writing header to tape ");
	    goto abort;
	    }

	/* recurse on every directory member */
	pDir = opendir( name ) ;

	if( pDir == NULL )
	    {
	    perror((sprintf(fn,"tar: error opening directory %s ", name),fn));
	    goto abort;
	    }

	for( pDirEnt = readdir(pDir); pDirEnt != NULL ;
			pDirEnt = readdir(pDir))
	    {
	    /* Skip the "." and ".." entries */
	    if ( strcmp( pDirEnt->d_name, ".") == 0)
		continue ;
	    if ( strcmp( pDirEnt->d_name, "..") == 0)
		continue ;
	    /* build the new name by concatenating */
	    strncpy( fn, name, NAMSIZ-2 );
	    strcat( fn, "/" );
	    strcat( fn, pDirEnt->d_name );
	    /* recurse ! nesting level of MAXLEVEL maximum */
	    (void )tarArchDo( pCtrl, verbose, fn ) ;
	    }

	closedir( pDir );
	}
    else if( S_ISREG(st.st_mode) )
	{
	int		fileFd = -1 ;
	register int fileSize ;
	register int rc ;
	register char *	pFileBuf ;
	unsigned bufSize = pCtrl->bFactor*TBLOCK;
	unsigned nBlocks = 0 ;

	/* handle plain file */
	/* write file header to tape */
	fileSize = tarCreateHdr( pCtrl, name, &st, &hblock ) ;

	/* write the file itself to tape */
	pFileBuf = KHEAP_ALLOC( bufSize );

	if( pFileBuf == NULL )
	    {
	    printErr("tar: not enough memory\n" );
	    goto abort;
	    }
	fileFd = open( name, O_RDONLY, 0);

	if( fileFd == ERROR )
	    {
	    perror((sprintf(pFileBuf,"tar: file open error %s, ", name),
			pFileBuf));
	    KHEAP_FREE(((char *) pFileBuf) ); 
	    goto abort;
	    }
	/* Handle Regular File - calculate number of blocks */
	if( fileSize > 0 )
	    nBlocks = ( fileSize / TBLOCK ) +  ((fileSize % TBLOCK)? 1 : 0 ) ;

	if( verbose )
	    printErr("tar: writing file %s, size %d bytes, %d blocks\n",
			name, fileSize, nBlocks );

	if (tarWrtBlks( pCtrl, (char *) &hblock, 1 ) == ERROR )
	    {
	    perror("tar: error writing header to tape ");
	    KHEAP_FREE(((char *) pFileBuf) ); 
	    goto abort;
	    }

	while( nBlocks > 0 )
	    {
	    /* try to optimize into direct tape writing here */
	    rc = read( fileFd, pFileBuf,
		bufSize - (pCtrl->bValid*TBLOCK) ) ;

	    if( rc == ERROR )
		{
		perror((sprintf(pFileBuf,"tar: file read error %s, ", name),
			pFileBuf));
		rc = 1;
		}
	    else if( rc == 0 )
		{
		printErr("tar: file changed size!\n");
		rc = 1; 
		}
	    else
		{
		/* recalculate read count in blocks */
		rc = ( rc / TBLOCK ) +  ((rc % TBLOCK)? 1 : 0 ) ;
		}

	    /* Now write the file blocks to tape */
	    tarWrtBlks( pCtrl, pFileBuf, rc );
	    nBlocks -= rc ;
	    }/*while*/

	close( fileFd );
	KHEAP_FREE(((char *) pFileBuf));
	} /* end of regular file handling */
    else
	{
	printErr("tar: not a regular file nor a directory %s, skipped\n",
		name );
	goto abort;
	}

    pCtrl->recurseCnt --;
    return OK;

abort:
    pCtrl->recurseCnt --;
    return ERROR;
    }

/*******************************************************************************
*
* tarArchive - archive named file/dir onto tape in tar format
*
* This function creates a UNIX compatible tar formatted archives
* which contain entire file hierarchies from disk file systems.
* Files and directories are archived with mode and time information
* as returned by stat().
*
* The <tape> argument can be any tape drive device name or a name of any
* file that will be created if necessary, and will contain the archive.
* If <tape> is set to "-", standard output will be used.
* If <tape> is NULL (unspecified from Shell), the default archive file
* name stored in global variable <TAPE> will be used.
*
* Each write() of the archive file will be exactly <bfactor>*512 bytes
* long, hence on tapes in variable mode, this will be the physical
* block size on the tape. With Fixed Mode tapes this is only a performance
* matter. If <bfactor> is 0, or unspecified from Shell, it will be set
* to the default value of 20.
*
* The <verbose> argument is a boolean, if set to 1, will cause informative
* messages to be printed to standard error whenever an action is taken,
* otherwise, only errors are reported.
*
* The <name> argument is the path of the hierarchy to be archived.
* if NULL (or unspecified from the Shell), the current directory path "."
* will be used.  This is the path as seen from the target, not from 
* the Tornado host.
*
* All informative and error message are printed to standard error.
*
* NOTE
* Refrain from specifying absolute path names in <path>, such archives
* tend to be either difficult to extract or can cause unexpected
* damage to existing files if such exist under the same absolute name.
*
* There is no way of specifying a number of hierarchies to dump.
*/

STATUS tarArchive
    (
    char *	pTape,		/* tape device name */
    int		bfactor,	/* requested blocking factor */
    BOOL	verbose,	/* if TRUE print progress info */
    char *	pName		/* file/dir name to archive */
    )
    {
    MT_TAR_SOFT	ctrl;		/* control structure */
    STATUS	retval = OK;

    /* Set defaults */
    if( pTape == NULL )
	pTape = TAPE ;

    if( bfactor == 0 )
	bfactor = 20 ;

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

    if( verbose )
	printErr("Archiving to %s\n", pTape );

    bzero( (char *)&ctrl, sizeof(ctrl) );
    bzero( bZero, sizeof(bZero) );	/* not harmful for reentrancy */

    /* Open tape device and initialize control structure */
    if( strcmp(pTape, "-") == 0)
	ctrl.fd = STD_OUT;
    else
	ctrl.fd = open( pTape, O_CREAT | O_WRONLY, 0644) ;

    if ( ctrl.fd < 0 )
	{
	printErr("Failed to open tape: %s\n", strerror(errnoGet()) );
	return ERROR;
	}
    
    ctrl.bValid = 0 ;
    ctrl.bFactor = bfactor ;
    ctrl.pBuf = KHEAP_ALLOC( bfactor * TBLOCK ) ;

    if ( ctrl.pBuf == NULL )
	{
	printErr("Not enough memory, exiting.\n" );
	if ( ctrl.fd != STD_OUT)
	    close( ctrl.fd );
	return ERROR ;
	}

    /* all exits from now via goto in order to free the buffer */

    retval = tarArchDo( &ctrl, verbose, pName ) ;

    /* at end of tape, write at least two zero blocks */
    if( verbose )
	printErr("tar: writing end of tape.\n");

    tarWrtBlks( &ctrl, bZero, 1 );
    tarWrtBlks( &ctrl, bZero, 1 );

    /* and fill the last blocked block until written to tape */
    while( ctrl.bValid > 0 )
	tarWrtBlks( &ctrl, bZero, 1 );
    
    if( ctrl.fd != STD_OUT )
	close( ctrl.fd );
    KHEAP_FREE(((char *) ctrl.pBuf));
    return( retval );
    }


/*******************************************************************************
*
* tarTocFile - display one file or directory from tar tape
*
* Called from tarToc for every file/dir found on tape.
*
* RETURNS: OK or ERROR
*/

LOCAL STATUS tarTocFile
    (
    MT_TAR_SOFT	*pCtrl,		/* control structure */
    MT_HBLOCK	*pBlk		/* header block */
    )
    {
    register	int rc ;
    int		sum = -1 ;		/* checksum */
    int		size = 0 ;		/* file size in bytes */
    int		nblks = 0;		/* file size in TBLOCKs */
    int		mode ;
    char *	fn ;			/* file/dir name */


    /* Check the checksum of this header */

    rc = sscanf( pBlk->dbuf.chksum, "%o", &sum ) ;	/* extract checksum */

    bfill( pBlk->dbuf.chksum, 8, ' ');		/* fill blanks */

    if( mtChecksum( pBlk->dummy, TBLOCK ) != sum )
	{
	printErr("bad checksum %d != %d\n",
		mtChecksum( pBlk->dummy, TBLOCK), sum );
	return ERROR;
	}

    /* Parse all fields of header that we need, and store them safely */
    sscanf( pBlk->dbuf.mode, "%o", &mode );
    sscanf( pBlk->dbuf.size, "%12o", &size );
    fn = pBlk->dbuf.name ;

    /* Handle directory */
    if( (size == 0) || ( fn[ strlen(fn) - 1 ] == '/' ) )
	{
	printErr("directory %s.\n", fn );
	}

    /* Filter out links etc */

    if ((pBlk->dbuf.linkflag != '\0') &&
    	(pBlk->dbuf.linkflag != '0') &&
	(pBlk->dbuf.linkflag != ' '))
	{
	printErr("we do not support links, %s skipped\n", fn );
	return OK;
	}

    /* Handle Regular File - calculate number of blocks */
    if( size > 0 )
	nblks = ( size / TBLOCK ) +  ((size % TBLOCK)? 1 : 0 ) ;

    printErr("file %s, size %d bytes, %d blocks\n",
		fn, size, nblks );

    /* Loop until entire file skipped */
    while (size > 0)
	{
	MT_HBLOCK *pBuf;

	rc = tarRdBlks( pCtrl, &pBuf, nblks) ;

	if ( rc < 0 )
	    {
	    printErr("error reading tape\n");
	    return ERROR;
	    }

	size -= rc*TBLOCK ;
	nblks -= rc ;
	}
    return( OK );
    }

/*******************************************************************************
*
* tarToc - display all contents of a tar formatted tape
*
* This is a UNIX-tar compatible utility that displays entire
* file hierarchies from tar-formatted media, e.g. tape.
*
* The <tape> argument may be any tape device name or file name
* that contains a tar formatted archive. If <tape> is equal "-",
* standard input is used. If <tape> is NULL (or unspecified from Shell)
* the default archive file name stored in global variable <TAPE> is used.
*
* The <bfactor> dictates the blocking factor the tape was written with.
* If 0, or unspecified from Shell, default of 20 is used.
*
* Archive contents are displayed on standard output, while
* all informative and eror message are printed to standard error.
*
*/

STATUS tarToc
    (
    char *	tape,		/* tape device name */
    int		bfactor 	/* requested blocking factor */
    )
    {
    register 	int rc ;		/* return codes */
    MT_TAR_SOFT	ctrl ;		/* control structure */
    STATUS	retval = OK;

    /* Set defaults */
    if( tape == NULL )
	tape = TAPE ;

    if( bfactor == 0 )
	bfactor = 20 ;

    printErr("Contents from %s\n", tape );

    bzero( (char *)&ctrl, sizeof(ctrl) );
    bzero( bZero, sizeof(bZero) );	/* not harmful for reentrancy */

    /* Open tape device and initialize control structure */
    if( strcmp(tape, "-") == 0)
	ctrl.fd = STD_IN;
    else
	ctrl.fd = open( tape, O_RDONLY, 0) ;

    if ( ctrl.fd < 0 )
	{
	printErr("Failed to open tape: %s\n", strerror(errnoGet()) );
	return ERROR;
	}
    
    ctrl.bFactor = bfactor ;
    ctrl.pBuf = KHEAP_ALLOC( bfactor * TBLOCK ) ;

    if ( ctrl.pBuf == NULL )
	{
	printErr("Not enough memory, exiting.\n" );
	if ( ctrl.fd != STD_IN )
	    close( ctrl.fd );
	return ERROR ;
	}

    /* all exits from now via goto in order to free the buffer */

    /* Read the first block and adjust blocking factor */

    rc = read( ctrl.fd, ctrl.pBuf->dummy, ctrl.bFactor*TBLOCK ) ;

    if ( rc == ERROR )
	{
	printErr("read error at the beginning of tape, exiting.\n" );
	retval = ERROR ;
	goto finish;
	}
    else if( rc == 0 )
	{
	printErr("empty tape file, exiting.\n" );
	goto finish;
	}
    else if( (rc % TBLOCK) != 0 )
	{
	printErr("tape block not multiple of %d, exiting.\n", TBLOCK);
	retval = ERROR ;
	goto finish;
	}

    ctrl.bValid = rc / TBLOCK ;
    ctrl.pBnext = ctrl.pBuf ;
    if ( ctrl.bFactor != ctrl.bValid )
	{
	printErr("adjusting blocking factor to %d\n", ctrl.bValid );
	ctrl.bFactor = ctrl.bValid ;
	}

    /* End of overture, start processing files until end of tape */

    FOREVER
	{
	MT_HBLOCK *	pBlk ;

	if ( tarRdBlks( &ctrl, &pBlk, 1) != 1 )
	    {
	    retval = ERROR ;
	    goto finish;
	    }

	if ( bcmp( pBlk->dummy, bZero, TBLOCK) == 0 )
	    {
	    printErr("end of tape encountered, read until eof...\n");
	    while( tarRdBlks( &ctrl, &pBlk, 1) > 0) ;
	    printErr("done.\n");
	    retval = OK ;
	    goto finish;
	    }

	if ( tarTocFile( &ctrl, pBlk) == ERROR )
	    {
	    retval = ERROR;
	    goto finish;
	    }

	} /* end of FOREVER */
    
finish:
	if ( ctrl.fd != STD_IN )
	    close( ctrl.fd );
	KHEAP_FREE((char *) ctrl.pBuf );
	return( retval );
    }

/* End of File */