/*

 * Copyright (C) 2017-2022 Red Hat, Inc.

 *

 * Author: Nikos Mavrogiannopoulos

 *

 * This file is part of GnuTLS.

 *

 * The GnuTLS is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public License

 * as published by the Free Software Foundation; either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>

 *

 */

#include "compress.h"

#ifdef HAVE_LIBZ

# include <zlib.h>

#endif

#ifdef HAVE_LIBBROTLI

# include <brotli/decode.h>

# include <brotli/encode.h>

#endif

#ifdef HAVE_LIBZSTD

# include <zstd.h>

#endif

typedef struct {

  gnutls_compression_method_t id;

  const char *name;

} comp_entry;

static const comp_entry comp_algs[] = {

  {GNUTLS_COMP_NULL, "NULL"},

#ifdef HAVE_LIBZ

  {GNUTLS_COMP_ZLIB, "ZLIB"},

#endif

#ifdef HAVE_LIBBROTLI

  {GNUTLS_COMP_BROTLI, "BROTLI"},

#endif

#ifdef HAVE_LIBZSTD

  {GNUTLS_COMP_ZSTD, "ZSTD"},

#endif

  {GNUTLS_COMP_UNKNOWN, NULL}

};

static const gnutls_compression_method_t alg_list[] = {

  GNUTLS_COMP_NULL,

#ifdef HAVE_LIBZ

  GNUTLS_COMP_ZLIB,

#endif

#ifdef HAVE_LIBBROTLI

  GNUTLS_COMP_BROTLI,

#endif

#ifdef HAVE_LIBZSTD

  GNUTLS_COMP_ZSTD,

#endif

  0

};

/**

 * gnutls_compression_get_name:

 * @algorithm: is a Compression algorithm

 *

 * Convert a #gnutls_compression_method_t value to a string.

 *

 * Returns: a pointer to a string that contains the name of the

 *   specified compression algorithm, or %NULL.

 **/

const char *gnutls_compression_get_name(gnutls_compression_method_t algorithm)

{

  const comp_entry *p;

  for (p = comp_algs; p->name; ++p)

    if (p->id == algorithm)

      return p->name;

  return NULL;

}

/**

 * gnutls_compression_get_id:

 * @name: is a compression method name

 *

 * The names are compared in a case insensitive way.

 *

 * Returns: an id of the specified in a string compression method, or

 *   %GNUTLS_COMP_UNKNOWN on error.

 **/

gnutls_compression_method_t gnutls_compression_get_id(const char *name)

{

  const comp_entry *p;

  for (p = comp_algs; p->name; ++p)

    if (!strcasecmp(p->name, name))

      return p->id;

  return GNUTLS_COMP_UNKNOWN;

}

/**

 * gnutls_compression_list:

 *

 * Get a list of compression methods.

 *

 * Returns: a zero-terminated list of #gnutls_compression_method_t

 *   integers indicating the available compression methods.

 **/

const gnutls_compression_method_t *gnutls_compression_list(void)

{

  return alg_list;

}

/*************************/

/* Compression functions */

/*************************/

size_t _gnutls_compress_bound(gnutls_compression_method_t alg, size_t src_len)

{

  switch (alg) {

#ifdef HAVE_LIBZ

  case GNUTLS_COMP_ZLIB:

    return compressBound(src_len);

#endif

#ifdef HAVE_LIBBROTLI

  case GNUTLS_COMP_BROTLI:

    return BrotliEncoderMaxCompressedSize(src_len);

#endif

#ifdef HAVE_LIBZSTD

  case GNUTLS_COMP_ZSTD:

    return ZSTD_compressBound(src_len);

#endif

  default:

    return 0;

  }

  return 0;

}

int

_gnutls_compress(gnutls_compression_method_t alg,

     uint8_t * dst, size_t dst_len,

     const uint8_t * src, size_t src_len)

{

  int ret = GNUTLS_E_COMPRESSION_FAILED;

  switch (alg) {

#ifdef HAVE_LIBZ

  case GNUTLS_COMP_ZLIB:

    {

      int err;

      uLongf comp_len = dst_len;

      err = compress(dst, &comp_len, src, src_len);

      if (err != Z_OK)

        return

            gnutls_assert_val

            (GNUTLS_E_COMPRESSION_FAILED);

      ret = comp_len;

    }

    break;

#endif

#ifdef HAVE_LIBBROTLI

  case GNUTLS_COMP_BROTLI:

    {

      BROTLI_BOOL err;

      size_t comp_len = dst_len;

      err = BrotliEncoderCompress(BROTLI_DEFAULT_QUALITY,

                BROTLI_DEFAULT_WINDOW,

                BROTLI_DEFAULT_MODE,

                src_len, src, &comp_len,

                dst);

      if (!err)

        return

            gnutls_assert_val

            (GNUTLS_E_COMPRESSION_FAILED);

      ret = comp_len;

    }

    break;

#endif

#ifdef HAVE_LIBZSTD

  case GNUTLS_COMP_ZSTD:

    {

      size_t comp_len;

      comp_len =

          ZSTD_compress(dst, dst_len, src, src_len,

            ZSTD_CLEVEL_DEFAULT);

      if (ZSTD_isError(comp_len))

        return

            gnutls_assert_val

            (GNUTLS_E_COMPRESSION_FAILED);

      ret = comp_len;

    }

    break;

#endif

  default:

    return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

  }

#ifdef COMPRESSION_DEBUG

  _gnutls_debug_log("Compression ratio: %f\n",

        (float)((float)ret / (float)src_len));

#endif

  return ret;

}

int

_gnutls_decompress(gnutls_compression_method_t alg,

       uint8_t * dst, size_t dst_len,

       const uint8_t * src, size_t src_len)

{

  int ret = GNUTLS_E_DECOMPRESSION_FAILED;

  switch (alg) {

#ifdef HAVE_LIBZ

  case GNUTLS_COMP_ZLIB:

    {

      int err;

      uLongf plain_len = dst_len;

      err = uncompress(dst, &plain_len, src, src_len);

      if (err != Z_OK)

        return

            gnutls_assert_val

            (GNUTLS_E_DECOMPRESSION_FAILED);

      ret = plain_len;

    }

    break;

#endif

#ifdef HAVE_LIBBROTLI

  case GNUTLS_COMP_BROTLI:

    {

      BrotliDecoderResult err;

      size_t plain_len = dst_len;

      err =

          BrotliDecoderDecompress(src_len, src, &plain_len,

                dst);

      if (err != BROTLI_DECODER_RESULT_SUCCESS)

        return

            gnutls_assert_val

            (GNUTLS_E_DECOMPRESSION_FAILED);

      ret = plain_len;

    }

    break;

#endif

#ifdef HAVE_LIBZSTD

  case GNUTLS_COMP_ZSTD:

    {

      size_t plain_len;

      plain_len = ZSTD_decompress(dst, dst_len, src, src_len);

      if (ZSTD_isError(plain_len))

        return

            gnutls_assert_val

            (GNUTLS_E_DECOMPRESSION_FAILED);

      ret = plain_len;

    }

    break;

#endif

  default:

    return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

  }

  return ret;

}