// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Cryptographic API.
 *
 * Deflate algorithm (RFC 1951), implemented here primarily for use
 * by IPCOMP (RFC 3173 & RFC 2394).
 *
 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
 * Copyright (c) 2023 Google, LLC. <ardb@kernel.org>
 * Copyright (c) 2025 Herbert Xu <herbert@gondor.apana.org.au>
 */
#include <crypto/internal/acompress.h>
#include <crypto/scatterwalk.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/overflow.h>
#include <linux/percpu.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/zlib.h>

#define DEFLATE_DEF_LEVEL               Z_DEFAULT_COMPRESSION
#define DEFLATE_DEF_WINBITS             11
#define DEFLATE_DEF_MEMLEVEL            MAX_MEM_LEVEL

struct deflate_stream {
        struct z_stream_s stream;
        u8 workspace[];
};

static DEFINE_MUTEX(deflate_stream_lock);

static void *deflate_alloc_stream(void)
{
        size_t size = max(zlib_inflate_workspacesize(),
                          zlib_deflate_workspacesize(-DEFLATE_DEF_WINBITS,
                                                     DEFLATE_DEF_MEMLEVEL));
        struct deflate_stream *ctx;

        ctx = kvmalloc_flex(*ctx, workspace, size);
        if (!ctx)
                return ERR_PTR(-ENOMEM);

        ctx->stream.workspace = ctx->workspace;

        return ctx;
}

static void deflate_free_stream(void *ctx)
{
        kvfree(ctx);
}

static struct crypto_acomp_streams deflate_streams = {
        .alloc_ctx = deflate_alloc_stream,
        .free_ctx = deflate_free_stream,
};

static int deflate_compress_one(struct acomp_req *req,
                                struct deflate_stream *ds)
{
        struct z_stream_s *stream = &ds->stream;
        struct acomp_walk walk;
        int ret;

        ret = acomp_walk_virt(&walk, req, true);
        if (ret)
                return ret;

        do {
                unsigned int dcur;

                dcur = acomp_walk_next_dst(&walk);
                if (!dcur)
                        return -ENOSPC;

                stream->avail_out = dcur;
                stream->next_out = walk.dst.virt.addr;

                do {
                        int flush = Z_FINISH;
                        unsigned int scur;

                        stream->avail_in = 0;
                        stream->next_in = NULL;

                        scur = acomp_walk_next_src(&walk);
                        if (scur) {
                                if (acomp_walk_more_src(&walk, scur))
                                        flush = Z_NO_FLUSH;
                                stream->avail_in = scur;
                                stream->next_in = walk.src.virt.addr;
                        }

                        ret = zlib_deflate(stream, flush);

                        if (scur) {
                                scur -= stream->avail_in;
                                acomp_walk_done_src(&walk, scur);
                        }
                } while (ret == Z_OK && stream->avail_out);

                acomp_walk_done_dst(&walk, dcur);
        } while (ret == Z_OK);

        if (ret != Z_STREAM_END)
                return -EINVAL;

        req->dlen = stream->total_out;
        return 0;
}

static int deflate_compress(struct acomp_req *req)
{
        struct crypto_acomp_stream *s;
        struct deflate_stream *ds;
        int err;

        s = crypto_acomp_lock_stream_bh(&deflate_streams);
        ds = s->ctx;

        err = zlib_deflateInit2(&ds->stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,
                                -DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL,
                                Z_DEFAULT_STRATEGY);
        if (err != Z_OK) {
                err = -EINVAL;
                goto out;
        }

        err = deflate_compress_one(req, ds);

out:
        crypto_acomp_unlock_stream_bh(s);

        return err;
}

static int deflate_decompress_one(struct acomp_req *req,
                                  struct deflate_stream *ds)
{
        struct z_stream_s *stream = &ds->stream;
        bool out_of_space = false;
        struct acomp_walk walk;
        int ret;

        ret = acomp_walk_virt(&walk, req, true);
        if (ret)
                return ret;

        do {
                unsigned int scur;

                stream->avail_in = 0;
                stream->next_in = NULL;

                scur = acomp_walk_next_src(&walk);
                if (scur) {
                        stream->avail_in = scur;
                        stream->next_in = walk.src.virt.addr;
                }

                do {
                        unsigned int dcur;
                        unsigned long avail_in;

                        dcur = acomp_walk_next_dst(&walk);

                        stream->avail_out = dcur;
                        stream->next_out = walk.dst.virt.addr;
                        avail_in = stream->avail_in;

                        ret = zlib_inflate(stream, Z_NO_FLUSH);

                        if (!dcur && avail_in == stream->avail_in) {
                                out_of_space = true;
                                break;
                        }

                        dcur -= stream->avail_out;
                        acomp_walk_done_dst(&walk, dcur);
                } while (ret == Z_OK && stream->avail_in);

                if (scur)
                        acomp_walk_done_src(&walk, scur);

                if (out_of_space)
                        return -ENOSPC;
        } while (ret == Z_OK);

        if (ret != Z_STREAM_END)
                return -EINVAL;

        req->dlen = stream->total_out;
        return 0;
}

static int deflate_decompress(struct acomp_req *req)
{
        struct crypto_acomp_stream *s;
        struct deflate_stream *ds;
        int err;

        s = crypto_acomp_lock_stream_bh(&deflate_streams);
        ds = s->ctx;

        err = zlib_inflateInit2(&ds->stream, -DEFLATE_DEF_WINBITS);
        if (err != Z_OK) {
                err = -EINVAL;
                goto out;
        }

        err = deflate_decompress_one(req, ds);

out:
        crypto_acomp_unlock_stream_bh(s);

        return err;
}

static int deflate_init(struct crypto_acomp *tfm)
{
        int ret;

        mutex_lock(&deflate_stream_lock);
        ret = crypto_acomp_alloc_streams(&deflate_streams);
        mutex_unlock(&deflate_stream_lock);

        return ret;
}

static struct acomp_alg acomp = {
        .compress               = deflate_compress,
        .decompress             = deflate_decompress,
        .init                   = deflate_init,
        .base.cra_name          = "deflate",
        .base.cra_driver_name   = "deflate-generic",
        .base.cra_flags         = CRYPTO_ALG_REQ_VIRT,
        .base.cra_module        = THIS_MODULE,
};

static int __init deflate_mod_init(void)
{
        return crypto_register_acomp(&acomp);
}

static void __exit deflate_mod_fini(void)
{
        crypto_unregister_acomp(&acomp);
        crypto_acomp_free_streams(&deflate_streams);
}

module_init(deflate_mod_init);
module_exit(deflate_mod_fini);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
MODULE_AUTHOR("Ard Biesheuvel <ardb@kernel.org>");
MODULE_AUTHOR("Herbert Xu <herbert@gondor.apana.org.au>");
MODULE_ALIAS_CRYPTO("deflate");
MODULE_ALIAS_CRYPTO("deflate-generic");