xref: /dports/sysutils/hexpeek/hexpeek-v1.0.20200804/src/hexpeek_files.c

// Copyright 2020 Michael Reilly (mreilly@resiliware.com).
//
// 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. Neither the names of the copyright holders nor the names of the
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDERS
// 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.

#define SRCNAME "hexpeek_files.c"

#include <hexpeek.h>

#include <stdlib.h>
#include <libgen.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

static int whichfile(int fd)
{
    if(fd < 0)
        return -1;
    for(int fi = 0; fi < MAX_INFILES; fi++)
    {
        if(fd == Params.infiles[fi].fd)
            return fi;
    }
    return -1;
}

char const *fdname(int fd)
{
    if(fd >= 0)
    {
        for(int fi = 0; fi < MAX_INFILES; fi++)
        {
            if(Params.infiles[fi].fd >= 0)
            {
                if(fd == Params.infiles[fi].fd)
                    return DT_NAME(fi);
                for(int bidx = 0; bidx < BACKUP_FILE_COUNT; bidx++)
                {
                    if(fd == Params.infiles[fi].bk_fds[bidx])
                        return BK_NAME(fi, bidx);
                }
            }
        }
    }
    return "";
}

static int isBackupFile(int fd)
{
    for(int fi = 0; fi < MAX_INFILES; fi++)
    {
        if(Params.infiles[fi].fd >= 0)
        {
            for(int bidx = 0; bidx < BACKUP_FILE_COUNT; bidx++)
            {
                if(fd == Params.infiles[fi].bk_fds[bidx])
                {
                    return 1;
                }
            }
        }
    }
    return 0;
}

rc_t hexpeek_open(char const *path, int flags, mode_t mode, int *fd)
{
    int tmpfd = open(path, flags, mode);
    if(tmpfd < 0)
    {
        prerr("error opening path \"%s\": %s\n", cleanstring(path),
              strerror(errno));
        return RC_CRIT;
    }
    *fd = tmpfd;
    return RC_OK;
}

#define _hexpeek_seek lseek

hoff_t hexpeek_seek(int fd, hoff_t offset, int whence)
{
    errno = 0;
    hoff_t result = _hexpeek_seek(fd, offset, whence);
    if(result < 0) switch(errno)
    {
    case EINVAL:
    {
        prerr("invalid file offset\n");
        break;
    }
    case ESPIPE:
    {
        // Try a forward-only seek for non-seekable files
        int wf = whichfile(fd);
        if(wf >= 0 && whence == SEEK_SET && Params.infiles[wf].track <= offset)
        {
            uint8_t discard[PAGESZ];
            while(Params.infiles[wf].track < offset)
            {
                ssize_t lcl_rd = read(fd,
                                      discard,
                                      min(sizeof discard,
                                          offset - Params.infiles[wf].track));
                if(lcl_rd <= 0)
                    goto fallthrough;
                Params.infiles[wf].track += (hoff_t)lcl_rd;
            }
            result = Params.infiles[wf].track;
            break;
        }
    }
    default:
    {
fallthrough:
        prerr("error seeking in %s: %s\n", fdname(fd), strerror(errno));
        break;
    }
    }
    return result;
}

bool isseekable(int file_index)
{
    return (_hexpeek_seek(DT_FD(file_index), 0, SEEK_CUR) >= 0);
}

rc_t seekto(int fd, hoff_t offset)
{
    // No current code path has offset < 0 here, but if it happens, fix it
    // rather than failing.
    int whence = (offset < 0 ? SEEK_END : SEEK_SET);
    if(hexpeek_seek(fd, offset, whence) >= 0)
        return RC_OK;
    else if(errno == EINVAL)
        return RC_USER;
    else
        return RC_CRIT;
}

ssize_t readfull(int fd, void *buf, size_t count)
{
    int wf = whichfile(fd);
    ssize_t result = -1;
    size_t octets_read = 0;

    while(octets_read < count)
    {
        ssize_t lcl_rd = read(fd,
                              buf + octets_read,
                              count - octets_read);
        if(lcl_rd < 0)
            goto end;
        if(lcl_rd == 0)
            break;
        octets_read += lcl_rd;
    }

    result = (ssize_t)octets_read;

end:
    if(wf >= 0)
    {
        if(Params.infiles[wf].track > HOFF_MAX - octets_read)
            Params.infiles[wf].track = HOFF_MAX;
        else
            Params.infiles[wf].track += (hoff_t)octets_read;
    }
    return result;
}

hoff_t hexpeek_read(int fd, void *buf, hoff_t count)
{
    if(count < 0 || (uintmax_t)count > (uintmax_t)SIZE_MAX)
        return (hoff_t)-1;
    if(count == 0)
        return 0;
    ssize_t result = readfull(fd, buf, (size_t)count);
    if(result < 0)
        prerr("error reading from %s: %s\n", fdname(fd), strerror(errno));
    return (hoff_t)result;
}

static hoff_t readstrict(int fd, void *buf, hoff_t count)
{
    hoff_t result = hexpeek_read(fd, buf, count);
    if(result >= 0 && result != count)
    {
        prerr(EofErrString, fdname(fd));
        result = -1;
    }
    return result;
}

hoff_t hexpeek_write(int fd, const void *buf, hoff_t count)
{
    if(count < 0 || (uintmax_t)count > (uintmax_t)SIZE_MAX)
        return (hoff_t)-1;
    if(count == 0)
        return 0;
    ssize_t result = write(fd, buf, (size_t)count);
    if(result != count)
        prerr("error writing to %s: %s\n", fdname(fd), strerror(errno));
    return (hoff_t)result;
}

rc_t hexpeek_stat(int fd, struct stat *fileinfo)
{
    if(fstat(fd, fileinfo))
    {
        prerr("error retrieving file info for %s: %s\n", fdname(fd),
              strerror(errno));
        return RC_CRIT;
    }
    return RC_OK;
}

rc_t hexpeek_sync(int fd)
{
    if(fsync(fd))
    {
        prerr("error syncing %s: %s\n", fdname(fd), strerror(errno));
        return RC_CRIT;
    }
    return RC_OK;
}

rc_t hexpeek_syncdir(char const *path)
{
    rc_t rc  = RC_UNSPEC;
    const size_t len = strlen(path) + 1;
    char buf[len];

    strncpy(buf, path, len);
    buf[len - 1] = '\0';

    char *directory = dirname(buf);
    int fd = open(directory, O_RDONLY);
    if(fd < 0)
    {
        rc = RC_CRIT;
        prerr("error opening path \"%s\": %s\n", cleanstring(directory),
              strerror(errno));
        goto end;
    }

    rc = hexpeek_sync(fd);

end:
    if(fd >= 0)
        close(fd);
    return rc;
}

rc_t hexpeek_truncate(int fd, hoff_t len)
{
    if(ftruncate(fd, len))
    {
        prerr("error truncating %s: %s\n", fdname(fd), strerror(errno));
        return RC_CRIT;
    }
    return RC_OK;
}

// Returns:
//   0 - unique
//   1 - same
//   2 - unknown
int sameness(int fd0, int fd1)
{
    int result = 2;

    if(fd0 == fd1)
    {
        result = 1;
    }
    else
    {
        struct stat i0, i1;
        if(hexpeek_stat(fd0, &i0))
            goto end;
        if(hexpeek_stat(fd1, &i1))
            goto end;
        result = (i0.st_dev == i1.st_dev && i0.st_ino == i1.st_ino) ? 1 : 0;
    }

end:
    return result;
}

hoff_t filesize(int file_index)
{
    struct stat info;
    assert(hexpeek_stat(DT_FD(file_index), &info) == RC_OK);
    assert(info.st_size >= 0);
    return info.st_size;
}

hoff_t pathsize(char const *path)
{
    struct stat info;
    errno = 0;
    if(stat(path, &info))
    {
        if(errno == ENOENT)
            return -1;
        prerr("error retrieving information about path \"%s\": %s\n",
              cleanstring(path), strerror(errno));
        die();
    }
    return info.st_size;
}

rc_t readat(int fd, hoff_t at, void *buf, hoff_t count)
{
    if(hexpeek_seek(fd, at, SEEK_SET) != at)
        return RC_CRIT;
    if(readstrict(fd, buf, count) != count)
        return RC_CRIT;
    return RC_OK;
}

rc_t writeat(int fd, hoff_t at, const void *buf, hoff_t count)
{
    if(hexpeek_seek(fd, at, SEEK_SET) != at)
        return RC_CRIT;
    if(hexpeek_write(fd, buf, count) != count)
        return RC_CRIT;
    return RC_OK;
}

// Copy data backwards. This function is safe for overlapping file regions
// when src_at is <= dst_at.
static rc_t cpybk(int src_fd, hoff_t src_at, int dst_fd, hoff_t dst_at,
                  hoff_t length)
{
    rc_t rc = RC_UNSPEC;
    hoff_t sz = (src_at + length) % PAGESZ;
    uint8_t cpybuf[max(BUFSZ, PAGESZ)];

    if(sz == 0)
        sz = BUFSZ;

    for(hoff_t rel = length; rel > 0; sz = BUFSZ)
    {
        sz = min(sz, rel);
        rel -= sz;
        progress(length - rel, length, 0);
        rc = readat(src_fd, src_at + rel, cpybuf, sz);
        checkrc(rc);
        rc = writeat(dst_fd, dst_at + rel, cpybuf, sz);
        checkrc(rc);
        plugin(2, NULL);
    }

    progress(-1, length, 0);

    rc = RC_OK;

end:
    return rc;
}

// Copy data forwards. This function is safe for overlapping file regions
// when src_at is >= dst_at.
static rc_t cpyfw(int src_fd, hoff_t src_at, int dst_fd, hoff_t dst_at,
                  hoff_t length)
{
    rc_t rc = RC_UNSPEC;
    hoff_t sz = distbound(src_at, PAGESZ);
    uint8_t cpybuf[max(BUFSZ, PAGESZ)];

    for(hoff_t rel = 0; rel < length; sz = BUFSZ)
    {
        sz = min(sz, length - rel);
        progress(rel, length, 0);
        rc = readat(src_fd, src_at + rel, cpybuf, sz);
        checkrc(rc);
        rc = writeat(dst_fd, dst_at + rel, cpybuf, sz);
        checkrc(rc);
        rel += sz;
        plugin(2, NULL);
    }

    progress(-1, length, 0);

    rc = RC_OK;

end:
    return rc;
}

// This function is NOT safe to use on the same file. It exists because this
// restriction allows less seeking than the functions above.
static rc_t cpyext(int src_fd, hoff_t src_at, int dst_fd, hoff_t dst_at,
                   hoff_t length, int isbk)
{
    rc_t rc = RC_UNSPEC;
    hoff_t sz = distbound(src_at, PAGESZ);
    uint8_t cpybuf[max(BUFSZ, PAGESZ)];

    rc = seekto(src_fd, src_at);
    checkrc(rc);
    rc = seekto(dst_fd, dst_at);
    checkrc(rc);

    for(hoff_t rel = 0; rel < length; sz = BUFSZ)
    {
        sz = min(sz, length - rel);
        progress(rel, length, isbk);
        if(readstrict(src_fd, cpybuf, sz) != sz)
        {
            rc = RC_CRIT;
            goto end;
        }
        if(hexpeek_write(dst_fd, cpybuf, sz) != sz)
        {
            rc = RC_CRIT;
            goto end;
        }
        rel += sz;
        plugin(2, NULL);
    }

    progress(-1, length, isbk);

    rc = RC_OK;

end:
    return rc;
}

rc_t filecpy(int src_fd, hoff_t src_at, hoff_t src_len,
             int dst_fd, hoff_t dst_at, hoff_t dst_len)
{
    rc_t rc = RC_UNSPEC;
    hoff_t src_before = -1, dst_before = -1, cpy_tot = 0;

    traceEntry("%s, " TRC_hoff ", " TRC_hoff ", "
               "%s, " TRC_hoff ", " TRC_hoff,
               fdname(src_fd), trchoff(src_at), trchoff(src_len),
               fdname(dst_fd), trchoff(dst_at), trchoff(dst_len));

    assert(src_fd >= 0);
    assert(dst_fd >= 0);
    assert(src_at >= 0);
    assert(src_len >= 0);
    assert(dst_at >= 0);
    assert(dst_len >= 0);
    assert(src_len <= dst_len);

    SAVE_OFFSET(src_fd, src_before);
    SAVE_OFFSET(dst_fd, dst_before);

    bool isbk = isBackupFile(src_fd) ^ isBackupFile(dst_fd);
    bool uniq = isbk || (sameness(src_fd, dst_fd) == 0);

    if(uniq)
    {
        // Copy src_len octets into start of dst_at
        rc = cpyext(src_fd, src_at, dst_fd, dst_at, src_len, isbk);
        checkrc(rc);
        cpy_tot += src_len;

        // Repeated write if needed
        while(cpy_tot < dst_len)
        {
            hoff_t cpy_len = min(dst_len - cpy_tot, src_len);
            rc = cpyext(src_fd, src_at, dst_fd, dst_at+cpy_tot, cpy_len, isbk);
            checkrc(rc);
            cpy_tot += cpy_len;
        }
    }
    else
    {
        // Copy src_len octets into start of dst_at
        if(src_at < dst_at && src_at + src_len > dst_at)
        {
            rc = cpybk(src_fd, src_at, dst_fd, dst_at, src_len);
            checkrc(rc);
        }
        else
        {
            rc = cpyfw(src_fd, src_at, dst_fd, dst_at, src_len);
            checkrc(rc);
        }
        cpy_tot += src_len;

        // Repeated write if needed (data at src_at may have been overwritten
        // depending on overlap, so read from dst_at).
        while(cpy_tot < dst_len)
        {
            hoff_t cpy_len = min(dst_len - cpy_tot, src_len);
            rc = cpyfw(dst_fd, dst_at, dst_fd, dst_at + cpy_tot, cpy_len);
            checkrc(rc);
            cpy_tot += cpy_len;
        }
    }

    rc = RC_OK;

end:
    if(src_before >= 0)
        RESTORE_OFFSET(src_fd, src_before);
    if(dst_before >= 0)
        RESTORE_OFFSET(dst_fd, dst_before);
    traceExit(TRC_rc, rc);
    return rc;
}

rc_t lclcpy(int fd, hoff_t src_at, hoff_t dst_at, hoff_t length)
{
    return filecpy(fd, src_at, length, fd, dst_at, length);
}

rc_t adjustSize(int data_fi, hoff_t pos, hoff_t amt, int backup_fd)
{
    rc_t rc = RC_UNSPEC;
    hoff_t f_sz = filesize(data_fi);

    traceEntry("%d, " TRC_hoff ", " TRC_hoff ", %d",
               DT_FD(data_fi), trchoff(pos), trchoff(amt), backup_fd);

    assert(pos >= 0);
    if(amt < 0)
        pos -= amt;
    if(backup_fd < 0)
        backup_fd = backupFd(data_fi);

    rc = makeAdjBackup(data_fi, backup_fd, pos);
    checkrc(rc);

    if(pos < f_sz)
    {
        rc = lclcpy(DT_FD(data_fi), pos, pos + amt, f_sz - pos);
        checkrc(rc);
    }

    if(amt < 0 && hexpeek_truncate(DT_FD(data_fi), f_sz + amt))
        goto end;

    rc = clearAdjBackup(backup_fd, NULL);
    checkrc(rc);

    rc = RC_OK;

end:
    traceExit(TRC_rc, rc);
    return rc;
}