Example #1
0
/*
|| Copy source to dest
*/
static int
copytape( void )
{
    int rc;
    char buf[ HETMAX_BLOCKSIZE ];

    while( TRUE )
    {
#ifdef EXTERNALGUI
        if( extgui )
        {
            off_t curpos;
            /* Report progress every nnnK */
            if ( i_faketape )
                curpos = ftell( s_fetb->fd );
            else
                curpos = ftell( s_hetb->fd );
            if( ( curpos & PROGRESS_MASK ) != ( prevpos & PROGRESS_MASK ) )
            {
                prevpos = curpos;
                fprintf( stderr, "IPOS=%" I64_FMT "d\n", (U64)curpos );
            }
        }
#endif /*EXTERNALGUI*/

        if ( i_faketape )
            rc = fet_read( s_fetb, buf );
        else
            rc = het_read( s_hetb, buf );
        if( rc == HETE_EOT )                // FAKETAPE and HETTAPE share codes
        {
            rc = 0;
            break;
        }

        if( rc == HETE_TAPEMARK )
        {
            if ( o_faketape )
                rc = fet_tapemark( d_fetb );
            else
                rc = het_tapemark( d_hetb );
            if( rc < 0 )
            {
                if ( o_faketape )
                    WRMSG( HHC00075, "E", "fet_tapemark()", fet_error( rc ) );
                else
                    WRMSG( HHC00075, "E", "het_tapemark()", het_error( rc ) );
                break;
            }
            continue;
        }

        if( rc < 0 )
        {
            if ( i_faketape )
                WRMSG( HHC00075, "E", "fet_read()", fet_error( rc ) );
            else
                WRMSG( HHC00075, "E", "het_read()", het_error( rc ) );
            break;
        }

        if ( o_faketape )
            rc = fet_write( d_fetb, buf, rc );
        else
            rc = het_write( d_hetb, buf, rc );
        if( rc < 0 )
        {
            if ( o_faketape )
                WRMSG( HHC00075, "E", "fet_write()", fet_error( rc ) );
            else
                WRMSG( HHC00075, "E", "het_write()", het_error( rc ) );
            break;
        }
    }

    return( rc );
}
Example #2
0
/*-------------------------------------------------------------------*/
DLL_EXPORT int
fet_open ( FETB **fetb, char *filename, int flags )
{
int             rc = -1;                /* Return code               */
char            pathname[MAX_PATH];     /* file path in host format  */
FETB           *tfetb;
char           *omode;
int             oflags;


    /* Open the FAKETAPE file */
    *fetb = NULL;

    hostpath(pathname, filename, sizeof(pathname));

    /*
    || Allocate a new FETB
    */
    tfetb = calloc( 1, sizeof( FETB ) );
    if( tfetb == NULL )
    {
        return( FETE_NOMEM );
    }

    /* Initialize FETB */
    tfetb->fd = -1;

    /*
    || clear FETOPEN_CREATE if FETOPEN_READONLY is specified
    */
    if(flags & FETOPEN_READONLY)
    {
        flags&=~FETOPEN_CREATE;
    }
    /*
    || Translate HET create flag to filesystem flag
    */
    oflags = ( ( flags & FETOPEN_CREATE ) ? O_CREAT : 0 );

    omode = "r+b";
    if( !( flags & FETOPEN_READONLY ) )
    {
        tfetb->fd = HOPEN( pathname, O_RDWR | O_BINARY | oflags, S_IRUSR | S_IWUSR | S_IRGRP );
    }

    /* If file is read-only, attempt to open again */
    if ( ( flags & FETOPEN_READONLY ) || (tfetb->fd < 0 && (EROFS == errno || EACCES == errno)))
    {
        omode = "rb";
        tfetb->writeprotect = TRUE;
        tfetb->fd = HOPEN( pathname, O_RDONLY | O_BINARY, S_IRUSR | S_IRGRP );
    }

    /*
    || Error out if both opens failed
    */
    if( tfetb->fd == -1 )
    {
        free( tfetb );
        return( FETE_ERROR );
    }

    /*
    || Associate stream with file descriptor
    */
    tfetb->fh = fdopen( tfetb->fd, omode );

    if( tfetb->fh == NULL )
    {
        rc = errno;
        close( tfetb->fd );
        errno = rc;
        free( tfetb );
        return( FETE_ERROR );
    }

    /*
    || If uninitialized tape, write 2 tapemarks to make it a valid NL tape
    */
    rc = fet_read_header( tfetb, 0L, NULL, NULL );
    if( rc < 0 && rc != FETE_TAPEMARK )
    {
        if( rc != FETE_EOT )
        {
            return( rc );
        }

        rc = fet_tapemark( tfetb );
        if( rc < 0 )
        {
            return( rc );
        }

        rc = fet_tapemark( tfetb );
        if( rc < 0 )
        {
            return( rc );
        }

        tfetb->created = TRUE;
    }
    else
        tfetb->created = FALSE;

    /*
    || Reposition tape to load point
    */
    rc = fet_rewind( tfetb );
    if( rc < 0 )
    {
        return( rc );
    }

    /*
    || Give the caller the new FETB
    */
    *fetb = tfetb;

    return( 0 );

} /* end function fet_open */
Example #3
0
/*
|| Standard main() function
*/
int
main( int argc, char *argv[] )
{
    char           *pgmname;                /* prog name in host format  */
    char           *pgm;                    /* less any extension (.ext) */
    char            msgbuf[512];            /* message build work area   */
    int             rc;
    SLLABEL         lab;
    HETB           *hetb;                   /* used for aws and het tapes*/
    FETB           *fetb;                   /* used for faketapes        */
    int             o_iehinitt;
    int             o_nl;
    int             o_compress;
    int             o_faketape;
    char           *o_filename;
    char           *o_owner;
    char           *o_volser;
    char           *strtok_str = NULL;


    /* Set program name */
    if ( argc > 0 )
    {
        if ( strlen(argv[0]) == 0 )
        {
            pgmname = strdup( UTILITY_NAME );
        }
        else
        {
            char path[MAX_PATH];
#if defined( _MSVC_ )
            GetModuleFileName( NULL, path, MAX_PATH );
#else
            strncpy( path, argv[0], sizeof( path ) );
#endif
            pgmname = strdup(basename(path));
#if !defined( _MSVC_ )
            strncpy( path, argv[0], sizeof(path) );
#endif
        }
    }
    else
    {
        pgmname = strdup( UTILITY_NAME );
    }

    pgm = strtok_r( strdup(pgmname), ".", &strtok_str);
    INITIALIZE_UTILITY( pgmname );

    /* Display the program identification message */
    MSGBUF( msgbuf, MSG_C( HHC02499, "I", pgm, "HET IEHINITT " ) );
    display_version (stderr, msgbuf+10, FALSE);

    hetb = NULL;
    fetb = NULL;
    o_filename = NULL;
    o_faketape = FALSE;
    o_iehinitt = TRUE;
    o_nl = FALSE;
    o_compress = TRUE;
    o_owner = NULL;
    o_volser = NULL;

    while( TRUE )
    {
        rc = getopt( argc, argv, "dhin" );
        if( rc == -1 )
        {
            break;
        }

        switch( rc )
        {
            case 'd':
                o_compress = FALSE;
            break;

            case 'h':
                usage( pgm );
                goto exit;
            break;

            case 'i':
                o_iehinitt = TRUE;
                o_nl = FALSE;
            break;

            case 'n':
                o_iehinitt = FALSE;
                o_nl = TRUE;
            break;

            default:
                usage( pgm );
                goto exit;
            break;
        }
    }

    argc -= optind;

    if( argc < 1 )
    {
        usage( pgm );
        goto exit;
    }

    o_filename = argv[ optind ];

    if ( ( rc = (int)strlen( o_filename ) ) > 4 && ( rc = strcasecmp( &o_filename[rc-4], ".fkt" ) ) == 0 )
    {
        o_faketape = TRUE;
    }

    if( o_iehinitt )
    {
        if( argc == 2 )
        {
            o_volser = argv[ optind + 1 ];
        }
        else if( argc == 3 )
        {
            o_volser = argv[ optind + 1 ];
            o_owner = argv[ optind + 2 ];
        }
        else
        {
            usage( pgm );
            goto exit;
        }
    }

    if( o_nl )
    {
        if( argc != 1 )
        {
            usage( pgm );
            goto exit;
        }
    }

    if( o_volser )
        het_string_to_upper( o_volser );

    if( o_owner )
        het_string_to_upper( o_owner );

    if ( o_faketape )  
    {
        rc = fet_open( &fetb, o_filename, FETOPEN_CREATE );
        if ( rc < 0 )
        {
            WRMSG( HHC00075, "E", "fet_open()", fet_error( rc ) );
            goto exit;
        }

    }
    else
    {
        rc = het_open( &hetb, o_filename, HETOPEN_CREATE );
        if( rc < 0 )
        {
            WRMSG( HHC00075, "E", "het_open()", het_error( rc ) );
            goto exit;
        }
   
        rc = het_cntl( hetb, HETCNTL_SET | HETCNTL_COMPRESS, o_compress );
        if( rc < 0 )
        {
            WRMSG( HHC00075, "E", "het_cntl()", het_error( rc ) );
            goto exit;
        }
    }

    if( o_iehinitt )
    {
        rc = sl_vol1( &lab, o_volser, o_owner );
        if( rc < 0 )
        {
            WRMSG( HHC00075, "E", "sl_vol1()", sl_error( rc ) );
            goto exit;
        }

        if ( o_faketape )
            rc = fet_write( fetb, &lab, (U16)sizeof( lab ) );
        else
            rc = het_write( hetb, &lab, sizeof( lab ) );
        if( rc < 0 )
        {
            if ( o_faketape )
                WRMSG( HHC00075, "E", "fet_write() for VOL1", fet_error( rc ) );
            else
                WRMSG( HHC00075, "E", "het_write() for VOL1", het_error( rc ) );
            goto exit;
        }

        rc = sl_hdr1( &lab, SL_INITDSN, NULL, 0, 0, NULL, 0 );
        if( rc < 0 )
        {
            WRMSG( HHC00075, "E", "sl_hdr1()", sl_error( rc ) );
            goto exit;
        }
        
        if ( o_faketape )  
            rc = fet_write( fetb, &lab, (U16)sizeof(lab) );
        else
            rc = het_write( hetb, &lab, sizeof( lab ) );
        if( rc < 0 )
        {
            if ( o_faketape )
                WRMSG( HHC00075, "E", "fet_write() for HDR1", fet_error( rc ) );
            else
                WRMSG( HHC00075, "E", "het_write() for HDR1", het_error( rc ) );
            goto exit;
        }

    }
    else if( o_nl )
    {
        if ( o_faketape )  
            rc = fet_tapemark( fetb );
        else
            rc = het_tapemark( hetb );
        if( rc < 0 )
        {
            if ( o_faketape )
                WRMSG( HHC00075, "E", "fet_tapemark()", fet_error( rc ) );
            else
                WRMSG( HHC00075, "E", "het_tapemark()", het_error( rc ) );
            goto exit;
        }
    }

    if ( o_faketape )  
        rc = fet_tapemark( fetb );
    else
        rc = het_tapemark( hetb );
    if( rc < 0 )
    {
        if ( o_faketape )
            WRMSG( HHC00075, "E", "fet_tapemark()", fet_error( rc ) );
        else
            WRMSG( HHC00075, "E", "het_tapemark()", het_error( rc ) );
        goto exit;
    }

exit:
    if ( o_faketape)
        fet_close( &fetb );
    else
        het_close( &hetb );

    return( rc < 0 );
}