sbin/st/st.c

/*
 * Copyright (c) 1980 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 The Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)mt.c        5.6 (Berkeley) 6/6/91";
#endif /* not lint */

/*
 * mt --
 *   magnetic tape manipulation program
 */
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/mtio.h>
#include <fcntl.h>
#include <stdio.h>
#include <ctype.h>

#define equal(s1,s2)    (strcmp(s1, s2) == 0)

struct commands {
        char *c_name;
        int c_code;
        int c_ronly;
} com[] = {
        { "weof",       MTWEOF, 0 },
        { "eof",        MTWEOF, 0 },
        { "fsf",        MTFSF,  1 },
        { "bsf",        MTBSF,  1 },
        { "fsr",        MTFSR,  1 },
        { "bsr",        MTBSR,  1 },
        { "rewind",     MTREW,  1 },
        { "offline",    MTOFFL, 1 },
        { "rewoffl",    MTOFFL, 1 },
        { "status",     MTNOP,  1 },
        { "blocksize",  MTSETBSIZ,      0 },
        { "density",    MTSETDNSTY,     0 },
        { 0 }
};

int mtfd;
struct mtop mt_com;
struct mtget mt_status;
char *tape;

main(argc, argv)
        char **argv;
{
        void usage();
        char line[80], *getenv();
        register char *cp;
        register struct commands *comp;

        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 = DEFTAPE;
        if (argc < 2) {
                usage();
                exit(1);
        }
        cp = argv[1];
        if ((strncmp(cp, "blocksize", strlen(cp)) == 0) && argc < 3 ) {
                usage();
                exit(1);
        }
        if ((strncmp(cp, "density", strlen(cp)) == 0) && argc < 3 ) {
                usage();
                exit(1);
        }
        for (comp = com; comp->c_name != NULL; comp++)
                if (strncmp(cp, comp->c_name, strlen(cp)) == 0)
                        break;
        if (comp->c_name == NULL) {
                fprintf(stderr, "st: don't grok \"%s\"\n", cp);
                usage();
                exit(1);
        }
        if ((mtfd = open(tape, comp->c_ronly ? O_RDONLY : O_RDWR)) < 0) {
                perror(tape);
                exit(1);
        }
        if (comp->c_code != MTNOP) {
                mt_com.mt_op = comp->c_code;
                mt_com.mt_count = (argc > 2 ? atoi(argv[2]) : 1);
                if (mt_com.mt_count < 0) {
                        fprintf(stderr, "st: negative repeat count\n");
                        exit(1);
                }
                if (ioctl(mtfd, MTIOCTOP, &mt_com) < 0) {
                        fprintf(stderr, "%s %s %d ", tape, comp->c_name,
                                mt_com.mt_count);
                        perror("failed");
                        exit(2);
                }
        } else {
                if (ioctl(mtfd, MTIOCGET, (char *)&mt_status) < 0) {
                        perror("st");
                        exit(2);
                }
                status(&mt_status);
        }
}

#ifdef vax
#include <vaxmba/mtreg.h>
#include <vaxmba/htreg.h>

#include <vaxuba/utreg.h>
#include <vaxuba/tmreg.h>
#undef b_repcnt         /* argh */
#include <vaxuba/tsreg.h>
#endif

#ifdef sun
#include <sundev/tmreg.h>
#include <sundev/arreg.h>
#endif

#ifdef tahoe
#include <tahoe/vba/cyreg.h>
#endif

struct tape_desc {
        short   t_type;         /* type of magtape device */
        char    *t_name;        /* printing name */
        char    *t_dsbits;      /* "drive status" register */
        char    *t_erbits;      /* "error" register */
} tapes[] = {
#ifdef vax
        { MT_ISTS,      "ts11",         0,              TSXS0_BITS },
        { MT_ISHT,      "tm03",         HTDS_BITS,      HTER_BITS },
        { MT_ISTM,      "tm11",         0,              TMER_BITS },
        { MT_ISMT,      "tu78",         MTDS_BITS,      0 },
        { MT_ISUT,      "tu45",         UTDS_BITS,      UTER_BITS },
#endif
#if defined(sun)
        { MT_ISCPC,     "TapeMaster",   TMS_BITS,       0 },
        { MT_ISAR,      "Archive",      ARCH_CTRL_BITS, ARCH_BITS },
#endif
#ifdef tahoe
        { MT_ISCY,      "cipher",       CYS_BITS,       CYCW_BITS },
#endif
#if  defined (__386BSD__)
        { MT_ISAR,      "Archive/Tandberg?",    0,      0 },
#endif
        { 0 }
};

/*
 * Interpret the status buffer returned
 */
status(bp)
        register struct mtget *bp;
{
        register struct tape_desc *mt;

        printf("Present Mode:   Density = 0x%02x, Blocksize = %d bytes\n",
                bp->mt_density, bp->mt_blksiz);
        printf("---------available modes----------\n");
        printf("Mode 0:         Density = 0x%02x, Blocksize = %d bytes\n",
                bp->mt_density0, bp->mt_blksiz0);
        printf("Mode 1:         Density = 0x%02x, Blocksize = %d bytes\n",
                bp->mt_density1, bp->mt_blksiz1);
        printf("Mode 2:         Density = 0x%02x, Blocksize = %d bytes\n",
                bp->mt_density2, bp->mt_blksiz2);
        printf("Mode 3:         Density = 0x%02x, Blocksize = %d bytes\n",
                bp->mt_density3, bp->mt_blksiz3);

#ifdef NOTYET
        printf("tape drive: residual=%d\n",
                 bp->mt_resid);
        printreg("ds", bp->mt_dsreg, mt->t_dsbits);
        printreg("\ner", bp->mt_erreg, mt->t_erbits);
        putchar('\n');
#endif
}

/*
 * Print a register a la the %b format of the kernel's printf
 */
printreg(s, v, bits)
        char *s;
        register char *bits;
        register unsigned short v;
{
        register int i, any = 0;
        register char c;

        if (bits && *bits == 8)
                printf("%s=%o", s, v);
        else
                printf("%s=%x", s, v);
        bits++;
        if (v && bits) {
                putchar('<');
                while (i = *bits++) {
                        if (v & (1 << (i-1))) {
                                if (any)
                                        putchar(',');
                                any = 1;
                                for (; (c = *bits) > 32; bits++)
                                        putchar(c);
                        } else
                                for (; *bits > 32; bits++)
                                        ;
                }
                putchar('>');
        }
}
void usage() {
        register struct commands *comp;

        fprintf(stderr, "Usage: st [ -f tape ] command [ count ] \n");
        fprintf(stderr, "       Where command is one of:\n");
        for (comp=com; comp->c_name != NULL; comp++) {
                fprintf(stderr, "       %s\n", comp->c_name);
        }
        fprintf(stderr,"Note that the count argument is required\n");
        fprintf(stderr, "with the \"blocksize\" , and the density setting commands.\n");
        fprintf(stderr, "Note that the count argument is a base 10 number\n");
}