/* Copyright (c) Pigeonhole authors, see top-level COPYING file */

#include "lib.h"

#include "str.h"

#include "sieve-common.h"

#include "sieve-extensions.h"

#include "sieve-error.h"

#include "sieve-script.h"

#include "sieve-binary.h"

#include "sieve-generator.h"

#include "sieve-interpreter.h"

#include "sieve-dump.h"

#include "ext-ihave-common.h"

#include "ext-ihave-binary.h"

/*

 * Forward declarations

 */

static bool

ext_ihave_binary_pre_save(const struct sieve_extension *ext,

        struct sieve_binary *sbin, void *context,

        enum sieve_error *error_code_r);

static bool

ext_ihave_binary_open(const struct sieve_extension *ext,

          struct sieve_binary *sbin, void *context);

static bool

ext_ihave_binary_up_to_date(const struct sieve_extension *ext,

          struct sieve_binary *sbin, void *context,

          enum sieve_compile_flags cpflags);

/*

 * Binary include extension

 */

const struct sieve_binary_extension ihave_binary_ext = {

  .extension = &ihave_extension,

  .binary_pre_save = ext_ihave_binary_pre_save,

  .binary_open = ext_ihave_binary_open,

  .binary_up_to_date = ext_ihave_binary_up_to_date,

};

/*

 * Binary context management

 */

struct ext_ihave_binary_context {

  struct sieve_binary *binary;

  struct sieve_binary_block *block;

  ARRAY(const char *) missing_extensions;

};

static struct ext_ihave_binary_context *

ext_ihave_binary_create_context(const struct sieve_extension *this_ext,

        struct sieve_binary *sbin)

{

  pool_t pool = sieve_binary_pool(sbin);

  struct ext_ihave_binary_context *ctx =

    p_new(pool, struct ext_ihave_binary_context, 1);

  ctx->binary = sbin;

  p_array_init(&ctx->missing_extensions, pool, 64);

  sieve_binary_extension_set(sbin, this_ext, &ihave_binary_ext, ctx);

  return ctx;

}

struct ext_ihave_binary_context *

ext_ihave_binary_get_context(const struct sieve_extension *this_ext,

           struct sieve_binary *sbin)

{

  struct ext_ihave_binary_context *ctx =

    (struct ext_ihave_binary_context *)

      sieve_binary_extension_get_context(sbin, this_ext);

  if (ctx == NULL)

    ctx = ext_ihave_binary_create_context(this_ext, sbin);

  return ctx;

}

struct ext_ihave_binary_context *

ext_ihave_binary_init(const struct sieve_extension *this_ext,

          struct sieve_binary *sbin, struct sieve_ast *ast)

{

  struct ext_ihave_ast_context *ast_ctx =

    ext_ihave_get_ast_context(this_ext, ast);

  struct ext_ihave_binary_context *binctx;

  const char *const *exts;

  unsigned int i, count;

  binctx = ext_ihave_binary_get_context(this_ext, sbin);

  exts = array_get(&ast_ctx->missing_extensions, &count);

  if (count > 0) {

    pool_t pool = sieve_binary_pool(sbin);

    if (binctx->block == NULL) {

      binctx->block = sieve_binary_extension_create_block(

        sbin, this_ext);

    }

    for (i = 0; i < count; i++) {

      const char *ext_name = p_strdup(pool, exts[i]);

      array_append(&binctx->missing_extensions, &ext_name, 1);

    }

  }

  return binctx;

}

/*

 * Binary extension

 */

static bool

ext_ihave_binary_pre_save(const struct sieve_extension *ext,

        struct sieve_binary *sbin, void *context,

        enum sieve_error *error_code_r ATTR_UNUSED)

{

  struct ext_ihave_binary_context *binctx =

    (struct ext_ihave_binary_context *)context;

  const char *const *exts;

  unsigned int count, i;

  exts = array_get(&binctx->missing_extensions, &count);

  if (binctx->block != NULL)

    sieve_binary_block_clear(binctx->block);

  if (count > 0) {

    if (binctx->block == NULL) {

      binctx->block =

        sieve_binary_extension_create_block(sbin, ext);

    }

    sieve_binary_emit_unsigned(binctx->block, count);

    for (i = 0; i < count; i++)

      sieve_binary_emit_cstring(binctx->block, exts[i]);

  }

  return TRUE;

}

static bool

ext_ihave_binary_open(const struct sieve_extension *ext,

          struct sieve_binary *sbin, void *context)

{

  struct sieve_instance *svinst = ext->svinst;

  struct ext_ihave_binary_context *binctx =

    (struct ext_ihave_binary_context *)context;

  struct sieve_binary_block *sblock;

  unsigned int i, count, block_id;

  sieve_size_t offset;

  sblock = sieve_binary_extension_get_block(sbin, ext);

  if (sblock != NULL) {

    binctx->block = sblock;

    block_id = sieve_binary_block_get_id(sblock);

    offset = 0;

    /* Read number of missing extensions to read subsequently */

    if (!sieve_binary_read_unsigned(sblock, &offset, &count)) {

      e_error(svinst->event, "ihave: "

        "failed to read missing extension count "

        "from block %d of binary %s",

        block_id, sieve_binary_path(sbin));

      return FALSE;

    }

    /* Read dependencies */

    for (i = 0; i < count; i++) {

      string_t *ext_name;

      const char *name;

      if (!sieve_binary_read_string(sblock, &offset,

                  &ext_name)) {

        /* Binary is corrupt, recompile */

        e_error(svinst->event, "ihave: "

          "failed to read missing extension name "

          "from block %d of binary %s",

          block_id, sieve_binary_path(sbin));

        return FALSE;

      }

      name = str_c(ext_name);

      array_append(&binctx->missing_extensions, &name, 1);

    }

  }

  return TRUE;

}

static bool

ext_ihave_binary_up_to_date(const struct sieve_extension *ext,

          struct sieve_binary *sbin ATTR_UNUSED,

          void *context, enum sieve_compile_flags cpflags)

{

  struct ext_ihave_binary_context *binctx =

    (struct ext_ihave_binary_context *)context;

  const struct sieve_extension *mext;

  const char *const *mexts;

  unsigned int count, i;

  mexts = array_get(&binctx->missing_extensions, &count);

  for (i = 0; i < count; i++) {

    mext = sieve_extension_get_by_name(ext->svinst, mexts[i]);

    if (mext != NULL &&

        ((cpflags & SIEVE_COMPILE_FLAG_NOGLOBAL) == 0 ||

         !mext->global))

      return FALSE;

  }

  return TRUE;

}

/*

 * Main extension interface

 */

bool ext_ihave_binary_load(const struct sieve_extension *ext,

         struct sieve_binary *sbin)

{

  (void)ext_ihave_binary_get_context(ext, sbin);

  return TRUE;

}

bool ext_ihave_binary_dump(const struct sieve_extension *ext,

         struct sieve_dumptime_env *denv)

{

  struct sieve_binary *sbin = denv->sbin;

  struct ext_ihave_binary_context *binctx =

    ext_ihave_binary_get_context(ext, sbin);

  const char *const *exts;

  unsigned int count, i;

  exts = array_get(&binctx->missing_extensions, &count);

  if (count > 0) {

    sieve_binary_dump_sectionf(

      denv, "Extensions missing at compile (block: %d)",

      sieve_binary_block_get_id(binctx->block));

    for (i = 0; i < count; i++)

      sieve_binary_dumpf(denv, "  -  %s\n", exts[i]);

  }

  return TRUE;

}