/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2025 Poul-Henning Kamp, <phk@FreeBSD.org>
 * Copyright (c) 1985, 1987, 1993
 *      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.
 *
 * 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.
 */

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sysexits.h>
#include <unistd.h>

#include <sys/endian.h>
#include <sys/mtio.h>
#include <sys/stat.h>
#include <sys/sysctl.h>
#include <sys/uio.h>

#include <libutil.h>

#define MAXREC  (1024 * 1024)
#define NOCOUNT (-2)

enum operation {READ, VERIFY, COPY, COPYVERIFY};

// Stuff the tape_devs need to know about
static int filen;
static uint64_t record;

//---------------------------------------------------------------------

class tape_dev {
        size_t  max_read_size;
public:
        int fd;
        char *name;
        enum direction {SRC, DST} direction;

        tape_dev(int file_handle, const char *spec, bool destination);

        virtual ssize_t read_blk(void *dst, size_t len);
        virtual ssize_t verify_blk(void *dst, size_t len, size_t expected);
        virtual void write_blk(const void *src, size_t len);
        virtual void file_mark(void);
        virtual void rewind(void);
};

tape_dev::tape_dev(int file_handle, const char *spec, bool destination)
{
        assert(file_handle >= 0);
        fd = file_handle;
        name = strdup(spec);
        assert(name != NULL);
        direction = destination ? DST : SRC;
        max_read_size = 0;
}

ssize_t
tape_dev::read_blk(void *dst, size_t len)
{
        ssize_t retval = -1;

        if (max_read_size == 0) {
                max_read_size = len;
                while (max_read_size > 0) {
                        retval = read(fd, dst, max_read_size);
                        if (retval >= 0 || (errno != EINVAL && errno != EFBIG))
                                break;
                        if (max_read_size < 512)
                                errx(1, "Cannot find a sane max blocksize");

                        // Reduce to next lower power of two
                        int i = flsl((long)max_read_size - 1L);
                        max_read_size = 1UL << (i - 1);
                }
        } else {
                retval = read(fd, dst, (size_t)max_read_size);
        }
        if (retval < 0) {
                err(1, "read error, %s, file %d, record %ju",
                    name, filen, (uintmax_t)record);
        }
        return (retval);
}

ssize_t
tape_dev::verify_blk(void *dst, size_t len, size_t expected)
{
        (void)expected;
        return read_blk(dst, len);
}

void
tape_dev::write_blk(const void *src, size_t len)
{
        assert(len > 0);
        ssize_t nwrite = write(fd, src, len);
        if (nwrite < 0 || (size_t) nwrite != len) {
                if (nwrite == -1) {
                        warn("write error, file %d, record %ju",
                            filen, (intmax_t)record);
                } else {
                        warnx("write error, file %d, record %ju",
                            filen, (intmax_t)record);
                        warnx("write (%zd) != read (%zd)", nwrite, len);
                }
                errx(5, "copy aborted");
        }
        return;
}

void
tape_dev::file_mark(void)
{
        struct mtop op;

        op.mt_op = MTWEOF;
        op.mt_count = (daddr_t)1;
        if (ioctl(fd, MTIOCTOP, (char *)&op) < 0)
                err(6, "tape op (write file mark)");
}

void
tape_dev::rewind(void)
{
        struct mtop op;

        op.mt_op = MTREW;
        op.mt_count = (daddr_t)1;
        if (ioctl(fd, MTIOCTOP, (char *)&op) < 0)
                err(6, "tape op (rewind)");
}

//---------------------------------------------------------------------

class tap_file: public tape_dev {
public:
        tap_file(int file_handle, const char *spec, bool dst) :
                tape_dev(file_handle, spec, dst) {};
        ssize_t read_blk(void *dst, size_t len);
        void write_blk(const void *src, size_t len);
        void file_mark(void);
        virtual void rewind(void);
};

static
ssize_t full_read(int fd, void *dst, size_t len)
{
        // Input may be a socket which returns partial reads

        ssize_t retval = read(fd, dst, len);
        if (retval <= 0 || (size_t)retval == len)
                return (retval);

        char *ptr = (char *)dst + retval;
        size_t left = len - (size_t)retval;
        while (left > 0) {
                retval = read(fd, ptr, left);
                if (retval <= 0)
                        return (retval);
                left -= (size_t)retval;
                ptr += retval;
        }
        return ((ssize_t)len);
}

ssize_t
tap_file::read_blk(void *dst, size_t len)
{
        char lbuf[4];

        ssize_t nread = full_read(fd, lbuf, sizeof lbuf);
        if (nread == 0)
                return (0);

        if ((size_t)nread != sizeof lbuf)
                err(EX_DATAERR, "Corrupt tap-file, read hdr1=%zd", nread);

        uint32_t u = le32dec(lbuf);
        if (u == 0 || (u >> 24) == 0xff)
                return(0);

        if (u > len)
                err(17, "tapfile blocksize too big, 0x%08x", u);

        size_t alen = (u + 1) & ~1;
        assert (alen <= len);

        ssize_t retval = full_read(fd, dst, alen);
        if (retval < 0 || (size_t)retval != alen)
                err(EX_DATAERR, "Corrupt tap-file, read data=%zd", retval);

        nread = full_read(fd, lbuf, sizeof lbuf);
        if ((size_t)nread != sizeof lbuf)
                err(EX_DATAERR, "Corrupt tap-file, read hdr2=%zd", nread);

        uint32_t v = le32dec(lbuf);
        if (u == v)
                return (u);
        err(EX_DATAERR,
            "Corrupt tap-file, headers differ (0x%08x != 0x%08x)", u, v);
}

void
tap_file::write_blk(const void *src, size_t len)
{
        struct iovec iov[4];
        uint8_t zero = 0;
        int niov = 0;
        size_t expect = 0;
        char tbuf[4];

        assert((len & ~0xffffffffULL) == 0);
        le32enc(tbuf, (uint32_t)len);

        iov[niov].iov_base = tbuf;
        iov[niov].iov_len = sizeof tbuf;
        expect += iov[niov].iov_len;
        niov += 1;

        iov[niov].iov_base = (void*)(uintptr_t)src;
        iov[niov].iov_len = len;
        expect += iov[niov].iov_len;
        niov += 1;

        if (len & 1) {
                iov[niov].iov_base = &zero;
                iov[niov].iov_len = 1;
                expect += iov[niov].iov_len;
                niov += 1;
        }

        iov[niov].iov_base = tbuf;
        iov[niov].iov_len = sizeof tbuf;
        expect += iov[niov].iov_len;
        niov += 1;

        ssize_t nwrite = writev(fd, iov, niov);
        if (nwrite < 0 || (size_t)nwrite != expect)
                errx(17, "write error (%zd != %zd)", nwrite, expect);
}

void
tap_file::file_mark(void)
{
        char tbuf[4];
        le32enc(tbuf, 0);
        ssize_t nwrite = write(fd, tbuf, sizeof tbuf);
        if ((size_t)nwrite != sizeof tbuf)
                errx(17, "write error (%zd != %zd)", nwrite, sizeof tbuf);
}

void
tap_file::rewind(void)
{
        off_t where;
        if (direction == DST) {
                char tbuf[4];
                le32enc(tbuf, 0xffffffff);
                ssize_t nwrite = write(fd, tbuf, sizeof tbuf);
                if ((size_t)nwrite != sizeof tbuf)
                        errx(17,
                            "write error (%zd != %zd)", nwrite, sizeof tbuf);
        }
        where = lseek(fd, 0L, SEEK_SET);
        if (where != 0 && errno == ESPIPE)
                err(EX_USAGE, "Cannot rewind sockets and pipes");
        if (where != 0)
                err(17, "lseek(0) failed");
}

//---------------------------------------------------------------------

class file_set: public tape_dev {
public:
        file_set(int file_handle, const char *spec, bool dst) :
                tape_dev(file_handle, spec, dst) {};
        ssize_t read_blk(void *dst, size_t len);
        ssize_t verify_blk(void *dst, size_t len, size_t expected);
        void write_blk(const void *src, size_t len);
        void file_mark(void);
        void rewind(void);
        void open_next(bool increment);
};

void
file_set::open_next(bool increment)
{
        if (fd >= 0) {
                assert(close(fd) >= 0);
                fd = -1;
        }
        if (increment) {
                char *p = strchr(name, '\0') - 3;
                if (++p[2] == '9') {
                        p[2] = '0';
                        if (++p[1] == '9') {
                                p[1] = '0';
                                if (++p[0] == '9') {
                                        errx(EX_USAGE,
                                            "file-set sequence overflow");
                                }
                        }
                }
        }
        if (direction == DST) {
                fd = open(name, O_RDWR|O_CREAT, DEFFILEMODE);
                if (fd < 0)
                        err(1, "Could not open %s", name);
        } else {
                fd = open(name, O_RDONLY, 0);
        }
}

ssize_t
file_set::read_blk(void *dst, size_t len)
{
        (void)dst;
        (void)len;
        errx(EX_SOFTWARE, "That was not supposed to happen");
}

ssize_t
file_set::verify_blk(void *dst, size_t len, size_t expected)
{
        (void)len;
        if (fd < 0)
                open_next(true);
        if (fd < 0)
                return (0);
        ssize_t retval = read(fd, dst, expected);
        if (retval == 0) {
                assert(close(fd) >= 0);
                fd = -1;
        }
        return (retval);
}

void
file_set::write_blk(const void *src, size_t len)
{
        if (fd < 0)
                open_next(true);
        ssize_t nwrite = write(fd, src, len);
        if (nwrite < 0 || (size_t)nwrite != len)
                errx(17, "write error (%zd != %zd)", nwrite, len);
}

void
file_set::file_mark(void)
{
        if (fd < 0)
                return;

        off_t where = lseek(fd, 0UL, SEEK_CUR);

        int i = ftruncate(fd, where);
        if (i < 0)
                errx(17, "truncate error, %s to %jd", name, (intmax_t)where);
        assert(close(fd) >= 0);
        fd = -1;
}

void
file_set::rewind(void)
{
        char *p = strchr(name, '\0') - 3;
        p[0] = '0';
        p[1] = '0';
        p[2] = '0';
        open_next(false);
}

//---------------------------------------------------------------------

class flat_file: public tape_dev {
public:
        flat_file(int file_handle, const char *spec, bool dst) :
                tape_dev(file_handle, spec, dst) {};
        ssize_t read_blk(void *dst, size_t len);
        ssize_t verify_blk(void *dst, size_t len, size_t expected);
        void write_blk(const void *src, size_t len);
        void file_mark(void);
        virtual void rewind(void);
};

ssize_t
flat_file::read_blk(void *dst, size_t len)
{
        (void)dst;
        (void)len;
        errx(EX_SOFTWARE, "That was not supposed to happen");
}

ssize_t
flat_file::verify_blk(void *dst, size_t len, size_t expected)
{
        (void)len;
        return (read(fd, dst, expected));
}

void
flat_file::write_blk(const void *src, size_t len)
{
        ssize_t nwrite = write(fd, src, len);
        if (nwrite < 0 || (size_t)nwrite != len)
                errx(17, "write error (%zd != %zd)", nwrite, len);
}

void
flat_file::file_mark(void)
{
        return;
}

void
flat_file::rewind(void)
{
        errx(EX_SOFTWARE, "That was not supposed to happen");
}

//---------------------------------------------------------------------

enum e_how {H_INPUT, H_OUTPUT, H_VERIFY};

static tape_dev *
open_arg(const char *arg, enum e_how how, int rawfile)
{
        int fd;

        if (!strcmp(arg, "-") && how == H_OUTPUT)
                fd = STDOUT_FILENO;
        else if (!strcmp(arg, "-"))
                fd = STDIN_FILENO;
        else if (how == H_OUTPUT)
                fd = open(arg, O_RDWR|O_CREAT, DEFFILEMODE);
        else
                fd = open(arg, O_RDONLY);

        if (fd < 0)
                err(EX_NOINPUT, "Cannot open %s:", arg);

        struct mtop mt;
        mt.mt_op = MTNOP;
        mt.mt_count = 1;
        int i = ioctl(fd, MTIOCTOP, &mt);

        if (i >= 0)
                return (new tape_dev(fd, arg, how == H_OUTPUT));

        size_t alen = strlen(arg);
        if (alen >= 5 && !strcmp(arg + (alen - 4), ".000")) {
                if (how == H_INPUT)
                        errx(EX_USAGE,
                            "File-sets files cannot be used as source");
                return (new file_set(fd, arg, how == H_OUTPUT));
        }

        if (how != H_INPUT && rawfile)
                return (new flat_file(fd, arg, how == H_OUTPUT));

        return (new tap_file(fd, arg, how == H_OUTPUT));
}

//---------------------------------------------------------------------

static tape_dev *input;
static tape_dev *output;

static size_t maxblk = MAXREC;
static uint64_t lastrec, fsize, tsize;
static FILE *msg;
static ssize_t lastnread;
static struct timespec t_start, t_end;

static void
report_total(FILE *file)
{
        double dur = (t_end.tv_nsec - t_start.tv_nsec) * 1e-9;
        dur += t_end.tv_sec - t_start.tv_sec;
        uintmax_t tot = tsize + fsize;
        fprintf(file, "total length: %ju bytes", tot);
        fprintf(file, " time: %.0f s", dur);
        tot /= 1024;
        fprintf(file, " rate: %.1f kB/s", (double)tot/dur);
        fprintf(file, "\n");
}

static void
sigintr(int signo __unused)
{
        (void)signo;
        (void)clock_gettime(CLOCK_MONOTONIC, &t_end);
        if (record) {
                if (record - lastrec > 1)
                        fprintf(msg, "records %ju to %ju\n",
                            (intmax_t)lastrec, (intmax_t)record);
                else
                        fprintf(msg, "record %ju\n", (intmax_t)lastrec);
        }
        fprintf(msg, "interrupt at file %d: record %ju\n",
            filen, (uintmax_t)record);
        report_total(msg);
        exit(1);
}

#ifdef SIGINFO
static volatile sig_atomic_t want_info;

static void
siginfo(int signo)
{
        (void)signo;
        want_info = 1;
}

static void
check_want_info(void)
{
        if (want_info) {
                (void)clock_gettime(CLOCK_MONOTONIC, &t_end);
                fprintf(stderr, "tcopy: file %d record %ju ",
                    filen, (uintmax_t)record);
                report_total(stderr);
                want_info = 0;
        }
}

#else /* !SIGINFO */

static void
check_want_info(void)
{
}

#endif

static char *
getspace(size_t blk)
{
        void *bp;

        assert(blk > 0);
        if ((bp = malloc(blk)) == NULL)
                errx(11, "no memory");
        return ((char *)bp);
}

static void
usage(void)
{
        fprintf(stderr,
            "usage: tcopy [-crvx] [-l logfile] [-s maxblk] [src [dest]]\n"
        );
        exit(1);
}

static void
progress(ssize_t nread)
{
        if (nread != lastnread) {
                if (lastnread != 0 && lastnread != NOCOUNT) {
                        if (lastrec == 0 && nread == 0)
                                fprintf(msg, "%ju records\n",
                                    (uintmax_t)record);
                        else if (record - lastrec > 1)
                                fprintf(msg, "records %ju to %ju\n",
                                    (uintmax_t)lastrec,
                                    (uintmax_t)record);
                        else
                                fprintf(msg, "record %ju\n",
                                    (uintmax_t)lastrec);
                }
                if (nread != 0)
                        fprintf(msg,
                            "file %d: block size %zd: ", filen, nread);
                (void) fflush(msg);
                lastrec = record;
        }
        if (nread > 0) {
                fsize += (size_t)nread;
                record++;
        } else {
                if (lastnread <= 0 && lastnread != NOCOUNT) {
                        fprintf(msg, "eot\n");
                        return;
                }
                fprintf(msg,
                    "file %d: eof after %ju records: %ju bytes\n",
                    filen, (uintmax_t)record, (uintmax_t)fsize);
                filen++;
                tsize += fsize;
                fsize = record = lastrec = 0;
                lastnread = 0;
        }
        lastnread = nread;
}

static void
read_or_copy(void)
{
        int needeof;
        ssize_t nread, prev_read;
        char *buff = getspace(maxblk);

        (void)clock_gettime(CLOCK_MONOTONIC, &t_start);
        needeof = 0;
        for (prev_read = NOCOUNT;;) {
                check_want_info();
                nread = input->read_blk(buff, maxblk);
                progress(nread);
                if (nread > 0) {
                        if (output != NULL) {
                                if (needeof) {
                                        output->file_mark();
                                        needeof = 0;
                                }
                                output->write_blk(buff, (size_t)nread);
                        }
                } else {
                        if (prev_read <= 0 && prev_read != NOCOUNT) {
                                break;
                        }
                        needeof = 1;
                }
                prev_read = nread;
        }
        (void)clock_gettime(CLOCK_MONOTONIC, &t_end);
        report_total(msg);
        free(buff);
}

static void
verify(void)
{
        char *buf1 = getspace(maxblk);
        char *buf2 = getspace(maxblk);
        int eot = 0;
        ssize_t nread1, nread2;
        filen = 0;
        tsize = 0;

        assert(output != NULL);
        (void)clock_gettime(CLOCK_MONOTONIC, &t_start);

        while (1) {
                check_want_info();
                nread1 = input->read_blk(buf1, (size_t)maxblk);
                nread2 = output->verify_blk(buf2, maxblk, (size_t)nread1);
                progress(nread1);
                if (nread1 != nread2) {
                        fprintf(msg,
                            "tcopy: tapes have different block sizes; "
                            "%zd != %zd.\n", nread1, nread2);
                        exit(1);
                }
                if (nread1 > 0 && memcmp(buf1, buf2, (size_t)nread1)) {
                        fprintf(msg, "tcopy: tapes have different data.\n");
                        exit(1);
                } else if (nread1 > 0) {
                        eot = 0;
                } else if (eot++) {
                        break;
                }
        }
        (void)clock_gettime(CLOCK_MONOTONIC, &t_end);
        report_total(msg);
        fprintf(msg, "tcopy: tapes are identical.\n");
        fprintf(msg, "rewinding\n");
        input->rewind();
        output->rewind();

        free(buf1);
        free(buf2);
}

int
main(int argc, char *argv[])
{
        enum operation op = READ;
        int ch;
        unsigned long maxphys = 0;
        size_t l_maxphys = sizeof maxphys;
        int64_t tmp;
        int rawfile = 0;

        setbuf(stderr, NULL);

        if (!sysctlbyname("kern.maxphys", &maxphys, &l_maxphys, NULL, 0UL))
                maxblk = maxphys;

        msg = stdout;
        while ((ch = getopt(argc, argv, "cl:rs:vx")) != -1)
                switch((char)ch) {
                case 'c':
                        op = COPYVERIFY;
                        break;
                case 'l':
                        msg = fopen(optarg, "w");
                        if (msg == NULL)
                                errx(EX_CANTCREAT, "Cannot open %s", optarg);
                        setbuf(msg, NULL);
                        break;
                case 'r':
                        rawfile = 1;
                        break;
                case 's':
                        if (expand_number(optarg, &tmp)) {
                                warnx("illegal block size");
                                usage();
                        }
                        if (tmp <= 0) {
                                warnx("illegal block size");
                                usage();
                        }
                        maxblk = tmp;
                        break;
                case 'v':
                        op = VERIFY;
                        break;
                case 'x':
                        if (msg == stdout)
                                msg = stderr;
                        break;
                case '?':
                default:
                        usage();
                }
        argc -= optind;
        argv += optind;

        switch(argc) {
        case 0:
                if (op != READ)
                        usage();
                break;
        case 1:
                if (op != READ)
                        usage();
                break;
        case 2:
                if (op == READ)
                        op = COPY;
                if (!strcmp(argv[1], "-")) {
                        if (op == COPYVERIFY)
                                errx(EX_USAGE,
                                    "Cannot copy+verify with '-' destination");
                        if (msg == stdout)
                                msg = stderr;
                }
                if (op == VERIFY)
                        output = open_arg(argv[1], H_VERIFY, 0);
                else
                        output = open_arg(argv[1], H_OUTPUT, rawfile);
                break;
        default:
                usage();
        }

        if (argc == 0) {
                input = open_arg(_PATH_DEFTAPE, H_INPUT, 0);
        } else {
                input = open_arg(argv[0], H_INPUT, 0);
        }

        if ((signal(SIGINT, SIG_IGN)) != SIG_IGN)
                (void) signal(SIGINT, sigintr);

#ifdef SIGINFO
        (void)signal(SIGINFO, siginfo);
#endif

        if (op != VERIFY) {
                if (op == COPYVERIFY) {
                        assert(output != NULL);
                        fprintf(msg, "rewinding\n");
                        input->rewind();
                        output->rewind();
                }

                read_or_copy();

                if (op == COPY || op == COPYVERIFY) {
                        assert(output != NULL);
                        output->file_mark();
                        output->file_mark();
                }
        }

        if (op == VERIFY || op == COPYVERIFY) {

                if (op == COPYVERIFY) {
                        assert(output != NULL);
                        fprintf(msg, "rewinding\n");
                        input->rewind();
                        output->rewind();
                        input->direction = tape_dev::SRC;
                        output->direction = tape_dev::SRC;
                }

                verify();
        }

        if (msg != stderr && msg != stdout)
                report_total(stderr);

        return(0);
}