433 lines
9.7 KiB
C
433 lines
9.7 KiB
C
/*
|
|
* Copyright (c) 1993 Steve Gerakines
|
|
*
|
|
* This is freely redistributable software. You may do anything you
|
|
* wish with it, so long as the above notice stays intact.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* ft.c - simple floppy tape filter
|
|
*
|
|
* 01/28/94 v0.3b (Jim Babb)
|
|
* Fixed bug when all sectors in a segment are marked bad.
|
|
*
|
|
* 10/30/93 v0.3
|
|
* Minor revisions. Seems pretty stable.
|
|
*
|
|
* 09/02/93 v0.2 pl01
|
|
* Initial revision.
|
|
*
|
|
* usage: ftfilt [ -f tape ] [ description ]
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <signal.h>
|
|
#include <time.h>
|
|
#include <sys/ftape.h>
|
|
|
|
#define DEFQIC "/dev/rft0"
|
|
|
|
char buff[QCV_SEGSIZE]; /* scratch buffer */
|
|
char hbuff[QCV_SEGSIZE]; /* header buffer */
|
|
QIC_Header *hptr = (QIC_Header *)hbuff; /* header structure */
|
|
int hsn = -1; /* segment number of header */
|
|
int dhsn = -1; /* segment number of duplicate header */
|
|
int tfd; /* tape file descriptor */
|
|
QIC_Geom geo; /* tape geometry */
|
|
int tvno = 1; /* tape volume number */
|
|
int tvlast; /* TRUE if last volume in set */
|
|
long tvsize = 0; /* tape volume size in bytes */
|
|
long tvtime = NULL; /* tape change time */
|
|
char *tvnote = ""; /* tape note */
|
|
|
|
/* Lookup the badmap for a given track and segment. */
|
|
#define BADMAP(t,s) hptr->qh_badmap[(t)*geo.g_segtrk+(s)]
|
|
|
|
/* Retrieve values from a character array. */
|
|
#define UL_VAL(s,p) (*((ULONG *)&(s)[p]))
|
|
#define US_VAL(s,p) (*((USHORT *)&(s)[p]))
|
|
|
|
#define equal(s1,s2) (strcmp(s1, s2) == 0)
|
|
|
|
|
|
|
|
/* Entry */
|
|
main(int argc, char *argv[])
|
|
{
|
|
int r, s;
|
|
char *tape, *getenv();
|
|
|
|
if (argc > 2 && (equal(argv[1], "-t") || equal(argv[1], "-f"))) {
|
|
argc -= 2;
|
|
tape = argv[2];
|
|
argv += 2;
|
|
} else
|
|
if ((tape = getenv("TAPE")) == NULL)
|
|
tape = DEFQIC;
|
|
if (argc > 1) {
|
|
tvnote = argv[1];
|
|
if (strlen(tvnote) > 18) argv[1][18] = '\0';
|
|
}
|
|
|
|
/* Open the tape device */
|
|
if ((tfd = open(tape, 2)) < 0) {
|
|
perror(tape);
|
|
exit(1);
|
|
}
|
|
|
|
if (!isatty(0))
|
|
do_write();
|
|
else if (!isatty(1))
|
|
do_read();
|
|
else
|
|
do_getname();
|
|
|
|
close(tfd);
|
|
exit(0);
|
|
}
|
|
|
|
|
|
/* Check status of tape drive */
|
|
int check_stat(int fd, int wr)
|
|
{
|
|
int r, s;
|
|
int sawit = 0;
|
|
|
|
/* get tape status */
|
|
if (ioctl(fd, QIOSTATUS, &s) < 0) {
|
|
fprintf(stderr, "could not get drive status\n");
|
|
return(1);
|
|
}
|
|
|
|
/* wait for the tape drive to become ready */
|
|
while ((s & QS_READY) == 0) {
|
|
if (!sawit) {
|
|
fprintf(stderr, "waiting for drive to become ready...\n");
|
|
sawit = 1;
|
|
}
|
|
sleep(2);
|
|
if (ioctl(fd, QIOSTATUS, &s) < 0) {
|
|
fprintf(stderr, "could not get drive status\n");
|
|
return(1);
|
|
}
|
|
}
|
|
|
|
if ((s & QS_FMTOK) == 0) {
|
|
fprintf(stderr, "tape is not formatted\n");
|
|
return(2);
|
|
}
|
|
|
|
if (wr && (s & QS_RDONLY) != 0) {
|
|
fprintf(stderr, "tape is write protected\n");
|
|
return(3);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
|
|
ULONG qtimeval(time_t t)
|
|
{
|
|
struct tm *tp;
|
|
ULONG r;
|
|
|
|
tp = localtime(&t);
|
|
r = 2678400 * tp->tm_mon +
|
|
86400 *(tp->tm_mday-1) +
|
|
3600 * tp->tm_hour +
|
|
60 * tp->tm_min +
|
|
tp->tm_sec;
|
|
r |= (tp->tm_year - 70) << 25;
|
|
return(r);
|
|
}
|
|
|
|
/* Return tm struct from QIC date format. */
|
|
struct tm *qtime(UCHAR *qt)
|
|
{
|
|
ULONG *vp = (ULONG *)qt;
|
|
struct tm t;
|
|
ULONG v;
|
|
time_t tv;
|
|
|
|
v = *vp;
|
|
t.tm_year = ((v >> 25) & 0x7f)+70; v &= 0x1ffffff;
|
|
t.tm_mon = v / 2678400; v %= 2678400;
|
|
t.tm_mday = v / 86400 + 1; v %= 86400;
|
|
t.tm_hour = v / 3600; v %= 3600;
|
|
t.tm_min = v / 60; v %= 60;
|
|
t.tm_sec = v;
|
|
t.tm_wday = 0; /* XXX - let mktime do the real work */
|
|
t.tm_yday = 0;
|
|
t.tm_isdst = 0;
|
|
t.tm_gmtoff = 0;
|
|
t.tm_zone = NULL;
|
|
tv = mktime(&t);
|
|
return(localtime(&tv));
|
|
}
|
|
|
|
/* Return a string, zero terminated */
|
|
char *qstr(char *str, int nchar)
|
|
{
|
|
static char tstr[256];
|
|
strncpy(tstr, str, nchar);
|
|
tstr[nchar] = '\0';
|
|
return(tstr);
|
|
}
|
|
|
|
/* Read header from tape */
|
|
get_header(int fd)
|
|
{
|
|
int r, sn, bytes;
|
|
QIC_Segment s;
|
|
int gothdr = 0;
|
|
|
|
if (ioctl(fd, QIOGEOM, &geo) < 0) {
|
|
fprintf(stderr, "couldn't determine tape geometry\n");
|
|
return(1);
|
|
}
|
|
|
|
/* Get the header and duplicate */
|
|
for (sn = 0; sn < 16; sn++) {
|
|
s.sg_trk = 0;
|
|
s.sg_seg = sn;
|
|
s.sg_badmap = 0;
|
|
s.sg_data = (UCHAR *)&buff[0];
|
|
ioctl(fd, QIOREAD, &s);
|
|
r = check_parity(s.sg_data, 0, s.sg_crcmap);
|
|
if (s.sg_data[0] == 0x55 && s.sg_data[1] == 0xaa &&
|
|
s.sg_data[2] == 0x55 && s.sg_data[3] == 0xaa) {
|
|
if (hsn >= 0) {
|
|
dhsn = sn;
|
|
if (!r && !gothdr) {
|
|
fprintf(stderr, "using secondary header\n");
|
|
bcopy(s.sg_data, hbuff, QCV_SEGSIZE);
|
|
gothdr = 1;
|
|
}
|
|
break;
|
|
}
|
|
hsn = sn;
|
|
if (!r) {
|
|
bcopy(s.sg_data, hbuff, QCV_SEGSIZE);
|
|
gothdr = 1;
|
|
} else {
|
|
fprintf(stderr, "too many errors in primary header\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!gothdr) {
|
|
fprintf(stderr, "couldn't read header segment\n");
|
|
ioctl(fd, QIOREWIND);
|
|
return(1);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
ask_vol(int vn)
|
|
{
|
|
FILE *inp;
|
|
int fd;
|
|
char c;
|
|
|
|
if ((fd = open("/dev/tty", 2)) < 0) {
|
|
fprintf(stderr, "argh!! can't open /dev/tty\n");
|
|
exit(1);
|
|
}
|
|
|
|
fprintf(stderr, "Insert ftfilt volume %02d and press enter:", vn);
|
|
read(fd, &c, 1);
|
|
close(fd);
|
|
}
|
|
|
|
|
|
/* Return the name of the tape only. */
|
|
do_getname()
|
|
{
|
|
if (check_stat(tfd, 0)) exit(1);
|
|
if (get_header(tfd)) exit(1);
|
|
fprintf(stderr, "\"%s\" - %s",
|
|
qstr(hptr->qh_tname,44), asctime(qtime(hptr->qh_chgdate)));
|
|
ioctl(tfd, QIOREWIND);
|
|
}
|
|
|
|
|
|
/* Extract data from tape to stdout */
|
|
do_read()
|
|
{
|
|
int sno, vno, sbytes, r;
|
|
long curpos;
|
|
char *hname;
|
|
QIC_Segment s;
|
|
|
|
/* Process multiple volumes if necessary */
|
|
vno = 1;
|
|
for (;;) {
|
|
if (check_stat(tfd, 0)) {
|
|
ask_vol(vno);
|
|
continue;
|
|
}
|
|
if (get_header(tfd)) {
|
|
ask_vol(vno);
|
|
continue;
|
|
}
|
|
|
|
/* extract volume and header info from label */
|
|
hname = hptr->qh_tname;
|
|
hname[43] = '\0';
|
|
tvno = atoi(&hname[11]);
|
|
tvlast = (hname[10] == '*') ? 1 : 0;
|
|
tvsize = atoi(&hname[14]);
|
|
tvnote = &hname[25];
|
|
if (vno != tvno || strncmp(hname, "ftfilt", 6) != 0) {
|
|
fprintf(stderr, "Incorrect volume inserted. This tape is:\n");
|
|
fprintf(stderr,"\"%s\" - %s\n", hname,
|
|
asctime(qtime(hptr->qh_chgdate)));
|
|
ask_vol(vno);
|
|
continue;
|
|
}
|
|
|
|
/* Process this volume */
|
|
curpos = 0;
|
|
for (sno = hptr->qh_first; tvsize > 0; sno++) {
|
|
s.sg_trk = sno / geo.g_segtrk;
|
|
s.sg_seg = sno % geo.g_segtrk;
|
|
s.sg_badmap = BADMAP(s.sg_trk,s.sg_seg);
|
|
sbytes = sect_bytes(s.sg_badmap) - QCV_ECCSIZE;
|
|
s.sg_data = (UCHAR *)&buff[0];
|
|
|
|
/* skip segments with *all* sectors flagged as bad */
|
|
if (sbytes > 0) {
|
|
if (ioctl(tfd, QIOREAD, &s) < 0) perror("QIOREAD");
|
|
r = check_parity(s.sg_data, s.sg_badmap, s.sg_crcmap);
|
|
if (r) fprintf(stderr, "** warning: ecc failed at byte %ld\n",
|
|
curpos);
|
|
if (tvsize < sbytes) sbytes = tvsize;
|
|
write(1, s.sg_data, sbytes);
|
|
tvsize -= sbytes;
|
|
curpos += sbytes;
|
|
}
|
|
}
|
|
if (tvlast) break;
|
|
ioctl(tfd, QIOREWIND);
|
|
ask_vol(++vno);
|
|
}
|
|
ioctl(tfd, QIOREWIND);
|
|
return(0);
|
|
}
|
|
|
|
|
|
/* Dump data from stdin to tape */
|
|
do_write()
|
|
{
|
|
int sno, vno, amt, sbytes;
|
|
int c, maxseg, r;
|
|
ULONG qnow;
|
|
QIC_Segment s;
|
|
char tmpstr[80];
|
|
|
|
qnow = qtimeval(time(NULL));
|
|
vno = 1;
|
|
|
|
for (;;) {
|
|
if (check_stat(tfd, 1)) {
|
|
ask_vol(vno);
|
|
continue;
|
|
}
|
|
if (get_header(tfd)) {
|
|
ask_vol(vno);
|
|
continue;
|
|
}
|
|
|
|
maxseg = geo.g_segtrk * geo.g_trktape - 1;
|
|
sno = hptr->qh_first;
|
|
tvno = vno;
|
|
tvsize = 0;
|
|
tvlast = 0;
|
|
|
|
/* Process until end of volume or end of data */
|
|
for (sno = hptr->qh_first; sno < maxseg && tvlast == 0; ++sno) {
|
|
/* Prepare to load the next segment */
|
|
s.sg_trk = sno / geo.g_segtrk;
|
|
s.sg_seg = sno % geo.g_segtrk;
|
|
s.sg_badmap = BADMAP(s.sg_trk,s.sg_seg);
|
|
sbytes = sect_bytes(s.sg_badmap) - QCV_ECCSIZE;
|
|
s.sg_data = (UCHAR *)&buff[0];
|
|
|
|
/* Ugh. Loop to get the full amt. */
|
|
for (amt = 0; amt < sbytes; amt += r) {
|
|
r = read(0, &s.sg_data[amt], sbytes - amt);
|
|
if (r <= 0) {
|
|
tvlast = 1;
|
|
break;
|
|
}
|
|
}
|
|
/* skip the segment if *all* sectors are flagged as bad */
|
|
if (amt) {
|
|
if (amt < sbytes)
|
|
bzero(&s.sg_data[amt], sbytes - amt);
|
|
r = set_parity(s.sg_data, s.sg_badmap);
|
|
if (r) fprintf(stderr, "** warning: ecc problem !!\n");
|
|
if (ioctl(tfd, QIOWRITE, &s) < 0) {
|
|
perror("QIOWRITE");
|
|
exit(1);
|
|
}
|
|
tvsize += amt;
|
|
}
|
|
}
|
|
|
|
/* Build new header info */
|
|
/* ftfilt vol*xx yyyyyyyyyy note56789012345678 */
|
|
/* 01234567890123456789012345678901234567890123 */
|
|
|
|
sprintf(tmpstr, "ftfilt vol%s%02d %010d %s",
|
|
(tvlast) ? "*" : " ", tvno, tvsize, tvnote);
|
|
strncpy(hptr->qh_tname, tmpstr, 44);
|
|
UL_VAL(hptr->qh_chgdate,0) = qnow;
|
|
|
|
/* Update the header for this volume */
|
|
if (hsn >= 0) {
|
|
s.sg_trk = hsn / geo.g_segtrk;
|
|
s.sg_seg = hsn % geo.g_segtrk;
|
|
s.sg_badmap = 0;
|
|
s.sg_data = (UCHAR *)hbuff;
|
|
r = set_parity(s.sg_data, s.sg_badmap);
|
|
if (r) fprintf(stderr, "** warning: header ecc problem !!\n");
|
|
if (ioctl(tfd, QIOWRITE, &s) < 0) {
|
|
perror("QIOWRITE");
|
|
exit(1);
|
|
}
|
|
}
|
|
if (dhsn >= 0) {
|
|
s.sg_trk = dhsn / geo.g_segtrk;
|
|
s.sg_seg = dhsn % geo.g_segtrk;
|
|
s.sg_badmap = 0;
|
|
s.sg_data = (UCHAR *)hbuff;
|
|
r = set_parity(s.sg_data, s.sg_badmap);
|
|
if (r) fprintf(stderr, "** warning: duphdr ecc problem !!\n");
|
|
if (ioctl(tfd, QIOWRITE, &s) < 0) {
|
|
perror("QIOWRITE");
|
|
exit(1);
|
|
}
|
|
}
|
|
ioctl(tfd, QIOREWIND);
|
|
if (tvlast) break;
|
|
ask_vol(++vno);
|
|
}
|
|
return(0);
|
|
}
|