/*-------------------------------------------------------------------*/
int syntax (char *pgm)
{
char usage[8192];
char buflfs[64];
#ifdef CCKD_COMPRESS_ZLIB
char *bufz = " -z compress using zlib [default]\n";
#else
char *bufz = "";
#endif
#ifdef CCKD_COMPRESS_BZIP2
char *bufbz = " -bz2 compress using bzip2\n";
#else
char *bufbz = "";
#endif
strncpy( buflfs,
(sizeof(off_t) > 4) ?
" -lfs create single large output file\n" : "",
sizeof( buflfs));
MSGBUF( usage, MSG_C( HHC02499, "I", pgm, "DASD copy/convert" ) );
display_version (stderr, usage+10, FALSE);
if (strcasecmp(pgm, "ckd2cckd") == 0)
MSGBUF( usage ,MSG( HHC02435, "I", bufz, bufbz ) );
else if (strcasecmp(pgm, "cckd2ckd") == 0)
MSGBUF( usage ,MSG( HHC02436, "I", buflfs ) );
else if (strcasecmp(pgm, "fba2cfba") == 0)
MSGBUF( usage ,MSG( HHC02437, "I", bufz, bufbz ) );
else if (strcasecmp(pgm, "cfba2fba") == 0)
MSGBUF( usage ,MSG( HHC02438, "I", buflfs ) );
else
MSGBUF( usage ,MSG( HHC02439, "I", pgm, bufz, bufbz, buflfs ) );
printf ("%s", usage);
return -1;
} /* end function syntax */
/*-------------------------------------------------------------------*/
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 cckd_diag_rc = 0; /* Program return code */
char *fn; /* File name */
CKDDASD_DEVHDR devhdr; /* [C]CKD device hdr */
CCKDDASD_DEVHDR cdevhdr; /* Compressed CKD device hdr */
CKDDEV *ckd=0; /* CKD DASD table entry */
FBADEV *fba=0; /* FBA DASD table entry */
int cmd_devhdr = 0; /* display DEVHDR */
int cmd_cdevhdr = 0; /* display CDEVHDR */
int cmd_l1tab = 0; /* display L1TAB */
int cmd_l2tab = 0; /* display L2TAB */
int cmd_trkdata = 0; /* display track data */
int cmd_hexdump = 0; /* display track data (hex) */
int cmd_offset = 0; /* 1 = display data at */
int op_offset = 0; /* op_offset of length */
int op_length = 0; /* op_length */
int cmd_cchh = 0; /* 1 = display CCHH data */
int op_cc = 0; /* CC = cylinder */
int op_hh = 0; /* HH = head */
int cmd_tt = 0; /* 1 = display TT data */
int op_tt = 0; /* relative track # */
int swapend; /* 1 = New endianess doesn't
match machine endianess */
int n, trk=0, l1ndx=0, l2ndx=0;
off_t l2taboff=0; /* offset to assoc. L2 table */
int ckddasd; /* 1=CKD dasd 0=FBA dasd */
int heads=0; /* Heads per cylinder */
off_t trkhdroff=0; /* offset to assoc. trk hdr */
int imglen=0; /* track length */
char pathname[MAX_PATH]; /* file path in host format */
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, "CCKD diagnostic program" ) );
display_version (stderr, msgbuf+10, FALSE);
/* parse the arguments */
argc--;
argv++ ;
while (argc > 0) {
if(**argv != '-') break;
switch(argv[0][1]) {
case 'v': if (argv[0][2] != '\0') return syntax (pgm);
return 0;
case 'd': if (argv[0][2] != '\0') return syntax (pgm);
cmd_devhdr = 1;
break;
case 'c': if (argv[0][2] != '\0') return syntax (pgm);
cmd_cdevhdr = 1;
break;
case '1': if (argv[0][2] != '\0') return syntax (pgm);
cmd_l1tab = 1;
break;
case '2': if (argv[0][2] != '\0') return syntax (pgm);
cmd_l2tab = 1;
break;
case 'a': if (argv[0][2] != '\0') return syntax (pgm);
cmd_cchh = 1;
argc--; argv++;
op_cc = offtify(*argv);
argc--; argv++;
op_hh = offtify(*argv);
break;
case 'r': if (argv[0][2] != '\0') return syntax (pgm);
cmd_tt = 1;
argc--; argv++;
op_tt = offtify(*argv);
break;
case 'o': if (argv[0][2] != '\0') return syntax (pgm);
cmd_offset = 1;
argc--;
argv++;
op_offset = offtify(*argv);
argc--;
argv++;
op_length = offtify(*argv);
break;
case 't': if (argv[0][2] != '\0') return syntax (pgm);
cmd_trkdata = 1;
break;
case 'x': if (argv[0][2] != '\0') return syntax (pgm);
cmd_hexdump = 1;
cmd_trkdata = 1;
break;
case 'g': if (argv[0][2] != '\0') return syntax (pgm);
debug = 1;
break;
default: return syntax (pgm);
}
argc--;
argv++;
}
if (argc != 1) return syntax (pgm);
fn = argv[0];
/* open the file */
hostpath(pathname, fn, sizeof(pathname));
fd = HOPEN(pathname, O_RDONLY | O_BINARY);
if (fd < 0) {
fprintf(stderr,
_("cckddiag: error opening file %s: %s\n"),
fn, strerror(errno));
return -1;
}
/*---------------------------------------------------------------*/
/* display DEVHDR - first 512 bytes of dasd image */
/*---------------------------------------------------------------*/
readpos(fd, &devhdr, 0, sizeof(devhdr));
if (cmd_devhdr) {
fprintf(stderr, "\nDEVHDR - %d (decimal) bytes:\n",
(int)sizeof(devhdr));
data_dump(&devhdr, sizeof(devhdr));
}
/*---------------------------------------------------------------*/
/* Determine CKD or FBA device type */
/*---------------------------------------------------------------*/
if (memcmp(devhdr.devid, "CKD_C370", 8) == 0
|| memcmp(devhdr.devid, "CKD_S370", 8) == 0) {
ckddasd = 1;
ckd = dasd_lookup(DASD_CKDDEV, NULL, devhdr.devtype, 0);
if (ckd == NULL) {
fprintf(stderr,
"DASD table entry not found for devtype 0x%2.2X\n",
devhdr.devtype);
clean();
exit(5);
}
}
else
if (memcmp(devhdr.devid, "FBA_C370", 8) == 0
|| memcmp(devhdr.devid, "FBA_S370", 8) == 0) {
ckddasd = 0;
fba = dasd_lookup(DASD_FBADEV, NULL, devhdr.devtype, 0);
if (fba == NULL) {
fprintf(stderr,
"DASD table entry not found for "
"devtype 0x%2.2X\n",
DEFAULT_FBA_TYPE);
clean();
exit(6);
}
}
else {
fprintf(stderr, "incorrect header id\n");
clean();
return -1;
}
/*---------------------------------------------------------------*/
/* Set up device characteristics */
/*---------------------------------------------------------------*/
if (ckddasd) {
heads = ((U32)(devhdr.heads[3]) << 24)
| ((U32)(devhdr.heads[2]) << 16)
| ((U32)(devhdr.heads[1]) << 8)
| (U32)(devhdr.heads[0]);
if (debug)
fprintf(stderr,
"\nHHC90000D DBG: %s device has %d heads/cylinder\n",
ckd->name, heads);
}
/*---------------------------------------------------------------*/
/* display CDEVHDR - follows DEVHDR */
/*---------------------------------------------------------------*/
readpos(fd, &cdevhdr, CKDDASD_DEVHDR_SIZE, sizeof(cdevhdr));
if (cmd_cdevhdr) {
fprintf(stderr, "\nCDEVHDR - %d (decimal) bytes:\n",
(int)sizeof(cdevhdr));
data_dump(&cdevhdr, sizeof(cdevhdr));
}
/*---------------------------------------------------------------*/
/* Find machine endian-ness */
/*---------------------------------------------------------------*/
/* cckd_endian() returns 1 for big-endian machines */
swapend = (cckd_endian() !=
((cdevhdr.options & CCKD_BIGENDIAN) != 0));
/*---------------------------------------------------------------*/
/* display L1TAB - follows CDEVHDR */
/*---------------------------------------------------------------*/
/* swap numl1tab if needed */
n = cdevhdr.numl1tab;
if (swapend) cckd_swapend4((char *)&n);
l1 = makbuf(n * CCKD_L1ENT_SIZE, "L1TAB");
readpos(fd, l1, CCKD_L1TAB_POS, n * CCKD_L1ENT_SIZE);
/* L1TAB itself is not adjusted for endian-ness */
if (cmd_l1tab) {
fprintf(stderr, "\nL1TAB - %d (0x%X) bytes:\n",
(int)(n * CCKD_L1ENT_SIZE), (unsigned int)(n * CCKD_L1ENT_SIZE));
data_dump(l1, n * CCKD_L1ENT_SIZE);
}
/*---------------------------------------------------------------*/
/* display OFFSET, LENGTH data */
/*---------------------------------------------------------------*/
if (cmd_offset) {
bulk = makbuf(op_length, "BULK");
readpos(fd, bulk, op_offset, op_length);
fprintf(stderr,
"\nIMAGE OFFSET %d (0x%8.8X) "
"of length %d (0x%8.8X) bytes:\n",
op_offset, op_offset, op_length, op_length);
data_dump(bulk, op_length);
free(bulk);
bulk = NULL;
}
/*---------------------------------------------------------------*/
/* FBA isn't supported here because I don't know much about FBA */
/*---------------------------------------------------------------*/
if ( (!ckddasd) && ((cmd_cchh) || (cmd_tt)) ) {
fprintf(stderr, "CCHH/reltrk not supported for FBA\n");
clean();
exit(3);
}
/*---------------------------------------------------------------*/
/* Setup CCHH or relative track request */
/*---------------------------------------------------------------*/
if (ckddasd) {
if (cmd_tt) {
trk = op_tt;
op_cc = trk / heads;
op_hh = trk % heads;
} else {
trk = (op_cc * heads) + op_hh;
}
l1ndx = trk / cdevhdr.numl2tab;
l2ndx = trk % cdevhdr.numl2tab;
l2taboff = l1[l1ndx];
if (swapend) cckd_swapend4((char *)&l2taboff);
}
/*---------------------------------------------------------------*/
/* display CKD CCHH or relative track data */
/*---------------------------------------------------------------*/
if ((cmd_cchh) || (cmd_tt)) {
fprintf(stderr,
"CC %d HH %d = reltrk %d; "
"L1 index = %d, L2 index = %d\n"
"L1 index %d = L2TAB offset %d (0x%8.8X)\n",
op_cc, op_hh, trk,
l1ndx, l2ndx,
l1ndx, (int)l2taboff, (int)l2taboff);
l2 = makbuf(cdevhdr.numl2tab * sizeof(CCKD_L2ENT), "L2TAB");
readpos(fd, l2, l2taboff,
cdevhdr.numl2tab * sizeof(CCKD_L2ENT));
if (cmd_l2tab) {
fprintf(stderr,
"\nL2TAB - %d (decimal) bytes\n",
(int)(cdevhdr.numl2tab * sizeof(CCKD_L2ENT)));
data_dump(l2, (cdevhdr.numl2tab * sizeof(CCKD_L2ENT)) );
}
fprintf(stderr, "\nL2 index %d = L2TAB entry %d bytes\n",
l2ndx, (int)sizeof(CCKD_L2ENT) );
data_dump(&l2[l2ndx], sizeof(CCKD_L2ENT) );
trkhdroff = l2[l2ndx].pos;
imglen = l2[l2ndx].len;
if (swapend) {
cckd_swapend4((char *)&trkhdroff);
cckd_swapend4((char *)&imglen);
}
fprintf(stderr, "\nTRKHDR offset %d (0x%8.8X); "
"length %d (0x%4.4X)\n",
(int)trkhdroff, (int)trkhdroff, imglen, imglen);
tbuf = makbuf(imglen, "TRKHDR+DATA");
readpos(fd, tbuf, trkhdroff, imglen);
fprintf(stderr, "\nTRKHDR track %d\n", trk);
data_dump(tbuf, sizeof(CKDDASD_TRKHDR) );
if (cmd_trkdata) showtrk(tbuf, imglen, trk, cmd_hexdump);
free(l2); free(tbuf);
l2 = NULL; tbuf = NULL;
}
/* Close file, exit */
fprintf(stderr, "\n");
clean();
return cckd_diag_rc;
}
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 = 0;
char *fn, *sfn;
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, "DASD list program" ) );
display_version (stderr, msgbuf+10, FALSE);
if (argc < 2)
{
fprintf( stderr, MSG( HHC02463, "I", pgm, "" ) );
exit(2);
}
/*
* If your version of Hercules doesn't have support in its
* dasdutil.c for turning off verbose messages, then remove
* the following line but you'll have to live with chatty
* progress output on stdout.
*/
set_verbose_util(0);
while (*++argv)
{
fn = *argv;
if (*(argv+1) && strlen (*(argv+1)) > 3 && !memcmp(*(argv+1), "sf=", 3))
sfn = *++argv;
else sfn = NULL;
if (do_ls(fn, sfn))
rc = 1;
}
return rc;
}
/*
|| Standard main
*/
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 */
char toname[ MAX_PATH ];
int rc;
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 Copy/Update" ) );
display_version (stderr, msgbuf+10, FALSE);
while( TRUE )
{
#if defined( HET_BZIP2 )
rc = getopt( argc, argv, "bc:dhrsvz0123456789" );
#else
rc = getopt( argc, argv, "c:dhrsvz0123456789" );
#endif /* defined( HET_BZIP2 ) */
if( rc == -1 )
{
break;
}
switch( rc )
{
case '1': case '2': case '3': case '4': /* Compression level */
case '5': case '6': case '7': case '8':
case '9':
o_level = ( rc - '0' );
break;
#if defined( HET_BZIP2 )
case 'b': /* Use BZLIB compression */
o_method = HETMETH_BZLIB;
o_compress = TRUE;
o_decompress = TRUE;
break;
#endif /* defined( HET_BZIP2 ) */
case 'c': /* Chunk size */
o_chunksize = atoi( optarg );
break;
case 'd': /* Decompress */
o_compress = FALSE;
o_decompress = TRUE;
break;
case 'h': /* Print usage */
usage( pgm );
exit( 1 );
break;
case 'r': /* Rechunk */
o_compress = FALSE;
o_decompress = FALSE;
break;
case 's': /* Strict HET spec */
o_chunksize = 4096;
o_compress = FALSE;
o_decompress = TRUE;
break;
case 'v': /* Be chatty */
o_verbose = TRUE;
break;
case 'z': /* Use ZLIB compression */
o_method = HETMETH_ZLIB;
o_compress = TRUE;
o_decompress = TRUE;
break;
default: /* Print usage */
usage( pgm );
exit( 1 );
break;
}
}
argc -= optind;
switch( argc )
{
case 1:
sprintf( toname, "%s.%010d", argv[ optind ], rand() );
o_dname = toname;
dorename = TRUE;
break;
case 2:
o_dname = argv[ optind + 1 ];
break;
default:
usage( pgm );
exit( 1 );
break;
}
o_sname = argv[ optind ] ;
rc = opentapes();
if( rc < 0 )
{
WRMSG( HHC02756, "E", "opening", het_error( rc ) );
}
else
{
rc = copytape();
if( rc < 0 )
{
WRMSG( HHC02756, "E", "copying", het_error( rc ) );
}
}
closetapes( rc );
return 0;
}
/*-------------------------------------------------------------------*/
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 */
IFD ifd; /* Input file descriptor */
int repl = 0; /* 1=replace existing file */
int quiet = 0; /* 1=suppress progress msgs */
BYTE *itrkbuf; /* -> Input track buffer */
U32 itrklen; /* Input track length */
U32 volcyls; /* Total cylinders on volume */
U32 heads = 0; /* Number of tracks/cylinder */
U32 maxdlen = 0; /* Maximum R1 data length */
U16 devtype; /* Device type */
char ifname[256]; /* Input file name */
char ofname[256]; /* Output file name */
BYTE volser[7]; /* Volume serial (ASCIIZ) */
int lfs = 0; /* 1 = Build large file */
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( pgm );
/* Display the program identification message */
MSGBUF( msgbuf, MSG_C( HHC02499, "I", pgm, "DASD CKD image conversion" ) );
display_version (stderr, msgbuf+10, FALSE);
/* Process the options in the argument list */
for (; argc > 1; argc--, argv++)
{
if (strcmp(argv[1], "-") == 0) break;
if (argv[1][0] != '-') break;
if (strcmp(argv[1], "-r") == 0)
repl = 1;
else if (strcmp(argv[1], "-q") == 0)
quiet = 1;
else
if (sizeof(off_t) > 4 && strcmp(argv[1], "-lfs") == 0)
lfs = 1;
else
argexit(5, pgm);
}
if (argc != 3)
argexit(5, pgm);
/* The first argument is the input file name */
if (argv[1] == NULL || strlen(argv[1]) == 0
|| strlen(argv[1]) > sizeof(ifname)-1)
argexit(1, pgm);
strcpy (ifname, argv[1]);
/* The second argument is the output file name */
if (argv[2] == NULL || strlen(argv[2]) == 0
|| strlen(argv[2]) > sizeof(ofname)-1)
argexit(2, pgm);
strcpy (ofname, argv[2]);
/* Read the first track of the input file, and determine
the device type and size from the track header */
ifd = open_input_image (ifname, &devtype, &volcyls,
&itrklen, &itrkbuf, volser);
/* Use the device type to determine track characteristics */
switch (devtype) {
case 0x2314: heads = 20; maxdlen = 7294; break;
case 0x3330: heads = 19; maxdlen = 13030; break;
case 0x3340: heads = 12; maxdlen = 8368; break;
case 0x3350: heads = 30; maxdlen = 19069; break;
case 0x3375: heads = 12; maxdlen = 35616; break;
case 0x3380: heads = 15; maxdlen = 47476; break;
case 0x3390: heads = 15; maxdlen = 56664; break;
case 0x9345: heads = 15; maxdlen = 46456; break;
default:
fprintf (stderr, MSG(HHC02416, "E", devtype));
EXIT(3);
} /* end switch(devtype) */
/* Create the device */
convert_ckd (lfs, ifd, ifname, itrklen, itrkbuf, repl, quiet,
ofname, devtype, heads, maxdlen, volcyls, volser);
/* Release the input buffer and close the input file */
free (itrkbuf);
IFCLOS (ifd);
/* Display completion message */
fprintf (stderr, MSG(HHC02423, "I"));
return 0;
} /* end function main */
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 */
CKDDASD_DEVHDR devhdr; /* CKD device header */
CCKDDASD_DEVHDR cdevhdr; /* Compressed CKD device hdr */
int level = 0; /* Chkdsk level */
int force = 0; /* 1=swap if OPENED bit on */
int rc; /* Return code */
int i; /* Index */
int bigend; /* 1=big-endian file */
DEVBLK devblk; /* DEVBLK */
DEVBLK *dev=&devblk; /* -> DEVBLK */
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, "Swap 'endianess' of a cckd file" ) );
display_version (stderr, msgbuf+10, FALSE);
/* parse the arguments */
for (argc--, argv++ ; argc > 0 ; argc--, argv++)
{
if(**argv != '-') break;
switch(argv[0][1])
{
case '0':
case '1':
case '2':
case '3': if (argv[0][2] != '\0') return syntax (pgm);
level = (argv[0][1] & 0xf);
break;
case 'f': if (argv[0][2] != '\0') return syntax (pgm);
force = 1;
break;
case 'v': if (argv[0][2] != '\0') return syntax (pgm);
return 0;
default: return syntax (pgm);
}
}
if (argc < 1) return syntax (pgm);
for (i = 0; i < argc; i++)
{
memset (dev, 0, sizeof (DEVBLK));
dev->batch = 1;
/* open the input file */
hostpath(dev->filename, argv[i], sizeof(dev->filename));
dev->fd = HOPEN (dev->filename, O_RDWR|O_BINARY);
if (dev->fd < 0)
{
fprintf(stdout, MSG(HHC00354, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename,
"open()", strerror(errno)));
continue;
}
/* read the CKD device header */
if ((rc = read (dev->fd, &devhdr, CKDDASD_DEVHDR_SIZE)) < CKDDASD_DEVHDR_SIZE)
{
fprintf(stdout, MSG(HHC00355, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename,
"read()", (U64)0, rc < 0 ? strerror(errno) : "incomplete"));
close (dev->fd);
continue;
}
if (memcmp(devhdr.devid, "CKD_C370", 8) != 0
&& memcmp(devhdr.devid, "CKD_S370", 8) != 0
&& memcmp(devhdr.devid, "FBA_C370", 8) != 0
&& memcmp(devhdr.devid, "FBA_S370", 8) != 0)
{
fprintf(stdout, MSG(HHC00356, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename));
close (dev->fd);
continue;
}
/* read the compressed CKD device header */
if ((rc = read (dev->fd, &cdevhdr, CCKD_DEVHDR_SIZE)) < CCKD_DEVHDR_SIZE)
{
fprintf(stdout, MSG(HHC00355, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename,
"read()", (U64)CCKD_DEVHDR_POS, rc < 0 ? strerror(errno) : "incomplete"));
close (dev->fd);
continue;
}
/* Check the OPENED bit */
if (!force && (cdevhdr.options & CCKD_OPENED))
{
fprintf(stdout, MSG(HHC00352, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename));
close (dev->fd);
continue;
}
/* get the byte order of the file */
bigend = (cdevhdr.options & CCKD_BIGENDIAN);
/* call chkdsk */
if (cckd_chkdsk (dev, level) < 0)
{
fprintf(stdout, MSG(HHC00353, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename));
close (dev->fd);
continue;
}
/* re-read the compressed CKD device header */
if (lseek (dev->fd, CCKD_DEVHDR_POS, SEEK_SET) < 0)
{
fprintf(stdout, MSG(HHC00355, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename,
"lseek()", (U64)CCKD_DEVHDR_POS, strerror(errno)));
close (dev->fd);
continue;
}
if ((rc = read (dev->fd, &cdevhdr, CCKD_DEVHDR_SIZE)) < CCKD_DEVHDR_SIZE)
{
fprintf(stdout, MSG(HHC00355, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename,
"read()", (U64)CCKD_DEVHDR_POS, rc < 0 ? strerror(errno) : "incomplete"));
close (dev->fd);
continue;
}
/* swap the byte order of the file if chkdsk didn't do it for us */
if (bigend == (cdevhdr.options & CCKD_BIGENDIAN))
{
fprintf(stdout, MSG(HHC00357, "I", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename,
cckd_endian() ? "big-endian" : "little-endian"));
if (cckd_swapend (dev) < 0)
fprintf(stdout, MSG(HHC00378, "E", SSID_TO_LCSS(dev->ssid), dev->devnum, dev->filename));
}
close (dev->fd);
} /* for each arg */
return 0;
} /* end main */
/*
|| 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 );
}
/*
|| Standard main
*/
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 */
FILE *outf;
int rc;
int i;
char pathname[MAX_PATH];
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, "Extract Files from AWS, HET or FAKETAPE" ) );
display_version (stderr, msgbuf+10, FALSE);
/*
|| Process option switches
*/
while( TRUE )
{
rc = getopt( argc, argv, "abhnsu" );
if( rc == -1 )
{
break;
}
switch( rc )
{
case 'a':
opts.flags |= O_ASCII;
set_codepage(NULL);
break;
case 'h':
usage( pgm );
exit( 1 );
break;
case 'n':
opts.flags |= O_NL;
break;
case 's':
opts.flags |= O_STRIP;
break;
case 'u':
opts.flags |= O_UNBLOCK;
break;
default:
usage( pgm );
exit( 1 );
break;
}
}
/*
|| Calc number of non-switch arguments
*/
argc -= optind;
/*
|| We must have at least the first 3 parms
*/
if(argc < 3)
{
if ( argc > 1 )
WRMSG( HHC02446, "E" );
usage( pgm );
exit( 1 );
}
hostpath( pathname, argv[ optind ], sizeof(pathname) );
opts.ifile = strdup( pathname );
if ( ( rc = (int)strlen( opts.ifile ) ) > 4
&& ( rc = strcasecmp( &opts.ifile[rc-4], ".fkt" ) ) == 0 )
{
opts.faketape = TRUE;
}
hostpath( pathname, argv[ optind + 1 ], sizeof(pathname) );
opts.ofile = strdup( pathname );
opts.fileno = atoi( argv[ optind + 2 ] );
if( opts.fileno == 0 || opts.fileno > 9999 )
{
char msgbuf[20];
MSGBUF( msgbuf, "%d", opts.fileno );
WRMSG( HHC02205, "E", msgbuf, "; file number must be within the range of 1 to 9999" );
exit( 1 );
}
/*
|| If NL tape, then we require the DCB attributes
*/
if( opts.flags & O_NL )
{
if( argc != 6 )
{
WRMSG( HHC02750, "E" );
exit( 1 );
}
}
/*
|| If specified, get the DCB attributes
*/
if( argc > 3 )
{
/*
|| Must have only three
*/
if( argc != 6 )
{
usage( pgm );
exit( 1 );
}
/*
|| Lookup the specified RECFM in our table
*/
opts.recfm = 0;
for( i = 0 ; i < (int)VALFMCNT ; i++ )
{
if( strcasecmp( argv[ optind + 3 ], valfm[ i ].recfm ) == 0 )
{
opts.recfm = valfm[ i ].fmt;
break;
}
}
/*
|| If we didn't find a match, show the user what the valid ones are
*/
if( opts.recfm == 0)
{
char msgbuf[512] = "";
char msgbuf2[64] = "";
char msgbuf3[16] = "";
char msgbuf4[128] = "";
/*
|| Dump out the valid RECFMs
*/
MSGBUF( msgbuf, MSG( HHC02751, "I" ) );
for( i = 0 ; i < (int)VALFMCNT ; i++ )
{
MSGBUF( msgbuf3, " %-4.4s", valfm[ i ].recfm );
if( ( ( i + 1 ) % 3 ) == 0 )
{
strcat( msgbuf2, msgbuf3 );
MSGBUF( msgbuf4, MSG( HHC02752, "I", msgbuf2 ) );
strcat( msgbuf, msgbuf4 );
msgbuf2[0] = 0;
}
else
{
strcat( msgbuf2, msgbuf3 );
}
}
printf( "%s", msgbuf );
exit( 1 );
}
/*
|| Get the record length
*/
opts.lrecl = atoi( argv[ optind + 4 ] );
/*
|| Get and validate the blksize
*/
opts.blksize = atoi( argv[ optind + 5 ] );
if( opts.blksize == 0 )
{
WRMSG( HHC02205, "E", "0", "; block size can't be zero" );
exit( 1 );
}
}
/*
|| Open the tape file
*/
if ( opts.faketape )
rc = fet_open( &opts.fetb, opts.ifile, FETOPEN_READONLY );
else
rc = het_open( &opts.hetb, opts.ifile, HETOPEN_READONLY );
if( rc >= 0 )
{
/*
|| Get memory for the tape buffer
*/
blkptr = malloc( HETMAX_BLOCKSIZE );
if( blkptr != NULL )
{
/*
|| Open the output file
*/
outf = fopen( opts.ofile, "wb" );
if( outf != NULL )
{
/*
|| Go extract the file from the tape
*/
rc = getfile( outf );
/*
|| Close the output file
*/
fclose( outf );
}
/*
|| Free the buffer memory
*/
free( blkptr );
}
}
else
{
if ( opts.faketape )
WRMSG( HHC00075, "E", "fet_open()", fet_error( rc ) );
else
WRMSG( HHC00075, "E", "het_open()", het_error( rc ) );
}
/*
|| Close the tape file
*/
if ( opts.faketape )
fet_close( &opts.fetb );
else
het_close( &opts.hetb );
return 0;
}
/*-------------------------------------------------------------------*/
int main (int argc, char *argv[])
{
char *pgmname; /* prog name in host format */
char *pgm; /* less any extension (.ext) */
int ckddasd=-1; /* 1=CKD 0=FBA */
int rc; /* Return code */
int quiet=0; /* 1=Don't display status */
int comp=255; /* Compression algorithm */
int cyls=-1, blks=-1; /* Size of output file */
int lfs=0; /* 1=Create 1 large file */
int alt=0; /* 1=Create alt cyls */
int r=0; /* 1=Replace output file */
int in=0, out=0; /* Input/Output file types */
int fd; /* Input file descriptor */
char *ifile, *ofile; /* -> Input/Output file names*/
char *sfile=NULL; /* -> Input shadow file name */
CIFBLK *icif, *ocif; /* -> Input/Output CIFBLK */
DEVBLK *idev, *odev; /* -> Input/Output DEVBLK */
CKDDEV *ckd=NULL; /* -> CKD device table entry */
FBADEV *fba=NULL; /* -> FBA device table entry */
int i, n, max; /* Loop index, limits */
BYTE unitstat; /* Device unit status */
char msgbuf[512]; /* Message buffer */
size_t fba_bytes_remaining=0; /* FBA bytes to be copied */
int nullfmt = CKDDASD_NULLTRK_FMT0; /* Null track format */
char pathname[MAX_PATH]; /* file path in host format */
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( pgm );
if (strcasecmp(pgm, "ckd2cckd") == 0)
{
in = CKD;
out = CCKD;
}
else if (strcasecmp(pgm, "cckd2ckd") == 0)
{
in = CCKD;
out = CKD;
}
else if (strcasecmp(pgm, "fba2cfba") == 0)
{
in = FBA;
out = CFBA;
}
else if (strcasecmp(pgm, "cfba2fba") == 0)
{
in = CFBA;
out = FBA;
}
/* Process the arguments */
for (argc--, argv++ ; argc > 0 ; argc--, argv++)
{
if (argv[0][0] != '-') break;
if (strcmp(argv[0], "-v") == 0)
{
MSGBUF( msgbuf, MSG_C( HHC02499, "I", pgm, "DASD copy/convert" ) );
display_version (stderr, msgbuf+10, FALSE);
return 0;
}
else if (strcmp(argv[0], "-h") == 0)
{
syntax(pgm);
return 0;
}
else if (strcmp(argv[0], "-q") == 0
|| strcmp(argv[0], "-quiet") == 0)
quiet = 1;
else if (strcmp(argv[0], "-r") == 0)
r = 1;
#ifdef CCKD_COMPRESS_ZLIB
else if (strcmp(argv[0], "-z") == 0)
comp = CCKD_COMPRESS_ZLIB;
#endif
#ifdef CCKD_COMPRESS_BZIP2
else if (strcmp(argv[0], "-bz2") == 0)
comp = CCKD_COMPRESS_BZIP2;
#endif
else if (strcmp(argv[0], "-0") == 0)
comp = CCKD_COMPRESS_NONE;
else if ((strcmp(argv[0], "-cyl") == 0
|| strcmp(argv[0], "-cyls") == 0) && cyls < 0)
{
if (argc < 2 || (cyls = atoi(argv[1])) < 0)
return syntax(pgm);
argc--; argv++;
}
else if ((strcmp(argv[0], "-blk") == 0
|| strcmp(argv[0], "-blks") == 0) && blks < 0)
{
if (argc < 2 || (blks = atoi(argv[1])) < 0)
return syntax(pgm);
argc--; argv++;
}
else if (strcmp(argv[0], "-a") == 0
|| strcmp(argv[0], "-alt") == 0
|| strcmp(argv[0], "-alts") == 0)
alt = 1;
else if (strcmp(argv[0], "-lfs") == 0)
lfs = 1;
else if (out == 0 && strcmp(argv[0], "-o") == 0)
{
if (argc < 2 || out != 0) return syntax(pgm);
if (strcasecmp(argv[1], "ckd") == 0)
out = CKD;
else if (strcasecmp(argv[1], "cckd") == 0)
out = CCKD;
else if (strcasecmp(argv[1], "fba") == 0)
out = FBA;
else if (strcasecmp(argv[1], "cfba") == 0)
out = CFBA;
else
return syntax(pgm);
argc--; argv++;
}
else
return syntax(pgm);
}
/* Get the file names:
input-file [sf=shadow-file] output-file */
if (argc < 2 || argc > 3) return syntax(pgm);
ifile = argv[0];
if (argc < 3)
ofile = argv[1];
else
{
if (strlen(argv[1]) < 4 || memcmp(argv[1], "sf=", 3))
return syntax(pgm);
sfile = argv[1];
ofile = argv[2];
}
/* If we don't know what the input file is then find out */
if (in == 0)
{
BYTE buf[8];
hostpath(pathname, ifile, sizeof(pathname));
fd = HOPEN (pathname, O_RDONLY|O_BINARY);
if (fd < 0)
{
fprintf (stderr, MSG(HHC02412, "E", "open()", strerror(errno)));
return -1;
}
rc = read (fd, buf, 8);
if (rc < 8)
{
fprintf (stderr, MSG(HHC02412, "E", "read()", strerror(errno)));
return -1;
}
if (memcmp(buf, "CKD_P370", 8) == 0)
in = CKD;
else if (memcmp(buf, "CKD_C370", 8) == 0)
in = CCKD;
else if (memcmp(buf, "FBA_C370", 8) == 0)
in = CFBA;
else
in = FBA;
close (fd);
}
/* If we don't know what the output file type is
then derive it from the input file type */
if (out == 0)
{
switch (in) {
case CKD: if (!lfs) out = CCKD;
else out = CKD;
break;
case CCKD: if (comp == 255) out = CKD;
else out = CCKD;
break;
case FBA: if (!lfs) out = CFBA;
else out = FBA;
break;
case CFBA: if (comp == 255) out = FBA;
else out = CFBA;
break;
}
}
/* Set default compression if out file is to be compressed */
if (comp == 255 && (out & COMPMASK))
#ifdef CCKD_COMPRESS_ZLIB
comp = CCKD_COMPRESS_ZLIB;
#else
comp = CCKD_COMPRESS_NONE;
#endif
/* Perform sanity checks on the options */
if ((in & CKDMASK) && !(out & CKDMASK)) return syntax(pgm);
if ((in & FBAMASK) && !(out & FBAMASK)) return syntax(pgm);
if (sfile && !(in & COMPMASK)) return syntax(pgm);
if (comp != 255 && !(out & COMPMASK)) return syntax(pgm);
if (lfs && (out & COMPMASK)) return syntax(pgm);
if (cyls >= 0 && !(in & CKDMASK)) return syntax(pgm);
if (blks >= 0 && !(in & FBAMASK)) return syntax(pgm);
if (!(in & CKDMASK) && alt) return syntax(pgm);
/* Set the type of processing (ckd or fba) */
ckddasd = (in & CKDMASK);
/* Open the input file */
if (ckddasd)
icif = open_ckd_image (ifile, sfile, O_RDONLY|O_BINARY, IMAGE_OPEN_NORMAL);
else
icif = open_fba_image (ifile, sfile, O_RDONLY|O_BINARY, IMAGE_OPEN_NORMAL);
if (icif == NULL)
{
fprintf (stderr, MSG(HHC02403, "E", ifile));
return -1;
}
idev = &icif->devblk;
if (idev->oslinux) nullfmt = CKDDASD_NULLTRK_FMT2;
/* Calculate the number of tracks or blocks to copy */
if (ckddasd)
{
if (cyls < 0) cyls = idev->devunique.dasd_dev.ckdcyls;
else if (cyls == 0) cyls = (idev->hnd->used)(idev);
ckd = dasd_lookup (DASD_CKDDEV, NULL, idev->devtype, 0);
if (ckd == NULL)
{
fprintf (stderr, MSG(HHC02430, "E",
idev->devtype, cyls));
close_image_file (icif);
return -1;
}
if (cyls <= ckd->cyls && alt) cyls = ckd->cyls + ckd->altcyls;
n = cyls * idev->devunique.dasd_dev.ckdheads;
max = idev->devunique.dasd_dev.ckdtrks;
if (max < n && out == CCKD) n = max;
}
else
{
fba_bytes_remaining = idev->devunique.dasd_dev.fbanumblk * idev->devunique.dasd_dev.fbablksiz;
if (blks < 0) blks = idev->devunique.dasd_dev.fbanumblk;
else if (blks == 0) blks = (idev->hnd->used)(idev);
fba = dasd_lookup (DASD_FBADEV, NULL, idev->devtype, 0);
if (fba == NULL)
{
fprintf (stderr, MSG(HHC02431, "E", blks));
close_image_file (icif);
return -1;
}
n = blks;
max = idev->devunique.dasd_dev.fbanumblk;
if (max < n && out == CFBA) n = max;
n = (n + FBA_BLKS_PER_GRP - 1) / FBA_BLKS_PER_GRP;
max = (max + FBA_BLKS_PER_GRP - 1) / FBA_BLKS_PER_GRP;
}
/* Create the output file */
if (ckddasd)
rc = create_ckd(ofile, idev->devtype, idev->devunique.dasd_dev.ckdheads,
ckd->r1, cyls, "", comp, lfs, 1+r, nullfmt, 0);
else
rc = create_fba(ofile, idev->devtype, fba->size,
blks, "", comp, lfs, 1+r, 0);
if (rc < 0)
{
fprintf (stderr, MSG(HHC02432, "E", ofile));
close_image_file (icif);
return -1;
}
/* Open the output file */
if (ckddasd)
ocif = open_ckd_image (ofile, NULL, O_RDWR|O_BINARY, IMAGE_OPEN_DASDCOPY);
else
ocif = open_fba_image (ofile, NULL, O_RDWR|O_BINARY, IMAGE_OPEN_DASDCOPY);
if (ocif == NULL)
{
fprintf (stderr, MSG(HHC02403, "E", ofile));
close_image_file (icif);
return -1;
}
odev = &ocif->devblk;
/* Copy the files */
#ifdef EXTERNALGUI
if (extgui)
/* Notify GUI of total #of tracks or blocks being copied... */
fprintf (stderr, "TRKS=%d\n", n);
else
#endif /*EXTERNALGUI*/
if (!quiet) printf (" %3d%% %7d of %d", 0, 0, n);
for (i = 0; i < n; i++)
{
/* Read a track or block */
if (ckddasd)
{
if (i < max)
rc = (idev->hnd->read)(idev, i, &unitstat);
else
{
memset (idev->buf, 0, idev->devunique.dasd_dev.ckdtrksz);
rc = nulltrk(idev->buf, i, idev->devunique.dasd_dev.ckdheads, nullfmt);
}
}
else
{
if (i < max)
rc = (idev->hnd->read)(idev, i, &unitstat);
else
memset (idev->buf, 0, FBA_BLKGRP_SIZE);
rc = 0;
}
if (rc < 0)
{
fprintf (stderr, MSG(HHC02433, "E",
ifile, ckddasd ? "track" : "block", i, unitstat,
ckddasd ? "track" : "block"));
if (ckddasd)
nulltrk(idev->buf, i, idev->devunique.dasd_dev.ckdheads, nullfmt);
else
memset (idev->buf, 0, FBA_BLKGRP_SIZE);
if (!quiet)
{
printf (_(" %3d%% %7d of %d"), 0, 0, n);
status (i, n);
}
}
/* Write the track or block just read */
if (ckddasd)
{
rc = (odev->hnd->write)(odev, i, 0, idev->buf,
idev->devunique.dasd_dev.ckdtrksz, &unitstat);
}
else
{
if (fba_bytes_remaining >= (size_t)idev->buflen)
{
rc = (odev->hnd->write)(odev, i, 0, idev->buf,
idev->buflen, &unitstat);
fba_bytes_remaining -= (size_t)idev->buflen;
}
else
{
ASSERT(fba_bytes_remaining > 0 && (i+1) >= n);
rc = (odev->hnd->write)(odev, i, 0, idev->buf,
(int)fba_bytes_remaining, &unitstat);
fba_bytes_remaining = 0;
}
}
if (rc < 0)
{
fprintf (stderr, MSG(HHC02434, "E",
ofile, ckddasd ? "track" : "block", i, unitstat));
close_image_file(icif); close_image_file(ocif);
return -1;
}
/* Update the status indicator */
if (!quiet) status (i+1, n);
}
close_image_file(icif); close_image_file(ocif);
if (!quiet) printf (_("\r"));
printf (MSG(HHC02423, "I"));
return 0;
}
