/*
 * Copyright (c) 1998 Michael Smith.
 * Copyright (c) 2026 Netflix, Inc.
 * 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 AUTHOR 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 AUTHOR 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.
 */

/*
 * Stacked filesystem for .zst compressed files, structured like gzipfs.c and
 * bzipfs.c above it. Only built when the zstd decompressor is already being
 * pulled into libsa for ZFS (see libsa/Makefile), since that's the only
 * source of the ZSTD_* symbols in this environment.
 */

#include "stand.h"

#include <sys/stat.h>
#include <string.h>
#include <zstd.h>

#define ZSTD_BUFSIZE 2048       /* XXX larger? */

struct zstd_file
{
    int                 zstdf_rawfd;
    ZSTD_DStream        *zstdf_strm;
    ZSTD_inBuffer       zstdf_in;
    unsigned char       zstdf_inbuf[ZSTD_BUFSIZE];
    int                 zstdf_endseen;
    off_t               zstdf_total_out;
};

static int      zstdf_fill(struct zstd_file *zstdf);
static int      zstdf_open(const char *path, struct open_file *f);
static int      zstdf_close(struct open_file *f);
static int      zstdf_read(struct open_file *f, void *buf, size_t size, size_t *resid);
static off_t    zstdf_seek(struct open_file *f, off_t offset, int where);
static int      zstdf_stat(struct open_file *f, struct stat *sb);

struct fs_ops zstdfs_fsops = {
        .fs_name = "zstd",
        .fs_flags = 0,
        .fo_open = zstdf_open,
        .fo_close = zstdf_close,
        .fo_read = zstdf_read,
        .fo_write = null_write,
        .fo_seek = zstdf_seek,
        .fo_stat = zstdf_stat,
        .fo_readdir = null_readdir,
};

static int
zstdf_fill(struct zstd_file *zstdf)
{
    int         result;
    int         avail_in;
    int         req;

    avail_in = zstdf->zstdf_in.size - zstdf->zstdf_in.pos;
    req = ZSTD_BUFSIZE - avail_in;
    result = 0;

    /* If we need more */
    if (req > 0) {
        /* move old data to bottom of buffer */
        if (avail_in > 0)
            bcopy(zstdf->zstdf_inbuf + zstdf->zstdf_in.pos, zstdf->zstdf_inbuf, avail_in);

        /* read to fill buffer and update availibility data */
        result = read(zstdf->zstdf_rawfd, zstdf->zstdf_inbuf + avail_in, req);
        zstdf->zstdf_in.src = zstdf->zstdf_inbuf;
        zstdf->zstdf_in.pos = 0;
        zstdf->zstdf_in.size = avail_in + (result >= 0 ? result : 0);
    }
    return (result);
}

static const unsigned char zstd_magic[4] = {0x28, 0xb5, 0x2f, 0xfd};

/*
 * Peek at the fixed-size zstd frame magic without consuming it, so the
 * header remains for ZSTD_decompressStream() to parse normally on the
 * first read.
 *
 * Returns 0 if the header is OK, nonzero if not.
 */
static int
check_header(struct zstd_file *zstdf)
{
    if (zstdf->zstdf_in.size - zstdf->zstdf_in.pos < sizeof(zstd_magic) &&
        zstdf_fill(zstdf) == -1)
        return (1);
    if (zstdf->zstdf_in.size - zstdf->zstdf_in.pos < sizeof(zstd_magic))
        return (1);
    return (memcmp((const unsigned char *)zstdf->zstdf_in.src + zstdf->zstdf_in.pos,
        zstd_magic, sizeof(zstd_magic)) != 0);
}

static int
zstdf_open(const char *fname, struct open_file *f)
{
    static char         *zstdfname;
    int                 rawfd;
    struct zstd_file    *zstdf;
    char                *cp;
    struct stat         sb;

    /* Have to be in "just read it" mode */
    if (f->f_flags != F_READ)
        return(EPERM);

    /* If the name already ends in a known compressed suffix, ignore it */
    if ((cp = strrchr(fname, '.')) && (!strcmp(cp, ".gz")
            || !strcmp(cp, ".bz2") || !strcmp(cp, ".xz")
            || !strcmp(cp, ".zst") || !strcmp(cp, ".split")))
        return(ENOENT);

    /* Construct new name */
    zstdfname = malloc(strlen(fname) + 5);
    if (zstdfname == NULL)
        return(ENOMEM);
    sprintf(zstdfname, "%s.zst", fname);

    /* Try to open the compressed datafile */
    rawfd = open(zstdfname, O_RDONLY);
    free(zstdfname);
    if (rawfd == -1)
        return(ENOENT);

    if (fstat(rawfd, &sb) < 0) {
        printf("zstdf_open: stat failed\n");
        close(rawfd);
        return(ENOENT);
    }
    if (!S_ISREG(sb.st_mode)) {
        printf("zstdf_open: not a file\n");
        close(rawfd);
        return(EISDIR);                 /* best guess */
    }

    /* Allocate a zstd_file structure, populate it */
    zstdf = malloc(sizeof(struct zstd_file));
    if (zstdf == NULL) {
        close(rawfd);
        return(ENOMEM);
    }
    bzero(zstdf, sizeof(struct zstd_file));
    zstdf->zstdf_rawfd = rawfd;
    zstdf->zstdf_in.src = zstdf->zstdf_inbuf;

    /* Verify that the file is zstd compressed */
    if (check_header(zstdf)) {
        close(zstdf->zstdf_rawfd);
        free(zstdf);
        return(EFTYPE);
    }

    /* Initialise the inflation engine */
    zstdf->zstdf_strm = ZSTD_createDStream();
    if (zstdf->zstdf_strm == NULL) {
        close(zstdf->zstdf_rawfd);
        free(zstdf);
        return(ENOMEM);
    }
    if (ZSTD_isError(ZSTD_initDStream(zstdf->zstdf_strm))) {
        ZSTD_freeDStream(zstdf->zstdf_strm);
        close(zstdf->zstdf_rawfd);
        free(zstdf);
        return(EIO);
    }

    /* Looks OK, we'll take it */
    f->f_fsdata = zstdf;
    return(0);
}

static int
zstdf_close(struct open_file *f)
{
    struct zstd_file    *zstdf = (struct zstd_file *)f->f_fsdata;

    ZSTD_freeDStream(zstdf->zstdf_strm);
    close(zstdf->zstdf_rawfd);
    free(zstdf);
    return(0);
}

static int
zstdf_read(struct open_file *f, void *buf, size_t size, size_t *resid)
{
    struct zstd_file    *zstdf = (struct zstd_file *)f->f_fsdata;
    ZSTD_outBuffer      out = { buf, size, 0 };
    size_t              ret;

    while (out.pos < out.size && zstdf->zstdf_endseen == 0) {
        if ((zstdf->zstdf_in.pos == zstdf->zstdf_in.size) && (zstdf_fill(zstdf) == -1)) {
            printf("zstdf_read: fill error\n");
            return(EIO);
        }
        if (zstdf->zstdf_in.pos == zstdf->zstdf_in.size) {      /* oops, unexpected EOF */
            printf("zstdf_read: unexpected EOF\n");
            if (out.pos == 0)
                return(EIO);
            break;
        }

        ret = ZSTD_decompressStream(zstdf->zstdf_strm, &out, &zstdf->zstdf_in);
        if (ZSTD_isError(ret)) {                        /* argh, decompression error */
            printf("zstdf_read: %s\n", ZSTD_getErrorName(ret));
            return(EIO);
        }
        if (ret == 0) {                         /* EOF, all done */
            zstdf->zstdf_endseen = 1;
            break;
        }
    }
    zstdf->zstdf_total_out += out.pos;
    if (resid != NULL)
        *resid = out.size - out.pos;
    return(0);
}

static int
zstdf_rewind(struct open_file *f)
{
    struct zstd_file    *zstdf = (struct zstd_file *)f->f_fsdata;

    if (lseek(zstdf->zstdf_rawfd, 0, SEEK_SET) == -1)
        return(-1);
    zstdf->zstdf_in.src = zstdf->zstdf_inbuf;
    zstdf->zstdf_in.pos = 0;
    zstdf->zstdf_in.size = 0;
    zstdf->zstdf_endseen = 0;
    zstdf->zstdf_total_out = 0;
    if (ZSTD_isError(ZSTD_initDStream(zstdf->zstdf_strm)))
        return(-1);

    return(0);
}

static off_t
zstdf_seek(struct open_file *f, off_t offset, int where)
{
    struct zstd_file    *zstdf = (struct zstd_file *)f->f_fsdata;
    off_t               target;
    char                discard[16];

    switch (where) {
    case SEEK_SET:
        target = offset;
        break;
    case SEEK_CUR:
        target = offset + zstdf->zstdf_total_out;
        break;
    default:
        errno = EINVAL;
        return(-1);
    }

    /* rewind if required */
    if (target < zstdf->zstdf_total_out && zstdf_rewind(f) != 0)
        return(-1);

    /* skip forwards if required */
    while (target > zstdf->zstdf_total_out) {
        errno = zstdf_read(f, discard, min(sizeof(discard),
            target - zstdf->zstdf_total_out), NULL);
        if (errno)
            return(-1);
        /* Break out of loop if end of file has been reached. */
        if (zstdf->zstdf_endseen)
            break;
    }
    /* This is where we are (be honest if we overshot) */
    return(zstdf->zstdf_total_out);
}

static int
zstdf_stat(struct open_file *f, struct stat *sb)
{
    struct zstd_file    *zstdf = (struct zstd_file *)f->f_fsdata;
    int                 result;

    /* stat as normal, but indicate that size is unknown */
    if ((result = fstat(zstdf->zstdf_rawfd, sb)) == 0)
        sb->st_size = -1;
    return(result);
}