/***********************license start************************************
 * Copyright (c) 2003-2017 Cavium, Inc.
 * All rights reserved.
 *
 * License: one of 'Cavium License' or 'GNU General Public License Version 2'
 *
 * This file is provided under the terms of the Cavium License (see below)
 * or under the terms of GNU General Public License, Version 2, as
 * published by the Free Software Foundation. When using or redistributing
 * this file, you may do so under either license.
 *
 * Cavium License:  Redistribution and use in source and binary forms, with
 * or without modification, are permitted provided that the following
 * conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *  * 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.
 *
 *  * Neither the name of Cavium Inc. 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, including technical data, may be subject to U.S. export
 * control laws, including the U.S. Export Administration Act and its
 * associated regulations, and may be subject to export or import
 * regulations in other countries.
 *
 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
 * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS
 * OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH
 * RESPECT TO THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY
 * REPRESENTATION OR DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT
 * DEFECTS, AND CAVIUM SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY)
 * WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A
 * PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET
 * ENJOYMENT, QUIET POSSESSION OR CORRESPONDENCE TO DESCRIPTION. THE
 * ENTIRE  RISK ARISING OUT OF USE OR PERFORMANCE OF THE SOFTWARE LIES
 * WITH YOU.
 ***********************license end**************************************/

#include "zip_crypto.h"

static void zip_static_init_zip_ops(struct zip_operation *zip_ops,
                                    int lzs_flag)
{
        zip_ops->flush        = ZIP_FLUSH_FINISH;

        /* equivalent to level 6 of opensource zlib */
        zip_ops->speed          = 1;

        if (!lzs_flag) {
                zip_ops->ccode          = 0; /* Auto Huffman */
                zip_ops->lzs_flag       = 0;
                zip_ops->format         = ZLIB_FORMAT;
        } else {
                zip_ops->ccode          = 3; /* LZS Encoding */
                zip_ops->lzs_flag       = 1;
                zip_ops->format         = LZS_FORMAT;
        }
        zip_ops->begin_file   = 1;
        zip_ops->history_len  = 0;
        zip_ops->end_file     = 1;
        zip_ops->compcode     = 0;
        zip_ops->csum         = 1; /* Adler checksum desired */
}

static int zip_ctx_init(struct zip_kernel_ctx *zip_ctx, int lzs_flag)
{
        struct zip_operation  *comp_ctx   = &zip_ctx->zip_comp;
        struct zip_operation  *decomp_ctx = &zip_ctx->zip_decomp;

        zip_static_init_zip_ops(comp_ctx, lzs_flag);
        zip_static_init_zip_ops(decomp_ctx, lzs_flag);

        comp_ctx->input  = zip_data_buf_alloc(MAX_INPUT_BUFFER_SIZE);
        if (!comp_ctx->input)
                return -ENOMEM;

        comp_ctx->output = zip_data_buf_alloc(MAX_OUTPUT_BUFFER_SIZE);
        if (!comp_ctx->output)
                goto err_comp_input;

        decomp_ctx->input  = zip_data_buf_alloc(MAX_INPUT_BUFFER_SIZE);
        if (!decomp_ctx->input)
                goto err_comp_output;

        decomp_ctx->output = zip_data_buf_alloc(MAX_OUTPUT_BUFFER_SIZE);
        if (!decomp_ctx->output)
                goto err_decomp_input;

        return 0;

err_decomp_input:
        zip_data_buf_free(decomp_ctx->input, MAX_INPUT_BUFFER_SIZE);

err_comp_output:
        zip_data_buf_free(comp_ctx->output, MAX_OUTPUT_BUFFER_SIZE);

err_comp_input:
        zip_data_buf_free(comp_ctx->input, MAX_INPUT_BUFFER_SIZE);

        return -ENOMEM;
}

static void zip_ctx_exit(struct zip_kernel_ctx *zip_ctx)
{
        struct zip_operation  *comp_ctx   = &zip_ctx->zip_comp;
        struct zip_operation  *dec_ctx = &zip_ctx->zip_decomp;

        zip_data_buf_free(comp_ctx->input, MAX_INPUT_BUFFER_SIZE);
        zip_data_buf_free(comp_ctx->output, MAX_OUTPUT_BUFFER_SIZE);

        zip_data_buf_free(dec_ctx->input, MAX_INPUT_BUFFER_SIZE);
        zip_data_buf_free(dec_ctx->output, MAX_OUTPUT_BUFFER_SIZE);
}

static int zip_compress(const u8 *src, unsigned int slen,
                 u8 *dst, unsigned int *dlen,
                 struct zip_kernel_ctx *zip_ctx)
{
        struct zip_operation  *zip_ops   = NULL;
        struct zip_state      *zip_state;
        struct zip_device     *zip = NULL;
        int ret;

        if (!zip_ctx || !src || !dst || !dlen)
                return -ENOMEM;

        zip = zip_get_device(zip_get_node_id());
        if (!zip)
                return -ENODEV;

        zip_state = kzalloc(sizeof(*zip_state), GFP_ATOMIC);
        if (!zip_state)
                return -ENOMEM;

        zip_ops = &zip_ctx->zip_comp;

        zip_ops->input_len  = slen;
        zip_ops->output_len = *dlen;
        memcpy(zip_ops->input, src, slen);

        ret = zip_deflate(zip_ops, zip_state, zip);

        if (!ret) {
                *dlen = zip_ops->output_len;
                memcpy(dst, zip_ops->output, *dlen);
        }
        kfree(zip_state);
        return ret;
}

static int zip_decompress(const u8 *src, unsigned int slen,
                   u8 *dst, unsigned int *dlen,
                   struct zip_kernel_ctx *zip_ctx)
{
        struct zip_operation  *zip_ops   = NULL;
        struct zip_state      *zip_state;
        struct zip_device     *zip = NULL;
        int ret;

        if (!zip_ctx || !src || !dst || !dlen)
                return -ENOMEM;

        zip = zip_get_device(zip_get_node_id());
        if (!zip)
                return -ENODEV;

        zip_state = kzalloc(sizeof(*zip_state), GFP_ATOMIC);
        if (!zip_state)
                return -ENOMEM;

        zip_ops = &zip_ctx->zip_decomp;
        memcpy(zip_ops->input, src, slen);

        /* Work around for a bug in zlib which needs an extra bytes sometimes */
        if (zip_ops->ccode != 3) /* Not LZS Encoding */
                zip_ops->input[slen++] = 0;

        zip_ops->input_len  = slen;
        zip_ops->output_len = *dlen;

        ret = zip_inflate(zip_ops, zip_state, zip);

        if (!ret) {
                *dlen = zip_ops->output_len;
                memcpy(dst, zip_ops->output, *dlen);
        }
        kfree(zip_state);
        return ret;
}

/* Legacy Compress framework start */
int zip_alloc_comp_ctx_deflate(struct crypto_tfm *tfm)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx = crypto_tfm_ctx(tfm);

        ret = zip_ctx_init(zip_ctx, 0);

        return ret;
}

int zip_alloc_comp_ctx_lzs(struct crypto_tfm *tfm)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx = crypto_tfm_ctx(tfm);

        ret = zip_ctx_init(zip_ctx, 1);

        return ret;
}

void zip_free_comp_ctx(struct crypto_tfm *tfm)
{
        struct zip_kernel_ctx *zip_ctx = crypto_tfm_ctx(tfm);

        zip_ctx_exit(zip_ctx);
}

int  zip_comp_compress(struct crypto_tfm *tfm,
                       const u8 *src, unsigned int slen,
                       u8 *dst, unsigned int *dlen)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx = crypto_tfm_ctx(tfm);

        ret = zip_compress(src, slen, dst, dlen, zip_ctx);

        return ret;
}

int  zip_comp_decompress(struct crypto_tfm *tfm,
                         const u8 *src, unsigned int slen,
                         u8 *dst, unsigned int *dlen)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx = crypto_tfm_ctx(tfm);

        ret = zip_decompress(src, slen, dst, dlen, zip_ctx);

        return ret;
} /* Legacy compress framework end */

/* SCOMP framework start */
void *zip_alloc_scomp_ctx_deflate(struct crypto_scomp *tfm)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx;

        zip_ctx = kzalloc(sizeof(*zip_ctx), GFP_KERNEL);
        if (!zip_ctx)
                return ERR_PTR(-ENOMEM);

        ret = zip_ctx_init(zip_ctx, 0);

        if (ret) {
                kfree_sensitive(zip_ctx);
                return ERR_PTR(ret);
        }

        return zip_ctx;
}

void *zip_alloc_scomp_ctx_lzs(struct crypto_scomp *tfm)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx;

        zip_ctx = kzalloc(sizeof(*zip_ctx), GFP_KERNEL);
        if (!zip_ctx)
                return ERR_PTR(-ENOMEM);

        ret = zip_ctx_init(zip_ctx, 1);

        if (ret) {
                kfree_sensitive(zip_ctx);
                return ERR_PTR(ret);
        }

        return zip_ctx;
}

void zip_free_scomp_ctx(struct crypto_scomp *tfm, void *ctx)
{
        struct zip_kernel_ctx *zip_ctx = ctx;

        zip_ctx_exit(zip_ctx);
        kfree_sensitive(zip_ctx);
}

int zip_scomp_compress(struct crypto_scomp *tfm,
                       const u8 *src, unsigned int slen,
                       u8 *dst, unsigned int *dlen, void *ctx)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx  = ctx;

        ret = zip_compress(src, slen, dst, dlen, zip_ctx);

        return ret;
}

int zip_scomp_decompress(struct crypto_scomp *tfm,
                         const u8 *src, unsigned int slen,
                         u8 *dst, unsigned int *dlen, void *ctx)
{
        int ret;
        struct zip_kernel_ctx *zip_ctx = ctx;

        ret = zip_decompress(src, slen, dst, dlen, zip_ctx);

        return ret;
} /* SCOMP framework end */